A framework for analyzing configurations of deployable software systems

Highly-configurable software systems can be easily adapted to address user's needs. Modelling parameter configurations and their relationships can facilitate software reuse. Combinatorial Interaction Testing (CIT) methods are already often used to drive systematic testing of software system configurations. However, a model of the system's configurations not conforming with respect to its software implementation, must be repaired in order to restore conformance. In this paper we extend CIT by devising a new search-based technique able to repair a model composed of a set of constraints among the various software system's parameters. Our technique can be used to detect and fix faults both in the model and in the real software system. Experiments for five real-world systems show that our approach can repair on average 37% of conformance faults. Moreover, we also show it can infer parameter constraints in a large real-world software system, hence it can be used for automated creation of CIT models.

The detection of function clones in software systems is valuable for the code adaptation and error checking maintenance activities. This paper presents an efficient metrics-based data mining clone detection approach. First, metrics are collected for all functions in the software system. A data mining algorithm, fractal clustering, is then utilized to partition the software system into a relatively small number of clusters. Each of the resulting clusters encapsulates functions that are within a specific proximity of each other in the metrics space. Finally, clone classes, rather than pairs, are easily extracted from the resulting clusters. For large software systems, the approach is very space efficient and linear in the size of the data set. Evaluation is performed using medium and large open source software systems. In this evaluation, the effect of the chosen metrics on the detection precision is investigated.

Metric-based Evaluation of Implemented Software Architectures

This paper describes the application of requirements engineering concepts to support the analysis of the impact of new software systems on system-wide goals. Requirements on a new or revised software component of a socio-technical system not only have implications on the goals of the subsystem itself, but they also impact upon the goals of the existing integrated system. In industries such as air traffic management and healthcare, impacts need to be identified and demonstrated in order to assess concerns such as risk, safety, and accuracy. A method called PiLGRIM was developed which integrates means-end relationships within goal modelling with knowledge associated with the application domain. The relationship between domain knowledge and requirements, as described in a satisfaction argument, adds traceability rationale to help determine the impacts of new requirements across a network of heterogeneous actors. We report procedures that human analysts follow to use the concepts of satisfaction arguments in a software tool for i* goal modelling. Results were demonstrated using models and arguments developed in two case studies, each featuring a distinct socio-technical system—a new controlled airspace infringement detection tool for NATS (the UK’s air navigation service provider), and a new version of the UK’s HIV/AIDS patient reporting system. Results provided evidence towards our claims that the conceptual integration of i* and satisfaction arguments is usable and useful to human analysts, and that the PiLGRIM impact analysis procedures and tool support are effective and scalable to model and analyse large and complex socio-technical systems.

Reverse engineering aims at obtaining high-level representations of software systems from existing low-level artifacts, such as binaries, source code, execution traces or historical information. Reverse engineering methods and technologies play an important role in many software engineering tasks and quite often are the only way to get an understanding of large and complex software systems. Given for example the task to understand certain aspects of the test code in large software systems, such as Eclipse. How would you figure out the answers to the following questions:

Administration and deployment of software systems become increasingly complex. This complexity results from the need of uniform access to applications from heterogeneous terminals through different communication infrastructures. Moreover, applications consists in complex architectures of lot of small components connected together. A first step to simplify deployment is to have an unified and abstract model for representing deployment dependencies and managing them properly. Therefore, we propose here a deployment model and a conceptual foundation for component installation. Installation dependencies and installation rules are expressed in a logic language.

OTS selection plays a crucial role in the deployment of software systems. One of its main current problems is how to deal with the vast amount of unstructured, incomplete, evolvable and widespread information that highly increases the risks of taking a wrong decision. The goal of our research is to tackle these information quality problems for facilitating the collection, storage, retrieval, analysis and reuse of OTS related information. An essential issue in this endeavor is to assess what OTS selectors mean by Information Quality and their needs to perform an informed selection. Therefore, we are putting forward an on-line survey to get empirical data supporting our approach.

The 27th IEEE International Requirements Engineering Conference, Jeju Island, South Korea, 23-27 September 2019

