Software Engineering Activities Research Articles

A combined approach to optimize the test suite size in regression testing

Testing is an important software engineering activity which is widely used by testers to reveal faults and improve the quality of the software by omitting or removing the detected faults. After required subsequent modifications in the software, there is a need to re-validate the software at each release. During this, new test cases are to be added to the existing test suite to check the new functionality implemented in the release. Enhancement of the test suite results in obvious test suite size increment and may also contain redundant test cases. Because of time and resource limits, revalidating the improved software every possible time is so tedious and complex. So, it is advantageous to develop such mechanism that increases the coverage and diversity of test cases in a test suite to optimize the results of test suite minimization and prioritization. The proposed approach can be beneficial for testers to solve the regression testing problems.

Semantic topic models for source code analysis

Topic modeling techniques have been recently applied to analyze and model source code. Such techniques exploit the textual content of source code to provide automated support for several basic software engineering activities. Despite these advances, applications of topic modeling in software engineering are frequently suboptimal. This can be attributed to the fact that current state-of-the-art topic modeling techniques tend to be data intensive. However, the textual content of source code, embedded in its identifiers, comments, and string literals, tends to be sparse in nature. This prevents classical topic modeling techniques, typically used to model natural language texts, to generate proper models when applied to source code. Furthermore, the operational complexity and multi-parameter calibration often associated with conventional topic modeling techniques raise important concerns about their feasibility as data analysis models in software engineering. Motivated by these observations, in this paper we propose a novel approach for topic modeling designed for source code. The proposed approach exploits the basic assumptions of the cluster hypothesis and information theory to discover semantically coherent topics in software systems. Ten software systems from different application domains are used to empirically calibrate and configure the proposed approach. The usefulness of generated topics is empirically validated using human judgment. Furthermore, a case study that demonstrates thet operation of the proposed approach in analyzing code evolution is reported. The results show that our approach produces stable, more interpretable, and more expressive topics than classical topic modeling techniques without the necessity for extensive parameter calibration.

Exploration and Exploitation of Developers' Sentimental Variations in Software Engineering

Software development is highly dependent on human efforts and collaborations, which are immensely affected by emotions. This paper presents a quantitative empirical study of the emotional variations in different types of development activities (e.g., bug-fixing tasks), development periods (i.e., days and times) and in projects of different sizes involving teams of variant sizes. The study also includes an in-depth investigation of emotions' impacts on software artifacts (i.e., commit messages) and exploration of scopes for exploiting emotional variations in software engineering activities. This work is based on careful analyses of emotions in more than 490 thousand commit comments across 50 open-source projects. The findings from this work add to our understanding of the role of emotions in software development, and expose scopes for exploitation of emotional awareness in improved task assignments and collaborations.

An experimental replication on the effect of the practice of mindfulness in conceptual modeling performance

Context: Mindfulness is a meditation technique aimed to increase clearness of mind and awareness. In the 2013–2014 academic year, an experiment was carried out to test whether the practice of mindfulness during 4 weeks improved or not the conceptual modeling performance using UML class diagrams of 32 second–year students of Software Engineering at the University of Seville. Objective: An internal replication with some changes in the original design was performed in the first semester of the 2014–2015 academic year in order to confirm the insights provided by the original study and increase the confidence in its conclusions. The sample were 53 students with the same profile than in the original study. Method: Half the students (27 subjects) practiced mindfulness during 6 weeks, while the other half (26 subjects), i.e. the control group, received no treatment during that time. All the students developed two conceptual models using UML class diagrams from a transcript of an interview, one before and another after the 6 weeks of mindfulness sessions, and the results were compared in terms of conceptual modeling effectiveness and efficiency. Results: The results of both experiments were similar, showing that the practice of mindfulness significantly improves conceptual modeling efficiency. Regarding conceptual modeling effectiveness, an improvement is observed in practice, but the analysis shows that such improvement is not statistically significant. After a reanalysis of data, consistent results have also been obtained. Conclusion: After a replication that leads to the same conclusions as the original study, the adequacy of the original experiment is confirmed and the credibility of its results is increased. Thus, we can state that the practice of mindfulness can improve the efficiency of Software Engineering students in the development of conceptual models, although further experimentation is needed in order to confirm the results in other contexts and other Software Engineering activities different from conceptual modeling.

