Software Engineering Techniques Research Articles

Software Engineering for Smart Cyber-Physical Systems -- Towards a Research Agenda

Cyber-Physical Systems (CPS) are large interconnected softwareintensive systems that influence, by sensing and actuating, the physical world. Examples are traffic management and power grids. One of the trends we observe is the need to endow such systems with the "smart" capabilities, typically in the form of selfawareness and self-adaptation, along with the traditional qualities of safety and dependability. These requirements combined with specifics of the domain of smart CPS -- such as large scale, the role of end-users, uncertainty, and open-endedness -- render traditional software engineering (SE) techniques not directly applicable; making systematic SE of smart CPS a challenging task. This paper reports on the results of the First International Workshop on Software Engineering of Smart Cyber-Physical Systems (SEsCPS 2015), where participants discussed characteristics, challenges and opportunities of SE for smart CPS, with the aim to outline an agenda for future research in this important area.

Cross-factor analysis of software engineering practices versus practitioner demographics: An exploratory study in Turkey

ContextUnderstanding the types of software engineering practices and techniques used in the industry is important. There is a wide spectrum in terms of the types and maturity of software engineering practices conducted in each software team and company. Furthermore, it is important to understand the cross-factor relationship of software engineering practices and practitioner demographics including their companies and projects, e.g., is it the case that practitioners developing software for sectors such as military would utilize software size measurement approaches more, or use different software development methodologies, compared to practitioners developing software for other sectors?, and what kinds of practices are conducted by practitioners in small versus large companies? ObjectiveOur objective is to get an understanding into the cross-factor correlation of various software engineering practices versus practitioner demographics including their companies and projects (e.g., target industry, size and work experience). Such an understanding will enable us to identify patterns and pinpoint special issues which should be studied and addressed in the context of each specific demographic (e.g., small versus large companies). Thus, we decided to conduct an exploratory study in this area and collected real industrial data in the context of Turkey which has a vibrant software industry. MethodTo achieve the above objective, we use the data from a recent Turkish-wide survey of software engineering practices which was systematically designed with 46 questions based on our past experience in the Canadian context and using the Software Engineering Body of Knowledge (SWEBOK). 202 practicing software engineers participated in the survey. We raise a set of 12 research questions about the cross-factor correlation of software engineering practices and practitioner demographics, and address them using statistical analysis. ResultsThe exploratory study results reveal important and interesting findings about cross-factor relationship of software engineering practices and practitioner demographics. Among some of the most interesting findings are the followings: (1) By analyzing the trends, we were first surprised to see that as a practitioner gets more years of work experience, against what one would expect, s/he experiences more challenges in Software Development Life-Cycle (SDLC) phases and SE tasks; (2) Almost 55% of participants measure software size; (3) Agile/lean development is used the least (16%) by the participants working in the companies serving the military and defense sector; (4) Usage of waterfall is low among participants employed by small-sized companies whereas Agile/lean development is relatively popular among this class of participants; and (5) As company size increases, usage of spiral development slightly increases, whereas usage of extreme programming practices decreases. ConclusionThe results of this exploratory study will be useful to software engineering professionals and researchers both in Turkey and world-wide by revealing the cross-factor relationship of software engineering practices versus practitioner demographics. The study raises several new research directions, e.g., (1) Why are not many practitioners using any size nor project estimation metrics and how these fundamental engineering approaches could be utilized more frequently?, (2) What are the best practices, success stories and challenging experiences in using SE tools?, and (3) Why is Agile/lean development is not popular in the military and defense sector and how these approaches could be utilized more frequently.

Engineering requirements for adaptive systems

The increasing demand for complex and distributed software calls for novel software engineering methods and techniques, to create systems able to autonomously adapt to dynamically changing situations. In this paper, we present a framework for engineering requirements for adaptive software systems. The approach, called Tropos4AS, combines goal-oriented concepts and high-variability design methods. The Tropos4AS requirements model can be directly mapped to software prototypes with an agent-oriented architecture which can be executed for requirements validation and refinement. We give a comprehensive description of the framework, with conceptual models, modelling guidelines, and supporting tools. The applicability of the framework to requirements validation and refinement is illustrated through a case study. Two controlled experiments with subjects provide an empirical evaluation of the proposed modelling language, with statistical evidence of the effectiveness of the modelling approach for gathering requirements of adaptive systems.

