Research Projects

Current research projects

Current projects in alphabetical order:

Modernization approaches for legacy systems

In this research project a new approach shall be developed to support the stakeholders in making the decision on how to modernise their system. We want to investigate the modernisation “good practice” in both academic and industrial context. Based on this, we want to develop new approaches and identify the information needed to manage the decision process behind the modernization of any (legacy) system.

SCAM - Security-Centric Architecture Modelling

It is impossible to imagine today's world without software: whether it is smartphones, with which we carry a powerful computer with us almost everywhere and are connected to the Internet around the clock, highly scalable cloud applications that we use in our everyday working lives, airports, hospitals, supermarkets - the list of areas in which software is used in one form or another seems endless. Being surrounded by software, most of which being connected to the internet all the time, i.e. 24/7 potential vulnerabilities for outside intruders and attackers, emphesizes the need for highly secure software systems. In order to cope with the high complexity introduced by solutions of security requirements in software architecture, appropriate modelling techniques are required. Although some approaches to security modeling have been developed in recent years, it is still difficult and cumbersome to design, maintain, and evaluate the security architecture of a software system. This is partly because security modeling and architecture modeling belong together, since security solutions can affect the architecture of the software system, but they are handled as separate topics. For instance, threat modeling can be used to identify potential threats in a software system and to design countermeasures for these threats. However, looking at the architecture description documents after the fact, it is not apparent what solutions have been incorporated to address threats, making it much more difficult to evaluate the security architecture of a software system. This research project aims to develop and test new approaches to get a better view of security from an architectural perspective.

SE4ML - Processes, People and Tools

In this reseach project, we aim to contribute to the development of new ML-specific system development approaches. To this end, we analyze and aim to improve the development processes and associated tooling environments. This of course involves a close coordination with the people involved in the process and applying the tools.

Past research projects

An Approach for Vertical Reuse of Unit Test Cases to Automate Integration Testing

Test automation is a central requirement in DevOps, which many companies adopt to increase the quality of their products and reduce the time to market. Despite the efforts, most companies still rely on manual testing to assess the functionality of their products. Besides the time to automate Tests, expertise is needed to design suitable test cases and to achieve the necessary testability of the products and automatability for the test cases. Given that the individual teams already invested effort in designing and creating the test cases for individual components, it is desirable to reuse these test cases for integration testing. Reusing information of test cases on one level to test on a different level is referred to as vertical reuse. This project aims for researching approaches to support test automation on the integration level by reusing information contained in those test cases.

Cloud Service Selection and Cost Optimization

Selecting suitable cloud services and estimating future cloud costs for organizations with a large set of software services is a challenging task. To achieve this, one needs to understand all software applications’ cloud service configuration requirements. Further, one needs to estimate how the applications’ requirements change over time, e.g., due to scaling with a growing number of application users. Then, one needs to compare for different cloud providers the costs over time of setups matching the requirements. This task, if done manually, is laborious, error prone, and has to be repeated when the organization’s business or application requirements change.

Enterprise Architecture Debt

IT initiatives have constituted a major proportion of the overall strategic initiatives in today’s businesses. To fulfill the full potential of IT investments, bridging all gaps between business and IT is the first fundamental step. Such alignment has been the core focus of Enterprise Architecture, a discipline for establishing and maintaining strategic governance and management of IT decisions in complex and dynamic businesses.

An Exploration Plattform for Microservice Applications

The microservice architecture pattern is a software architecture pattern that structures a software application into many individual services that are closely aligned with business capabilities. To be able to explore the effect of changes in a software architecture on the quality of the software system, one usually needs a system under test. These are often missing in the microservice context and can only be used with high information loss by software architecture reconstruction. In this research project we try to develop a platform that allows explorations on microservice architectures and thus does not require the existence of microservice applications and their reconstruction for research on microservice systems.

DevOps-aware Software Engineering

