Search result: Catalogue data in Spring Semester 2015

Computer Science Master Information
Focus Courses
Focus Courses in Software Engineering
Focus Core Courses Software Engineering
In spring 2015 there will be no course offered in this category.
Focus Elective Courses Software Engineering
NumberTitleTypeECTSHoursLecturers
252-0268-00LConcepts of Concurrent Computation Information W7 credits3V + 2U + 1AS. Nanz
AbstractConcurrent programming is one of the major challenges in software development. The "Concepts of Concurrent Computation" course explores important models of concurrency, with a special emphasis on concurrent object-oriented programming and process calculi.
ObjectiveAfter completing this course, students will understand the principles and techniques of concurrent programming, supporting theories allowing formal reasoning about concurrent systems, and advances in concurrent object-oriented programming.
ContentTopics include:

Overview
- Concurrent and parallel programming
- Multitasking and multiprocessing
- Shared-memory and distributed-memory multiprocessing
- Notion of process and thread
- Performance of concurrent systems

Approaches to concurrent programming
- Issues: data races, deadlock, starvation
- Synchronization algorithms
- Semaphores
- Monitors
- Java and .NET multithreading

Concurrent object-oriented programming: the SCOOP model
- Processors; handling an object
- Synchronous and asynchronous feature calls
- Design by Contract in a concurrent context
- Separate objects and entities
- Accessing separate objects; validity rules
- Synchronization: waiting, reserving, preconditions as wait conditions, Wait by Necessity
- Examples and applications

Programming approaches to concurrency
- Message-passing vs. shared-memory communication
- Language examples: Ada, Polyphonic C#, Erlang (Actors), X10, Linda, Cilk and others.
- Lock-free programming
- Software Transactional Memory

Reasoning about concurrent programs
- Properties of concurrent programs
- Temporal logic
- Process calculi: CCS and coalgebra
- Petri nets
- Proofs of concurrent programs
Literature- Bertrand Meyer and Sebastian Nanz: Course textbook (draft)
- Mordechai Ben-Ari: Principles of Concurrent and Distributed Programming. Prentice Hall, 2006
- Maurice Herlihy and Nir Shavit: The Art of Multiprocessor Programming. Morgan Kaufmann, 2008
- Gregory R. Andrews: Foundations of Multithreaded, Parallel, and Distributed Programming. Addison Wesley, 1999
Prerequisites / NoticeThe course's lectures are of two different kinds: the Tuesday session is a traditional lecture; the Wednesday session is devoted to seminar talks by the student participants, based on research papers related to the topics of the course. The research papers to be presented will be assigned at the start of the course.
263-2300-00LHow To Write Fast Numerical Code Information
Prerequisite: Master student, solid C programming skills.
W6 credits3V + 2UM. Püschel
AbstractThis course introduces the student to the foundations and state-of-the-art techniques in developing high performance software for numerical functionality such as linear algebra and others. The focus is on optimizing for the memory hierarchy and for special instruction sets. Finally, the course will introduce the recent field of automatic performance tuning.
ObjectiveSoftware performance (i.e., runtime) arises through the interaction of algorithm, its implementation, and the microarchitecture the program is run on. The first goal of the course is to provide the student with an understanding of this interaction, and hence software performance, focusing on numerical or mathematical functionality. The second goal is to teach a general systematic strategy how to use this knowledge to write fast software for numerical problems. This strategy will be trained in a few homeworks and semester-long group projects.
ContentThe fast evolution and increasing complexity of computing platforms pose a major challenge for developers of high performance software for engineering, science, and consumer applications: it becomes increasingly harder to harness the available computing power. Straightforward implementations may lose as much as one or two orders of magnitude in performance. On the other hand, creating optimal implementations requires the developer to have an understanding of algorithms, capabilities and limitations of compilers, and the target platform's architecture and microarchitecture.

This interdisciplinary course introduces the student to the foundations and state-of-the-art techniques in high performance software development using important functionality such as linear algebra functionality, transforms, filters, and others as examples. The course will explain how to optimize for the memory hierarchy, take advantage of special instruction sets, and, if time permits, how to write multithreaded code for multicore platforms. Much of the material is based on state-of-the-art research.