Special section on the 17th International Software Product Line Conference

Today, companies develop, maintain and deploy families of similar software products (e.g., games for different models of smartphones) rather than a single product. Software product lines engineering refers to software engineering methods, tools and techniques for creating a collection of similar software systems from a shared set of software assets using a common means of production. Software Product Line Conferences started in 1996, as the premier forum for practitioners, researchers and educators to present and discuss the most recent ideas, innovations, trends, experiences, and concerns in the area of software product lines, software product family engineering and, more recently, systems family engineering, managing families of software products as a whole rather than each family member individually. This special section stems from the 17th SPL Conference held in Tokyo, Japan, in August 2013. The contributions to this special section are further elaborations of the papers presented at the conference.

A survey of software engineering practices in Turkey

Understanding the types of software engineering (SE) practices and techniques used in industry is important. There is a wide spectrum in terms of the types and maturity of SE practices conducted in industry. Turkey has a vibrant software industry and it is important to characterize and understand the state of its SE practices. Our objective is to characterize and grasp a high-level view on type of SE practices in the Turkish software industry. To achieve this objective, we systematically designed an online survey with 46 questions based on our past experience in the Canadian and Turkish contexts and using the Software Engineering Body of Knowledge (SWEBOK). Two hundred and two practicing software engineers from the Turkish software industry participated in the survey. The survey results reveal important and interesting findings about SE practices in Turkey and beyond. They also help track the profession of SE, and suggest areas for improved training, education and research. Among the findings are the followings: (1) The military and defense software sectors are quite prominent in Turkey, especially in the capital Ankara region, and many SE practitioners work for those companies. (2) 54% of the participants reported not using any software size measurement methods, while 33% mentioned that they have measured lines of code (LOC). (3) In terms of effort, after the development phase (on average, 31% of overall project effort), software testing, requirements, design and maintenance phases come next and have similar average values (14%, 12%, 12% and 11% respectively). (4) Respondents experience the most challenge in the requirements phase. (5) Waterfall, as a rather old but still widely used lifecycle model, is the model that more than half of the respondents (53%) use. The next most preferred lifecycle models are incremental and Agile/lean development models with usage rates of 38% and 34%, respectively. (6) The Waterfall and Agile methodologies have slight negative correlations, denoting that if one is used in a company, the other will less likely to be used. The results of our survey will be of interest to SE professionals both in Turkey and world-wide. It will also benefit researchers in observing the latest trends in SE industry identifying the areas of strength and weakness, which would then hopefully encourage further industry–academia collaborations in those areas.

Review on Reverse Engineering Techniques of Software Engineering

Reverse Engineering is an approach to extract requirement information application from XML at higher level of abstraction. In the present study XML to UML transformation methods has been explored and discussed along with some other related work in reverse engineering. A brief review of reverse engineering shows that the transformation results of XML to UML are beneficial for developer. However it does not show changes as per the requirements view. Generation of Natural Language specifications from UML class diagrams is also discussed where results were found encouraging and feasible. All related work of reverse engineering of XML and Natural language specification from UML is clear but a lot of work is to be done to solve real world problems satisfactorily. Capability of different reverse engineering tools is also discussed. Automatic code generation using UML to XML schema transformation is reviewed which shows that it can reduce the time and efforts of coding.

Embedding, Evolution, and Validation of Model-Driven Spreadsheets

This paper proposes and validates a model-driven software engineering technique for spreadsheets. The technique that we envision builds on the embedding of spreadsheet models under a widely used spreadsheet system. This means that we enable the creation and evolution of spreadsheet models under a spreadsheet system. More precisely, we embed ClassSheets, a visual language with a syntax similar to the one offered by common spreadsheets, that was created with the aim of specifying spreadsheets. Our embedding allows models and their conforming instances to be developed under the same environment. In practice, this convenient environment enhances evolution steps at the model level while the corresponding instance is automatically co-evolved. Finally, we have designed and conducted an empirical study with human users in order to assess our technique in production environments. The results of this study are promising and suggest that productivity gains are realizable under our model-driven spreadsheet development setting.

