Course Software Engineering for Automation

---

Responsible: Prof.Dr. Kreiser

Course

Meets requirements of following modules(MID)

• in active programs
  • Ba ET2012 SE
  • Ba ET2010 SEA

Course Organization

Version created 2013-06-06 VID 1 valid from WS 2012/13 valid to

Course identifiers Long name Software Engineering for Automation CID F07_SEA_Kreiser CEID (exam identifier)

Contact hours per week (SWS) Lecture 2 Exercise (unsplit) 2 Exercise (split) Lab 1 Project Seminar Tutorial(voluntary) 2

Total contact hours Lecture 30 Exercise (unsplit) 30 Exercise (split) Lab 15 Project Seminar Tutorial (voluntary) 30

Max. capacity Exercise (unsplit) Exercise (split) Lab 18 Project Seminar

Total effort (hours): 180

Instruction language

• German, 70%
• English, 30%

Study Level

• Undergraduate

Prerequisites

• basic skills in modeling of technical system behavior (e.g. State Charts, Petri Nets)
• basic skills in project management

Textbooks, Recommended Reading

• I. Sommerville: Software Engineering (Addison-Wesley / Pearson Studium)
• H. Balzert et.al.: Lehrbuch der Softwaretechnik (Spektrum Akademischer Verlag)
  • Basiskonzepte und Req.Eng.
  • Softwaremanagement
• G.E. Thaller: Software- und Systementwicklung (Heise Verlag)
• Bernd Oestereich: Analyse und Design mit UML 2.3 (Oldenbourg)
• Gamma et.al.: Design Patterns, (Addison-Wesley)
• OMG Unified Modeling Language Spec., www.omg.org/uml
• K. Beck: eXtreme Programming (Addison-Wesley Professional)
• Ken Schwaber: Agiles Projektmanagement mit Scrum (Microsoft Press)
• H.D. Litke: Projektmanagement (Hanser)

Instructors

• Prof.Dr.Kreiser

Supporting Scientific Staff

• Dipl.-Ing. Kellersohn

Transcipt Entry

Software Engineering for Automation

Assessment

