Lecture course Software Engineering (Vorlesung Softwaretechnik) SS 2020


Software Engineering is the discipline of software construction on a large scale and an important part of systems engineering.

Software Engineering aims at providing answers to the following questions:

  • How to find out which characteristics a software should have (requirements engineering)
  • How to describe these characteristics (specification)
  • How to structure software so that it can be built easily and changed flexibly (architecture and design)
  • How to change software which does not (or no longer) have such a structure or that is difficult to understand (reengineering)
  • How to uncover defects in software (quality assurance, testing)
  • How to organize the tasks in a software company or department to regularly achieve cost-efficient and high-quality results (constructive quality assurance, process management, project management)
  • Which common problems underlie all of these questions and which general approaches underlie the methods and techniques that are used

...and many similar ones.

This course gives an overview of the problems and methods and provides essential basic knowledge for any computer scientist working as a software engineer.

Organizational Matters


Requirements & Target Group, Classification, Credits, etc.

See entry in the KVV course catalog.

This lecture is a required course for Computer Science Bachelor students.

Dates & News

  • The subdivision into tutorial groups is done via the KVV
  • As from 2020-04-17 14:00 you may register for the tutorials.

  • Tutorials start in the second week of the course (calender week 18)
  • The first practice sheet will be made available in the first week of the course on Thursday, 2020-04-20 and is due on Sunday, 2020-04-26.

  • Lecture:
    • Monday 12–14, auditorium of the Institute of Computer Science (Großer Hörsaal der Informatik), Takustr. 9
    • Thursday 12–14, auditorium of the Institute of Computer Science (Großer Hörsaal der Informatik), Takustr. 9
  • Tutorials:
    When Who KVV Where Exception
    Monday 16:00–18:00 Pascal Müller 1 Takustraße 9 SR 053  
    Wednesday 16:00–18:00 Tamara Fischer 2 Takustraße 9 SR 055  
    Tuesday 12:00–14:00 Jannis Hamann 3 Takustraße 9 SR 046  
    Friday 12:00–14:00 Pascal Müller 4 Takustraße 9 SR 055  
    Thursday 16:00–18:00 Tamara Fischer 5 Takustraße 9 SR 049  
    Wednesday 12:00–14:00 Jannis Hamann 6 Arnimallee 7 SR 031  
    Friday 16:00–18:00 (aktuell unbesetzt) 7 Takustraße 9 SR 046  

  • Exams: see next section

Credits & Exams

The criteria for gaining credits are
  • regular participation in the tutorials
  • active participation in the tutorials: oral participation in the tutorials & regular preparation of the tasks
  • passing of the exam
    • The following information is preliminary, as the form of the exam is yet undetermined!:
    • The exam takes 90 minutes and there are 90 points to be achieved.
    • To pass, a number of points typically between 28 and 35, will suffice. The actual threshold will be decided upon when correcting.
    • You may use the following resources during the exam:
      • A handwritten cheat sheet prepared by yourself with a maximum size of 1 sheet of DIN A3. Alternatively: Two tightly linked DIN A4 sheets (stapled or glued). There are no restrictions as to the content. The sheet may be written on from both sides. You may only use your own sheet you brought.
        The sheet needs to be handwritten by yourself, as its purpose is mainly fulfilled in the process of preparation, less so during the actual exam.
      • Students whose mother tongue is not German may use a dictionary during the exam. They also may write their answers in English.

  • 1st exam: Thursday 2020-07-30, 11:59–13:55



Lecture Videos, Slide PDFs

Recorded lectures will appear over time in the next few weeks. The links will be inserted in the "Subject matter" list below.

There are two versions of each video:
  • Full HD (1080p): recommended for large screens when enough network bandwidth is available.
  • SD (480p): recommended for small screens (smartphone) or when network bandwidth is scarce. These videos have only about half the data volume and thus need only half as much bandwidth.

The slides will be reworked a bit and will also appear only over time. If you want to peek ahead, see the previous year.

Subject Matter