Use Case Application in Requirements Analysis using Secure Tropos to UMLsec - Security Issues

Information Systems Security is one of the most critical challenges presently facing nearly every one of the organizations. However, making certain security and quality in both information and the systems which control information is a difficult goal necessitating the mixture of two wide research disciplines which are typically separate: security engineering and secure software engineering. Security engineering has an extensive history, and has focused generally on providing advances in security models, techniques and protocols, but it remains in a steady state of the development. Secure software engineering, however, has emerged relatively recently, but is growing quickly and is paying attention on the integration of security into software engineering techniques; models and processes, in order to build up more secure information systems.The main aim of this paper is to show the requirements analysis using Secure Tropos to Umlsec. Secure tropos is a security oriented extension of tropos methodology and UMLsec is a security oriented extension of standard UML model. To do this we identify different transformation rules and we apply these rules by identifying different steps. We use kent Modeling Transformation Language as a Transformation Language to transform the secure tropos model to UMLsec model and then finally we use a case study to exemplify these rules.

A located and user personalized event's dissemination platform

Ambient Intelligence has emerged lately as the integrating concept which includes Ubiquitous Computing, Ubiquitous Communication and Intelligent User Interfaces. The real implementation of such concepts is based on the use of new technology and innovative ways of development. Agent Oriented Software Engineering techniques and concepts have been used as a way of providing support to ubiquitous computing and communication. In addition, intelligent user interfaces require systems that provide a more efficient and rich interface with the user than the traditional ones. This paper presents a platform called MAPAS, which uses Ambient Intelligence concepts and techniques to give a fully scalable solution to a particular problem. The chosen system provides a solution, using the platform, to personalize the dissemination of events, that is, the system makes available to the user a set of events of his/her interest. This kind of systems requires a high degree of user's personalization. However nowadays, it is the user who must search the events of interest or subscribe to several different services or pages. The platform introduced in this paper takes profit of Agent Oriented technology to provide a system composed of various agents who may run in different devices, which communicate and provide a user personalized selection of events. Moreover, the system is aware of the surrounding environment, can be installed on smart devices, provides a rich and intuitive user interface and uses Augmented Reality techniques to give spatial location data about the events. Regarding the characteristics of the solution, it seems to be suitable for problems in the domain of Ambient Intelligence.

A framework for software process deployment and evaluation

ContextSoftware Process Engineering promotes the systematic production of software by following a set of well-defined technical and management processes. A comprehensive management of these processes involves the accomplishment of a number of activities such as model design, verification, validation, deployment and evaluation. However, the deployment and evaluation activities need more research efforts in order to achieve greater automation. ObjectiveWith the aim of minimizing the required time to adapt the tools at the beginning of each new project and reducing the complexity of the construction of mechanisms for automated evaluation, the Software Process Deployment & Evaluation Framework (SPDEF) has been elaborated and is described in this paper. MethodThe proposed framework is based on the application of well-known techniques in Software Engineering, such as Model Driven Engineering and Information Integration through Linked Open Data. It comprises a systematic method for the deployment and evaluation, a number of models and relationships between models, and some software tools. ResultsAutomated deployment of the OpenUP methodology is tested through the application of the SPDEF framework and support tools to enable the automated quality assessment of software development or maintenance projects. ConclusionsMaking use of the method and the software components developed in the context of the proposed framework, the alignment between the definition of the processes and the supporting tools is improved, while the existing complexity is reduced when it comes to automating the quality evaluation of software processes.

Investigating the effect of “defect co-fix” on quality assurance resource allocation: A search-based approach

