Facilitate Software Development Research Articles

Introduction to the Special Issue on “International Conference on Software Reuse 2015”

Conducting requirements reviews before the start of software design is one of the central goals in requirements management. Fast and accurate reviews promise to facilitate software development process and mitigate technical risks of late design modifications. In large software development companies, however, it is difficult to conduct reviews as fast as needed, because the number of regularly incoming requirements is typically several thousand. Manually reviewing thousands of requirements is a time-consuming task and disrupts the process of continuous software development. As a consequence, software engineers review requirements in parallel with designing the software, thus partially accepting the technical risks. In this paper we present a measurement-based method for automating requirements reviews in large software development companies. The method, Rendex, is developed in an action research project in a large software development organization and evaluated in four large companies. The evaluation shows that the assessment results of Rendex have 73%-80% agreement with the manual assessment results of software engineers. Succeeding the evaluation, Rendex was integrated with the requirements management environment in two of the collaborating companies and is regularly used for proactive reviews of requirements.

Rendex: A method for automated reviews of textual requirements

Abstract Conducting requirements reviews before the start of software design is one of the central goals in requirements management. Fast and accurate reviews promise to facilitate software development process and mitigate technical risks of late design modifications. In large software development companies, however, it is difficult to conduct reviews as fast as needed, because the number of regularly incoming requirements is typically several thousand. Manually reviewing thousands of requirements is a time-consuming task and disrupts the process of continuous software development. As a consequence, software engineers review requirements in parallel with designing the software, thus partially accepting the technical risks. In this paper we present a measurement-based method for automating requirements reviews in large software development companies. The method, Rendex, is developed in an action research project in a large software development organization and evaluated in four large companies. The evaluation shows that the assessment results of Rendex have 73%-80% agreement with the manual assessment results of software engineers. Succeeding the evaluation, Rendex was integrated with the requirements management environment in two of the collaborating companies and is regularly used for proactive reviews of requirements.

Multi-amalgamated triple graph grammars: Formal foundation and application to visual language translation

Visual languages (VLs) facilitate software development by not only supporting communication and abstraction, but also by generating various artifacts such as code and reports from the same high-level specification. VLs are thus often translated to other formalisms, in most cases with bidirectionality as a crucial requirement to, e.g., support re-engineering of software systems. Triple Graph Grammars (TGGs) are a rule-based language to specify consistency relations between two (visual) languages from which bidirectional translators are automatically derived. TGGs are formally founded but are also limited in expressiveness, i.e., not all types of consistency can be specified with TGGs. In particular, 1-to-n correspondence between elements depending on concrete input models cannot be described. In other words, a universal quantifier over certain parts of a TGG rule is missing to generalize consistency to arbitrary size. To overcome this, we transfer the well-known multi-amalgamation concept from algebraic graph transformation to TGGs, allowing us to mark certain parts of rules as repeated depending on the translation context. Our main contribution is to derive TGG-based translators that comply with this extension. Furthermore, we identify bad smells on the usage of multi-amalgamation in TGGs, prove that multi-amalgamation increases the expressiveness of TGGs, and evaluate our tool support.

An analysis of tools for automatic software development and automatic code generation

Software development is an important area in software engineering, which is why a wide range of techniques, methods, and approaches has emerged to facilitate software development automation. This paper presents an analysis and evaluation of tools for automated software development and automatic code generation in order to determine whether they meet a set of quality metrics. Diverse quality metrics were considered such as effectiveness, productivity, safety, and satisfaction in order to carry out a qualitative and quantitative evaluation. The tools evaluated are CASE tools, frameworks, and Integrated Development Environments (IDEs). The evaluation was conducted to measure not only the tools’ ability to be employed, but also their support for automated software development and automatic source code generation. The aim of this work is to provide a methodology and a brief review of the most important works to identify the main features of these works and present a comparative evaluation in qualitative and quantitative terms of quality metrics. This would provide software developers with the information they need to decide the tools that can be useful for them.

A context-aware style of software design

