Program Design

How to design programs that result in simple, re-usable and easy to maintain code

Course benefits:

Development departments wrestle with two persistent and major problems, maintenance and enhancement of existing code, and the feeling that they have written this code before somewhere.

All programs require maintenance and enhancement at some point in their lives, but not all programs are designed to allow modification. Program structures can be ill-conceived, undocumented, based on unwarranted assumptions, or just not designed at all. When change is required effort can be wasted trying to shoehorn the new need into the existing constructs, sometimes with unpredictable or catastrophic results. Modular components with clearly defined interfaces are the key to successful program design. These components are candidates for re-use in a range of applications. Moreover, well-structured programs have longer lives and allow for change. In this way, modular components contribute towards the goals of maintainability and re-use.

Who should attend:

This course is for programmers who design and write solutions to programming problems. The course is particularly suitable for those about to make the transition to object-oriented programming.

Prerequisites:

Attendees should be familiar with at least one programming language, for example C, Basic, COBOL, Pascal or Java.

What you will learn:

This course teaches the principles of functional modularity by showing both how to define modular components and how to improve the modularity of interfaces by applying a program design health check. Data modularity - the encapsulation of data behind a set of related functional interfaces - extends these principles to provide a powerful means of structuring program designs. Encapsulation also forms the bridge to the use of object-oriented technology.

On successful completion of the course, attendees will be able to:

Apply the principles of functional modularity to design a program as a collection of clearly-defined functional modules
Apply the principles of data modularity to design a program component as a set of functional interfaces that encapsulate a data structure
Express a program design using the Structure Chart notation and translate the diagram into programming language constructs
Evaluate and improve a program design using the concepts from the program design health check

What you will cover:

The Benefits of Modularity - striving for reusability, cheaper maintenance and enhancement, easier error diagnosis and testing and built-in resilience
Modules and Interfaces - passing parameters and returning results; side-effects; pre-conditions, post-conditions and other types of assertion
Structure Charts - basic notation: module, data couple, control couple; control flow Implementing
Functional Modularity: procedures and functions; parameter mechanisms; the scope and lifetime of local, global and static variables; reasons for avoiding global and static variables
Program Design Health Check - program readability; data coupling between modules; cohesion within a module; measures of design complexity; error handling
Encapsulation - data, know-how and responsibilities; external interface versus internal data representation; public versus private; programming language implementation; from data encapsulation to objects

How you will learn:

A mixture of discussion, best practices, and realistic, practical examples is employed in this course to exemplify and re-enforce principles. All design constructs are related to programming language implementations and the whole course is based on well-established software engineering principles.

Duration and availability:

Two days non-residential. In-house only.