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

Learning objectives:

Students know and understand the importance of the six phases planning, definition, design, implementation, testing and acceptance, deployment and maintenance of the waterfall model for the software development process and know the various steps and artifacts that arise in the individual phases.

Students master the modeling of use cases of a scenario using UML use case diagrams. Students know the different types of requirements as well as problems and techniques of requirements elicitation. Students know the structure and organization of a requirements specification and understand the need for a glossary and a feasibility study.

Students can create a requirements specification for a given task according to the described requirements specification scheme.

Students know the concept of modeling as well as different types of UML models and their elements. Students master the creation of object models and dynamic models with 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, co-/contravariance, in-/variance, polymorphism, visibility/"access protection".

Students understand the necessity of design considerations and the concepts of modular and object-oriented design as well as architecture and design patterns and can compare and apply these.

Students know the terms abstract machine/virtual machine and program family/software product line.

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

Students know the different categories of design patterns and can apply and evaluate 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 handling patterns single piece, flyweight, memento, prototype and state and the control patterns command and master/worker as well as 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 and are familiar with typical programming errors and can explain the benefits of error and time logs.

Students understand the necessity of software tests and know the three different types of errors, failure or fault, defect or bug and error or manufacturing error and their relationship.

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

Students understand the differences between testing, verifying and analyzing test procedures. Students can explain and differentiate between the various error classes of requirements 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 know the different types of tests: unit test, integration test, system test, acceptance test, the corresponding phases in the software development process and the artifacts on which they are applied.

Students are proficient in the dynamic test methods of 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 test methods, including test programs for static analysis and the manual test methods of inspection, review and walkthrough.

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

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

Students understand the concept of automatically running test cases and their significance as regression tests and know and master the creation and verification of tests using the JUnit framework architecture. Students know test programs for determining the instruction coverage of test cases (EMMA) and for checking the programming style (Checkstyle). Students know tools for the (partial) automation of tasks during the development process (Maven).

Students are familiar with the methods of functional equivalence class formation, limit value analysis, random testing and testing state machines to determine test cases.

Students are proficient in regression tests, the various integration strategies of integration tests (direct, incremental, procedure-oriented and test target-oriented) and know the difference between functional and non-functional system tests.

Students are familiar with test tools and concepts such as assertions and test programs for identifying defects using error patterns (findbugs).

Students understand the individual activities and processes of the acceptance, introduction and maintenance phases and can reproduce them. Students know the differences between maintenance and servicing. Students understand the concepts of change management and tracking (error messages and suggestions for improvement).

Students can reproduce 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 influencing factors of 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 know the different process models programming by trial and error, 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 master the development of event-driven software.

Students know and understand concepts for identifying and tracking software changes with the help of version management and know basic terms of (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 know the differences between the Revision Control System, Subversion and Git version management systems.

Workload:

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

approx. 45 hours of lecture attendance
approx. 15 hours of follow-up work
approx. 15 hours attending exercises
approx. 15 hours attending tutorials
approx. 45 hours working on exercises
approx. 1.5 hours written examination (90 minutes)
approx. 44 hours exam preparation