Contemporary large software systems rely on complex software ecosystems for managing infrastructural tasks. While these ecosystems facilitate software development, the software architect must put care in not relying on assumptions on behaviors and policies of the ecosystem that may change with platform evolution. Based on our experience with developing analyses within MARPLE, a framework for software comprehension and architecture reconstruction, we propose an abstract, context-aware style for specifying software. In the spirit of decoupling computation from coordination, this style decouples the specification of the computations to be performed from the specification of the contexts where they must take place. Software described in this way exposes its primitives at a level of abstraction closer to that of the framework, enabling better reasoning on the features of the design, easing correct implementation, and fostering a better interaction between the software and the framework it relies on.

Using UML Modeling to Facilitate Three-Tier Architecture Projects in Software Engineering Courses

This article presents the use of a model-centric approach to facilitate software development projects conforming to the three-tier architecture in undergraduate software engineering courses. Many instructors intend that such projects create software applications for use by real-world customers. While it is important that the first version of these applications satisfy the customer by providing the functionality the customer expects and perform reliably and efficiently, it is equally important to be able to accommodate the customer's change requests over the period of the product's lifetime. The challenges in achieving these goals include the lack of real-world software development experience among the student developers and the fact that postdeployment change requests will almost certainly have to be handled by students who are not among the original developers. In this article, we describe how a model-centric approach using UML has been effective in enabling students to develop and maintain eight software applications for small businesses over a 9-year period. We discuss the characteristics of our modeling technique, which include the application of modeling patterns and quality check rules that enable students to create a model that can be clearly and consistently mapped to code. We also describe the nature of these mapping-to-code techniques, emphasizing how they reduce coupling among the implementation's classes. We then discuss our experiences in the classroom with these techniques, focusing on how we have improved our teaching over the years based on the analysis of student performance and feedback. Finally, we compare our approach to related work teaching modeling and the development and maintenance of code in software engineering courses with both extensive and minimal modeling.

Role and relevance of reuse repository facilitating software development

This paper discusses the role and relevance of reuse repositories and how software reuse influences software development. Reuse repositories are designed to increase the possibility of locating reusable components at a centralized location to ease component reuse to solve the problem in hand. As a result programmers need not always begin development from scratch. This paper focuses on various search techniques that are used for identifying, selecting and retrieving relevant reusable components from reuse repositories. The paper highlights the Signature Matching technique used in CodeBroker (active reuse repository system), which is based on type constraints. The signature matching technique requires the user to specify the components needed in the form of a query. This technique then fetches the components matching the query from the underlying repository.

Evaluating the productivity of a reference-based programming approach: A controlled experiment

ContextDomain engineering aims at facilitating software development in an efficient and economical way. One way to measure that is through productivity indicators, which refer to the ability of creating a quality software product in a limited period and with limited resources. Many approaches have been devised to increase productivity; however, these approaches seem to suffer from a tension between expressiveness on the one hand, and applicability (or the lack of it) in providing guidance for developers. ObjectiveThis paper evaluates the applicability and efficiency of adopting a domain engineering approach, called Application-based DOmain Modeling (ADOM), in the context of the programming task with Java, and thus termed ADOM-Java, for improving productivity in terms of code quality and development time. MethodTo achieve that objective we have qualitatively evaluate the approach using questionnaires and following a text analysis procedure. We also set a controlled experiment in which 50 undergraduate students performed a Java-based programming task using either ADOM-Java or Java alone. ResultsThe qualitative evaluation reveal that the approach is easy to uses and provides valuable guidance. Nevertheless, it requires training. The outcomes of the experiment indicate that the approach is applicable and that the students that used ADOM-Java achieved better code quality, as well as better functionality and within less time than the students who used only Java. ConclusionThe results of the experiments imply that by providing a code base equipped with reuse guidelines for programmers can increase programming productivity in terms of quality and development time. These guidelines may also enforce coding standards and architectural design.

A Review and Analysis on Mobile Application Development Processes using Agile Methodologies

