Software Engineering Problems Research Articles

Metric’s Thresholds for Encoding Evolutionary Computing Representation in Software Engineering Problem

algorithm as alternative to human experts at the presentation phase of the GA. This algorithm proposed as an empirical technique in opposing the current experts' opinions for the Evolutionary algorithms (EA) chromosome formulation. The algorithm was evaluated and validated by applying the technique to the practical model. The model was the initial implementation of GA software metrics selection model aimed to predict the software maintainability. The promising results of the final GA model are intuition toward other evolutionary computation methods. The final developed model was compared with Principal Component Analysis (PCA) and software metrics suite to evaluate its performance. In addition, the model used two different case studies to get more clarification.

The Study on Case-Driven Methodology to Teach Software Engineering in Graduate Education

This paper discusses the reform of teaching contents, teaching model, teaching method of software engineering courses, and assesses the effects of a series of reform measures and programs. It formed a case-driven methodology to teach software engineering. The teaching practice undertaken by Northeast Petroleum University has shown that the methodology provides graduate students with the opportunities to experience the realistic software engineering problems and environments, and then effectively raise their interest in learning.

Enabling improved IR-based feature location

Recent solutions to software engineering problems have incorporated tools and techniques from information retrieval (IR). The use of IR requires choosing an appropriate retrieval model and deciding on a query that best captures a particular information need. Taking feature location as a representative example, three research questions are investigated: (1) the impact of query preprocessing, (2) the impact that different scraping techniques for queries have on retrieval performance, (3) the performance impact that the underlying retrieval model has on identifying the correct source-code functions (the correct documents). These research questions are addressed using the five open source projects released as part of the SEMERU dataset. In the experiments, five methods of scraping queries from modification requests and seven retrieval model instances are considered. Using the standard evaluation metric Mean Reciprocal Rank (MRR), the experimental analysis reveals that better retrieval models are not the ones commonly used by software engineering researchers. Results find that models based on query-likelihood perform about twice as well as models in common use in software engineering such as LSI and thus deserve greater attention. Furthermore, corpus preprocessing has a significant impact as the top performing setting is over 100% better than the average.

Quantitative causality

Events generated by the execution of a distributed system are related by causality and concurrency. While providing a means of reasoning about the relative occurrence of events, this partial order fails to represent the timeliness of occurrence. In this paper, we develop a novel means of assigning weights to events where the weights are reduced as the temporal proximity to an anchor event decreases. This weight quantifies the strength of the causal or concurrent relationship with respect to an anchor event. Those events that causally succeed the anchor are the focus of this paper with concurrency and causally preceding being part of future work plans. Three methods of computing event weights for causally succeeding events are defined. Each contains a tunable parameter to determine the rate of weight decrease. The methods are piece-wise linear, exponential, and relevant vector difference decay. A case study has been performed that applied quantitative causality to the well-known software engineering problem of feature location. A summary of the case study results is provided to illustrate the utility of quantitative causality for succeeding events.

Measuring Complexity, Development Time and Understandability of a Program: A Cognitive Approach

One of the central problems in software engineering is the inherent complexity. Since software is the result of human creative activity and cognitive informatics plays an important role in understanding its fundamental characteristics. This paper models one of the fundamental characteristics of software complexity by examining the cognitive weights of basic software control structures. Cognitive weights are the degree of the difficulty or relative time and effort required for comprehending a given piece of software, which satisfy the definition of complexity. Based on this approach a new concept of New Weighted Method Complexity (NWMC) of software is developed. Twenty programs are distributed among 5 PG students and development time is noted of all of them and mean is considered as the actual time needed time to develop the programs and Understandability (UA) is also measured of all the programs means how much time needed to understand the code. This paper considers Jingqiu Shao et al Cognitive Functional Size (CFS) of software for study. In order to validate the new complexity metrics we have calculated the correlation between proposed metric and CFS with respect to actual development time and performed analysis of NWMC with CFS with Mean Relative Error (MRE) and Standard Deviation (Std.). Finally, the authors found that the accuracy to estimate the development time with proposed measure is far better than CFS.

Analyzing privacy requirements: A case study of healthcare in Saudi Arabia