Each software system relies on infrastructure elements to be operated correctly. Caused by the growing complexity and distributed manner of modern software systems the management of infrastructure get more and more important. In parallel the delivery and operation of software gain more attention. The agile manifest proposes the continuously delivery of valuable software to the customer. A tight integration of methods from software engineering and software operation the software development process can achieve this goal.

Business-centered Software Development

Software development is a major investment for any company. To maximize the return, the process of software development needs to be governed strategically. Such governance can be achieved only if IT and business decision-makers collaborate in harmony. The attempts to bridge the gap between IT and business have been referred to as business-IT alignment. In software development, the software architecture has been considered an effective means of communication between business and IT stakeholders. Therefore, recent approaches to software development have addressed business-IT alignment on this level by aligning software architecture to various business models, such as concept and process models. However, conceptual and process alignment concerns have always been addressed separately, for example domain-driven design and process-centric architecture approaches which strongly differ in this regard. While conceptual alignment focuses on the ontological conformance between software architecture and business models, process alignment focuses on functional granularity conformance. We strongly argue that the alignment of both aspects is necessary for the sustainability of software development. To address the aformentioned issues, this research project aims to develop an approach to business-IT alignment which incorporates business concept and process modeling techniques into software architecture activities.

ROBUSTA – Combinatorial Robustness Testing

Combinatorial testing (CT) is a well-known black-box test design approach. Based on the system’s specification, test inputs are generated to systematically detect errors in a system under test (SUT). The degree to which systems can deal with invalid inputs and stressful environmental conditions, i.e. robustness, is an important characteristic of software systems. Robust is often implemented by if-statements that detect invalid inputs and exceptional control-flows that activate error-handlers to recover the system. Because the exceptional control-flow. When errors are detected, the normal control-flow ist left. These systems require different test inputs to prevent the so-called input masking effect. Therefore, this research project aims to improve the activities of modelling and generating test inputs to test the robustness of software systems. But, the generation of effective test suites is not the only challenge in CT. After test execution, the test inputs of failing tests require further analysis to reveal failure-inducing combinations. Manual analysis is a tedious and cumbersome task, especially for SUTs with many input parameters and values. Therefore, this research project aims to to fully automate the combinatorial (robustness) testing by deeply integrating testing lifecycle, the activities of test input modelling, test input generation, test method execution and fault characterization. COFFEe is a framework which integrates the aforementioned steps as a JUnit5 extension, which makes it easy to integrate it into software development and build processes.

EARTh – Integrated Enterprise Architecture Roundtrip Approach

Within EAM guidelines and models will be defined which are used or refined in projects. Projects should be conform with the planned architecture. Unfortunately the project architecture differs from the planned one. This changes have to transferred from the project architecture to the as-is enterprise architecture orchestrated by a quality management process. Additional it should be assessed how this changes affect the planned enterprise architecture. In this research project an approach should be developed aiming at a continuous and systematic alignment of the project architectures to the enterprise architecture and vice versa. To achieve this aim the integration of the used tools by ITERGO has to be promoted. This includes the adjustment of related processes, transfers of information between the tools and the delivery of all needed information the EAM customer.

Scalable Distributed Data Processing with Microservices

Processing increasingly large amounts of data requires the underlying system to be scalable. A system can be designed to scale with the resources of a single computer using "shared-memory parallelization. Another approach is to scale with the number of computers by splitting up a large work package into smaller ones, distributing these smaller work packages, processing them, and then collecting and merging the result. Established frameworks for scalable distributed computing like Apache Hadoop and Apache Spark assist in realizing this. However, in order to fully profit from these frameworks, one has to stay within their ecosystem of supported programming languages and technology stacks. A recent trend in software architectures is to build and compose microservices rather than one monolithic system. This architecture approach yields the benefit that developers can choose the best-fitting programming languages as well as technology stacks individually for every microservice. This project aims for researching approaches to utilize microservices in distributed data processing scenarios."

Model-based Software Architecture Evolution and Evaluation

