CIS300 Spring 2005
Fundamentals of Program Design
Every computer program is built from components, data,
single-user application (used by one person at a time),
reads data, saves it in a data structure,
computes on the data, and writes the results,
there is a standard way of organizing the component structure,
data structure, and control structure:
Once the four-step design is finished, then it is time to convert
the design into (Java) coding.
design the program's component structure
with three components, organized in a
Next, decide what form of data structure (array,
table, set, list, tree, etc.) will hold the program's data.
The data structure will be inserted in the program's model
Then, write the algorithm that defines the execution steps --- the
The algorithm will be placed inside the program's
Determine the form of input and output (disk file, typed text
in a command window, dialogs, a graphical-use interface, etc.)
that the program uses. This will be embedded in the program's
We now consider each stage of the design process.
the program's job is to
read information into the computer and save it in a
format which lets the computer compute answers from the data
that can be written.
The program can be written as one large piece of code,
but this forces a programmer to think about all parts of the program
at once. Years of experience has shown that it is better to design
a program in three parts, in a model-view-controller pattern:
The data flows into the program through the view component
and is directed by the controller into
the model. The controller component
manipulates the data and tells the view to output the answer.
A bit more precisely, we have that
All three components are important, but the key to building a good
quality program is selecting the appropriate data structure for
the model component.
The controller component holds the algorithm, that is the instructions that
tell the computer when
to read data, compute on it, and write the answers.
The model component holds the structures that save the data so
that it can be easily computed upon. For example, if the program
is a spreadsheet program, then the model holds a table (grid)
that represents (``models'') the spreadsheet. Or, if the program
is the file manager for Linux, then the model is a tree structure
that represents the folder-and-file structure of the disk-file system.
The view component holds the operations that connect the program
to the input and output devices (the disk or display or printer....).
When you solve a problem with a computer program, always ask first,
How should the program store the information upon which it computes?
Sometimes people talk about ``modelling'' the problem within the
computer; the way the data is held is called the model.
Recall the previous examples:
Each of these problems required a distinct data structure
in the solution.
the program is a spreadsheet program, then the information should
be held in a data structure that is a grid.
If the program is a bank-account database, then the information should
be grouped into customer accounts, each with a unique ID,
saved in an array or set.
If the program is a file-system manager, then the information are files
and folders that are organized in a tree-like structure.
It helps to draw a picture of the structure.
For example, if you are writing a vote-counting program for the 2004
US presidential election, you might draw this picture of the model:
On the other hand, if you are writing the file-system manager for
Linux, then your program must hold folders and files,
and the picture of the model might look like this:
The picture should suggest to you the kind of computer variables and
data structures you will require to build the solution.
The purpose of a data-structures course like
CIS300 is to train you at using a variety of such structures.
The model component is ``passive'' --- another program component,
the controller, inserts data into the structure, asks
for computations, and extracts the answers.
Every program follows a series of steps to solve a problem.
The series of steps is called an algorithm; it
controls the computer's work.
It is best to begin with an ``outline'' of the algorithm.
The outline can be written in a graphical form, called a
For example, here is an outline, written as a flowchart, of an
algorithm for reading and totalling the votes of the presidential
Many people like to develop their algorithms with a flowchart,
because the various paths can be developed one at a time,
and the arrows make it less likely to forget a case in the development.
The algorithm is inserted into the controller component, and when
writing the program in Java, you can code the algorithm into the
Methods for the components
Often we see phrases in the algorithm
that are not at the level of Java instructions.
(Examples: ``add one to Kerry's count'';
``print the totals in the model.'')
These phrases are clues that you should write procedures (methods)
that do the work described by the phrases. For example,
since the phrase, ``add one to Kerry's count''
implicitly mentions the data structure in the model, we might revise our
our description of the model component to have a method that does what
the phrase suggests:
This makes the algorithm in the controller easier to write, because
it merely invokes the model's method, meaning that the controller
does not have to deal with the details of the data structure.
(This arrangement is also important if we must change the data structure
within the model: the codings of the methods in the model are changed, and
we do not rewrite the controller.)
Later, we write the code
for the methods. If the coding
is complicated, we might wish to write flow charts, possibly
defining even more methods.
Input and output
A program that reads and writes data will normally use a prebuilt
component. For example, when a program prints output to the command
window, it uses the System.out component and its
methods, print and println.
For input, if we use the JOptionPane object from
javax.swing to generate an input dialog, then the
application we design would look like this:
Finally, in some cases, the programmer will build a customized
input-output component that uses frames, text fields, buttons,
etc. This makes the View component more complex still.
In the next lectures, we design and build
applications using this design
Software Development Methodology
The design stage is only one stage in the stages one undertakes to
build and deliver a software application.
A standard development methodology goes in three stages:
At this point, the program is given to the user, who will almost
certainly respond with more requirements that cause the above
three-step process to repeat.
The program's intended user tells us how she wishes to use the program.
The user must tell us stories and draw pictures that explain the
different ways the program might be used. Each possible usage is
called a use-case. (Use-cases are presented in the next lecture.)
Design: The programmer studies the use-cases
and applies the knowledge to designing the component structure,
data structure, and control structure of the solution, as described
Once the program is designed, the programmer does a ``safety check,''
explaining how each use-case executes with the design.
Implementation and Testing: The program is written to match
the design, and it is tested to verify that
it behaves correctly. The testing
usually proceeds in two stages: unit testing, where each
component is tested by itself as much as possible, and integration
testing, where the entire assembled program is tested on the use-caes.
We apply the software development methodology in the next lecture.