Developing legally compliant systems is a challenging software engineering problem, especially in systems that are governed by law, such as healthcare information systems. This challenge comes from the ambiguities and domain-specific definitions that are found in governmental rules. Therefore, there is a significant business need to automatically analyze privacy texts, extract rules and subsequently enforce them throughout the supply chain. The existing works that analyze health regulations use the U.S. Health Insurance Portability and Accountability Act as a case study. In this article, we applied the Breaux and Antón approach to the text of the Saudi Arabian healthcare privacy regulations; in Saudi Arabia, privacy is among the top dilemmas for public and private healthcare practitioners. As a result, we extracted and analyzed 2 rights, 4 obligations, 22 constraints, and 6 rules. Our analysis can assist requirements engineers, standards organizations, compliance officers and stakeholders by ensuring that their systems conform to Saudi policy. In addition, this article discusses the threats to the study validity and suggests open problems for future research.

Design pattern mining using distributed learning automata and DNA sequence alignment.

ContextOver the last decade, design patterns have been used extensively to generate reusable solutions to frequently encountered problems in software engineering and object oriented programming. A design pattern is a repeatable software design solution that provides a template for solving various instances of a general problem.ObjectiveThis paper describes a new method for pattern mining, isolating design patterns and relationship between them; and a related tool, DLA-DNA for all implemented pattern and all projects used for evaluation. DLA-DNA achieves acceptable precision and recall instead of other evaluated tools based on distributed learning automata (DLA) and deoxyribonucleic acid (DNA) sequences alignment.MethodThe proposed method mines structural design patterns in the object oriented source code and extracts the strong and weak relationships between them, enabling analyzers and programmers to determine the dependency rate of each object, component, and other section of the code for parameter passing and modular programming. The proposed model can detect design patterns better that available other tools those are Pinot, PTIDEJ and DPJF; and the strengths of their relationships.ResultsThe result demonstrate that whenever the source code is build standard and non-standard, based on the design patterns, then the result of the proposed method is near to DPJF and better that Pinot and PTIDEJ. The proposed model is tested on the several source codes and is compared with other related models and available tools those the results show the precision and recall of the proposed method, averagely 20% and 9.6% are more than Pinot, 27% and 31% are more than PTIDEJ and 3.3% and 2% are more than DPJF respectively.ConclusionThe primary idea of the proposed method is organized in two following steps: the first step, elemental design patterns are identified, while at the second step, is composed to recognize actual design patterns.

Architecture Synthesis Process for Scheduler Concept Based On Design Algebra with Object Oriented Design Methods

Synthesis analysis is the effective process for solving problems in Software engineering. We provide description for scheduler concept by using synthesis analysis. We presented implementation of architecture design alternatives for scheduler concept based on design algebra concept. During the process of alternative space analysis different alternative solutions are searched and also evaluating the different design solutions based on quality criteria or constraints. This is more effective processes for designing the different systems based on quality criteria and constraints. In this paper balancing design alternatives for this concept with object oriented design methods.

A mapping study of the Brazilian SBSE community

Research communities evolve over time, changing their interests for specific problems or research areas. Mapping the evolution of a research community, including the most frequently addressed problems, the strategies selected to propose solution for them, the venues on which results observed from applying these strategies are published, and the collaboration among distinct groups may provide lessons on actions that can positively influence the growth of research in a given field. To this end, this paper presents an analysis of the Brazilian SBSE research community. We present our major research groups focusing on the field, the software engineering problems most addressed by them, the search techniques most frequently used to solve these problems, and an analysis of our publications and collaboration. We could conclude that the Brazilian community is still expanding, both geographically and in terms of publications, and that the creation of a national workshop focusing on the research field was a keystone to allow this growth.

Guest editorial: Search-based software engineering

Search-based software engineering (SBSE) models complex software engineering problems as optimization problems, and uses metaheuristic search algorithms to solve these. SBSE has the potential to address the challenges posed by the growing size of complexity of modern computer systems, and has already been successfully applied to solve problems in nearly all software development life cycle phases. This special issue presents three articles demonstrating the versatility of SBSE by tackling three very different aspects of software engineering: Software module clustering, network optimisation, requirements for dynamic adaptive systems.

