Real-Time Software Design with UML 2.0

A detailed design course which focuses on designing a Real-Time Embedded System (RTES) using UML 2.0 notation to document the proposed design. This makes it significantly different from most UML courses which primarily focus on UML notation rather than design principles.

By using comprehensive real-world examples it also identifies the areas where UML 2.0 improves on UML 1.5, but also discusses its weaknesses (areas such as concurrency, multi-processing and distributed systems). The course is backed up by a comprehensive ‘real-world’ CASE study demonstrating how to apply UML 2.0 to ato RTES.

This course has been developed by the leading author Dr. J. E. Cooling.

OO-503
5 days
£2260
pdf download
1 - 5 Oct 2012

Course Overview

 

Course Objectives:

  • To provide an understanding of the design principles of modern real-time software developments methods.
  • To show how to develop real-time software in a rigorous and systematic manner.
  • To enable attendees to develop their own practical design skills.
  • To teach the UML 2.0 design notation for use on RTES.

Delegates Will Learn:

  • The fundamental concepts and terminology of real-time software techniques.
  • The diagrammatic and modelling underpinnings provided by UML for OO development methods.
  • How to apply the design principles in real-time applications.
  • The basics of an integrated, traceable and consistent approach in the development of software for real-time systems.
  • Where and how CASE tools can be used in the development process.

Pre-requisites:

  • Some understanding of technical software development methods and some knowledge of a high-level programming language.

Who Should Attend:

  • Designers new to the area of real-time software design.
  • Developers embarking on projects using UML-based techniques for the first time.

Duration:

  • Five days

Course Materials:

  • Delegate handbook
  • All worked examples and solutions

Related courses:

Course Workshop:
Approximately 50% of the course involves practical application of the techniques discussed. Delegates work in small groups dealing with problems based on real-world systems.

The course specifically does not make use of a CASE tool. From our experience a CASE tool distracts delegates from learning design issues and UML. However, the workshops clearly demonstrate the benefits and disadvantages of CASE tools thus aiding CASE tool selection.

Course Outline

 

Introduction to Real-Time Systems Design

  • An overview of real-time systems
  • Incremental design processes

Software Machines - Fundamentals:

  • Modularization principles and practices
  • Diagramming techniques in program design - the UML activity diagram

Overview of OO Design Concepts:

  • Designing systems as sets of collaborating objects
  • Classes, objects and their features
  • Key design and build issues: software templates, encapsulation, interfacing, information hiding, inheritance and aggregation

Basic Class and Object Modelling:

  • Design templates, encapsulation, interfacing and information hiding
  • Class and object generalisation and specialisation: inheritance

Modelling Dynamic Behaviour:

  • State diagrams to define system and object dynamics
  • The concepts, syntax and semantics of UML state machine diagrams

Developing the Ideal Object Podel:

  • Object relationships, communication and control in an ideal environment
  • Scenarios, sequence diagrams and communication diagrams
  • Responsibility-based design techniques
  • Interfacing to the real-world

Developing the Practical Sequential (Procedural) Object Model:

  • Controlling the collective behaviour of objects in sequential code: the coordinator object
  • Specifying algorithmic (processing) operations using activity diagrams

Developing the Specification Model for Small Systems:

  • The role of the specification model
  • Concurrent and non-concurrent structures - active and passive objects
  • Specifying object structures - flat object structure

Concurrent Systems and Task-based Design:

  • Problems with abstract software design
  • Fundamentals of multitasking design

Developing the Implementation (tasking) Model for Small Systems:

  • Mapping the specification model to the tasking model.

Developing Medium-sized Systems:

  • Introduction to composite structures, ports and interfaces
  • Generating the specification model for composite structures
  • Specifying the implementation (tasking) model

Developing Larger Systems:

  • Key building blocks - packages and components
  • Subsystem structuring of designs
  • Implementation modelling

Multi-computer Systems:

  • Multi-computer architectures for real-time systems
  • Criteria for mapping software onto hardware
  • A practical design technique

Use Case Analysis:

  • Use cases for organising and presenting requirements
  • Scenarios and use cases
  • System scope and direct and indirect actors.
  • Modelling actor-system interactions graphically

Case Study:

  • This is based on developing embedded software for a computer-controlled manufacturing test rig.