The architecture of software systems directly influences crucial quality attributes and therefore should be considered whenever important decisions regarding their evolution must be taken. However, up-to-date descriptions that correctly reflect the system’s architecture rarely exist. Architecture descriptions are usually elaborated at the beginning of a software project. After the initial version of the system has been constructed, the system tends to evolve independently from its architecture description. Changes to the system are rarely documented properly and originally imposed rules are gradually violated. Within this project, to help architects manage this situation, we have developed ARAMIS, – the Architecture Analysis and Monitoring Infrastructure. Its main goal is to support the understanding and architectural evaluation and evolution of software systems. With the advent of new architectural styles (component-based architectures, micro-services, etc.) there is a clear shift from mere structural towards behavior-based complexity. Consequently, ARAMIS focuses on the analysis and monitoring of the run-time of complex systems, pursuing to answer questions such as: “how do the architecture units interact with each other upon performing a certain scenario (e.g., running a test-case, interacting with the graphical user inter­face, etc.)?”, “which are the architecture units that need to be redesigned?”, “which are the various hot spots of the system (e.g., in terms of received calls, outgoing calls, caused violations, etc.)?”, “are there violations against the architecture description?”, etc.

Regression Test Optimization

"Software regresses when existing functionality stops working upon the change of the program. Thus, the importance of automatic regression testing is increasing; this is especially true for fast-evolving systems and continuous delivery done right. To stress functional behavior, the regression test suite and its execution time is, in general, large. Moreover, by definition, regression test suites are executed recurrently, and thus, the number of test cases greatly influences the execution time. However, a change has only a partial impact on the system, so we can choose to execute only relevant test cases (test selection). Similarly, we can permanently remove test cases that are irrelevant (test minimization). Last but not least, the order of the test cases can reveal regression errors faster (test prioritization)."

Reusing Domain-engineered Artifacts for Code Generation

The goal of this research project is to bolstered model reuse by providing a holistic approach. This means, the three steps in a reuse process need to be supported on a conceptual and on a tool level. First, reusable model parts need to be identified and “harvested” (hermes.harvest) so they can be put away for later reuse (hermes.store). Second, the stored model parts need to undergo evolutions so they can enhance over time and preserve the benefits (hermes.evolve). Last, the stored model parts need to be found and recommended to interested users (hermes.reuse). To do so, we developed an enhanced knowledge libraries (MoCCa and hermes.store) which build the foundation for harvesting, evolving, and reusing. They do not treat models as in an isolated world, but relate them to each other by describing how they were used together. These relationships cross borders and overcome the usual reuse obstacles and enable the full power of previously modeled knowledge.

Cost/Benefit-based Technical Debt Management

Implementing a payback strategy to reduce the technical debt (TD) is a must for every software organization, as TD exists in most software systems. If we do not cautiously manage the debt or have no strategy to pay it back, the system finally may go to the bankruptcy phase, i.e., the software is unmaintainable and the maintenance cost will increase continuously. In general, refactoring is one of the strategies to pay it back. Usually, project managers are always juggling on the decision to either implement new features or to make improvements in a release cycle as it is always complicated to decide, which refactoring task should be done first or could be postponed. To this end we propose an approach called Cost-Benefit based Technical Debt Management (CoBeTDM). It aims to help business and technical people to decide which refactoring/maintenance should be implemented in a short-term or long-term. At first, TD items are identified on detected code and architecture smells using specified metrics. Then the identified TD items are quantified and prioritized applying a Cost-Benefit analysis taking also into consideration the risks associated to respective refactoring tasks. Based on the Cost-Benefit analysis Return on Investment values can be determined which can be used to decide when to implement which refactoring in order to pay back the TD step by step.

Metric-based Project and Process Management