Allocation of resources to pre-release quality assurance (QA) tasks, such as source code analysis, peer review, and testing, is one of the challenges faced by a software project manager. The goal is to find as many defects as possible with the available QA resources prior to the release. This can be achieved by assigning more resources to the more defect-prone artifacts, e.g., components, classes, and methods. The state-of-the-art QA resource allocation approaches predict the defect-proneness of an artifact using the historical data of different software metrics, e.g., the number of previous defects and the changes in the artifact. Given a QA budget, an allocation technique selects the most defect-prone artifacts, for further investigation by the QA team. While there has been many research efforts on discovering more predictive software metrics and more effective defect prediction algorithms, the cost-effectiveness of the QA resource allocation approaches has always been evaluated by counting the number of defects per selected artifact. The problem with such an evaluation approach is that it ignores the fact that, in practice, fixing a software issue is not bounded to an artifact under investigation. In other words, one may start reviewing a file that is identified as defect-prone and detect a defect, but to fix the defect one may modify not only the defective part of the file under review, but also several other artifacts that are somehow related to the defective code (e.g., a method that calls the defective code). Such co-fixes (fixing several defects together) during analyzing/reviewing/testing of an artifact under investigation will change the number of remaining defects in the other artifacts. Therefore, a QA resource allocation approach is more effective if it prioritizes the artifacts that would lead to the smallest number of remaining defects. Investigating six medium-to-large releases of open source systems (Mylyn, Eclipse, and NetBeans, two releases each), we found that co-fixes happen quite often in software projects (30–42% of the fixes modify more than one artifact). Therefore, in this paper, we first introduce a new cost-effectiveness measure to evaluate QA resource allocation, based on the concept of “remaining defects” per file. We then propose several co-fix-aware prioritization approaches to dynamically optimize the new measure, based on the historical defect co-fixes. The evaluation of these approaches on the six releases shows that (a) co-fix-aware QA prioritization approaches improve the traditional defect prediction-based ones, in terms of density of remaining defects per file and (b) co-fix-aware QA prioritization can potentially benefit from search-based software engineering techniques.

A COMPLEX NETWORKS PERSPECTIVE ON COLLABORATIVE SOFTWARE ENGINEERING

Large collaborative software engineering projects are interesting examples for evolving complex systems. The complexity of these systems unfolds both in evolving software structures, as well as in the social dynamics and organization of development teams. Due to the adoption of Open Source practices and the increasing use of online support infrastructures, large-scale data sets covering both the social and technical dimension of collaborative software engineering processes are increasingly becoming available. In the analysis of these data, a growing number of studies employ a network perspective, using methods and abstractions from network science to generate insights about software engineering processes. Featuring a collection of inspiring works in this area, with this topical issue, we intend to give an overview of state-of-the-art research. We hope that this collection of articles will stimulate downstream applications of network-based data mining techniques in empirical software engineering.

Automatic construction of Fuzzy Inference Systems for computerized clinical guidelines and protocols

Clinical guidelines and protocols (CGPs) are standard documents with the aim of helping practitioners in their daily work. Their computerization has received much attention in recent years, but it still presents some problems, mainly due to the low sustainability and low adaptability to changes (both in knowledge and technology) of the computerized CGPs. This paper presents an approach to an easy and automatic creation of Fuzzy Inference Systems (FISs), which are suitable for the computerized interpretation of differential diagnoses. The proposed FIS development process is based on applying Model-Driven Software Engineering techniques: automatic generation of computer artefacts and separation of concerns. The process focuses on the separation of roles during the design stage: domain experts use a basic editor that allows them to define the categories and factors that will be involved in the FIS in natural language, while knowledge engineers at a later stage refine these elements using a more advanced editor. The whole system has been tested by automatically generating two FISs that have been included in a computerized CGP for the diagnosis of a rare disease called hyperammonemia. This CGP has been validated and it is currently in use.

Minimac2: faster genotype imputation.

Genotype imputation is a key step in the analysis of genome-wide association studies. Upcoming very large reference panels, such as those from The 1000 Genomes Project and the Haplotype Consortium, will improve imputation quality of rare and less common variants, but will also increase the computational burden. Here, we demonstrate how the application of software engineering techniques can help to keep imputation broadly accessible. Overall, these improvements speed up imputation by an order of magnitude compared with our previous implementation. minimac2, including source code, documentation, and examples is available at http://genome.sph.umich.edu/wiki/Minimac2

Applying software engineering techniques in the development and management of linear and integer programming applications

