Towards a Synergistic Combination of Research and Practice in Software Engineering

Industrial real-time computer systems are designed to operate with high reliability level. It is most often achieved by the use of redundancy. Additional elements introduced to the system are supposed to make it invulnerable to failures of their redundant components. Implementation of redundancy entails significant extra costs. The financial costs are quite obvious and easy to estimate they are associated with the need to deliver, configure, program, service and maintain additional devices and communication interfaces. There are however another costs which are not so evident because they derive from the system operation and data processing. Those are the temporal costs of redundancy that influence the real-time systems characteristics and in the end may determine the system usability.

The paper introduces a new domain-specific language designed essentially for specifying exercises for interactive programming courses. The language covers the four crucial elements of interactive programming exercise, i.e.: metainformation, exercise description, solution checking and feedback, and aims at conciseness, human readability and ease of use. The paper discusses the issues with alternative forms of specifying programming exercises, presents the general concepts and syntax of the language, and reports on its implementation and validation.

Complexity of software quickly approaches the limits of what today’s programming paradigm can handle. Similarities (i.e., similar requirements, design solutions, as well as program structures) are inherent in software domain. In the paper, we discuss unexploited potentials of software similarities to ease management of complex software systems. We describe the concept of power-generics to exploit this potential. A key idea is meta-program level flexible parameterization, without restrictions of C++ templates or Java generics. To illustrate the concept, we discuss ART (Adaptive Reuse Technique) that extends conventional programming paradigms with an unconventional generative technique, in a synergistic and easy to adopt way. With ART, we illustrate general concepts discussed in the first part of the paper.

Existing domain ontologies are a source of domain knowledge about the specific areas of interest. The article presents a prototype tool for semantic validation of UML class diagrams. A knowledge base for validating the diagram is the domain ontology expressed in OWL 2 selected by the user of the tool. The tool automatically recognises if the diagram is compliant, not contradictory or contradictory to the selected domain ontology. Additionally, it proposes a set of suggestions what should be corrected in the class diagram in order for the diagram to more adequately reflect the needed domain.

Algorithms for the transaction rollback belong to the fundamentals of database theory and practice. Much less attention has been paid to the method rollback in the realm of object-oriented systems. This issue was studied in the context of exception handling. In a previous paper, a new algorithm for computing old attribute values has been proposed. In this paper that algorithm is used to implement a procedure for method rollback. It is shown that this procedure ensures the so called strong exception safety.

Time is important. New software rarely works as a standalone service—usually, it is part of a much bigger network of interconnected applications, running on different hardware, operating systems and designed with various technology stacks. Even applications which do not need network connectivity, such as some embedded devices, rely on time-based events for task scheduling. However, support for testing time-dependent code is often not sufficient both on operating system level and on framework/library level, and generally, requires special ways of designing software to provide sufficient testability. Custom design often means implementing special testing library or modifying the source code for test purposes. This paper points out some of the things that may go wrong when using these approaches, introduces a portable model of time-based computation and presents zurvan—an open-source library for Node.js applications which provides an abstraction over time and allows users to efficiently test time-dependent, asynchronous code. Advantages of using presented model include test case repeatability, increased code testability and shorter test suite execution times.

Business rules are such requirements that can change very often. As they are formulated by business people (e.g. domain experts) they should be expressed in the way that is—from one side—easy to understood and—from the other—possible for automatic processing. This paper demonstrates a solution to the processing of dynamic business rules which are written in a controlled natural language. A user can add or modify rules during program operation influencing the way the program behaves. The proof-of-concept implementation confirmed that such approach is feasible and can be extended to become mature enough to be introduced in production.

Test-Driven Development (TDD) is an agile software development and design practice popularized by the eXtreme Programming methodology. Continuous Test-Driven Development (CTDD), proposed by the authors, is the recent enhancement of the TDD practice and combines TDD with the continuous testing (CT) practice that recommends background testing. Thus CTDD eliminates the need to manually execute the tests by a developer. This paper uses CTDD research to test out the idea of Agile Experimentation. It is a refined approach performing disciplined scientific research in an industrial setting. The objective of this paper is to evaluate the new CTDD practice versus the well-established TDD practice via a Single Case empirical study involving a professional developer in a real, industrial software development project employing Microsoft .NET. We found that there was a slight (4 min) drop in the mean red-to-green time (i.e., time from the moment when any of the tests fails or the project does not build to the time when the project compiles and all the tests are passing), while the size of the CTDD versus TDD effect was non-zero but small (\(d-index=0.22\)). The recorded results are not conclusive but are in accordance with the intuition. By eliminating the mundane need to execute the tests we have made the developer slightly faster. If the developers that use TDD embrace CTDD it can lead to small improvements in their coding performance that, taking into account a number of developers using TDD, could lead to serious savings in the entire company or industry itself.

