Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Section 4.6
More on Program Design

UNDERSTANDING HOW PROGRAMS WORK IS ONE THING. Designing a program to perform some particular task is another thing altogether. In Section 3.2, I discussed how stepwise refinement can be used to methodically develop an algorithm. We can now see how subroutines can fit into the process.

Stepwise refinement is inherently a top-down process, but the process does have a "bottom," that is, a point at which you stop refining the pseudocode algorithm and translate what you have directly into proper programming language. In the absence of subroutines, the process would not bottom out until you get down to the level of assignment statements and very primitive input/output operations. But if you have subroutines lying around to perform certain useful tasks, you can stop refining as soon as you've managed to express your algorithm in terms of those tasks.

This allows you to add a bottom-up element to the top-down approach of stepwise refinement. Given a problem, you might start by writing some subroutines that perform tasks relevant to the problem domain. The subroutines become a toolbox of ready-made tools that you can integrate into your algorithm as you develop it. (Alternatively, you might be able to buy or find a software toolbox written by someone else, containing subroutines that you can use in your project as black boxes.)

Subroutines can also be helpful even in a strict top-down approach. As you refine your algorithm, you are free at any point to take any sub-task in the algorithm and make it into a subroutine. Developing that subroutine then becomes a separate problem, which you can work on separately. Your main algorithm will merely call the subroutine. This, of course, is just a way of breaking your problem down into separate, smaller problems. It is still a top-down approach because the top-down analysis of the problem tells you what subroutines to write. In the bottom-up approach, you start by writing or obtaining subroutines that are relevant to the problem domain, and you build your solution to the problem on top of that foundation of subroutines.

Preconditions and Postconditions

When working with subroutines as building blocks, it is important to be clear about how a subroutine interacts with the rest of the program. This interaction is specified by the contract of the subroutine, as discussed in Section 1. A convenient way to express the contract of a subroutine is in terms of preconditions and postconditions.

The precondition of a subroutine is something that must be true when the subroutine is called, if the subroutine is to work correctly. For example, for the built-in function Math.sqrt(x), a precondition is that the parameter, x, is greater than or equal to zero, since it is not possible to take the square root of a negative number. In terms of a contract, a precondition represents an obligation of the caller of the subroutine. If you call a subroutine without meeting its precondition, then there is no reason to expect it to work properly. The program might crash or give incorrect results, but you can only blame yourself, not the subroutine.

A postcondition of a subroutine represents the other side of the contract. It is something that will be true after the subroutine has run (assuming that its preconditions were met -- and that there are no bugs in the subroutine). The postcondition of the function Math.sqrt() is that the square of the value that is returned by this function is equal to the parameter that is provided when the subroutine is called. Of course, this will only be true if the preconditiion -- that the parameter is greater than or equal to zero -- is met. A postcondition of the built-in subroutine System.out.print() is that the value of the parameter has been displayed on the screen.

Preconditions most often give restrictions on the acceptable values of parameters, as in the example of Math.sqrt(x). However, they can also refer to global variables that are used in the subroutine. The postcondition of a subroutine specifies the task that it performs. For a function, the postcondition should specify the value that the function returns.

Subroutines are often described by comments that explicitly specify their preconditions and postconditions. When you are given a pre-written subroutine, a statement of its preconditions and postcondtions tells you how to use it and what it does. When you are assigned to write a subroutine, the preconditions and postconditions give you an exact specification of what the subroutine is expected to do. I will use this approach in the example that constitutes the rest of this section. I will also use it occasionally later in the book, although I will generally be less formal in my commenting style.

Preconditions and postconditions will be discussed more thoroughly in Chapter 9, which deals with techniques for writing correct and robust programs.

A Design Example

Let's work through an example of program design using subroutines. In this example, we will both use prewritten subroutines as building blocks and design new subroutines that we need to complete the project.