In this paper, a Service-Oriented Software Reengineering (SOSR) methodology is proposed for reengineering a legacy system into a service-oriented system. Although Service-Oriented Computing (SOC) enables a software developer to design loosely coupled software components and integrate them with other software systems, most components in a legacy system were not developed as services. The SOSR methodology is based on a set of best practices that are architecture-centric, service-oriented, role-specific and model-driven. The SOSR methodology is demonstrated by the modernisation of two different legacy systems – a Business-to-Business (B2B) system and the other is a Business-to-Consumer (B2C) System. The resulting service-oriented systems and the evaluation of the methodology in terms of non-functional system requirements such as interoperability, etc. show that this methodology can be used by software developers and system integrators to reengineer tightly coupled legacy information systems into the loosely coupled, agile, service-oriented information systems.

Aspect-oriented Component Engineering uses early aspects to better categorize and reason about provided and required services of individual components in software systems. Our earlier work on AOCE demonstrated an increase in the reusability and understandability of software components and systems via its usage of early requirements and design-phase aspects but lacked adequate tool support. We describe a novel design tool called Aspect-Oriented UML (AO-UML) that can be used to efficiently capture and manage early aspects for software development using the Aspect-oriented Component Engineering methodology. The key benefits of our tool are its use throughout the development lifecycle and its ability to support and take advantage of Aspect-Oriented Component Engineering's features and capabilities.

The 7th International Workshop on Economics-Driven Software Engineering Research (EDSER-7) continues to be the leading forum for the discussion of emerging research ideas in software economics. The focus of the workshop is on the use of economic models for reasoning about technical issues and decisions in the definition, design, development, deployment, and evolution of software and software-intensive systems.

A software architecture is typically drawn as a nested set of box and arrow diagrams. The boxes represent components of the software system and the edges represent interactions These diagrams correspond to typed graphs, in which there are a number of types or colors of edges, and in which there is a distinguished contain relation that represents the system hierarchy (the nesting of boxes). During reverse engineering, one often transforms such diagrams in various ways to make them easier to understand. These transformations include edge aggregation, box abstraction (closing a box to hide its contents), and box separation (separating a box from its surrounding system). Such transformations are essential in helping make software architecture diagrams useful in practice. Paper shows how structural manipulations such as these can be specified and automatically carried out in a notation based on Tarski's relational algebra. The operators in this algebra include relational composition, union, subtraction, etc. These operators are supported in a language called Grok. Grok scripts have been used in manipulating the graphs for large scale software systems, such as Linux, to help in program visualization and understanding.

Identifying and removing the causes of poor performance in software systems are complex problems, and these issues are usually tackled after software deployment only with human-based means. Performance antipatterns can be used to harness these problems since they capture design patterns that are known leading to performance problems, and they suggest refactoring actions that can solve the problems. This paper introduces an approach to automate software model refactoring based on performance antipatterns. A Role-Based Modeling Language is used to model antipattern problems as Source Role Models (SRMs), and antipattern solutions as Target Role Models (TRMs). Each (SRM, TRM) pair is represented by a difference model that encodes refactoring actions to be operated on a software model to remove the corresponding antipattern. Differences are applied to software models through a model transformation automatically generated by a higher-order transformation. The approach is shown at work on an example in the e-commerce domain.

There is nothing permanent except change. The only constant is change. Many engineering changes must be communicated to a broad range of stakeholders. The process is often labor intensive, paper laden, and error prone. Product data management (PDM) system and configuration management theory are the most popular system and theory for handling engineering changes today. In practice, when utilizing a product data management system, a planned effectivity must be filled in each engineering change request (ECR) during analyzing and evaluating phase of an engineering change. A change effectivity decision may be required to identify all of the required actions, the responsibility, and the timing from detail design phase to production phase in the life cycle of the product. This paper presents a specific product configuration, which is called engineering change decision bill of materials (ECD-BOM). The procedure for generating such a product configuration from product data management system is also provided. Import states of such product configuration into an advanced planning and scheduling (APS) system, planned effectivity of approved changed configuration items are then computed.

Software systems become increasingly distributed, involving many independent and collaborating components working towards achieving system goals. At the same time, security attacks on these systems have also grown being more sophisticated and are quite difficult to identify and mitigate, in particular including distributed attacks. In this paper, we argue that one way to detect and resist against such attacks is through the collaboration of a system's constituent components. To achieve collaborative defense in a distributed component-based system, a common basis (vocabulary) is needed for the components to communicate and work with each other in detecting attacks and devising countermeasures. We adopt an ontological approach to establishing such a common base and introduce ontologies concerning security attacks and defenses. The ontologies specify the security concepts and their relationships in a way understandable to both humans and software agents. We use a case study involving Mitnick attacks to demonstrate how system components use the ontologies to detect and counter attacks.