Introduction to Software Design

Software production timeline:
- Starting from a relatively high-level view of design
- Increasing detail
- Ending with programming language-specific techniques that support our design.

Constructing nontrivial software is a complex task
- problem analysis
- overall design
- documentation
- testing
- maintenance
- management of all of the above
Neither the details nor the big picture must be permanently lost in the rush to get a system shipped.

The discussion about design is a bit less precise and a bit less detailed than the discussions of individual programming language features and techniques.
There is no cookbook method for creating good software systems...
- ...However, detailed descriptions of design patterns do exist for specific, well understood kinds of applications.
There is no substitute for intelligence, experience, and taste in programming.

The design constraints are:
- the abstract nature of software
- techniques that work for small projects do not necessarily scale to medium and large projects.
The design discussions can be formulated in terms of analogies rather than in terms of code examples.
- Please remember that proof by analogy is fraud... :-)
- ...that is why software design is an iterative process.

Observations drawn from real-life projects often apply to a wide variety of situations...

...therefore "We can have our next project done in two weeks..."
Unfortunately, observations can never be considered universal...

...Look at such observations with a healthy degree of skepticism.

Most modern programming languages (such as C++ or Java) can be used simply as procedural languages.
However, doing so leaves the most powerful techniques unused...
- ...only a small fraction of the potential language benefits is gained.
Focus is on approaches to design that enable effective use of
- data abstraction
- object-oriented programming facilities
Such techniques are often called object-oriented design.

Old software systems were implemented with third generation programming languages that used procedural programming concepts.
These systems are called legacy systems.
Procedural programming involves writing a series of instructions in sequence:
- all input data from keyboard or disk drive is read into "globally" shared memory;
- the "next" computer instruction follows "current" instruction, occasionally passing control to another instruction somewhere in memory;
- all output data is written to console screen, printer, or disk drive from the shared memory.
Procedural programming is also known as structured code.

In procedural programming, any part of the program can add, modify, or delete any data in shared memory at any time.
This has a huge potential for some serious design and maintenance problems down the road.
Alternatively, the software can be implemented as a collection of objects.
Each object is defined by its attributes and its behaviors.
Combining certain data and operations to form an object is known as encapsulation. This separates data inside objects from "globally" shared memory.

Keep objects small with minimum data required by their functionality and a minimum number of methods.
Each object should be designed to have specific tasks.
A system should contain many small interacting objects rather than a few large objects.