Over a last decade, mobile telecommunication industry has observed a rapid growth, proved to be highly competitive, uncertain and dynamic environment. Besides its advancement, it has also raised number of questions and gained concern both in industry and research. The development process of mobile application differs from traditional softwares as the users expect same features similar to their desktop computer applications with additional mobile specific functionalities. Advanced mobile applications require assimilation with existing enterprise computing systems such as databases, legacy applications and Web services. In addition, the lifecycle of a mobile application moves much faster than that of a traditional Web application and therefore the lifecycle management associated therein must be adjusted accordingly. The Security and application testing are more stimulating and interesting in mobile application than in Web applications since the technology in mobile devices progresses rapidly and developers must stay in touch with the latest developments, news and trends in their area of work. With the rising competence of software market, researchers are seeking more flexible methods that can adjust to dynamic situations where software system requirements are changing over time, producing valuable software in short duration and within low budget. The intrinsic uncertainty and complexity in any software project therefore requires an iterative developmental plan to cope with uncertainty and a large number of unknown variables. Agile Methodologies were thus introduced to meet the new requirements of the software development companies. The agile methodologies aim at facilitating software development processes where changes are acceptable at any stage and provide a structure for highly collaborative software development. Therefore, the present paper aims in reviewing and analysing different prevalent methodologies utilizing agile techniques that are currently in use for the development of mobile applications. This paper provides a detailed review and analysis on the use of agile methodologies in the proposed processes associated with mobile application skills and highlights its benefit and constraints. In addition, based on this analysis, future research needs are identified and discussed .

Massively parallel feature selection: an approach based on variance preservation

Advances in computer technologies have enabled corporations to accumulate data at an unprecedented speed. Large-scale business data might contain billions of observations and thousands of features, which easily brings their scale to the level of terabytes. Most traditional feature selection algorithms are designed and implemented for a centralized computing architecture. Their usability significantly deteriorates when data size exceeds tens of gigabytes. High-performance distributed computing frameworks and protocols, such as the Message Passing Interface (MPI) and MapReduce, have been proposed to facilitate software development on grid infrastructures, enabling analysts to process large-scale problems efficiently. This paper presents a novel large-scale feature selection algorithm that is based on variance analysis. The algorithm selects features by evaluating their abilities to explain data variance. It supports both supervised and unsupervised feature selection and can be readily implemented in most distributed computing environments. The algorithm was implemented as a SAS High-Performance Analytics procedure, which can read data in distributed form and perform parallel feature selection in both symmetric multiprocessing mode (SMP) and massively parallel processing mode (MPP). Experimental results demonstrated the superior performance of the proposed method for large scale feature selection.

The VERITAS Facility: A Virtual Environment Platform for Human Performance Research

The Virtual Environment Research, Interactive Technology, And Simulation (VERITAS) facility is designed to support basic and applied research in complex multisensory environments including: 3D audio displays for improving safety in general aviation flight operations, advanced audio displays for improving performance in combat search and rescue missions, basic and applied research on multisensory (audio/visual/haptic) interactions, and displays for instrument landing systems. The central component of the facility is a CAVE®, a room-sized virtual environment presentation system. Several of our multi-user distributed experiments also utilized a virtual environment display system in the Appenzeller Visualization Laboratory (AVL). The facilities include a set of commercial-off-the-shelf (COTS) software solutions that work together with custom applications developed by our team to create immersive virtual environments. To facilitate software development and coherence, we created the Integrated Virtual Platform (IVP) as a flexible, expandable, and portable software platform for human performance experimentation. The experiments, experiences, and results in the VERITAS facility presented here, provide an example of a VE platform being actively used for human performance experimentation. The success of the research we have completed suggests that immersive virtual environments are useful tools in investigating complex human performance tasks.

Raven-II: An Open Platform for Surgical Robotics Research

The Raven-II is a platform for collaborative research on advances in surgical robotics. Seven universities have begun research using this platform. The Raven-II system has two 3-DOF spherical positioning mechanisms capable of attaching interchangeable four DOF instruments. The Raven-II software is based on open standards such as Linux and ROS to maximally facilitate software development. The mechanism is robust enough for repeated experiments and animal surgery experiments, but is not engineered to sufficient safety standards for human use. Mechanisms in place for interaction among the user community and dissemination of results include an electronic forum, an online software SVN repository, and meetings and workshops at major robotics conferences.

