The lecture covers the entire software life cycle, from project planning, system analysis, cost estimation, design and implementation, validation and verification, to software maintenance. It also covers UML, design patterns, software tools, programming environments, and configuration control.

Learning objectives:

Students will learn and understand the significance of the six phases of planning, definition, design, implementation, testing and acceptance, deployment, and maintenance of the waterfall model for the software development process and will learn about the various steps and artifacts that arise in each phase.

Students will master the modeling of use cases for a scenario using UML use case diagrams. Students will learn about the different types of requirements as well as problems and techniques involved in requirements analysis. Students will learn about the structure and layout of a requirements specification and understand the necessity of a glossary and a feasibility study.

Students can create a functional specification for a given task in accordance with the described functional specification scheme.

Students are familiar with the concept of modeling and different types of UML models and their elements. Students are proficient in creating object models and dynamic models using the UML diagram types class diagram, use case diagram, activity diagram, interaction diagram, sequence diagram, state diagram, and package diagram.

Students understand the basic OO concepts of object, class, instance, attribute, state, encapsulation principle, association and relation, cardinality, multiplicity, inheritance, is-a relationship, abstract method, interface, covariance/contravariance, variance/invariance, polymorphism, visibility/"access protection."

Students understand the necessity of design trade-offs and the concepts of modular and object-oriented design as well as architecture and design patterns, and can compare and apply them.

Students are familiar with the terms abstract machine/virtual machine and program family/software product line.

Students are familiar with and understand the architectural styles of layered architecture, client/server, peer-to-peer, repository, model-view-controller, pipeline, framework, and service-oriented architecture.

Students are familiar with the various categories of design patterns and can use the decoupling patterns adapter, observer, bridge, iterator, proxy, and mediator; the variant patterns abstract factory, visitor, factory method, composite, template method, strategy, and decorator; the state management patterns singleton, flyweight, Memento, Prototype, and State, the control patterns Command and Master/Worker, and the convenience patterns Convenience Class, Convenience Method, Facade, and Null Object.

Students master the mapping of UML models to code.

Students understand the necessity of programming guidelines and self-controlled programming, are familiar with typical programming errors, and can explain the benefits of error and time logs.

Students understand the necessity of software testing and are familiar with the three different types of errors, failures or faults, defects or bugs, and mistakes or manufacturing errors, and their interrelationships.

Students understand the test aids stub, dummy, and mock object and can apply them.

Students understand the differences between testing, verification, and analysis test procedures. Students can explain and distinguish between the different error classes: requirement errors, design errors, and implementation errors.

Students understand the basic terms (software) test, test object, component under test (CUT), test case, test driver, and testing framework and can reproduce them.

Students are familiar with the different types of tests: unit test, integration test, system test, acceptance test, the corresponding phases in the software development process, and the artifacts to which they are applied.

Students are proficient in dynamic testing methods such as structural testing (control flow-oriented testing, data flow-oriented testing, white/glass box testing), functional testing (black box testing), and performance testing (load and stress testing), as well as static testing methods, including static analysis testing programs and manual testing methods such as inspection, review, and walkthrough.

Students can create a control flow graph from a given program.

Students know and understand the control flow-oriented test procedures of statement, branch, and (complete or structured) path coverage and the handling of loops with the "boundary-interior test" and can apply them. Students know simple, multiple, and minimal multiple condition coverage procedures and can apply them.

Students understand the concept of automatically executed test cases and their significance as regression tests, and are familiar with and proficient in creating and verifying tests using the JUnit framework architecture. Students are familiar with test programs for determining the statement coverage of test cases (EMMA) and for checking programming style (Checkstyle). Students are familiar with tools for (partial) automation of tasks during the development process (Maven).

Students master the methods of functional equivalence class formation, boundary value analysis, random testing, and testing of state machines for test case determination.

Students master regression testing, the various integration strategies of integration testing (immediate, incremental, process-oriented, and test-goal-oriented), and know the difference between functional and non-functional system testing.

Students are familiar with testing tools and concepts such as assertions and test programs for identifying defects based on error patterns (Findbugs).

Students understand the individual activities and processes of the acceptance, implementation, and maintenance phases and can describe them. Students are familiar with the differences between maintenance and servicing. Students understand the concepts of change management and tracking (error reports and suggestions for improvement).

Students can describe methods for estimating costs and deadlines, such as scope (in lines of code (LOC)) or person-months (PM), and apply them to examples. Students understand important factors influencing effort estimation ("devil's square": quantity, quality, development time, costs) and basic methods of effort estimation (analogy method, relation method, multiplier method, COCOMO II, consensus estimation methods (Delphi method, planning poker)) and can apply them.

Students are familiar with the various process models: trial and error programming, waterfall model, V-model, prototype model, iterative models, synchronize and stabilize, extreme programming, and Scrum, and can compare them.

Students can design and build graphical user interfaces (GUI) in Java. Students are proficient in developing event-driven software.

Students are familiar with and understand concepts for identifying and tracking software changes using version management and are familiar with basic terms related to (software) configurations, such as version, revisions, and variants. Students master the concepts of check-in/check-out, merging and conflict resolution, as well as the creation and merging of development lines. They are familiar with the differences between the version control systems Revision Control System, Subversion, and Git.

Workload:

6 LP corresponds to approx. 180 working hours, of which

approx. 45 hours Lecture attendance
approx. 15 hours Follow-up work
approx. 15 hours Exercise attendance
approx. 15 hours Tutorial attendance
approx. 45 hours Completing exercises
approx. 1.5 hours Written exam (90 minutes)
approx. 44 hours Exam preparation