Further, a general strategy for performance analysis and optimization is introduced that the students will apply in group projects that accompany the course. Finally, the course will introduce the students to the recent field of automatic performance tuning.
263-2810-00LAdvanced Compiler Design Information W7 credits3V + 2U + 1AT. Gross
AbstractThis course covers advanced topics in compiler design: SSA intermediate representation and its use in optimization, just-in-time compilation, profile-based compilation, exception handling in modern programming languages.
ObjectiveUnderstand translation of object-oriented programs, opportunities and difficulties in optimizing programs using state-of-the-art techniques (profile-based compilation, just-in-time compilation, runtime system interaction)
ContentThis course builds conceptually on Compiler Design (a basic class for advanced undergraduates), but this class is not a prerequisite. Students should however have a solid understanding of basic compiler technology.

The focus is on handling the key features of modern object-oriented programs. We review implementations of single and multiple inheritance (incl. object layout, method dispatch) and optimization opportunities.

Specific topics: intermediate representations (IR) for optimizing compilers, static single assignment (SSA) representation, constant folding, partial redundancy optimizations, profiling, profile-guided code generation. Special topics as time permits: debugging optimized code, multi-threading, data races, object races, memory consistency models, programming language design. Review of single inheritance, multiple inheritance, object layout, method dispatch, type analysis, type propagation and related topics.

This course provides another opportunity to explore software design in a medium-scale software project.
LiteratureAho/Lam/Sethi/Ullmann, Compilers - Principles, Techniques, and Tools (2nd Edition). In addition, papers as provided in the class.
Prerequisites / NoticeA basic course on compiler design is helpful but not mandatory. Student should have programming skills/experience to implement an optimizer (or significant parts of an optimizer) for a simple object-oriented language. The programming project is implemented using Java.
263-2910-00LProgram Analysis Information W4 credits2V + 1UM. Vechev
AbstractModern program analysis techniques are the predominant approach for automatically reasoning about real world programs -- its techniques have been applied in a vast range of application domains.

The course provides an introduction to the fundamental principles, applications, and research trends of modern program analysis.
ObjectiveThe course has 4 main objectives:

* Understand the foundational principles behind program analysis techniques.

* Understand how to apply these principles to build practical, working analyzers for real world problems.

* Understand how to combine these techniques with other approaches (e.g. machine learning techniques) to build powerful end-to-end reasoning systems, not possible otherwise.

* Gain familiarity with the state-of-the-art in the area and the future research trends in the next 5-10 years.
ContentThe last decade has seen an explosion in modern program analysis techniques. These techniques are increasingly being used to reason about a vast range of computational paradigms including:

