The goal of this one-day course is to introduce and discuss the main design principles and methods that underlie the object-oriented, generic and functional programming styles. The topics are language-independent and they only need to be learned once, after which they can be implemented in programming languages such as C++, C# and Java, for example. In this way we reduce the design to its core features without getting bogged down in non-essential implementation details (at least, not just yet) that we shall relegate to the programming phase of the software development process.

We discuss the full design process and we show the main steps in mapping system requirements to design blueprints. We document these blueprints using UML class and component diagrams. Finally, we can use these diagrams directly in a given object-oriented programming language.

Some key features of the course are:

• Clear, concise and language-independent overview of the software design process.
• Tips and guidelines on good design practice.
• Do's and don'ts: how to design maintainable, loosely-coupled software systems.
• Create design blueprints that map seamlessly to code.
• Learn to distinguish between good and bad designs.

The topics from this course are used in later language-focused courses.

Part I: System Design

System Goals

• Core process and major system data flow
• Functional and non-functional requirements
• Activity diagrams
• Discovering potential concurrency

System Scoping

• System context diagrams
• System Under Discussion (SUD)
• Satellite systems
• System decomposition and system responsibilities

Software Interconnection Architectures

• Interface Interconnection Architecture (ICA)
• Object Interconnection Architecture (OCA)
• Plug and Socket Interconnection Architecture (P&S)
• Software contracts

Part II: Detailed Component Design

Component Design

• Component black-box and white-box interfaces
• Interface specification and design
• Loose coupling and choice of interconnection architecture
• External and internal components
• UML component diagrams

Object Design

• Inheritance (and its dangers)
• Composition (state-based and stateless variants)
• Combining inheritance and composition
• Subtype, static and parametric polymorphism
• Interface Design
• What is an interface?
• Interface versus abstract base classes (ABC)
• Implementing interfaces
• Advantages of interfaces

Signals-based Design

• Whirlwind overview of Functional Programming (FP)
• Using FP to define system interfaces
• Signals-based programming
• Delegates

Part III: Guidelines and Good Practice

Combining Programming Styles

• What is the optimal mix
• Some less-than-optimal solutions
• Lessons learned
• Best practices

Demos

• C++, C# and Java
• Using design patterns
• Using libraries

Conclusions

• Which design process?
• Which programming style and language?
• The software team