AbstractThis work addresses characteristics of software environments for mathematical modeling and proposes a system for developing and managing models of linear and integer programming (IP) problems. The main features of this modeling environment are: version control of models and data; client‐server architecture, which allows the interaction among modelers and decision makers; the use of a database to store information about the models and data scenarios; and the use of remote servers of optimization, which allows the optimization problems to be solved on different machines. The modeling environment proposed in this work was validated using mathematical programming models that exploit different characteristics, such as the treatment of conditions for generating variables and constraints, the use of calculated parameters derived from other parameters, and the use of integer and continuous variables in mixed IP models among others. This validation showed that the proposed environment is able to treat models found in various application areas of operations research and to solve problems with tens of thousands of variables and constraints.

An Analytical Security Model for Existing Software Systems

Nowadays, evaluation of software security, as one of the important quality attributes, is of paramount importance. There are many software systems have not considered security in their design; this makes them vulnerable to security risks. Architecture is the most important consideration in software design that affects final quality of software. Quality attributes such as efficiency and reliability have been studied at software architecture level; however, no report has ever been provided about the effect of software architecture on security. The purpose of this paper is to propose a mathematical-based method for evaluating and quantifying software security using the coupling aspects of the software architecture. To achieve this go al, first, we show the relationship between coupling types and vulnerability using an empirical-based software engineering technique that adopts Mozilla Firefox Browser vulnerability data. Then, we propose a mathematical weighted relationship between coupling types and vulnerability, where regression statistical analysis and Mozilla Firefox vulnerability data are used to predicate the relationship coeffi cients. Finally, we extract software architecture using DAGC tool and then convert the extracted architecture into Discrete Time Markov chains, which are used to predict and compute the system over all vulnerability.

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.

Development and Specification of a Reference Architecture for Agent-Based Systems

The recent growth of agent-based software systems was achieved without the development of a reference architecture. From a software engineering standpoint, a reference architecture is necessary to compare, evaluate, and integrate past, current, and future agent-based software systems. The agent systems reference architecture (ASRA) advances the agent-based system development process by providing a set of key interaction patterns for functional areas that exist between the layers and protocols of agent-based systems. Furthermore, the ASRA identifies the points for interoperability between agent-based systems and increases the level of discussion when referring to agent-based systems. This paper presents methodology, grounded in software forensics, to develop the ASRA and provides an overview of the resulting architectural representation. The methodology uses an approach based on software engineering techniques adapted to study agent frameworks-the libraries and tools for building agent systems. The resulting ASRA can serve as an abstract representation of the components necessary for facilitating comparison, integration, and interoperation of software systems composed of agents.

DEVELOPING CORE SOFTWARE REQUIREMENTS OF ENERGY MANAGEMENT SYSTEM FOR SMART CAMPUS WITH ADVANCED SOFTWARE ENGINEERING

Higher educational institutions such as universities provide campus data and information to stakeholders such as students, faculty staff, administrators, media, and community members. They also analyze such data and information for decision making, planning and continuous improvement. They obtain necessary capabilities for collecting, providing and analyzing data and information by acquiring products and services from suppliers or by developing products and services by themselves. As in today’s social infrastructure, software plays an important role and software seems to keep growing in its scope, size and complexity in infrastructure of educational institutions. However, many organizations have not invested in the capabilities necessary to effectively manage life-cycle process for such software products and services. We argue that software engineering techniques, such as process improvement framework and software product line engineering are important in developing requirements and systems effective in continuous improvement. In this paper, we discuss a trial case to improve the energy management system in our campus, as an emerging area of institutional continuous improvement, by using software engineering techniques under the goal of increasing the awareness and involvement of members for smart energy management.

Amalgamation of Personal Software Process in Software Development Practice

Today, concern for quality has become an international movement. Eventhough most industrial organizations have now adopted modern qualityprinciples, the software community has continued to rely on testing as theprincipal quality management method. Different decades have different trends in software engineering. The Personal Software Process (PSP) is anevolutionary series of personal software engineering techniques that an engineer learns and practices. A software process is nothing without theindividual programmer. PSP a data driven process customized to teaching individuals about their programming styles, helping software engineers further develop their skills in developing quality software. Apart from discussing about PSP as a framework of techniques to help engineers and their organizations to improve their performance while simultaneously increasing product quality, in this paper, the Personal Software Process definition, principles, design, advantages and opportunities are explained focusing on the incorporation of PSP concepts in software development practice.