Dynamically Reconfigurable Energy Aware Modular Software (DREAMS) Architecture for WSNs in Industrial Environments

This paper describes a dynamically reconfigurable energy aware modular software (DREAMS) architecture to facilitate software development for energy harvesting Wireless Sensor Networks (WSNs) in harsh industrial equipment monitoring applications. The DREAMS architecture simplifies WSN software development for applications with strict requirements for energy harvesting as an alternative power source to conventional batteries. Each software module has a set of features including an energy stamp (ES) and associated priority level (PL) required for the module execution management unit (MEMU) to carry forward a dynamic execution model in compliance with the current harvested energy level. In order to accommodate various design requirements addressing inherent difficulties in industrial equipment monitoring applications, software modules can be selected and configured at compile-time or remotely upgraded at run-time based on the low energy stamps or stringent application requirements. Loosely coupled software modules add increasing level of software architecture flexibility and dynamic configurability while allowing for optional optimizations for specific aspects such as reliability, security, power savings, or time critical event reporting. DREAMS architecture was successfully prototyped to monitor real-time eminent faults present in the ligaments of large vibration screens used in the filtration process of the Oil Sands located in North Alberta, Canada.

CHOC'LATE

In spite of its importance in software reliability, testing is labor intensive and expensive. It has been found that software testing without a good strategy may not be more effective than testing the system with random data. Obviously, the effectiveness of testing relies heavily on how well the test suite --- the set of test cases actually used --- is generated. This is because the comprehensiveness of the test suite will affect the scope of testing and, hence, the chance of revealing software faults. There are two main approaches to generating test suites: specification-based and code-based. The former generates a test suite from information derived from the specification, without requiring the knowledge of the internal structure of the program. The latter approach, on the other hand, generates a test suite based on the source code of the program. Neither of these approaches is sufficient; they are complementary to one another. In software development, the requirements have to be established before implementation, and the specification should exist prior to coding. In this respect, the specification-based approach to test suite generation is particularly useful because test cases can be generated before coding has been completed. This facilitates software development phases to be performed in parallel, thus allowing time for preparing more thorough test plans and yet shortening the length of the whole process.

Facilitating information system development with panoramic view on data

The increasing amount of information and the absence of an effective tool for assisting users with minimal technical knowledge lead us to use associative thinking paradigm for implementation of a software solution - Panorama. In this study, we present object recognition process, based on context + focus information visualization techniques, as a foundation for realization of Panorama. We show that user can easily define data vocabulary of selected domain that is furthermore used as the application framework. The purpose of Panorama approach is to facilitate software development of certain problem domains by shortening the Software Development Life Cycle with minimizing the impact of implementation, review and maintenance phase. Our approach is focused on using and updating data vocabulary by users without extensive programming skills. Panorama therefore facilitates traversing through data by following associations where user does not need to be familiar with the query language, the data structure and does not need to know the problem domain fully. Our approach has been verified by detailed comparison to existing approaches and in an experiment by implementing selected use cases. The results confirmed that Panorama fits problem domains with emphasis on data oriented rather than ones with process oriented aspects. In such cases the development of selected problem domains is shortened up to 25%, where emphasis is mainly on analysis, logical design and testing, while omitting physical design and programming, which is performed automatically by Panorama tool.

A theory of aspects as latent topics

After more than 10 years, Aspect-Oriented Programming (AOP) is still a controversial idea. While the concept of aspects appeals to everyone's intuitions, concrete AOP solutions often fail to convince researchers and practitioners alike. This discrepancy results in part from a lack of an adequate theory of aspects, which in turn leads to the development of AOP solutions that are useful in limited situations. We propose a new theory of aspects that can be summarized as follows: concerns are latent topics that can be automatically extracted using statistical topic modeling techniques adapted to software. Software scattering and tangling can be measured precisely by the entropies of the underlying topic-over-files and files-over-topics distributions. Aspects are latent topics with high scattering entropy. The theory is validated empirically on both the large scale, with a study of 4,632 Java projects, and the small scale, with a study of 5 individual projects. From these analyses, we identify two dozen topics that emerge as general-purpose aspects across multiple projects, as well as project-specific topics/concerns. The approach is also shown to produce results that are compatible with previous methods for identifying aspects, and also extends them. Our work provides not only a concrete approach for identifying aspects at several scales in an unsupervised manner but, more importantly, a formulation of AOP grounded in information theory. The understanding of aspects under this new perspective makes additional progress toward the design of models and tools that facilitate software development.