Suppose that I have found an already-written class called Mosaic. This class allows a program to work with a window that displays little colored rectangles arranged in rows and columns. The window can be opened, closed, and otherwise manipulated with static member subroutines defined in the Mosaic class. Here are some of the available routines:

      void rows, int cols, int w, int h);
         Precondition:  The parameters rows, cols, w, and h are
                        greater than zero.
         Postcondition: A "mosaic" window is opened on the screen that can
                        display rows and columns of colored rectangles.
                        Each rectangle is w pixels wide and h pixels high.
                        The number of rows is given by the first
                        parameter and the number of columns by the second.
                        Initially, all the rectangles are black.
         Note: The rows are numbered from 0 to rows - 1, and the columns
               are numbered from 0 to cols - 1.
      void Mosaic.setColor(int row, int col, int r, int g, int b);
         Precondition:  row and col are in the valid ranges of row numbers and
                        column numbers.  r, g, and b are in the range 0 to 255.
                        Also, the mosaic window should be open.
         Postcondition: The color of the rectangle in row number row and column
                        number col has been set to the color specified by
                        r, g, and b.  r gives the amount of red in the color
                        with 0 representing no red and 255 representing the
                        maximum possible amount of red.  The larger the value
                        of r, the more red in the color.  g and b work
                        similarly for the green and blue color components.
      int Mosaic.getRed(int row, int col);
      int Mosaic.getBlue(int row, int col);
      int Mosaic.getGreen(int row, int col);
         Precondition:  row and col are in the valid ranges of row numbers
                        and column numbers.  Also, the mosaic window should
                        be open.
         Postcondition: Returns an int value that represents one of the
                        three color components of the rectangle in row
                        number row and column number col.  The return value
                        is in the range 0 to 255.  (Mosaic.getRed() returns
                        the red component of the rectangle, Mosaic.getGreen()
                        the green component, and Mosaic.getBlue() the blue
      void Mosaic.delay(int milliseconds);
         Precondition:  milliseconds is a positive integer.
         Postcondition: The program has paused for at least the number
                        of milliseconds given by the parameter, where
                        one second is equal to 1000 milliseconds.
         Note:  This can be used to insert a time delay in the program (to
                regulate the speed at which the colors are changed, for
      boolean Mosaic.isOpen();
         Precondition:  None.
         Postcondition: The return value is true if the mosaic window
                        is open on the screen, and is false otherwise.
         Note:  The window will be closed if the user clicks its
                close box.  It can also be closed programmatically by
                calling the subroutine Mosaic.close().

My idea is to use the Mosaic class as the basis for a neat animation. I want to fill the window with randomly colored squares, and then randomly change the colors in a loop that continues as long as the window is open. "Randomly change the colors" could mean a lot of different things, but after thinking for a while, I decide it would be interesting to have a "disturbance" that wanders randomly around the window, changing the color of each square that it encounters. Here's an applet that shows what the program will do:

(Applet "RandomMosaicWalkApplet" would be displayed here
if Java were available.)

With basic routines for manipulating the window as a foundation, I can turn to the specific problem at hand. A basic outline for my program is

        Open a Mosaic window
        Fill window with random colors;
        Move around, changing squares at random.

Filling the window with random colors seems like a nice coherent task that I can work on separately, so let's decide to write a separate subroutine to do it. The third step can be expanded a bit more, into the steps: Start in the middle of the window, then keep moving to a new square and changing the color of that square. This should continue as long as the mosaic window is still open. Thus we can refine the algorithm to:

       Open a Mosaic window
       Fill window with random colors;
       Set the current position to the middle square in the window;
       As long as the mosaic window is open:
          Randomly change color of current square;
          Move current position up, down, left, or right, at random;

I need to represent the current position in some way. That can be done with two int variables named currentRow and currentColumn. I'll use 10 rows and 20 columns of squares in my mosaic, so setting the current position to be in the center means setting currentRow to 5 and currentColumn to 10. I already have a subroutine,, to open the window, and I have a function, Mosaic.isOpen(), to test whether the window is open. To keep the main routine simple, I decide that I will write two more subroutines of my own to carry out the two tasks in the while loop. The algorithm can then be written in Java as:,20,10,10)
       currentRow = 5;       // Middle row, halfway down the window.
       currentColumn = 10;   // Middle column.
       while ( Mosaic.isOpen() ) {
           changeToRandomColor(currentRow, currentColumn);

With the proper wrapper, this is essentially the main() routine of my program. It turns out I have to make one small modification: To prevent the animation from running too fast, the line "Mosaic.delay(20);" is added to the while loop.

The main() routine is taken care of, but to complete the program, I still have to write the subroutines fillWithRandomColors(), changeToRandomColor(int,int), and randomMove(). Writing each of these subroutines is a separate, small task. The fillWithRandomColors() routine is defined by the postcondition that "each of the rectangles in the mosaic has been changed to a random color." Pseudocode for an algorithm to accomplish this task can be given as:

        For each row:
           For each column:
              set the square in that row and column to a random color

"For each row" and "for each column" can be implemented as for loops. We've already planned to write a subroutine changeToRandomColor that can be used to set the color. (The possibility of reusing subroutines in several places is one of the big payoffs of using them!) So, fillWithRandomColors() can be written in proper Java as:

      static void fillWithRandomColors() {
         for (int row = 0; row < 10; row++)
            for (int column = 0; column < 20; column++)

Turning to the changeToRandomColor subroutine, we already have a method, Mosaic.setColor(row,col,r,g,b), that can be used to change the color of a square. If we want a random color, we just have to choose random values for r, g, and b. According to the precondition of the Mosaic.setColor() subroutine, these random values must be integers in the range from 0 to 255. A formula for randomly selecting such an integer is "(int)(256*Math.random())". So the random color subroutine becomes:

         static void changeToRandomColor(int rowNum, int colNum) {
              int red = (int)(256*Math.random());
              int green = (int)(256*Math.random());
              int blue = (int)(256*Math.random());

Finally, consider the randomMove subroutine, which is supposed to randomly move the disturbance up, down, left, or right. To make a random choice among four directions, we can choose a random integer in the range 0 to 3. If the integer is 0, move in one direction; if it is 1, move in another direction; and so on. The position of the disturbance is given by the variables currentRow and currentColumn. To "move up" means to subtract 1 from currentRow. This leaves open the question of what to do if currentRow becomes -1, which would put the disturbance above the window. Rather than let this happen, I decide to move the disturbance to the opposite edge of the applet by setting currentRow to 9. (Remember that the 10 rows are numbered from 0 to 9.) Moving the disturbance down, left, or right is handled similarly. If we use a switch statement to decide which direction to move, the code for randomMove becomes:

           int directionNum;
           directoinNum = (int)(4*Math.random());
           switch (directionNum) {
              case 0:  // move up
                 if (currentRow < 0)   // CurrentRow is outside the mosaic;
                    currentRow = 9;    // move it to the opposite edge.
              case 1:  // move right
                 if (currentColumn >= 20)
                    currentColumn = 0;
              case 2:  // move down
                 if (currentRow >= 10)
                    currentRow = 0;
              case 3:  // move left
                 if (currentColumn < 0)
                    currentColumn = 19;

Putting this all together, we get the following complete program. The variables currentRow and currentColumn are defined as static members of the class, rather than local variables, because each of them is used in several different subroutines. This program actually depends on two other classes, Mosaic and another class called MosaicCanvas that is used by Mosaic. If you want to compile and run this program, both of these classes must be available to the program.

    public class RandomMosaicWalk {
          This program shows a window full of randomly colored
          squares.  A "disturbance" moves randomly around
          in the window, randomly changing the color of
          each square that it visits.  The program runs
          until the user closes the window.
       static int currentRow; // row currently containing the disturbance
       static int currentColumn; // column currently containing disturbance
       public static void main(String[] args) {
              // Main program creates the window, fills it with
              // random colors, then moves the disturbance in
              // a random walk around the window for as long as
              // the window is open.
           currentRow = 5;   // start at center of window
           currentColumn = 10;
           while (Mosaic.isOpen()) {
               changeToRandomColor(currentRow, currentColumn);
       }  // end of main()
       static void fillWithRandomColors() {
               // Precondition:  The mosaic window is open.
               // Postcondition: Each rectangle has been set to a
               //                random color
            for (int row=0; row < 10; row++) {
               for (int column=0; column < 20; column++) {
                   changeToRandomColor(row, column);
       }  // end of fillWithRandomColors()
       static void changeToRandomColor(int rowNum, int colNum) {
               // Precondition:  rowNum and colNum are in the valid range
               //                of row and column numbers.
               // Postcondition: The rectangle in the specified row and
               //                column has been changed to a random color.
            int red = (int)(256*Math.random());    // choose random levels in range
            int green = (int)(256*Math.random());  //     0 to 255 for red, green,
            int blue = (int)(256*Math.random());   //     and blue color components
        }  // end of changeToRandomColor()
        static void randomMove() {
               // Precondition:  The global variables currentRow and currentColumn
               //                specify a valid position in the grid.
               // Postcondition: currentRow or currentColumn is changed to
               //                one of the neighboring positions in the grid,
               //                up, down, left, or right from the previous
               //                position.  If this moves the position outside
               //                the grid, then it is moved to the opposite edge
               //                of the window.
            int directionNum; // Randomly set to 0, 1, 2, or 3 to choose direction.
            directionNum = (int)(4*Math.random());
            switch (directionNum) {
               case 0:  // move up
                  if (currentRow < 0)
                     currentRow = 9;
               case 1:  // move right
                  if (currentColumn >= 20)
                     currentColumn = 0;
               case 2:  // move down
                  currentRow ++;
                  if (currentRow >= 10)
                     currentRow = 0;
               case 3:  // move left
                  if (currentColumn < 0)
                     currentColumn = 19;
        }  // end of randomMove()
    } // end of class RandomMosaicWalk

[ Next Section | Previous Section | Chapter Index | Main Index ]

  Published under free license. Design by Interspire