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

Learning Objectives:

Students will know and understand the importance of the six phases of planning, defining, designing (drafting), implementing, testing and accepting, deploying and maintaining the waterfall model for the software development process and will know the different steps and artifacts that occur in each phase.

Students are proficient in modeling 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 outline of a requirements specification and understand the need for a glossary and 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 machine diagram and package diagram.

Students understand the basic OO concepts of object, class, copy, 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 need for 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 know the concepts of 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, and the convenience patterns convenience class, convenience method, facade, and null object.

Students are proficient in mapping UML models to code.

Students understand the need for programming guidelines and self-controlled programming and know typical programming errors and can explain the usefulness of error and time logs.

Students understand the need for software testing and know the three different types of errors, failure, fault, defect, bug, and mistake and how they are related.

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

Students understand the differences between testing, verifying and analyzing test procedures. Students can explain and distinguish between the different classes of errors: 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 are familiar with the different types of testing: unit test, integration test, system test, acceptance test, the associated phases in the software development process and the artifacts to 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 static analysis test programs and the manual test methods of inspection, review, 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 (full or structured) path covering and the treatment of loops with the boundary-interior test and can apply them. Students know simple, multiple, and minimum-multiple conditional coverage procedures and can apply them.

Students understand the concept of automatically running test cases and their importance as regression tests and know and are proficient in creating and reviewing 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 (partial) automation of tasks during the development process (Maven).

Students are proficient in functional equivalence classing, limit analysis, random testing, and state machine testing for test case determination.

Students are proficient in regression testing, the various integration test integration strategies (immediate, incremental, procedural, and test goal oriented), and know the difference between functional and non-functional system testing.

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

Students understand and are able to reproduce the individual activities and processes of the acceptance, implementation and maintenance phases. Students know the differences between maintenance and servicing. Students understand the concepts of change management and tracking (error messages and improvement suggestions).

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

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 (GBO) in Java. Students are proficient in developing event-driven software.

Students know and understand concepts for identifying and tracking software changes using version management and know basic concepts of (software) configurations such as version, revisions and variants. Students master the concepts of posting/unposting (check-in/check-out), merging and conflict resolution, and creating and merging development lines. They know the differences between the Revision Control System, Subversion, and Git version control systems.

Workload:

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

approx. 45 hrs. lecture attendance
approx. 15 hrs. post-processing
approx. 15 hrs. tutorial attendance
approx. 15 hrs. tutorial attendance
approx. 45 hrs. processing of tutorial exercises
approx. 1.5 hrs. written examination (90 minutes)
approx. 44 hrs. examination preparation