Lightweight Traceability for the Agile Architect

Although traceability information is vital to many software engineering activities, agile development approaches rarely use it because of the extra effort required. In this industry case study, the authors report the results of applying their lightweight semiautomated method that integrates traceability into software architecture developed with an agile process like Scrum.

Large-scale information retrieval in software engineering - an experience report from industrial application

Software Engineering activities are information intensive. Research proposes Information Retrieval (IR) techniques to support engineers in their daily tasks, such as establishing and maintaining traceability links, fault identification, and software maintenance. We describe an engineering task, test case selection, and illustrate our problem analysis and solution discovery process. The objective of the study is to gain an understanding of to what extent IR techniques (one potential solution) can be applied to test case selection and provide decision support in a large-scale, industrial setting. We analyze, in the context of the studied company, how test case selection is performed and design a series of experiments evaluating the performance of different IR techniques. Each experiment provides lessons learned from implementation, execution, and results, feeding to its successor. The three experiments led to the following observations: 1) there is a lack of research on scalable parameter optimization of IR techniques for software engineering problems; 2) scaling IR techniques to industry data is challenging, in particular for latent semantic analysis; 3) the IR context poses constraints on the empirical evaluation of IR techniques, requiring more research on developing valid statistical approaches. We believe that our experiences in conducting a series of IR experiments with industry grade data are valuable for peer researchers so that they can avoid the pitfalls that we have encountered. Furthermore, we identified challenges that need to be addressed in order to bridge the gap between laboratory IR experiments and real applications of IR in the industry.

Comparison of Design Models: A Systematic Mapping Study

Context: Model comparison plays a central role in many software engineering activities. However, a comprehensive understanding about the state-of-the-art is still required. Goal: This paper aims at classifying and performing a thematic analysis of the current literature. Method: For this, we have followed well-established empirical guidelines to define and perform a systematic mapping study. Results: Some studies (14 out of 40) provide generic model comparison techniques, rather than specific ones for UML diagrams. Conclusion: Fine-grained techniques are still required to support ever-present and complex model comparison tasks during the evolution of design models.

Can method data dependencies support the assessment of traceability between requirements and source code?

Requirements traceability benefits many software engineering activities, such as change impact analysis and risk assessment. However, these activities require complete and correct traceability links which is not trivial, making traceability assessment an important field of study. In recent years, requirements traceability research has focused on using call dependencies within source code to understand how code properties contribute to the implementation of a requirement and to assess whether traceability links are correct and complete. These approaches largely ignore the role of existing data dependencies within the source code. That is, methods may never call each other, but may still depend upon another by sharing data. We identified five research questions and validated them on five software systems, covering 4 to 72 KLOC. We found that data dependencies are as relevant as call dependencies for assessing requirements traceability. Even more interesting, our analyses show that data dependencies complement call dependencies in the assessment. These findings have strong implications on code understanding, including trace capture, maintenance, and validation techniques. Copyright © 2015 John Wiley & Sons, Ltd.

Green cloud computing: reduced overload with a better architecture