Type
oE	normal case (except on large numbers of assessments: wE

Total effort [hours]
oE	10

Frequency: 2-3/year

---

Course components

Lecture/Exercise

Objectives

Contents

• terms
  • software system
  • software produkt
  • software quality
  • complexity in software systems
• modeling object oriented software systems using UML
  • domain model
    • structure
    • behavior
    • interfaces
  • architectural model
  • implementation model
  • model transformation
  • modeling tools
• software development life cycle
  • linear process models
    • phase model
    • V-Modell
  • evolutionary process models
    • spiral model
    • eXtreme Programming
    • Scrum
    • Timebox
  • quality management
    • SOPs
• requirements analysis
  • requirements engineering
  • design-input-requirements
  • legal, regulatory and organisational requirements and constraints
• product risk analysis
  • FMEA
  • FTA
• concept and design
  • design principles
  • feasibility analysis
  • system specification (Pflichtenheft)
  • software specifications
• development
  • chosing suitable programming languages
  • coding standards, coding conventions
  • team development, distributed teams
  • developer controlled testing
  • system integration
  • system launch
  • development tools
• verification & valididation
  • formalized software testing
    • dynamic testing
    • static testing / reviews
  • field evaluation
  • field monitoring / site monitoring
• management activities
  • document management
  • configuration management
    • version management
    • build management
  • test management
  • change management

Aquired Skills

• analyse technical software systems
  • methodically retrieve, consolidate and prioritize system requirements
  • construct a formalized design-input-requirements specification
• model technical software systems
  • unified modeling language, using various diagram types to model simple software systems
    • structural notations
      • class diagram
      • package diagram
      • component diagram
      • deployment diagram
    • behavioral notations
      • use-case diagram
      • activity diagram and concept of actions
      • state machine diagram and variants
      • sequence diagram
  • role based hierachical modeling
    • domain model (customers view)
      • system entity model
      • system interface model
      • system behavioral model
    • software model (devlopers view)
      • class model (technical)
      • detailed behavioral model
      • design principles
      • basic software architecture
  • derive context, interfaces, tasks, behavior and structure of simple software systems out of technical documents
    • understand compact technical documents in detail
    • realize implicit specifications
    • realize and resolve inconsistant specifications
    • realize missing specifications, resolve gaps by own deduction and/or customer interview
  • modeling software systems using UML2.x
    • iteratively develop simple domain models
      • develop entity model
      • develop context and use-case-models (customers view)
      • specify use-cases
        • evaluate and describe standard scenario and essential alternative scenarios
        • refine and formalize as activity diagram
    • iteratively develop simple software models
      • refactor and detail entity model (developers view)
      • detail behavioral models (developers view)
        • model structural based bahavior by state machines
        • refine activites down to the actions layer
        • link actions to class methods
  • efficently use a professional UML2 development tool
  • verify models
    • define evaluation criteria
      • compliance to modeling guides and standards und to design principles
      • completeness vs. unnecessary complexity
      • quality regarding to specific, customer originated criteria
    • define test cases
    • conduct and document model reviews
      • by own
      • with a peer
      • in a group
    • capture and specify model defects
  • refactor models (correct and optimize based on evaluation results)
• design technical software systems
  • analyse product risks, define suitable mitigation methods and specify an appropriate design
  • find suitable design principles to reach given quality criteria, motivate their usage and apply them to the software design
  • find and apply a suitable system and software architecture
  • explain software development methods with respect to distributed teams and make use of suitable methods
  • explain software test methods with respect to distributed teams and make use of suitable methods
• develop technical software systems
  • describe, compare and exemplarily make use of process models
  • derive information from international regulatory standards on software development (german/english)

Additional Component Assessment

Type
fPS	excercise (on course and self study)

Contribution to course grade
fPS	not rated

Frequency: 1/year

Lab

Objectives

Aquired Skills

• analyse larger technical software systems
  • read and understand comprehensive technical documents, especially in english language
  • analyse comprehensive system requirements
• model larger technical software systems
  • separate model layers
    • domain model (customers view)
    • software model (developers view)
  • systematically use model notations to describe software systems
  • iteratively develop behavioral and structural models using UML2
  • efficently use a professional UML2 development tool
  • verify and evaluate models, correct model defects and optimize models
• design larger technical software systems
  • use design principles to reach specific quality criteria
  • use a suitable system and software architecture
  • conduct development and test in a project team
  • handling program code
    • analyze given program code fragments
    • use an object oriented programming language (C++)
• develop larger technical software systems
  • use an evolutionary process model
  • derive information from international regulatory standards on software development (german/english)
  • make a compact presentation of the teams work results to a given target audience in english language

Operational Competences

• model real world systems
  • decomposition
    • evaluate and take account of system borders and system interfaces
    • evaluate and take account of system structure
    • evaluate and take account of system behavior
  • composition
    • design structural and behavioral models
    • integrate models
    • verify and evaluate decomposed and integral models
• manage complex tasks as a team
  • plan and control small projects
  • meet agreements and deadlines
  • plan and conduct reviews
• make use of model transformations (round trip engineering)
  • revert model elements from given C++ code or code fragments
  • manually verify and complete reverted model elements by analyzing code fragments
  • model system extensions and enhancements based on new requirement specification
  • generate code out of a model and manually add or complete not generatable code fragments
  • debug code and systematically verify software units on the target system

Additional Component Assessment

Type
fSC	lab experiment (4h)
fTP	2 lab experiments (each 4h) per project team
oR	presentation on fTP (20min per project team)

Contribution to course grade
fSC	Attestation
fTP	Attestation
oR	prerequisite to course exam

Frequency: 1/year