Search result: Catalogue data in Spring Semester 2015
Computer Science Master | ||||||
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 | ||||||
Number | Title | Type | ECTS | Hours | Lecturers | |
---|---|---|---|---|---|---|
252-0268-00L | Concepts of Concurrent Computation | W | 7 credits | 3V + 2U + 1A | S. Nanz | |
Abstract | Concurrent 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. | |||||
Objective | After 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. | |||||
Content | Topics 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 / Notice | The 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-00L | How To Write Fast Numerical Code Prerequisite: Master student, solid C programming skills. | W | 6 credits | 3V + 2U | M. Püschel | |
Abstract | This 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. | |||||
Objective | Software 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. | |||||
Content | The 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-00L | Advanced Compiler Design | W | 7 credits | 3V + 2U + 1A | T. Gross | |
Abstract | This 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. | |||||
Objective | Understand 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) | |||||
Content | This 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. | |||||
Literature | Aho/Lam/Sethi/Ullmann, Compilers - Principles, Techniques, and Tools (2nd Edition). In addition, papers as provided in the class. | |||||
Prerequisites / Notice | A 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-00L | Program Analysis | W | 4 credits | 2V + 1U | M. Vechev | |
Abstract | Modern 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. | |||||
Objective | The 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. | |||||
Content | The 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 notes | The lectures notes will be distributed in class. | |||||
Literature | Distributed in class. | |||||
Prerequisites / Notice | This course is aimed at both graduate (M.Sc., PhD) students as well as advanced undergraduate students. | |||||
252-0284-00L | Java and C # in depth Does not take place this semester. | W | 5 credits | 2V + 1U + 1A | to be announced | |
Abstract | Java 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. | |||||
Objective | This 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. | |||||
Content | Introduction, 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 / Notice | The 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-00L | System Construction Does not take place this semester. The course will be offered again in the autumn semester 2015. | W | 4 credits | 2V + 1U | not available | |
Abstract | Main 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. | |||||
Objective | The 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. | |||||
Content | Case 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 notes | Printed lecture notes will be delivered during the lecture. Slides will also be available from the lecture homepage. | |||||
Seminar in Software Engineering | ||||||
Number | Title | Type | ECTS | Hours | Lecturers | |
263-2100-00L | Research Topics in Software Engineering Number of participants limited to 22. | W | 2 credits | 2S | T. Hoefler | |
Abstract | This 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. | |||||
Objective | At 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. | |||||
Content | A selection of research papers with a focus on foundations of parallel computing/programming. | |||||
Literature | The publications to be presented will be announced on the seminar home page at least one week before the first session. | |||||
Prerequisites / Notice | Papers will be distributed in the first session. |
- Page 1 of 1