Software systems architects had been continually facing challenges of scaling up software systems architectures. Scaling up the architectures to meet these needs certainly introduces additional energy cost. Improvement of applications, algorithms, energy efficient hardware has been done to achieve energy efficiency. Reducing the energy demands in such architectures is always challenging. The greatest environmental challenge today is e-wastes and energy crisis, bringing green computing in the limelight. Green computing requires algorithms and mechanisms to be redesigned for energy efficiency. In accordance to the state of art for distributed software architectures, are not aware on green cloud computing while the implementation needs, changing the whole infrastructure cost effectively. Software architectures don’t provide the primitives for reasoning and managing power consumption. In present work, an energy efficient resource management system for virtualized Cloud data centers that reduces operational costs and provides required Quality of Service (QoS) has been proposed and fulfilled. Our proposal towards software engineering demands to be green aware, where the software engineering and design activities should not only be judged by their technical merits, but also by their contributions to energy savings. In particular, the software system architecture seems to be adequate to address green-aware concerns but need revival. Software architectures should be green-aware, providing power management mechanisms as part of the architecture. The results of present work improvised that the proposed technique brings substantial energy savings, while ensuring reliable QoS. This justifies further investigation and development of the proposed resource management system.

Introduction to the special issue on software maintenance and evolution research

The past decade has seen tremendous changes in the landscape of software engineering activities in industry and of software engineering research topics in academia. Software engineering activities used to be mostly “hidden” behind the closed doors of software industries. In the 1990’s, the emergence of the open-source development model and movement revolutionized software development but also software engineering research. Nowadays, open-source software (OSS) development has become a major source of new libraries and programs, and more and more industries either use OSS or even release OSS themselves. Even large corporations, in which trade secrets were the norm, now consider releasing their source code as open-source, for example Microsoft with its Windows operating system (http://arstechnica.com/information-technology/2015/ 04/open-source-windows-is-definitely-possible-but-dont-hold-your-breath/). The open-source revolution gave rise to the development of many collaborative development tools, including distributed version control systems (such as Git and its popular Web platforms GitHub and BitBucket), issue trackers (such as Bugzilla), and continuous integration tools (such as Travis). These tools now depend on one another, leading to the creation of so-called software ecosystems, sets of programs and libraries relying on one another. These ecosystems further feed the dependence on, and development of, OSS.

Empirical investigation of SEA-based dependence cluster properties

Dependence clusters are (maximal) groups of source code entities that each depend on the other according to some dependence relation. Such clusters are generally seen as detrimental to many software engineering activities, but their formation and overall structure are not well understood yet. In a set of subject programs from moderate to large sizes, we observed frequent occurrence of dependence clusters using Static Execute After (SEA) dependences (SEA is a conservative yet efficiently computable dependence relation on program procedures). We identified potential linchpins; these are procedures that can primarily be made responsible for keeping the cluster together. Furthermore, we found that as the size of the system increases, it is more likely that multiple procedures are jointly responsible as sets of linchpins. We also give a heuristic method based on structural metrics for locating possible linchpins as their exact identification is unfeasible in practice, and presently there are no better ways than the brute-force method. We defined novel metrics to be able to uncover clusters of different sizes in programs, and also to relate programs in terms of their degree of clusterization. Finally, we present a possible application of SEA-based dependences in change impact analysis, and investigate the effect of dependence clusters on the successfulness of this activity.

Software Engineering Challenges in Multi Platform Mobile Application Development

Mobile application development for smart phones has been increasing in last years as mobile phones have become an essential part of our contemporary life. As with any new phenomena, mobile application development has its own set of challenges, which attracted interested researchers in this new field. Nowadays, mobile applications become more complex, moving beyond inexpensive entertaining applications to more business critical uses, thus, it becomes essential to apply software engineering process to assure the development of secure, high-quality mobile applications. This paper highlights important issues in mobile application development using native development kits and cross-platform frameworks; it also discusses challenges in the software engineering activities for mobile applications development.

Automated end user-centred adaptation of web components through automated description logic-based reasoning

ContextThis paper addresses one of the major end-user development (EUD) challenges, namely, how to pack today’s EUD support tools with composable elements. This would give end users better access to more components which they can use to build a solution tailored to their own needs. The success of later end-user software engineering (EUSE) activities largely depends on how many components each tool has and how adaptable components are to multiple problem domains. ObjectiveA system for automatically adapting heterogeneous components to a common development environment would offer a sizeable saving of time and resources within the EUD support tool construction process. This paper presents an automated adaptation system for transforming EUD components to a standard format. MethodThis system is based on the use of description logic. Based on a generic UML2 data model, this description logic is able to check whether an end-user component can be transformed to this modelling language through subsumption or as an instance of the UML2 model. Besides it automatically finds a consistent, non-ambiguous and finite set of XSLT mappings to automatically prepare data in order to leverage the component as part of a tool that conforms to the target UML2 component model. ResultsThe proposed system has been successfully applied to components from four prominent EUD tools. These components were automatically converted to a standard format. In order to validate the proposed system, rich internet applications (RIA) used as an operational support system for operators at a large services company were developed using automatically adapted standard format components. These RIAs would be impossible to develop using each EUD tool separately. ConclusionThe positive results of applying our system for automatically adapting components from current tool catalogues are indicative of the system’s effectiveness. Use of this system could foster the growth of web EUD component catalogues, leveraging a vast ecosystem of user-centred SaaS to further current EUSE trends.

SOFTWARE PROCESS MATURITY AND CAPABILITY EVALUATION AND ITS IMPLEMENTATION IN THE AREAS OF E-LEARNING ORGANIZATIONS

A detailed literature review revealed that, most of the organizations develop their projects and associated software engineering activities using in-house established methods. There are discrete references in the literature on application of broad based scientific methods in designing and developing process capability and maturity models by software organizations. Documentation and extent of adherence to a well defined organized scientific method plays a major role in standardizing the systems. Capability Maturity Model Integration (CMMI) is a recognized model for providing process maturity and capability in managing the software engineering activities. Further, the area of development of process models for optimization and implementation of thrust areas were not given due attention by researchers. To address above issues, we made an attempt in this study (i) to review the extent to which software organization make use of software process capability models, (ii) to develop an organized software process modeling and (iii) to evaluate its performance through a case study conducted in an IT industry developing E-learning maturity models and to arrive at optimized model for E-Learning thrust areas. The basis for above work is drawn by comparing the existing methods and tools used, with international models. The major contribution of present work is that, the proposed process capability model will enable organizations to follow broad based scientific methods for pre modeling their software activities and will also enable them to form levels that result in bench mark approach for E-Learning modules.

Suitability of KNN Regression in the Development of Interaction based Software Fault Prediction Models

Accurate fault prediction is an indispensable step, to the extent of being a critical activity in software engineering. In fault prediction model development research, combination of metrics significantly improves the prediction capability of the model, but it also gives rise to the issue of handling an increased number of predictors and evolved nonlinearity due to complex interaction among metrics.Ordinary least square (OLS) based parametric regression techniques cannot effectively model such nonlinearity with a large number of predictors because the global parametric function to fit the data is not known beforehand. In our previous studies[1–3], we showed the impact of interaction in the combined metrics approach of fault prediction and statistically established the simultaneous increment in the predictive accuracy of the model with interaction.In this study we use K-Nearest Neighbor (KNN) regression as an example of nonparametric regression technique, otherwise well known for classification tasks in the data mining community. Through the results derived here, we empirically establish and validate the hypothesis that the performance of KNN regression remains ordinarily unaffected with increasing number of interacting predictors and simultaneously provides superior performance over widely used multiple linear regression (MLR).

设计模式指导的软件分簇方法

Program comprehension is the process of achieving knowledge information from computer program. It aims to gain all the information from the program in order to understand the intention of the developers so as to support reviewing, defect localization, reverse-engineering, re-engineering, porting, maintenance, reuse and other software engineering activities of existing or legacy systems. This paper proposes a design pattern directed software clustering approach to support program comprehension, which employs design pattern information hidden in programs to direct software clustering processes, helping program developers and maintainers rapidly and conveniently comprehend open source code using the divide and conquer strategy. Firstly, we utilize existing design pattern detection techniques to identify design pattern information from source code. Then, we direct software clustering using the identi ed design pattern information based on the inter-role relationship among design pattern roles. Last, we visualize clustering result to support program understanding. We also developed a prototype tool, TasteJ, and conducted controlled human subject experiments. The results of our experiments demonstrate the feasibility of our approach.

Generic and standard database constraint meta-models

Many software engineering activities entail dealing with legacy information systems. When these systems become too costly to maintain, or when new technologies need to be incorporated, they need to be replaced or somehow reengineered. This can be done with significantly reduced amount of effort and cost if the conceptual models of these systems are available. Reverse engineering is the process of analyzing a subject system to create representations of the system at a higher level of abstraction. Relational databases are a common source of reverse engineering. Starting from a physical database schema, that is recorded into relational database schema data repository, the conceptual database schema or logical database schema could be extracted. The extraction process may be seen as a chain of model-to-model transformations that trace model elements from a model at the lower level of abstraction to a model at the higher level of abstraction, achieved through meta-modeling. In the paper we present generic and standard database constraint meta-models, focusing on multi-relational database constraints captured in a legacy database. These meta-models are aimed at support of model transformations to create conceptual models, as a useful source for the system reengineering process.

Bridging the Gap between Systems and Software Engineering by Using the SPES Modeling Framework as a General Systems Engineering Philosophy

A multitude of disciplines is involved in the engineering of embedded systems. One major challenge of engineering these systems is to consider the synchronization between different engineering disciplines on the process and artifact level in a coherent manner. Process standards address this challenge by defining a transition between the involved activities of the disciplines but they do not provide sufficient support with respect to the corresponding artifacts and their relationships. The missing artifact-oriented integration of the engineering disciplines (e.g. electrical engineering, software engineering, and mechanical engineering) within the systems engineering process leads to error-prone and cost-intensive synchronizations. In recent years, we participate in a consortium of more than twenty partners from academia and industry that jointly developed the SPES (Software Platform Embedded Systems) Modeling Framework (SPES MF) to support a seamless artifact-based engineering of software for embedded systems. In this paper, we present an approach that fosters the close integration of systems engineering and software engineering activities based on ISO/IEC 15288 and ISO/IEC 12207, by using the core concepts of the SPES MF as a general engineering philosophy for the architectural design of embedded systems.

Tag recommendation for open source software

Nowadays open source software becomes highly popular and is of great importance for most software engineering activities. To facilitate software organization and retrieval, tagging is extensively used in open source communities. However, finding the desired software through tags in these communities such as Freecode and ohloh is still challenging because of tag insufficiency. In this paper, we propose TRG (tag recommendation based on semantic graph), a novel approach to discovering and enriching tags of open source software. Firstly, we propose a semantic graph to model the semantic correlations between tags and the words in software descriptions. Then based on the graph, we design an effective algorithm to recommend tags for software. With comprehensive experiments on large-scale open source software datasets by comparing with several typical related works, we demonstrate the effectiveness and efficiency of our method in recommending proper tags.

Comparing text‐based and dependence‐based approaches for determining the origins of bugs

SUMMARYIdentifying bug origins – the point where erroneous code was introduced – is crucial for many software engineering activities, from identifying process weaknesses to gathering data to support bug detection tools. Unfortunately, this information is not usually recorded when fixing bugs, and recovering it later is challenging. Recently, the text approach and the dependence approach have been developed to tackle this problem. Respectively, they examine textual and dependence‐related changes that occurred prior to a bug fix. However, only limited evaluation has been carried out, partially because of a lack of available implementations and of datasets linking bugs to origins. To address this, origins of 174 bugs in three projects were manually identified and compared to a simulation of the approaches. Both approaches were partially successful across a variety of bugs – achieving 29–79% precision and 40–70% recall. Results suggested the precise definition of program dependence could affect performance, as could whether the approaches identified a single or multiple origins. Some potential improvements are explored in detail and identify pragmatic strategies for combining techniques along with simple modifications. Even after adopting these improvements, there remain many challenges: large commits, unrelated changes and long periods between origins and fixes all reduce effectiveness. Copyright © 2013 John Wiley & Sons, Ltd.