Detecting Return Value Mismatch during Component Adaptation with Concern of System Performance

Component adaptation becomes a critical problem in component-based software engineering (CBSE). This problem appears during assembling and reusing of components into new system. The interoperability among components needs to use adaptation technique to solve this problem. Usually, there are mismatches between interfaces of reusable components. This research will focus on detecting fully semantic component interface mismatch by proposing a solution including return value match next to other match such as operation name, method of operation and parameter type match. This research just explains return value mismatch that are not considered in other solutions. The proposed solution also concerns about system performance that is neglected in previous solutions by proposing a Detector tool that is responsible to assign and delete unwanted functions from reusable component before integration.

An experimental evaluation of the importance of randomness in hill climbing searches applied to software engineering problems

Random number generators are a core component of heuristic search algorithms. They are used to build candidate solutions and reduce bias while transforming these solutions during the search. Despit...

Special issue on realizing artificial intelligence synergies in software engineering

This special issue focuses on issues arising from the RAISE’12 Workshop on Realizing Artificial Intelligence Synergies in Software Engineering. Our objective is to provide a forum for researchers and industrial practitioners to exchange and discuss the latest innovative synergistic AI and SE techniques/practices. Why explore this combination of SE and AI? We think there are many answers to that question. As SE is asked to answer dynamic automated, adaptive, and/or large-scale demands, other computer science disciplines come to play. AI is one of them that may bring SE to further heights. Conversely, SE can also play a role to alleviate development costs and the development effort associated with AI tools. Such mutually beneficial characteristics have appeared in the past few decades and still evolve due to new challenges. That is, this special issue explores not only the application of AI techniques to software engineering problems but also the application of software engineering techniques to AI problems. This special issue is the result of much work that is still ongoing. As to future work, the RAISE series is also on-going. At the time of this writing, the RAISE’13 workshop has just completed (that event was sponsored by the United States National Science Foundation, and we thank them for their generous support). At that meeting, we saw much continued interest in this union of AI and SE. The reader should expect much novel and exciting work from this combination of ideas, in the very near future. And regarding the work seen to date, we hope that all the aforementioned papers will provide readers with some glimpse of the kind of work discussed at RAISE’12. Also, we would like to sincerely thank the reviewers for their assistance in the reviewing process.

Developing tools as plug‐ins: TOPI 2012 special issue

SUMMARYOur knowledge as to how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a preexisting development that can provide integration with existing elements such as compilers, debuggers, profilers, and visualizers as well as numerous other development and, often, runtime tools. However, building tools as plug‐ins can be challenging and raise many questions: How do they interact with the core environment? How do they interact with other existing plug‐ins, especially as each developer may choose a different set of plug‐ins. How can we share tools across different and future core development environments? How do we evaluate the usefulness of the tools? The series of workshops on Developing Tools as Plug‐ins (TOPI) tries to address these questions. Researchers are invited to present position papers spotting the medium‐term and long‐term challenges of developing tools as plug‐ins as well as research contributions identifying recent successful tools as plug‐ins, characteristics of good plug‐ins and reports of the main difficulties in implementing plug‐ins in current platforms. This issue includes extended versions of the best papers presented at TOPI 2012. Copyright © 2014 John Wiley & Sons, Ltd.

Optimize the Multi-Dimensional Test Coverage Based on Multiple Attribute Decision Making and Cross Entropy Method

With the scale and complexity of software increasing, people's awareness of software quality assurance has gradually strengthened. How to carry out the test, test scheme optimization selection and how to improve the testing efficiency become the reality problems in software engineering. Using the test coverage of the multidimensional metric, the effectiveness of comprehensive test coverage, test coverage rate of satisfaction and test efficiency as the optimization test scheme selection, use of multiple attribute decision making lifting scheme selection algorithm to measure the optimal test program, ameliorate the severity of the past subjective experience dependent, so as to provide guidance for reasonable, effective and scientific test. The optimization of comprehensive test coverage scheme is applied to the Markov model of software testing; software testing with the average cost minimization as objective, using the cross entropy method the optimal coverage testing section to optimize the test process.