Parallel context-sensitive compilation

The searching power of massively parallel associative computers is an under used and under investigated capability that can be used to facilitate software development. This paper describes the development of a context sensitive compiler for pattern-matching languages using that searching power. The described compiler was implemented on the STARAN parallel computer and the compiled OPS5 programs were also executed on the STARAN obtaining an estimated throughput of 6000 rules per second. The described compilation of production rules into equivalent procedural rules is completely data parallel, with the degree of parallelism depending on the number of tokens in the program being compiled. During any one step of the context-sensitive analysis, the entire program is processed in constant time.

Computer software in civil aircraft

Airborne software is an increasingly large and important system element. However, it is only one element of aircraft systems, and only one element of the aviation software environment. Consequently, it must be considered similarly to the other system and software elements, and cannot be considered in isolation. It is commonly appreciated that there are no such things as systems that are free from risk, but only systems that reduce overall risk and improve overall performance. The apportionment of risk varies with the systems, some of which contain software. Airborne software, like other system changes, is used where its benefits outweigh its disadvantages, notably to improve human factors, which are involved in most aircraft accidents. The timescales involved extend over many decades, and involve a large number of suppliers. Airborne software is produced in accordance with uniquely severe aviation standards, and has now been in service for over 20 years. Other safety critical industries are only now beginning to put into service software with comparable standards. These standards ensure that very great efforts are made to aim at freedom from errors, but freedom from faults is not assumed, and thus fault consequences are assessed and dealt with on a continuing basis, as is the practice in other aspects of aviation systems. A number of powerful tools have been developed to facilitate software development and compliance with these standards. The service record of aircraft that incorporate airborne software has shown that the promise of benefits has been realized. For decades airborne software has been contributing, and continues to contribute, towards making aviation more efficient, and above all, safer.

Software development tools for microcontrollers

AbstractTwo software tools are described that are designed to facilitate software development for microcontrollers. One is a mid‐level programming language called Pascal/48 and the other is a circuit simulation system. Pascal/48 is designed to give the programmer many of the advantages of a high‐level language, but also provide access to all of the hardware of the Intel MCS‐48 series of microcontrollers. The circuit simulation system combines many of the advantages of simulation and emulation. It provides a software testing environment in which many more software functions can be tested than with conventional simulators. The system integrates an instruction‐set simulator with simulators for other devices. They operate in parallel and are synchronized by a clock that records simulated time. I/O lines of the microcontroller can be linked to other components so that complete circuits can be simulated. Displays are provided of the internal and external state of the simulated circuit, and of the Pascal/48 program being executed. They are updated as simulated execution proceeds using the screen updating facilities of ASCII terminals. Simulation can be continuous, single step, or execution can be reversed (i.e. instructions are ‘unexecuted’).

High thermal conductivity ceramics

The Virtual Environment Research, Interactive Technology, And Simulation (VERITAS) facility is designed to support basic and applied research in complex multisensory environments including: 3D audio displays for improving safety in general aviation flight operations, advanced audio displays for improving performance in combat search and rescue missions, basic and applied research on multisensory (audio/visual/haptic) interactions, and displays for instrument landing systems. The central component of the facility is a CAVE®, a room-sized virtual environment presentation system. Several of our multi-user distributed experiments also utilized a virtual environment display system in the Appenzeller Visualization Laboratory (AVL). The facilities include a set of commercial-off-the-shelf (COTS) software solutions that work together with custom applications developed by our team to create immersive virtual environments. To facilitate software development and coherence, we created the Integrated Virtual Platform (IVP) as a flexible, expandable, and portable software platform for human performance experimentation. The experiments, experiences, and results in the VERITAS facility presented here, provide an example of a VE platform being actively used for human performance experimentation. The success of the research we have completed suggests that immersive virtual environments are useful tools in investigating complex human performance tasks.