As changes to organisations and the systems supporting them are getting ever more rapid, the modifiability of evaluation architecture is becoming ever more important. This paper presents a proposal of a scenario-based method for evaluating the modifiability of enterprise architectures. The method has been developed as an adaptation of the Software Architecture Analysis Method (SAAM) onto the field of enterprise architecture. It assumes that such architecture should be represented as a set of models in the ArchiMate language. The proposed method delivers an architecture assessment process together with techniques supporting the architecture assessment, such as representing requirements as scenarios of probable changes, analysing the impact of the changes represented by scenarios on enterprise architecture. The method has been validated on a real world example of an Enterprise Architecture of a Social Policy Support Entity of a certain municipality.

Business analysis is recognized as one of the most important areas determining the outcome (success or failure) of a software project. In this paper we explore this subject further by investigating the potential impact of techniques applied in business analysis on essential software quality characteristics. We conducted a literature search for software quality models, analyzed the existing models and selected a subset of commonly recognized quality characteristics. Also, we identified a representative set of recommended state-of-the-art business analysis techniques. These two sets provided the basis for questionnaire survey and interviews. We conducted a survey involving 20 industry professionals, followed up by 2 interviews with experienced business analysts to discuss and interpret survey results. The main outcome are recommendations regarding techniques to be used in software project for a given quality characteristic considered essential.

Women have been shown to be effective leaders in many team-based situations. However, it is also well-recognized that women are underrepresented in engineering and technology areas, which leads to wasted efforts and a lack of diversity in professional organizations. Although studies about gender and leadership are rich, research focusing on engineering-specific activities, are scarce. To react on this gap, we explored the experience of female leaders of software development projects and possible context factors that influence leadership effectiveness. The study was conducted as a longitudinal multiple case study. Data was collected from survey, interviews, observation and project reports. In this work, we reported some preliminary findings related to leadership style, team perception on leadership and team-task context factors. We found a strong correlation between perceived team leadership and task management. We also observed a potential association between human-oriented leading approach in low customer involvement scenarios and task-oriented leading approach in high customer involvement situations.

Alvis is a formal language specifically intended for modelling systems consisting of concurrently operating units. By default, the time dependencies of the modelled system are taken into account, what is expressed by the possibility of determining the duration of each statement performed by the model components. This makes Alvis suitable for modelling and verification of real-time systems. The paper focuses on Alvis time models. The article outlines the syntax and semantics of such models, and discusses the main issues related to the generation of Labelled Transition Systems for time models. Particular attention was paid to tools that support the verification process.

As mobile devices tend to become more and more essential part of everyday life the significance of security of applications designed for the use on such devices is constantly growing. Most of the mobile platform providers assure sophisticated security mechanisms which aim to prevent threatening applications to be published as well as they make certain security features available to use. Nevertheless, the design and implementation of these features leaves a vast area where potential enhancements can be brought to life and mistakes avoided. In order to address this field of mobile application development MABAC, an access control model was introduced which aims to characterize the access control flow specific for mobile systems. The paper describes the crucial processes connected with the MABAC model and brings closer the details of the control flow in the mobile application designed according to the rules of the model.

The process of creating software for modeling and simulation of phenomena taking place in computer networks should take into account many aspects of their functioning. However, until now, the creation of such software was based on a reductionist approach. This approach is typical for simple or most complicated systems. In contrast, software for modeling and simulation of computer networks should be treated as a complex system. Therefore, the process of its creation should take into account such properties of complex systems as: feedback loop, non-extensivity, indeterminacy, self-similarity, non-additivity, etc. The authors use computer simulators in their work on everyday basis. However, they have generally an outdated, static architecture that prevents their easy and continuous development. Therefore, the authors started working on developing their own model of creating such software and this paper is an introduction to this issue. The authors focused on the selected features of complex systems in the context of the software development process. Based on the feedback loop, a new spiral of software development and modeling for computer networks is presented. The paper also defines the notion of process and functional non-additivity and its importance in the software development process. The presented approach allows for flexible development of the software under consideration in terms of their functionality. The authors also presented examples of application of complex system properties when creating selected functional modules of software for modeling and simulation of computer networks.

Teaching Scrum and other complex Software Engineering (SE) practices, methods, and tools within a regular academic course is often a challenging task because the examples shown to students and their working environment are not realistic enough. This problem is frequently tackled by organizing courses in the form of capstone projects. Unfortunately, this approach requires additional resources (e.g., more tutors, external customers, etc.) what limits the potential number of participants. As a response to this problem, we propose a Scrum-centric framework that allows combining lectures and laboratory classes with a minimalistic capstone project, all within a regular SE course. The course is organized similarly to a project run according to the Scrum guidelines. The focal point of the framework is the synchronization between the content presented during lectures and laboratory classes with the capstone project iterations (sprints). We also share our experience from 2 years of conducting Software Engineering course organized according to the framework together with the results of a cross-sectional survey assessing student perceptions of the effectiveness of the approach.