TRADITIONAL SOFTWARE DEVELOPMENT PROCESSES - Software Design for Six-Sigma: A Roadmap for Excellence - page 33

of the system, and that such linking may not be as easy as first thought. Reusability
of code is one of the main benefits of the bottom-up approach.
Top-down design was promoted in the 1970s by IBM researcher Harlan Mills
and Niklaus Wirth (Top down bottom up, 2008). Harlan Mills developed structured
programming concepts for practical use and tested them in a 1969 project to automate
the New York Times Morgue Index (Top down bottom up, 2008). The engineering
and management success of this project led to the spread of the top-down approach
through IBM and the rest of the computer industry. Niklaus Wirth, among other
achievements the developer of the Pascal programming language, wrote the influential
paper, “Program Development by Stepwise Refinement.” (Top down bottom up, 2008)
As Niklaus Wirth went on to develop languages such as Modula and Oberon (where
one could define a module before knowing about the entire program specification), one
can infer that top-down programming was not strictly what he promoted. Top-down
methods were favored in software engineering until the late 1980s, and object-oriented
programming assisted in demonstrating the idea that both aspects of top-down and
bottom-up programming could be used (Top down bottom up, 2008).
Modern software design approaches usually combine both top-down and bottom-
up approaches. Although an understanding of the complete system is usually consid-
ered necessary for good design, leading theoretically to a top-down approach, most
software projects attempt to make use of existing code to some degree. Preexisting
modules give designs a bottom-up flavor. Some design approaches also use an ap-
proach in which a partially functional system is designed and coded to completion,
and this system is then expanded to fulfill all the requirements for the project.
Top-down starts with the overall design. It requires finding modules and interfaces
between them, and then going on to design class hierarchies and interfaces inside
individual classes. Top-down requires going into smaller and smaller detail until the
code level is reached. At that point, the design is ready and one can start the actual
implementation. This is the classic sequential approach to the software process.
Top-down programming is a programming style, the mainstay of traditional pro-
cedural languages, in which design begins by specifying complex pieces and then
dividing them into successively smaller pieces. Eventually, the components are spe-
cific enough to be coded and the program is written. This is the exact opposite of the
bottom-up programming approach, which is common in object-oriented languages
such as C or Java. The technique for writing a program using top-down methods

is to write a main procedure that names all the major functions it will need. Later,
the programming team looks at the requirements of each of those functions and the
process is repeated. These compartmentalized subroutines eventually will perform
actions so simple they can be coded easily and concisely. When all the various
subroutines have been coded, the program is done.
By defining how the application comes together at a high level, lower level work
can be self-contained. By defining how the lower level objects are expected to integrate
into a higher level object, interfaces become defined clearly (Top down bottom up,
2008).
Bottom-up means to start with the “smallest things.” For example, if there is a need
for a custom communication protocol for a given distributed application, then start

++