Suchergebnis: Katalogdaten im Herbstsemester 2017

Informatik Master Information
Vertiefungsfächer
Vertiefung in Software Engineering
Kernfächer der Vertiefung in Software Engineering
NummerTitelTypECTSUmfangDozierende
252-0237-00LConcepts of Object-Oriented Programming Information W6 KP3V + 2UP. Müller
KurzbeschreibungCourse that focuses on an in-depth understanding of object-oriented programming and compares designs of object-oriented programming languages. Topics include different flavors of type systems, inheritance models, encapsulation in the presence of aliasing, object and class initialization, program correctness, reflection
LernzielAfter this course, students will:
Have a deep understanding of advanced concepts of object-oriented programming and their support through various language features. Be able to understand language concepts on a semantic level and be able to compare and evaluate language designs.
Be able to learn new languages more rapidly.
Be aware of many subtle problems of object-oriented programming and know how to avoid them.
InhaltThe main goal of this course is to convey a deep understanding of the key concepts of sequential object-oriented programming and their support in different programming languages. This is achieved by studying how important challenges are addressed through language features and programming idioms. In particular, the course discusses alternative language designs by contrasting solutions in languages such as C++, C#, Eiffel, Java, Python, and Scala. The course also introduces novel ideas from research languages that may influence the design of future mainstream languages.

The topics discussed in the course include among others:
The pros and cons of different flavors of type systems (for instance, static vs. dynamic typing, nominal vs. structural, syntactic vs. behavioral typing)
The key problems of single and multiple inheritance and how different languages address them
Generic type systems, in particular, Java generics, C# generics, and C++ templates
The situations in which object-oriented programming does not provide encapsulation, and how to avoid them
The pitfalls of object initialization, exemplified by a research type system that prevents null pointer dereferencing
How to maintain the consistency of data structures
LiteraturWill be announced in the lecture.
Voraussetzungen / BesonderesPrerequisites:
Mastering at least one object-oriented programming language (this course will NOT provide an introduction to object-oriented programming); programming experience
263-2800-00LDesign of Parallel and High-Performance Computing Information W7 KP3V + 2U + 1AT. Hoefler, M. Püschel
KurzbeschreibungAdvanced topics in parallel / concurrent programming.
LernzielUnderstand concurrency paradigms and models from a higher perspective and acquire skills for designing, structuring and developing possibly large concurrent software systems. Become able to distinguish parallelism in problem space and in machine space. Become familiar with important technical concepts and with concurrency folklore.
Wahlfächer der Vertiefung in Software Engineering
NummerTitelTypECTSUmfangDozierende
252-0286-00LSystem Construction Information W4 KP2V + 1UF. Friedrich Wicker
KurzbeschreibungMain 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.
LernzielThe 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.
InhaltCase 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
SkriptPrinted lecture notes will be delivered during the lecture. Slides will also be available from the lecture homepage.
263-2400-00LReliable and Interpretable Artificial Intelligence Information W4 KP2V + 1UM. Vechev
KurzbeschreibungCreating reliable and explainable probabilistic models is a major challenge to solving the artificial intelligence problem. This course covers some of the latest advances that bring us closer to constructing such models. These advances span the areas of program synthesis/induction, programming languages, machine learning, and probabilistic programming.
LernzielThe main objective of this course is to expose students to the latest and most exciting research in the area of explainable and interpretable artificial intelligence, a topic of fundamental and increasing importance. Upon completion of the course, the students should have mastered the underlying methods and be able to apply them to a variety of problems.
InhaltThe material draws on some of the latest research advances in several areas of computer science: program synthesis/induction, programming languages, deep learning, and probabilistic programming.

The material consists of three interconnected parts:

Part I: Program Synthesis/Induction
----------------------------------------

Synthesis is a new frontier in AI where the computer programs itself from user provided examples. Synthesis has significant applications for non-programmers as well as for programmers where it can provide massive productivity increase (e.g., wrangling for data scientists). Modern synthesis techniques excel at learning functions over discrete spaces from (partial) intent. There have been a number of recent, exciting breakthroughs in techniques that discover complex, interpretable/explainable functions from few examples, partial sketches and other forms of supervision.

Topics covered:

- Theory of program synthesis: version spaces, counter-example guided inductive synthesis (CEGIS) with SAT/SMT, synthesis from noisy examples, learning with few examples, compositional synthesis, lower bounds on learning.

- Applications of techniques: synthesis for end users (e.g., spreadsheets), data analytics and financial computing, interpretable machine learning models for structured data.

- Combining neural networks and synthesis

Part II: Robustness of Deep Learning
-----------------------------------------

Deep learning methods based on neural networks have made impressive advances in recent years. A fundamental challenge with these models is that of understanding what the trained neural network has actually learned, for example, how stable / robust the network is to slight variations of the input (e.g., an image or a video), how easy it is to fool the network into mis-classifying obvious inputs, etc.

Topics covered:

- Basics of neural networks: fully connected, convolutional networks, residual networks, activation functions

- Finding adversarial examples in deep learning with SMT

- Methods and tools to guarantee robustness of deep nets (e.g., via affine arithmetic, SMT solvers); synthesis of robustness specs


Part III: Probabilistic Programming
--------------------------------------

Probabilistic programming is an emerging direction whose goal is democratize the construction of probabilistic models. In probabilistic programming, the user specifies a model while inference is left to the underlying solver. The idea is that the higher level of abstraction makes it easier to express, understand and reason about probabilistic models.

Topics covered:

- Inference: MCMC samplers and tactics (approximate), symbolic inference (exact).

- Semantics: basic measure theoretic semantics of probability; bridging measure theory and symbolic inference.