It is commonly known, that projects management greatly benefit by the application of metrics. However, research shows that it is demanding to find the right metrics; 58% of all project managers and 50% of all senior managers find it difficult to collect, analyze, and use the right metrics. On the one hand, metric frameworks like GQM help to derive metrics from abstract goals for the project. On the other hand, defining measures just for one project (in a multi project organization with a lot of similar projects) is costly and ineffective. Hence, it is wise to reuse metric experience (metric definitions, evaluations, and models) as all experience can and should be reused. Although considerable research has been devoted to the modeling of metrics and metric frameworks, rather less attention has been paid to investigating how the results of this research (metric meta models, metric frameworks, and metric experience bases) can lead to a sound concept for metric reuse. Therefore, the aim of this project is to develop such a concept for metric reuse. The concept should be enriched by metric processes which include metric reuse as well as dedicated tool support for metric documentation, metric reuse and metric calculation.

Model-based Testing of Web Applications

Nowadays many organizations are using web applications for e-business/e-commerce purpose. Hence, it is important to ensure the required quality of web applications before distributing them. In contrasts to traditional software, there are many aspects of web applications that are different. First, web applications typically implement a 3-tier-architecture comprising web browser, web server and database tier which are communicating by stateless protocols such as HTTP request and HTTP response. Second, each tier is implemented using a diversity of programming languages (e.g. HTML, JavaScript, JSP, PHP, ASP). Third, web pages are often generated from prior dynamic web pages which depend on their previous inputs and server’s states. There are many published approaches to test Web application. However, none of these approaches reflects the complete behavior of web applications. This project aims to develop a new model-based testing approach using structural analysis methods, called white box testing. The basic idea is to transform the source code into an intermediate model which is used to generate test cases, test setup information and test oracle information. In addition, our proposed approach introduces a novel coverage metric called Content Coverage. The generation procedure ensures that there are no duplicated and no un-executable test cases as well as 100% content coverage. The approach should guide testers to setup the test environment before running the test cases (e.g. selecting input data and parameters needed to run the tests) and aims to produce expected results which can be automatically compared to the actual program execution.

Goal-based Process Improvement

The aim of this project is to develop a model based approach that provides an objective and semiautomatic selection of improvement practices of multiple RMs that best fit to an organization. To select the best suited practices the organizations' internal processes, wishes, problems, environment etc. have to be considered. The selected practices have to address the improvement potentials of the internal processes and the organizations' wishes. These are reflected by the goals of the organization. The selected practices should also be evaluated and filtered according to their return on investment. According to goals and on this analysis improvement practices can be selected that are extracted from similar or standalone practices from a build-in repository of all considered RMs. For an efficient implementation of the RMs, the traces between the improvement practices and their corresponding RM practices and the dependencies between the improvement practices are also given. For efficient adoption and further selection of improvement practices, the implementation of the improvement practices should be continuously monitored considering the given goals.

Interactive Use Case based Prototyping

Prototyping is a widely accepted technique to evaluate complex system behavior. Prototypes are especially helpful to analyze use cases that many stakeholders find complicated due to their abstractness and fragmentation. Nowadays prototypes are typically created manually and they are not directly connected to other requirements specification documents. Thus their development is expensive and often of sync with corresponding requirements specifications. Therefore we have devised a generative approach to derive interactive prototypes automatically from a use case based requirements specification.

Process Assessment based on Software Repository Data

The development of a large portfolio of software projects raises several managerial challenges, like balancing resource allocation between different projects, and aligning development processes to the standards of the organization. Hence the project status and process quality characteristics, like planning precision or problem resolution speed, must be monitored continuously in order to identify development process weaknesses, and assess process improvements. Collecting the required data by regularly project status reporting can be expensive and intrusive, and furthermore ignores the past history of a process. This motivates mining data from routinely collected repositories like change request management (CRM) systems.

Model-based Software Engineering of Small Embedded & Real-Time Systems