* finding security violations in web and mobile applications such as JavaScript and Android
* practical type checking and inference (e.g. Facebook's recently released Flow analyzer).
* combinations with machine learning techniques for learning from massive programming data guiding prediction of program properties and prediction of new code.
* establishing properties of biological systems (e.g. DNA computation)
* finding serious errors in systems software (e.g. Linux kernel, device drivers, file systems)
* automatic discovery of new algorithms (e.g. concurrent data structures, distributed algorithms) and end-user programming.
* compilers for domain specific languages
* architecture-driven reasoning of concurrent software (e.g. Intel's x86, ARM, IBM's Power).

This course will provide a comprehensive introduction to modern, state-of-the-art program analysis concepts, principles and research trends, including:

* Static & Dynamic Analysis:
- concepts: memory safety, type checking and inference, typestate, concurrency analysis, abstract interpretation (domains, soundness, precision, fixed points)
- frameworks: Valgrind, FastTrack, EventRacer, Apron, PPL, Facebook's Flow analyzer.

* Statistical program reasoning:
- concepts: combining analysis with statistical models (e.g. Language models, Bayesian networks, Neural networks, etc)
- frameworks: Slang, JSNice (Link)

* Predicate abstraction:
- concepts: Graf-Saidi, Boolean programs, lazy abstraction
- frameworks: Microsoft's SLAM for C programs, Fender

* Symbolic execution:
- concepts: SMT, concolic execution
- frameworks: S2E, KLEE, Sage

* Security Analysis:
- concepts: static + dynamic combination
- example: malware detection

* Pointer analysis:
- concepts: Andersen's, Steensgaard's analysis
- frameworks: Soot, LLVM, WALA

* Program synthesis:
- concepts: L*, version spaces, PBE, CEGIS
- frameworks: Sketch, AGS, SmartEdit, ReSynth

* Applications of Analysis & Synthesis:
- GPU programs, security errors, device drivers, concurrent algorithms, end-user programming.

To gain a deeper understanding of how to apply these techniques in practice, the course will involve a small hands-on programming project where based on the principles introduced in class, the students will build a program reasoning engine (e.g. analysis, predictions) for a modern programming language.
Lecture notesThe lectures notes will be distributed in class.
LiteratureDistributed in class.
Prerequisites / NoticeThis course is aimed at both graduate (M.Sc., PhD) students as well as advanced undergraduate students.
252-0284-00LJava and C # in depth Information
Does not take place this semester.
W5 credits2V + 1U + 1Ato be announced
AbstractJava and C#, both similar and each with its own characteristics, are important languages with wide applications. This course goes into the depth of both languages, each considered for itself but also in comparison with the other.
ObjectiveThis course provides students with an in-depth understanding of:

- The language design philosophy behind Java.
- The language design philosophy behind C#.
- The key language mechanisms of both languages, and how to use them.
- The main properties differentiating the languages.
ContentIntroduction, object-oriented concepts.
Frameworks overview and in-the-small language features.
Classes, objects, inheritance, polymorphism.
Packages/assemblies, abstract classes and interfaces.
Exceptions and genericity.
Reflection.
Threads and Concurrency.
Persistence.
Web Services.
Prerequisites / NoticeThe course is particularly intended for students already having a knowledge of an object-oriented programming language (one of the two listed, or another one such as Eiffel).
252-0286-00LSystem Construction Information
Does not take place this semester.
The course will be offered again in the autumn semester 2015.
W4 credits2V + 1Unot available
AbstractMain goal is teaching knowledge and skills needed for building custom operating systems and runtime environments. Relevant topics are studied at the example of sufficiently simple systems that have been built at our Institute in the past, ranging from purpose-oriented single processor real-time systems up to generic system kernels on multi-core hardware.
ObjectiveThe lecture's main goal is teaching of knowledge and skills needed for building custom operating systems and runtime environments.

The lecture intends to supplement more abstract views of software construction, and to contribute to a better understanding of "how it really works" behind the scenes.
ContentCase Study 1: Embedded System
- Safety-critical and fault-tolerant monitoring system
- Based on an auto-pilot system for helicopters

Case Study 2: Multi-Processor Operating System
- Universal operating system for symmetric multiprocessors
- Shared memory approach
- Based on Language-/System Codesign (Active Oberon / A2)

Case Study 3: Custom designed Single-Processor System
- RISC Single-processor system designed from scratch
- Hardware on FPGA
- Graphical workstation OS and compiler (Project Oberon)

Case Study 4: Custom-designed Multi-Processor System
- Special purpose heterogeneous system on a chip
- Masssively parallel hard- and software architecture based on message passing
- Focus: dataflow based applications
Lecture notesPrinted lecture notes will be delivered during the lecture. Slides will also be available from the lecture homepage.
Seminar in Software Engineering
NumberTitleTypeECTSHoursLecturers
263-2100-00LResearch Topics in Software Engineering Information Restricted registration - show details
Number of participants limited to 22.
W2 credits2ST. Hoefler
AbstractThis seminar introduces students to fundamental results in parallel programming and design. Students will study and present research papers that span topics in both theory and practice, ranging from foundations parallel computing to applications. The focus will be on fundamental lower and upper bounds, thus, many papers will be dated. Students need a solid mathematical background.
ObjectiveAt the end of the course, the students should be familiar with a broad range of key research results in the area of parallel computing, know how to read and assess papers in the area, and be able to highlight practical examples/applications, limitations of existing work, and outline potential improvements.
ContentA selection of research papers with a focus on foundations of parallel computing/programming.
LiteratureThe publications to be presented will be announced on the seminar home page at least one week before the first session.
Prerequisites / NoticePapers will be distributed in the first session.
  •  Page  1  of  1