SE

main page

staff

teaching

theses

research

publications

books

jobs

news/events


SE-Lab

RWTH Aachen

Fachgruppe Informatik

Software Engineering Research
(Department of Computer Science 3)

Prominent research projects (Prof. Nagl)

An overview over the research projects can be found here.

Mission statement

Define, improve and industrially apply techniques, concepts, and methods for innovative and efficient development of software and software-intensive systems, such that high-quality products can be developed in a shorter period of time and with flexible integration of changing requirements.

The Software Engineering group concentrates on innovative and practically useful concepts, methods, and tools for the development of complex business and software-intensive embedded systems on a sound and reliable scientific and engineering basis.

In recent years software engineering has significantly extended and consolidated its portfolio of methods, techniques, and tools to support development of highly critical, reliable or functionally complex systems within the predefined time and a given budget while meeting the required quality [BEP+00]. It is our mission to transfer this knowledge and the accompanying tools into industry as well as to customize and apply them to project and company specific needs. Thus optimized use (and reuse) of given resources enables an efficient realization of given goals.

Main areas of research

Within our scope the following and related fields of research and technology transfer are of particular significance:

  • Model-based development
  • UML, MDA
  • Domain specific languages (DSL)
  • Automotive Software Engineering
  • Test development
  • Evolution of models, architecture, software
  • Agile methods, XP
  • Distributed systems
  • Non-functional properties (reliability, safety, ...)
  • Automata, Statecharts
  • Semantics
  • Model analysis and modeling guidelines
  • Transformational software development
  • Code generation


Model-driven development / MDA / DSL

Like any other engineering discipline, software engineering uses blue prints before building the actual system. In our work we use and improve the de'facto standard Unified Modeling Language (UML). We have adapted the UML [BS01] towards domain specific languages (DSL) [CKM+99], e.g. to model railway stations and their software architecture in terms of tracks, trains, and signals instead of abstract objects and links.

For an efficient use of models we elaborate an agile version of a model-driven development process where models are the central artifacts. Models are used for requirement capture, architecture definition, design, documentation, test generation and even quality assurance and certification. Ideally, code, automated tests and quality certificates are generated from extended models. This increases the efficiency of developers as well as the quality of and trust on the resulting system.

Equally important, this approach enables and improves reuse of artifacts (models) in a way that evolution of systems according to changing hardware or extended functional requirements [BRW03,PR99] becomes easier. This is particularly of interest when developing innovative software (such as research project prototypes that later become products) or product line software (such as automotive device controllers that evolve over car model variants and generations).

Software and system architecture

Defining the proper architecture early in a project is the key to a successful and stable product. The architecture of software-intensive distributed systems normally consists of several layers: the structure of the function net, the embedding in reliable communication architecture and its mapping to physical devices using e.g. an operating system or AutoSAR for basic infrastructural services. Offering a notation for specification of distributed, asynchronously communicating components, and corresponding Model-Driven-Architecture (MDA) techniques, we increase the level of automation of these mappings (deployment) as well as the identification and explicit description of architectural patterns [FPR01,RSRS99] that are reusable in similar or extended applications.

Quality management

Quality is not for free. It is an emerging property of a product and must be planned from the beginning of the development process. We are developing techniques to analyze and measure certain project and product characteristics that give hints on potential problems as well as the overall quality of a system. In particular the development of automated tests covering specification models [Rum03] or the code together with the definition of software architectures that allow efficient development of tests are within our focus. These quality measurements will be available as services via the internet for development projects in the industry.

Agile development methods

At first sight model-based development and agile development techniques look contradictory. On the second look they aren't. [HR04,Rum04a,Rum04b] show how both aim to improve the efficiency of the process and the quality of the result. Putting the offered agile and model-based techniques together, synergy allows us to use the best of both worlds. We transfer existing agile and model-based techniques to industry and investigate further improvement of these methodological tools.

Automotive Software Engineering

Innovations in today's cars are to 90% induced by software functions implemented in distributed controllers using different kinds of operating systems and development tools. OEMS and suppliers are increasingly using successful principles and methods of modern and efficient software engineering for other domains. This revolution on the one hand means, modern software technology is migrating into the automotive domain, but also that SE-solutions need to be adapted to fit to automotive specific problems. Our main goals here are to assist the early phases from requirements engineering to function net based architecture (before mapping to any implementation on the control devices) and such increasing reuse, efficiency and portability, which is very important in product lines. Secondly, we are specifically interested in autonomous driving and its the technical infrastructure.

Domain-Specific Languages / MontiCore

One powerful technique for software development is the use of a specific notation for describing domain specific solutions. Domain specific languages (DSLs) allow the representation of information and models in a way that domain experts prefer over the use of general-purpose notations. DSLs make domain knowledge explicit and simplify the communication between domain and IT experts. MontiCore provides a framework for efficient development of DSLs [GKR+06,GKR+08]. It unifies the necessary development steps to create tools for processing DSLs, analyzing the expressed content and creating code based on the DSL. MontiCore therefore provides a powerful software development infrastructure which is available here as an online service.



Selected References