As the history of software engineering unveils, abstraction is the means to face complexity. While the 1970's and 1980's have been strongly based on functional and data abstraction, and while the 1990's and early 2000's have been dominated by object-orientation, model-based software development (MBSD) seems to be the predominant development paradigm of the present and upcoming decade. Due to its increased capabilities in terms of abstraction, traceability and analyzability, it seems to be the in particular useful to address the very special constraints, being faced in the domain of embedded & real-time systems. However, as current surveys unveil, from a state-of-the-practice viewpoint, model-based software development does not seem to have penetrated the embedded & real-time domain yet. Tracing this back to domain-specific technical, economical and organizational constraints, not being properly reflected by current model-based approaches, it is the goal of this project to introduce modern model-based technology and techniques, being however constraint-adequate. As only a common, integrated methodology, formed by a systematic and concise method, by profound supporting tools, and by underlying languages, being related via common concepts and principles, allows to unleash the full potential of model-based development, it is the central goal of this project to deliver the latter. Regarding the very special constraints, being additionally faced in the domain of small embedded & real-time systems, the approach should in particular be applicable to a domain, which has been very much elided so far.

Architectures for Software Product Lines
  • Researcher:
  • Time: 2000 – 2007

Product line-based software development can only lead to full success if it is recognized as an integrated concept, which involves all phases of the software engineering process. This project concentrates on architecture modelling for Software Product Lines. We have developed a top-level process for Software Product Line architecture modelling. Within the *domain engineering* initially the requirements for the entire Product Line Platform are collected together with the identified variability and afterwards compiled into a *requirements model* for the Product Line Platform, which among other things contains for example a *feature model*. This requirements model forms the basis for the top-level layer of the Product Line Platform architecture. Starting from this still abstract architecture layer, the PLP architecture gets more and more refined in further architecture layers. This procedure is according to the *Model Driven Architecture* (MDA) approach introduced by the OMG

Requirements Engineering for Software Product Lines

The development of a Software Product Line (SPL) is a demanding task for all stages of the software development process, especially for requirements engineering. The identification and modelling of common and variable characteristics are an essential task during the requirements engineering process. Communicating variability to stakeholders affects the success of projects significantly. Our research group has developed a prototype of a requirements engineering tool, named *RequiLine* that supports the management of requirements and feature models, equally. The development of RequiLine has been mainly driven by the identified requirements for an adequate tool support for product lines and therefore to overcome the deficiencies existing requirements engineering tools have in managing variability and dependencies. Our experience shows, that requirements engineering tools are used together with graphical editors to draw feature models.

Role-based Software Test

The goal of this project is to develop a more efficient testing approach for the members of a program family. With the objective to save development effort, programs for related application areas are often developed as a program family, which consists of different program variants that share a common core of functionality. Particularly the concepts of object-oriented programming support this form of development, since common functionality of different program variants can be easily implemented using object-oriented frameworks. For this reason our current work is focussed on the use of object-oriented frameworks for this purpose.

Object-based Internet Search

Internet search engines compute their centralized index by crawling web contents. This approach implies two major problems; large and relevant parts of the Internet content are notreachable by crawling and thus remain inaccessible for search engines, bandwidth and its growth impose harsh limits on central index currency and indexable share of vastly growing available information. The obvious solution is a distributed approach to information retrieval that better leverages the available bandwidth in order to achieve higher index currency and improved coverage, including deep web contents. Forward knowledge -like keyword indices – have to be stored closer to the searchable information sources than the central index approach currently does. Furthermore, their updating has to happen in a more bandwidth-efficient manner as compared to the change detection heuristics and brute force crawling methods used today. Metrics collected have shown that the amount of publicly accessible information on the Internet grows much faster than the available Internet backbone bandwidth. In particular it turns out that the amount of application generated content grows especially fast. Crawling-based technologies for global Internet search won’t be able to scale with these growth factors. Furthermore, many of the application-generated contents are unreachably hidden from the crawlers in the deep web. The solution lies in reversing the paradigm of Internet search. Content providers will have to contribute to the searchability of their information space, thus making search more bandwidth-efficient and making deep web contents accessible to search.