Research Group for Applied Software Engineering
Forschungsgruppe für Angewandte Softwaretechnik

Introduction to Software Engineering (EIST) - Summer 2022 (Garching)

Course Information at a Glance:

  • Language: English
  • Type: 3V + 2Ü
  • Module: IN0006 (Garching)
  • ECTS Credits: 6
  • Prerequisites: Lab Course - Foundations of Programming (IN0002)
    • Only students, who passed IN0002 or a comparable course, can participate in this course
    • You must have experience with object-oriented programming in Java
    • You can find more details below
  • TUMonline: You must register for this course in TUMonline before the course starts
  • Course Material: You can find slides and exercises on Artemis
  • Code of Conduct: When participating in this course, you confirm to follow the:
  • Time and Location:
    • Lecture:
    • Exercises: individual tutor groups (Registration required. More details in the first lecture.)
      • Garching (on-campus),
      • Main Campus Munich (on-campus), and
      • Zoom (online)
  • Contact:
    • Post your questions to the corresponding channels on Zulip.
    • You can contact us at This email address is being protected from spambots. You need JavaScript enabled to view it..
    • Please do not contact instructors on their personal email addresses!
  • Announcements (Requires registration on TUMonline)

Go to course registration

Important Information

  • Lectures and exercises are based on interaction; we expect active participation (also over the Livestream)!
  • Students can earn a bonus by completing in-class exercises, team exercises, and homework exercises successfully
  • You must have your own computer and you are required to use it during the lecture and during the tutor groups!
  • You must have experience with object-oriented programming in Java, with an IDE (e.g., Eclipse, IntelliJ) and with git

Intended Learning Outcomes

After successful completion of this module, students are familiar with the concepts and methods of the different phases of a software project, e.g. modeling the problem, reusing classes and components, and delivering the software. They have the ability to select and apply suitable concepts and methods for the development of software for concrete problems.

Students can explain the most important software engineering terms and workflows and are able to analyze and evaluate given problems. They can solve concrete problems in software engineering using development principles, methods and tools, e.g. design, architectural and testing patterns.


Software engineering is the establishment and systematic use of engineering principles, methods, and tools for the division of work, the development and application of extensive, complex software systems. It deals with the development and production of software, the organization and modeling of data structures and objects, and the operation of software systems. Topics of the lecture include, among others:

  • Model-based software engineering with the Unified Modeling Language (UML)
  • Requirements elicitation and analysis (functional model, dynamic model, and object model)
  • System design (specification, software architecture, architectural patterns, and design goals)
  • Object design and implementation (reuse, design patterns, and interface specification)
  • Testing (unit test, integration test, and system test, mock object pattern)
  • Process models in software development, in particular agile development with Scrum
  • Configuration management, build management, release management, and container deployment
  • Quality management, software maintenance and evolution
  • Project organization and communication


You need detailed experiences in object oriented programming to participate successfully in this course. You should be able to ...

  • Understand Java syntax, create variables, write conditional statements (e.g. if and switch) and control structures (e.g. traditional for loop, enhanced for loop and while loop)
  • Use Java’s data types (e.g. bool, int, long, float, double, String) and operators (e.g. =, ==, !=, <, >)
  • Create and invoke static and non-static methods
  • Understand how to use collection types (e.g. Array, List, Set, Map, Stack) with generics
  • Understand the differences between compile time and runtime, and between compile time types and runtime types
  • Understand the differences between classes and objects
  • Create classes, instantiate objects, use attributes, methods, constructors and associations
  • Use modifiers to apply information hiding
  • Apply the concepts of encapsulation, polymorphism and inheritance
  • Write abstract classes and interfaces
  • Understand the differences between overriding and overloading
  • Apply exception handling
  • Use lambda expressions and streams
  • Create simple graphical user interfaces with JavaFX
  • Use Maven (pom.xml) to configure dependencies
  • Write simple test cases with JUnit 5
  • Interact with git repositories (clone, commit, push)

Here are online tutorials to refresh your prerequisites:


Recommended Preparation

  1. If you have not used Artemis before, please follow the tutorial on (you might need to click on your login in the upper right corner and then on Continue Tutorial
  2. Check if you meet the most important preconditions with the programming exercise on Try to solve this programming exercise on your own without the help of others. If you can solve all tasks in a few hours, you are well prepared for this course. If you have problems with some tasks, you should have another look at the online tutorials mentioned above. If you cannot solve all tasks in this programming exercise on your own, this course will be very difficult for you and we strongly recommend that you first learn the prerequisites in another course (e.g. IN0001 and IN0002) and that you take IN0006 at a later time.


Teaching and Learning Methods

By means of a slide presentation with animations, the interactive lecture introduces the concepts and methods of software engineering and explains them using examples. Small exercises, e.g. quizzes, modeling, and programming tasks, with individual feedback help students to identify whether they have understood the concepts and methods.

Accompanying tutorials deepen the understanding of the concepts explained in the lecture by means of suitable group exercises and show the application of the different methods with the help of manageable problems in the different phases of software engineering. Homework enables students to deepen their knowledge in self-study. The presentation of the own solution in the accompanying tutorials improves communication skills, which are essential in software engineering. Individual feedback on homework allows students to measure learning progress and improve their skills.


Lecture with digital slides, live stream, online exercises (programming, modeling, quiz, text) with individual feedback, a communication platform for the exchange between instructors, tutors, and students.


Bernd Bruegge, Allen H. Dutoit: Object-Oriented Software Engineering: Using UML, Patterns and Java, 3rd Edition Publisher: Prentice Hall, 2009


For further questions, please contact us at This email address is being protected from spambots. You need JavaScript enabled to view it.. Please do not contact instructors on their personal email addresses!