Impressum

You are here: SE » TeachingHome » VorlesungSoftwaretechnik2024

Lecture course Software Engineering (Vorlesung Softwaretechnik) SS 2024

29 Aug 2024 - 11:42 | Version 10 | gesinem

Description

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

Lecturers

Barry Linnert (lecturer)
Linus Ververs (tutorial co-ordination)
Oskar Besler (tutor)
Alexander Stage (tutor)
Manuel Zschäbitz (tutor)

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 Mon 2024-04-15 14:00 you may register for the tutorials.

Tutorials start in the second week of the course (calendar week 17)
The first practice sheet will be made available in the first week of the course and is due on Monday, 2024-04-22.

Lecture:
- Monday 10–12, T9/Gr. Hörsaal (Takustr. 9)
- Thursday 12–14, T9/Gr. Hörsaal (Takustr. 9)

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, 2024-07-25, 11:59–13:55, Gr. Hörsaal / Taku 9 & Hs B Hörsaal / Arnimallee 22 & Hs 001 Hörsaal / Arnimallee 3
- Please make sure you travel to the right location as space is limited. On-site, you will be assigned to your table.
post-exam review: Thursday 2024-10-10, 09:59 until at least 10:30, SR 049 / T9
2nd exam: Monday 2024-10-07, 13:59–15:55, T9/Gr. Hörsaal & Hs A Hörsaal / Arnimallee 22
- post-exam review: XXX 2024-10-XX, 15:59 until at least 16:30, XXX

Content

Literature

The lecture is partly based on the book
Bernd Brügge, Allen H. Dutoit: Objektorientierte Softwaretechnik mit UML, Entwurfsmustern und Java, Pearson 2004.
The book is helpful at some points, but not a compulsory material. Or:
Ian Sommerville: Software Engineering, Pearson 2018.
Alternatively, most other modern Software Engineering textbooks may be used.
Additional literature: Harald Störrle: UML 2 für Studenten, Pearson 2005.
Other resources and references are given directly on the corresponding slides.
For the correspondence of German and English technical terms see the glossary on VorlesungSoftwaretechnikGlossar.
The Miniscript summarizes the basic statements of the lecture (16 pages).
A good warm-up would be Robert Glass' Frequently Forgotten Fundamental Facts about Software Engineering.

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.

Subject Matter

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

Introduction: 2024-04-15
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
Case study: 2024-04-18
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.
Introduction: 2024-04-22
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")
Modeling: 2024-04-25
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)
Identify WHAT: 2024-04-29
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
Identify WHAT: 2024-05-02
Use Cases
- Video 06-1 (1-12, 15', 480p): Usecase examples
- Video 06-2 (13-18, 8', 480p): 2 types of use cases: user interaction, overview
- Video 06-3 (19-30, 23', 480p): Getting the level of detail right; use case hierarchies
- Video 06-4 (31-42, 18', 480p): Overall method; checklist
Understand WHAT: 2024-05-06
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
Understand WHAT: 2024-05-13
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
Decide HOW: 2024-05-16
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)
Decide HOW: 2024-05-23
Modularization
- 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, design in conventional vs. agile
Reuse HOW: 2024-05-27
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
Reuse HOW: 2024-05-30
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
Specify HOW: 2024-06-03
Interface Specification
- Video 13-1 (1-10, 16', 480p): specifying visibility (public, protected, package, private) and method signatures
- Video 13-2 (11-23, 19', 480p): OCL part 1
- Video 13-3 (24-29, 12', 480p): OCL part 2
- Video 13-4 (30-40, 24', 480p): systematic or automatic code generation
Test IF: 2024-06-06
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
Test IF: 2024-06-10
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.
Prevent THAT: 2024-06-13
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
Decide HOW (Process): 2024-06-17
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.
Constraints: 2024-06-20
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.
Implement (Process): 2024-06-24
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
Implement (Process): 2024-06-27
Project Management, part 2
- Video 20-1 (1-10, 10', 480p): time planning
- Video 20-2 (11-21, 18', 480p): time and resource planning; critical path
- Video 20-3 (22-30, 14', 480p): risk management
- Video 20-4 (31-38, 13', 480p): risk management details
Implement (Process): 2024-07-01
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
Implement (Process): 2024-07-04
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
Maximize Normal Design: 2024-07-08
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
Maximize Normal Design: 2024-07-11
Reuse, part 2
- Video 24-1 (1-15, 16', 480p): usabililty-related patterns
- Video 24-2 (16-27, 23', 480p): process-related patterns
- Video 24-3 (28-42, 18', 480p): anti-patterns; literature about reuse
Pass on Knowledge: 2024-07-15
Documentation
- 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
Famous Last Words: XXX
Closing
- 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

To familiarize yourself with UML you may use the following online sources besides the recommend book by Brügge/Dutoit: UML specification (attention: difficult to read!), Uni Magdeburg, OBJECTspektrum, Wikipedia, overview of notations. Take note of different UML versions used.
Links for design patterns: Huston, WikiWiki 1, WikiWiki 2, Hillside, Cheat Sheet.
Concerning OCL we recommend the specification itself. It is clearly laid out and has many examples on the basis of a UML class diagram.
Extreme Programming techniques have been described briefly and well by Frank Westphal (in German). Find many more resources at http://www.whoishostingthis.com/resources/extreme-programming/.

Software

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
- recommended by students: Gantt Project

Tutorials

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.

#AktiveTN

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.

#ProjektInDerUebung

Projects

A project is organized like this:

3 to 5 students form a team.
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?
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.
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.
The team carries out the project autonomously. The tutor is available as a coach, in particular when faced with tricky decisions.
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.
The tutor (hopefully) accepts the result.
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 itselfto 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 managementless 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 2006/2007 and WS 2007/2008
- tutorials reorganized with group work

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 (<nop>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