Winter Term 2011/2012
On this page you find all the courses offered by the chair of Software Engineering in the winter term 2011/2012 as well as respective slides and accompanying exercises.
Often computers are used in embedded, networked, safety critical applications. The cost of failure is high. In this lecture we introduce the basis of automatic tools for ensuring that a system does not have bad behaviours. In the lecture, we start with a short introduction to propositional logic and ﬁrst-order reasoning. We then go on to establish a setting for the verification of programs, whose correctness is specified by a kind of program comments. In this setting, the correctness of the program is reduced to the validity of logical formulas. The validity is proven automatically by a new generation of powerful reasoning engines. Finally, we connect verification with static analysis methods that have been developed originally in compiler optimization and which are formalized by Patrick and Radhia Cousot's framework of abstract interpretation.
Recently, formal methods have been successfully used to specify and verify large software system. A current example is the Verisoft project, whose goal is to create a fully verified processor, operating system and compiler. In this lecture we will investigate the exising methods for the language Java. The language Java was chosen because it is a mature language, with a semi-formal definition of its semantics (The Java Language Specification). However, to use mathematical reasoning, we need a precise definition of the semantics. Therefore, we will sketch the definition of an operational semantics for Java. Furthermore, we will investigate different formal methods for Java. The starting point will be the language extension JML that allows Design by Contract. This allows to add pre- and postconditions to methods and invariants to classes and loops. These assertions can be checked during runtime and this is the purpose of the JML runtime assertion checker (jmlrac). On the other hand, there are static methods, e.g., ESC/Java and Jahob, that automatically provide mathematical proofs that the Java code ensures the post-condition for each possible pre-condition. If these proofs cannot be find automatically, one can also use theorem provers that assists finding a proof manually. In this lecture, we will present the different approaches for verification of Java code. In the exercise you can investigate different tools on small practical examples.
The model-driven approach to software and systems development proposes to address quality and complexity issues in the development process. The usage of modelling languages not only for documentation, but, e.g., for automated analysis, test generation, and code generation is gaining momentum in particular in the context of (safety) critical software development. The necessary pre-requisites are a semantically founded modelling language and methods and tools for analysis. We will take the Unified Modelling Language (UML) as an example and demonstrate how to equip a relevant sublanguage (sometimes referred to as executable core) with a precise meaning in line with the official standard documents. To complement these discussions, we provide access to a contemporary UML modelling tool and use it for some of the exercises.
In the classical sense static analysis techniques are used to extract information regarding the possible behavior of a program, without actually running the program. This statically extracted information is then used for revealing bugs or optimizing the code.
This seminar covers important achievements in the area of Automated White-box Testing, Statistical Debugging, and Random Testing.
In diesem Praktikum soll ein Softwareentwicklungsprozess, beginnend bei Anforderungserhebung über Entwurfsphase bis hin zur Implementierung, die Organisation der Arbeit innerhalb einer Gruppe und der Umgang mit komplexen Systemen erlernt werden. Die Teilnehmer werden von den Betreuern in Gruppen eingeteilt und müssen eine bestimmte Aufgabenstellung realisieren. Hierzu müssen sie sich selbst organisieren, die Anforderungen definieren, Arbeit geschickt auf Gruppenmitglieder verteilen und neue Technologien selbstständig erlernen.