Validation of Novel Approach to Detect Type Mismatch Problem Using Component Based Development

Adaptation software component is a crucial problem in component-based software engineering (CBSE). Components that assembled or reused sometimes cannot perfectly fit one another because of the incompatibility issues between them. The focus today is on finding adaptation technique, to solve the mismatch between component interfaces and to guarantee that the software components are able to interact in the right way. This paper will focus on detecting mismatch, which considers as an important step through adaptation process. We propose a solution to detect mismatch, by suggesting improvement in Symbolic Transition Systems that used in representing component interface, and synchronous vector algorithm to deal with parameters data type mismatch.

Introduction to the special issue on search based software engineering

The field of Search Based Software Engineering (SBSE) has grown around the need to find new ways of heuristically selecting solutions for software engineering problems. As software systems increase in size and complexity, we face an increasing number of tasks that are intractable to perform through manual or even automated exhaustive means. In essence, the potential solution spaces for these problems are very large and often exponential in nature. This includes tasks such as generating test cases to cover specific branches or lines of code, finding optimal sequences of program refactorings, and reverse engineering a program’s module structure. In SBSE, heuristic algorithms such as hill climbing, or meta-heuristic algorithms such as simulated annealing, tabu search, genetic algorithms, and ant colony optimisation are used to efficiently explore the solution space. They are guided by a f itness function, which is a measure of the quality of an individual solution. The idea is to converge on a solution that may not be optimal, but that is good enough. SBSE has been rapidly growing in its presence in the software engineering literature. According to the online SBSE repository,1 the annual number of publications in SBSE more than doubled between 2006 and 2010 (from 60 to almost 160). While this jump in the use of SBSE is an exciting development, the stochastic nature of these algorithms means that individual runs of an algorithm may not be indicative of its effectiveness. In order to obtain reliable data, and to be able to extrapolate results to valid and meaningful conclusions, it is essential to create carefully designed empirical evaluations. Experiments must include a well thought

Developing tools as plug‐ins: TOPI 2011 special issue editorial

SUMMARYOur knowledge of how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre‐existing integrated development environment (IDE). This approach allows integration with existing elements such as compilers, debuggers, profilers, visualizers, and numerous other development and, often, runtime tools. Tools and environments to increase software quality and productivity have always been an important aspect of software engineering. A plug‐in is a modern way for incrementally adding new tools into existing environments. However, building tools as plug‐ins can be challenging. How do they interact with the core environment? How do they interact with one another ‐ especially since each developer may choose a different set of plug‐ins? How can we share tools across different, and future, core development environments?

Study on Effective Classifier for Software Engineering Data Sets

A wide range of important software engineering problems need solutions that involve accurately predicting outcomes, such as the number of defects in a module, the estimated cost, or deciding the best software development process to use. Mathematically a classifier is a function that maps an N-dimensional attribute space to a discrete set of labels of the class variable. We proposed an effective classifier for software engineering data sets, the results show that the accurate predictions can have an enormous positive impact on reducing these problems and ensure projects’ successes.

Parameter tuning or default values? An empirical investigation in search-based software engineering

Many software engineering problems have been addressed with search algorithms. Search algorithms usually depend on several parameters (e.g., population size and crossover rate in genetic algorithms), and the choice of these parameters can have an impact on the performance of the algorithm. It has been formally proven in the No Free Lunch theorem that it is impossible to tune a search algorithm such that it will have optimal settings for all possible problems. So, how to properly set the parameters of a search algorithm for a given software engineering problem? In this paper, we carry out the largest empirical analysis so far on parameter tuning in search-based software engineering. More than one million experiments were carried out and statistically analyzed in the context of test data generation for object-oriented software using the EvoSuite tool. Results show that tuning does indeed have impact on the performance of a search algorithm. But, at least in the context of test data generation, it does not seem easy to find good settings that significantly outperform the “default” values suggested in the literature. This has very practical value for both researchers (e.g., when different techniques are compared) and practitioners. Using “default” values is a reasonable and justified choice, whereas parameter tuning is a long and expensive process that might or might not pay off in the end.