- Frameworks and languages: WebPPL (MIT/Stanford), PSI (ETH), Picture/Venture (MIT), Anglican (Oxford).

- Synthesis for probabilistic programs: this connects to Part I

- Applications of probabilistic programming: using the above solvers for reasoning about bias in machine learning models (connects to Part II), reasoning about computer networks, security protocols, approximate computing, cognitive models, rational agents.
263-2810-00LAdvanced Compiler Design Information W7 KP3V + 2U + 1AR. Eigenmann, T. Gross
KurzbeschreibungThis 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.
LernzielUnderstand 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)
InhaltThis 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.
LiteraturAho/Lam/Sethi/Ullmann, Compilers - Principles, Techniques, and Tools (2nd Edition). In addition, papers as provided in the class.
Voraussetzungen / BesonderesA 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-4630-00LComputer-Aided Modelling and Reasoning Information
In the Master Programme max. 10 credits can be accounted by Labs on top of the Interfocus Courses. Additional Labs will be listed on the Addendum.
W8 KP7PA. Lochbihler, D. Traytel
KurzbeschreibungThe "computer-aided modelling and reasoning" lab is a hands-on course about using an interactive theorem prover to construct formal models of algorithms, protocols, and programming languages and to reason about their properties. The lab has two parts: The first introduces various modelling and proof techniques. The second part consists of a project in which the students apply these techniques
LernzielThe students learn to effectively use a theorem prover to create unambiguous models and rigorously analyse them. They learn how to write precise and concise specifications, to exploit the theorem prover as a tool for checking and analysing such models and for taming their complexity, and to extract certified executable implementations from such specifications.
InhaltThe "computer-aided modelling and reasoning" lab is a hands-on course about using an interactive theorem prover to construct formal models of algorithms, protocols, and programming languages and to reason about their properties. The focus is on applying logical methods to concrete problems supported by a theorem prover. The course will demonstrate the challenges of formal rigor, but also the benefits of machine support in modelling, proving and validating.

The lab will have two parts: The first part introduces basic and advanced modelling techniques (functional programs, inductive definitions, modules), the associated proof techniques (term rewriting, resolution, induction, proof automation), and compilation of the models to certified executable code. In the second part, the students work in teams of two on a project assignment in which they apply these techniques: they build a formal model and prove its desired properties. The project lies in the area of programming languages, model checking, or information security.
LiteraturTextbook: Tobias Nipkow, Gerwin Klein. Concrete Semantics, part 1 (Link)
Seminar in Software Engineering
NummerTitelTypECTSUmfangDozierende
263-2100-00LResearch Topics in Software Engineering Information Belegung eingeschränkt - Details anzeigen
Maximale Teilnehmerzahl: 22
W2 KP2SP. Müller, T. Gross, M. Püschel, M. Vechev
KurzbeschreibungThis seminar is an opportunity to become familiar with current research in software engineering and more generally with the methods and challenges of scientific research.
LernzielEach student will be asked to study some papers from the recent software engineering literature and review them. This is an exercise in critical review and analysis. Active participation is required (a presentation of a paper as well as participation in discussions).
InhaltThe aim of this seminar is to introduce students to recent research results in the area of programming languages and software engineering. To accomplish that, students will study and present research papers in the area as well as participate in paper discussions. The papers will span topics in both theory and practice, including papers on program verification, program analysis, testing, programming language design, and development tools. A particular focus will be on domain-specific languages.
LiteraturThe publications to be presented will be announced on the seminar home page at least one week before the first session.
Voraussetzungen / BesonderesOrganizational note: the seminar will meet only when there is a scheduled presentation. Please consult the seminar's home page for information.
263-2920-00LMachine Learning for Interactive Systems and Advanced Programming Tools Information
Findet dieses Semester nicht statt.
W2 KP2SO. Hilliges, M. Vechev
KurzbeschreibungSeminar on the intersection of machine learning, interactive systems and advanced concepts in programming and programming tools.
LernzielThe seminar will cover a variety of machine learning models and algorithms (including deep neural networks) and will discuss their applications in a diverse set of domains. Furthermore, the seminar will discuss how domain knowledge is integrated into vanilla ML models.
InhaltSeminars often suffer from poor attention retention and low student engagement. This is often due to the format of the seminar where only one student reads papers in-depth and then prepares a long presentation about one or sometimes several papers. There is little reason for the other students to really pay attention or engage in the discussion.

To improve this the seminar will use a case-study format where all students read the same paper each week but fulfill different roles and hence prepare with different viewpoints in mind.

Student roles/instructions

The seminar is organized with each student taking one of the following roles on a rotating basis:

Conference Reviewer (e.g., reviewer of UIST/ICML/PLDI ): Complete a full critical review of the paper. Use the original review from and come to a recommendation whether the paper should be accepted or not.

Historian: Find out how this paper sits in the context of the related work. Use bibliography tools to find the most influential papers cited by this work and at least one paper influenced by the work (and summarize the two papers).

PhD student: Propose a follow-up project for your own research based on this paper - importantly the project should be directly inspired by the paper or even use/extend the method proposed.

Hacker: Implement a (simplified) version of the core aspect of the paper. Prepare a demo for the seminar. In case the complexity is too high perform an in-depth analysis of reproducibility of the paper.

Detective: Find out background information about the authors. Where did they work when the paper was published; what was their role; who else have they published with; which prior work of the authors may have inspired the current paper? Students may contact the authors (but need to adhere to politeness and courteous manners and stay on topic in their conversations).

All students (every week): Come up with alternative title; find a missing result that the paper should have included.
Voraussetzungen / BesonderesParticipation will be limited subject to available topics.
  •  Seite  1  von  1