Most slide sets are in German. A few are English and a few are mixed German/English.

  1. Introduction: 2020-04-20
    Introduction (Einführung)
    • Video 00-1 (4'): Hello!; Lutz Prechelt; how to use the videos
    • Video 01-1 (1-9, 14', 480p): software; software engineering (SE); tasks of SE.
    • Video 01-2 (10-15, 12', 480p): personal relevance; stakeholders
    • Video 01-3 (16-20, 8', 480p): quality criteria
    • Video 01-4 (21-24, 12', 480p): rough partitionings of software engineering: product/process; principle/method/procedure/tool; technical vs. human aspects
    • Video 01-5 (25-33, 20', 480p): kinds of software engineering settings
    • Video 01-6 (34-40, 13', 480p): learning goals; learning approach
  2. Case study: 2020-04-23
    Electronic Health Card (Elektronische Gesundheitskarte)
    • Video 02-1 (1-10, 14', 480p): eGK: a complex software project
    • Video 02-2 (11-19, 17', 480p): functional requirements for the e-prescription ('eRezept')
    • Video 02-3 (20-25, 14', 480p): nonfunctional requirements (performance, availability, security)
    • Video 02-4 (26-35, 13', 480p): still more notations, size of the project
    • Video 02-5 (36-42, 19', 480p): what became of it and why, and what to learn from that: participants; beneficiaries and lines of conflict; resulting introduction schedule
    • addendum: digital signatures.
    • "bear-in-mind"-hints regarding: domains, non-functional requirements, need of cooperation, project risk.
  3. Introduction: 2020-04-27
    The Software Engineering Landscape ("Die Welt der Softwaretechnik")
    • Video 03-1 (1-13, 14', 480p): Tacoma Narrows bridge
    • Video 03-2 (14-27, 20', 480p): normal vs. radical design
    • Video 03-3 (27-33, 9', 480p): properties of normal design
    • Video 03-4 (34-46, 13', 480p): SE problems ("Die Welt der Problemstellungen")
    • Video 03-5 (47-52, 7', 480p): SE technical solution approaches ("Die Welt der technischen Lösungsansätze")
    • Video 03-6 (53-62, 20', 480p): SE methods space ("Die Welt der methodischen Lösungsansätze")
  4. Modeling: 2020-04-30
    Modeling with UML
    • Video 04-1 (1-9, 12', 480p): Modelling and UML (reality vs. model; phenomena vs. concepts)
    • Video 04-2 (10-23, 17', 480p): class diagrams
    • Video 04-3 (24-33, 13', 480p): sequence diagrams, state machine diagrams (statecharts)
    • Video 04-4 (34-46, 12', 480p): activity diagrams, other diagrams (component diagrams, collaboration diagrams, interaction overview diagrams etc.)
    • Video 04-5 (47-54, 12', 480p): UML meta model; profiles; what to learn about UML
    • some notation details (classes, associations, interfaces, states)
  5. Identify WHAT: 2020-05-04
    Requirements Elicitation
    • Video 05-1 (1-8, 14', 480p): requirements and requirements engineering; types and kinds of requirements (RE)
    • Video 05-2 (9-14, 10', 480p): conventional vs. agile approach and view
    • Video 05-3 (15-22, 13', 480p): requirements vs. specifications; domain properties and their role for validity; requirements elicitation tasks
    • Video 05-4 (23-28, 7', 480p): difficulties in requirements elicitation
    • Video 05-5 (29-42, 16', 480p): requirements elicitation methods
  6. Identify WHAT: 2020-05-07
    Use Cases
  7. Understand WHAT: 2020-05-11
    Requirements Analysis (Static Object Model)
    • Video 07-1 (1-10, 12', 480p): Object modelling intro
    • Video 07-2 (11-19, 13', 480p): noun/verb requirements text analysis (nouns are candidates for classes, verbs for operations, adjectives for attributes, proper nouns for instances, "is a" for inheritance, etc.)
    • Video 07-3 (20-28, 16', 480p): checklists for the identification of classes, associations, attributes, operations, inheritance; method hints
    • Video 07-4 (29-40, 19', 480p): participant roles and their different views on class diagrams; analysis model vs. design model
  8. Understand WHAT: 2020-05-14
    Requirements Analysis (Dynamic Object Model)
    • Video 08-1 (1-11, 12', 480p): sequence diagrams
    • Video 08-2 (12-25, 13', 480p): Statecharts
    • Video 08-3 (26-34, 14', 480p): Requirements document structure; nonfunctional requirements
    • Video 08-4 (35-43, 14', 480p): conventional vs. agile; verification vs. validation; project agreement
  9. Decide HOW: 2020-05-18
    Software Architecture
    • Video 09-1 (1-11, 14', 480p): Architecture (overall structure, in particular a plan how to fulfill the nonfunctional requirements)
    • Video 09-2 (12-21, 18', 480p): Architectural styles (for self-developed parts of an architecture)
    • Video 09-3 (22-34, 29', 480p): Web architecture (many elements of reusable architecture: GUI+API, i18n, anti-injection measures, scalability, decoupled development by microservices)
    • Video 09-4 (35-50, 27', 480p): Modularization (coupling, interface, information hiding, responsibility, modifiability, criteria for good modules)
  10. Decide HOW: 2020-05-25
    • Video 10-1 (1-10, 10', 480p): what is a module?; how to split into modules?, KWIC case study, KWIC 1: data flow architecture
    • Video 10-2 (11-21, 10', 480p): KWIC 1 discussion
    • Video 10-3 (22-29, 8', 480p): KWIC2 with central control
    • Video 10-4 (30-40, 11', 480p): KWIC3 with data abstraction, change scenarios, change scenario review
    • Video 10-5 (41-49, 20', 480p): analysis vs design, conclusions, desigin in conventional vs. agile
  11. Reuse HOW: 2020-05-28 (combined with the next lecture below!)
    Design Patterns, part 1
    • Video 11-1 (1-12, 8', 480p): Why patterns?: Examples Get-15 and Tic-Tac-Toe
    • Video 11-2 (13-24, 21', 480p): Composite pattern
    • Video 11-3 (25-34, 18', 480p): Complexity reduction through patterns, Adapter pattern, Bridge pattern
    • Video 11-4 (35-40, 12', 480p): Facade pattern, design heuristics, literature
  12. Reuse HOW: 2020-05-28 (combined with the previous lecture)
    Design Patterns, part 2
    • If you don't want to view all of both parts, skip Bridge in unit 11 and skip Abstract Factory and Builder in unit 12.
    • Video 12-1 (1-11, 12', 480p): types of design patterns, Proxy pattern
    • Video 12-2 (12-23, 18', 480p): Command pattern, Observer pattern
    • Video 12-3 (24-33, 12', 480p): Strategy pattern, Abstract Factory pattern
    • Video 12-4 (34-42, 12', 480p): Builder pattern, summary, conventional vs. agile
  13. Specify HOW: 2020-06-04
    Interface Specification
  14. Test IF: 2020-06-08
    Analytical Quality Assurance, part 1
    • Video 14-1 (1-12, 18', 480p): terminology: test, testing, testcase, failure, defect, error etc.
    • Video 14-2 (13-21, 14', 480p): test case selection: function testing (black box testing)
    • Video 14-3 (22-30, 15', 480p): structure testing (white box testing), heuristics
    • Video 14-4 (31-41, 16', 480p): choosing what part of the software to test: pure module test, bottom-up, top-down
    • Video 14-5 (42-49, 10', 480p): how to determine the expected behavior; when to repeat tests
    • Video 14-6 (50-60, 16', 480p): test automation
    • Video 14-7 (61-64, 7', 480p): when to stop testing, specifically agile approaches
  15. Test IF: 2020-06-11
    Analytical Quality Assurance, part 2
    • Video 15-1 (1-12, 17', 480p): Test frameworks: JUnit
    • Video 15-2 (13-23, 22', 480p): GUI test autmation; usability testing; load testing; profiling; acceptance testing
    • Video 15-3 (24-37, 22', 480p): manual static methods: reviews and inspections, perspective-based reading
    • Video 15-4 (38-43, 7', 480p): automatic static methods: model checking etc.
    1. Additional event as part of the FU Berlin International Week 2020-06-11
      Marian Petre: Understanding what it takes to become an effective software developer
    • The slides alone are not too useful as a summary, as they have hardly any text, but this short article is (plus possibly the longer one about the introductory part)
  16. Prevent THAT: 2020-06-15
    Constructive Quality Assurance (Quality Mgmt, Process Mgmt)
    • Video 16-1 (1-10, 11', 480p): principles of constructive QA; conventional vs. agile approaches
    • Video 16-2 (11-19, 19', 480p): CMMI
    • Video 16-3 (20-29, 16', 480p): CMMI results; ISO 9000 series; Total Quality Management (TQM)
    • Video 16-4 (30-38, 13', 480p): Agile retrospectives; QA lectures overall structure
  17. Decide HOW (Process): 2020-06-18
    Process Models
    • Video 17-1 (1-9, 12', 480p): software development processes and process models; roles/artifacts/activities; waterfall model
    • Video 17-2 (10-21, 22', 480p): repairs to the waterfall model: iteration (prototype model, evolutionary models, spiral model); reduced planning (agile processes).
    • Video 17-3 (22-28, 11', 480p): differences between models; how to pick one.
    • Video 17-4 (29-36, 10', 480p): adaptable and allegedly universal models: RUP, V-Modell XT.
    • Video 17-5 (37-42, 10', 480p): an Agile process model: eXtreme Programming (XP); summary.
  18. Constraints: 2020-06-22
    Personality Types
    • Video 18-1 (1-8, 6', 480p): personality types as a tool
    • Video 18-2 (9-19, 14', 480p): your reactions to that idea; MBTI dimension E/I, warnings.
    • Video 18-3 (20-26, 8', 480p): MBTI dimensions S/N, T/F, J/P.
    • Video 18-4 (27-35, 10', 480p): Keirsey temperaments: SJ, SP, NT, NF
    • Video 18-5 (36-41, 7', 480p): Enneagramm, Five Factor Model (Big 5)
    • Video 18-6 (42-48, 17', 480p): personality type in software development (strengths and pitfalls of various types); identify your own type.
  19. Implement (Process): 2020-06-25
    Project Management, part 1
    • Video 19-1 (1-10, 17', 480p): 2 project management (PM)styles: planning-steering and agile-selforganizing ; definition of PM; magic triangle
    • Video 19-2 (11-21, 14', 480p): the 9 sub-areas of PM
    • Video 19-3 (22-32, 18', 480p): basic cost estimation methods
    • Video 19-4 (33-42, 16', 480p): more basic cost estimation methods; Function Point; cost estimation difficulties
  20. Implement (Process): 2020-06-29
    Project Management, part 2
  21. Implement (Process): 2020-07-02
    Project Management, part 3
    • Video 21-1 (1-11, 15', 480p): teams; roles (classical vs. agile); classical vs. agile decision-making
    • Video 21-2 (12-21, 15', 480p): Psychological phenomena: probability estimation, motivation
    • Video 21-3 (22-28, 14', 480p): attribution, attitudes, cognitive dissonance
    • Video 21-4 (29-36, 9', 480p): social influences
  22. Implement (Process): 2020-07-02 (likely combined with the previous lecture)
    Project Management, part 4
    • Video 22-1 (1-10, 11', 480p): project plan
    • Video 22-2 (11-18, 19', 480p): project management approaches in agile processes; in general
    • Video 22-3 (19-28, 22', 480p): examples of non-linear project dynamcics and how to cope with them: Brook's law; reinforcement of quality deficits; vicious circle of quality and time pressure
    • Video 22-4 (29-37, 17', 480p): communication (planned/unplanned, synchronous/asynchronous); meetings
  23. Maximize Normal Design: 2020-07-06
    Reuse, part 1
    • Video 23-1 (1-12, 19', 480p): aspects and dimensions of reuse (product/process; object; aim); risks assessment; obstacles; productivity;
    • Video 23-2 (13-19, 10', 480p): normal design via reuse; the idea of patterns
    • Video 23-3 (20-30, 14', 480p): principles as patterns: abstraction, structuring, hierarchy, modularization, locality, consistency, reuse, notations
    • Video 23-4 (31-42, 15', 480p): analysis patterns
  24. Maximize Normal Design: 2020-07-09
    Reuse, part 2
  25. Pass on Knowledge: 2020-07-13
    • Video 25-1 (0-10, 17', 480p): Definition; types of documentation; quality attributes (clear, precise, correct, helpful); typical problems; solution approaches
    • Video 25-2 (11-20, 25', 480p): self-documentation; minimal documentation; positve and negative examples
    • Video 25-3 (21-29, 12', 480p): what is important for documentation of: APIs, modules, architecture, requirements; idea of rationale management
    • Video 25-4 (30-40, 14', 480p): rationale management details (questions + suggestions + criteria + arguments make decisions) and example; the English serial comma
  26. Famous Last Words: 2020-07-16
    • Video 26-1 (1-11, 17', 480p): reminder: some ideas from the introduction; what to expect in practice; factors and challenges for job satisfaction
    • Video 26-2 (12-12, 16', 480p): a walkthrough of the topic list: key ideas
    • Video 26-3 (13-21, 25', 480p): four topics not addressed; final words

Further resources


  • UML diagrams
    • BOUML. It's not the greatest program in the world, but fast and sufficiently good. Alternatively you may browse through the following big list of UML tools (or the list at Wikipedia).
    • Or use a vector-oriented paint program like e.g. Inkscape or the handy web-based draw.io.
    • In the computer rooms ("Rechnerpools"): IBM Rational Rose (a full-fledged CASE tool) is installed on the computers in the basement, which enables you to draw diagrams easily. However, Rose has many additional functions and is a complex software package.
    • recommended by students:
      • Dia - part of the Gnome desktop (also available under Windows)
      • UMLet - free and open source UML tool written in Java; stand-alone, as Eclipse plugin, or web-based as UMLetino
  • Gantt charts


  • tutorials begin in the second week of the course
  • the first practice sheet will be given out in the first week of the course

Practice Sheets

Each new practice sheet will appear in the KVV. Solutions must be uploaded to the KVV before the respective deadline.

Active Participation

As an alternative to the tutorials you may define a software engineering project on your own and disengage to a large extent from the tutorials.
But beware: consequently the necessary exam preparation is more your personal responsibility! For details refer to the next section.


A project is organized like this:
  1. 3 to 5 students form a team.
  2. The team formulates a written project proposal:
    • What do we want to do? Why?
    • What is the goal of the project? When is it achieved (criteria)?
    • What are the subtasks? Who is responsible for which subtask? How much effort will each subtask demand?
  3. The tutor agrees to the proposal (or requests changes/amendments). Project topics may concern any aspect of software engineering (preferably many aspects), but should not focus on implementation. Especially non-trivial planning and quality assurance elements need to be included. Projects starting from scratch are hardly ever suitable.
  4. The team presents a proposal in the tutorial and asks for comments: hints as to additions and improvements, warnings concerning risks and pitfalls, technical tips.
  5. The team carries out the project autonomously. The tutor is available as a coach, in particular when faced with tricky decisions.
  6. The team presents the project result to the tutor, with all team members taking on an active role and being able to answer most questions well.
  7. The tutor (hopefully) accepts the result.
  8. The team presents the result in the tutorial. The tutor decides whether all project members have contributed (well) enough to the project to pass.

Exam Preparation

Basically the content of the lecture plus the content of the tutorials will be tested.

The practice sheets suggest possible exam questions, but not all material suits itself to a written exam well, so expect "hard" stuff such as terminology, modeling, patterns, specific methods, etc. to be represented well and "soft" topics such as project management less so. Some of the practice sheet tasks derive from old exam questions. An extra practice sheet for exam preparation may be found amongst the practice sheets, also giving advice as to the answers.

The 16-page mini script not only summarizes the course nicely, it also gives concrete learning advice.

History of the Curriculum

(small changes are made every year)

  • SS 2020
    • created videos for all units
    • added comparisons "conventional vs. agile" to most units
    • greatly reworked unit "architecture", more concrete examples

  • SS 2019
    • discussed or emphasized agile methods more in many places

  • SS 2008 shortened the curriculum from 30 units to 26 units due to the shift to the summer semester:
    • replaced the three units about electronic health card (eGK) by a completely new one
    • shortened the two units about UML introduction/overview down to a single one
    • shortened unit 35_Schnittstellenspezifikation somewhat and 36_Objektimplementierung a lot; and merged the two.

  • WS 2005/2006
    • lecture completely changed based on own concept, partly based on book "Objektorientierte Softwaretechnik" by Brügge and Detoit.

  • WS 2004/2005
    • lecture completely changed based on book SE7 by Ian Sommerville (prior: book by Helmut Balzert)

  • WS 2003/2004
    • Omitted:
      • unit about components (JavaBeans, COM);
      • unit about server (serverseitigen) components (EJB, Corba, COM+)
      • unit about web UI (Servlet, JSP, CGI)
      • unit about reuse
    • Added:
      • unit about documentation
      • unit about test automatisation
      • unit about risk management

  • WS 2002/2003 (block seminar in march)
    • first lecture, based on "Lehrbuch der Softwaretechnik" (part 1 and 2) by Helmut Balzert.


Should you have comments or suggestions as to this page, please leave them here (preferably with date and name):


Topic revision: r54 - 15 Jul 2020, GesineMilde
  • Printable version of this topic (p) Printable version of this topic (p)