|
Chapter 3:
Organizing a Program
Introduction
When you write a program, you are actually
setting out to solve a problem. It is often helpful to develop a
plan of how you want to solve your problem. The plan may need
revisions along the way, but at least it gives you a framework
out of which you can get both an overall and detailed
understanding of the problem you are trying to solve. Often the
most monumental problem can be broken into parts that can be
easily dealt with.
By taking some time to analyze your goals and
writing down some preliminary plans, you can shorten your
program development time considerably. In this chapter we will
discuss some methods for planning your programming efforts and
along the way, you will get a more detailed look at how AutoLISP
works.
Looking at a Programs Design
As simple as the box.lsp program is, it
follows some basic steps in its design. These steps are as
follows:
1. Establish the name of the program or
function
2. Obtain information by prompting the
user
3. process the information
4. Produce the output
Lets look at a breakdown of the program to
see these steps more clearly. The first line defines the program
by giving it a name and listing the variables it is to use.
(defun c:box (/dx dy pt1 pt2 pt3
pt4)
The second and third line of the program
obtain the minimum information needed to define the box.
The fourth, fifth, and sixth lines process
the information to find the other two points needed to draw the
box.
The last line draws the box in the drawing
editor.
(command
"line'' pt1 pt2 pt3 pt4 "c'' )
This four step process can be applied to
nearly every program you produce.
You should also consider how standard
AutoCAD commands work. A program that has an unusual way of
prompting for information will seem jarring and unfamiliar to
the user. By designing your prompts and prompt sequence to match
closely those of AutoCAD's, your programs will seem more
familiar and therefore easier to use. For example, when a
command requires editing of objects, you are first prompted to
select the objects to be edited. So when you design a program
that performs some editing function, you may want to follow
AutoCAD's lead and have your program select objects first (we
will cover functions that allow you to select objects later in
this book).
Outlining Your Programming Project
But before you get to actual writing of code,
you will want to chart a path describing what your program is to
do. The box program might be planned as the following sequence
of statements:
1. Get the location of one corner of the
box. Save that location as a variable called pt1.
2. Get the location of the other corner
of the box. Save that location as a variable called pt3.
3. calculate the other two corners by
using information about the known corner locations pt1 and
pt3.
4. Draw the box
The above list outlines the procedures
needed to accomplish your task. This type of list is often
called Pseudocode.
It is a plain language description of the code your program is
to follow. It acts like an outline of your programs code. You
could even incorporate your pseudocode as comments to the actual
code of the program. Just as with an outline, you may have to go
through several iterations of lists like this before actually
hitting on one that seem workable.
Along with the pseudocode of a program, you
may also want to sketch out what your program is supposed to do,
especially if your program is performing some graphic
manipulation. Figure 3.1 shows a sketch done as an aid to
developing the box program.
Figure 3.1: Sample sketch used to develop
box.lsp
Using Functions
We have broken the box program down
conceptually into three processes. We can also break it down
physically by turning each process into a function as in the
following:
(defun
getinfo ()
(setq pt1 (getpoint "Pick first
corner: "))
(setq pt3 (getcorner pt1 "Pick
opposite corner: "))
)
(defun procinfo ()
(setq pt2 (list (car pt3) (cadr
pt1)))
(setq pt4 (list (car pt1) (cadr
pt3)))
)
(defun output ()
(command "line'' pt1 pt2 pt3 pt4
"c'' )
)
You now have three functions that can be
called independently. We now need a way to tie these functions
together. We can write a main program that does just that:
(defun C:BOX1
(/ pt1 pt2 pt3 pt4)
(getinfo)
(procinfo)
(output)
)
Let's see how this new version of the Box
drawing program works.
1. Open a new AutoLISP file called box1.lsp.
2. Enter the above three functions, Getinfo,
Procinfo, and output, along with the new box program. Your file
should look like Figure 3.2.
3. Open a new AutoCAD file called chapt3= and
load the Box1.lsp file.
4. Run the C:BOX1 program. You will see that
it acts no differently from the first box program in chapter 1.
(defun getinfo ()
(setq pt1 (getpoint "Pick first corner: "))
(setq pt3 (getcorner pt1 "Pick opposite corner: "))
)
(defun procinfo ()
(setq pt2 (list (car pt3) (cadr pt1)))
(setq pt4 (list (car pt1) (cadr pt3)))
)
(defun output ()
(command "pline" pt1 pt2 pt3 pt4 "c" )
)
(defun C:BOX1 (/ pt1 pt2 pt3 pt4)
(getinfo)
(procinfo)
(output)
)
Figure 3.2: The contents of box1.lsp
The C:Box1 program listed above acts as a
sort of master organizer that evaluates each of the three
functions, getinfo, procinfo, and output, as they are needed.
This modular approach to programming has several advantages.
First, since each function exists
independently, they can be used by other programs thereby
reducing the amount of overall code needed to run your system.
Though in the above example, we actually increased the size of
the Box program, as you increase the number of program you use,
you will find that you can use functions from this program in
other programs. Functions you write in this way can serve as
tools in building other programs.
Second, while writing programs, you can more
easily locate bugs since they can be localized within one
function or another. Whenever AutoCAD encounters an error, it
displays an error message along with the offending expression.
Third, smaller groups of code are more
manageable making your problem solving task seem less
intimidating. The actual Box program represents the problem in
general terms while the functions take care of the details. You
can get a clearer idea of how your programs work because clarity
is built into the program by virtue of this modular structure.
Finally, features can be added and modified
more easily by "plugging" other functions either into the main
program or into the individual functions that make up the
program.
Adding a Function
As great a program AutoCAD is, it does have
some glaring shortcomings. One is the fact that it does not
dynamically display relative X and Y coordinates. It does
display relative polar coordinates dynamically, but often, it is
helpful to see distances in relative X and Y coordinates. One
example where this would be useful is in the creation of floor
plans where a dynamic reading of relative X and Y coordinates
could help you size rooms in a building. It would be also
helpful if this dynamic readout would display the rooms area as
the cursor moved. Figure 3.3 Shows a function that displays
relative X and Y coordinates in the status line.
(defun RXY (/ pt lt x last pick lpt1)
(if (not pt1)(setq lpt1 (getvar "lastpoint"))(setq lpt1 pt1))
(while (/= pick t)
(setq pt (cadr (setq lt (grread t))))
(if (= (car lt) 5)(progn
(setq x (strcat
(rtos (- (car pt) (car lpt1))) " x "
(rtos (- (cadr pt) (cadr lpt1))) " SI= "
(rtos (*(- (car pt) (car lpt1))
(- (cadr pt) (cadr lpt1))
)
2 2)
)
)
(grtext -2 x)
)
)
(setq pick (= 3 (car lt)))
)
(cadr lt)
)
Figure 3.3: The RXY function
1. Exit AutoCAD temporarily either by
using the AutoCAD Shell command or by using the End command
to exit AutoCAD entirely.
2. Open an AutoLISP file called Rxy.lsp
and copy the program listed in figure 3.4. Check your file
carefully against the listing to be sure it is correct.
3. Return to the Chapt3 AutoCAD file.
4. Turn on the snap and dynamic
coordinate readout.
5. Load Rxy.LSP then start the line
command.
6. At the First point prompt, pick the
coordinate 2,2 then, at the next point prompt, enter the
following:
Notice how the coordinate readout now
dynamically displays the relative XY coordinates from the
first point you picked.
7. Move the cursor until the coordinate
readout lists 6.0000,7.0000 then pick that point. A line is
draw with a displacement from the first point of 6,7.
We won't go into a detailed explanation of
this function quite yet. Imagine, however, that you have just
finished writing and debugging this function independent of the
box program and you want to add it permanently to the box
program.
1. Exit AutoCAD temporarily either by
using the AutoCAD Shell command or by using the End command
to exit AutoCAD entirely.
2. Open the box1.lsp file and change the
Getinfo function to the following:
(defun getinfo ()
(setq pt1 (getpoint "Pick first
corner: "))
(princ "Pick opposite corner: ")
(setq pt3 (rxy))
)
Your new Box1.lsp file should look like
figure 3.4. We have replaced the expression that obtains PT3
with two lines, one that displays a prompt:
(princ "Pick
opposite corner: ")
and another that uses the RXY function
to obtain the location of PT3:
(setq pt3 (rxy))
Now when you use the box program, the
width and height of the box along with its area are
displayed on the status prompt.
3. Return to the
Chapt3 file.
4. Load the Rxy.lsp and Box1.lsp files.
5. Run the C:BOX1 program by entering
box1 at the command prompt.
6. Make sure the Snap mode and Dynamic
coordinate readout are both on.
7. At the Pick first corner prompt, pick
the coordinate 2,3.
8. At the Opposite corner prompt, move
the cursor and note how the coordinate readout responds. If
you move the cursor to the first point you picked, the
coordinate readout will list 0,0 telling you that you are a
relative distance of 0,0 from the first corner.
9. Now move the cursor until the
coordinate readout lists 5.0000,5.0000 then pick that point.
You have drawn a box exactly 5 units in the x axis by 5
units in the y axis.
(defun getinfo ()
(setq pt1 (getpoint "Pick first corner: "))
(princ "Pick opposite corner: ")
(setq pt3 (rxy))
)
(defun procinfo ()
(setq pt2 (list (car pt3) (cadr pt1)))
(setq pt4 (list (car pt1) (cadr pt3)))
)
(defun output ()
(command "pline" pt1 pt2 pt3 pt4 "c" )
)
(defun C:BOX1 (/ pt1 pt2 pt3 pt4)
(getinfo)
(procinfo)
(output)
)
Figure 3.4: The revised Box1.lsp file
In the above exercise, after you pick the
first corner of the box, the window no longer appears. Instead,
the status line changes to display the height and width of you
box dynamically as you move the cursor. It also displays the
square inch area of that height and width. By altering a
function of the main C:BOX1 program, you have added a new
features to it. Of course, you had to do the work of creating
Rxy.lsp but Rxy.lsp can also be used to dynamically display
relative X Y coordinates in any command that reads point values.
Reusing Functions
You have seen that by breaking the box
program into independent functions, you can add other functions
to your program to alter the way the program works. In the
following section, you will create two more programs, one to
draw a 3D rectangle, and one to draw a wedge, using those same
functions from the box program.
Creating an 3D Box program
To create a 3D box from a rectangle, all you
really need to do is extrude your rectangle in the Z axis then
add a 3dface to the top and bottom of the box. Extruding the box
can be accomplished using the Change command. Figure 3.5 shows
how this would be done with standard AutoCAD commands.
Figure 3.5: Drawing a
three-dimensional box manually
Your box program also needs a way to prompt
the user for a height. We can accomplish these things by
creating a modified version of the C:BOX1 main program. Figure
3.6 shows such a program.
(defun C:3DBOX (/ pt1 pt2 pt3 pt4 h)
(getinfo)
(setq h (getreal "Enter height of box: "))
(procinfo)
(output)
(command "change" "L" "" "P" "th" h ""
"3dface" pt1 pt2 pt3 pt4 ""
"3dface" ".xy" pt1 h ".xy" pt2 h
".xy" pt3 h ".xy" pt4 h ""
)
)
Figure 3.6: A program to draw a 3D
box.
In the following exercise, you will add
the 3D box program to the Box1.lsp file then run C:3DBOX.
1. Exit AutoCAD temporarily either by
using the AutoCAD Shell command or by using the End command
to exit AutoCAD entirely.
2. Open the box1.lsp file again and add
the program listed in figure 3.6 to the file. Your Box1.lsp
file should look like figure 3.7.
3. Return to the Chapt3 AutoCAD file.
4. Load Box1.lsp again. If you had to
Exit AutoCAD to edit Box1.lsp, Load Rxy.lsp also.
5. Start the C:3DBOX program by entering
3dbox at the command prompt.
6. At the Pick first corner prompt, pick
a point near the coordinate 2,3.
7. At the Pick opposite corner prompt,
move the cursor until the coordinate readout lists
7.0000,5.0000 then pick that point.
8. At the Enter height prompt, enter 6. A
box appears.
9. Issue the Vpoint command and at the
prompt:
Rotate/<View point>
<0.0000,0.0000,1.0000>:
10. Enter
-1,-1,1. Now you can see that the
box is actually a 3d box.
11. Issue the Hide command. The box
appears as a solid object.
(defun getinfo ()
(setq pt1 (getpoint "Pick first corner: "))
(princ "Pick opposite corner: ")
(setq pt3 (rxy))
)
(defun procinfo ()
(setq pt2 (list (car pt3) (cadr pt1)))
(setq pt4 (list (car pt1) (cadr pt3)))
)
(defun output ()
(command "pline" pt1 pt2 pt3 pt4 "c" )
)
(defun C:BOX1 (/ pt1 pt2 pt3 pt4)
(getinfo)
(procinfo)
(output)
)
(defun C:3DBOX (/ pt1 pt2 pt3 pt4 h)
(getinfo)
(setq h (getreal "Enter height of box: "))
(procinfo)
(output)
(command "change" "L" "" "P" "th" h ""
"3dface" pt1 pt2 pt3 pt4 ""
"3dface" ".xy" pt1 h ".xy" pt2 h
".xy" pt3 h ".xy" pt4 h ""
)
)
Figure 3.7: The Box1.lsp file with the
C:3DBOX program added.
In the C:3DBOX program, a line is added to
obtain height information.
(setq h (getreal "Enter height of
box: "))
In most cases, it is impractical to try to
enter a 3D point value using a cursor, though it can be done. We
use the Getreal function here to allow the input of a real value
for the height since this is the simplest route to obtain the
height information.
To actually draw the box, other AutoCAD
commands have been added to give the box a third dimension:
(command
"change" "L" "" "P" "th" h ""
"3dface" pt1 pt2 pt3 pt4 ""
"3dface" ".xy" pt1 h ".xy" pt2 h
".xy" pt3 h ".xy" pt4 h ""
)
This expression issues several AutoCAD
commands to turn the simple rectangle drawn by the Output
function into a 3 dimensional box. the first line changes the
thickness of the box previously drawn by the Output function.
The second line draws a 3dface at the base of the box to close
the bottom of the box. The third and fourth lines draw a 3dface
at the top of the box by using the .xy point filter to designate
the x and y coordinate of each corner, then entering the Z
coordinate using the H variable.
Figure 3.8: A 3D box using the C:3DBOX
program
You may have noticed that although you added
the program C:3DBOX to the Box1.lsp file, you still called up
the program by entering its name, 3DBOX. We should emphasize
here that AutoLISP files are only use as the vessel to hold your
program code. AutoLISP makes no connection between the program
name and the name of the file that holds the program. You could
have called Box1.lsp by another name like Myprogm.lsp or
Mybox.lsp, and the programs would still run the same. Of course,
you would have to give the appropriate name when loading the
file.
Creating a 3D Wedge Program
Let's create a new program that draws a wedge
shape based on similar information given for the 3d box. Figure
3.9 shows how you might draw a wedge based on the rectangle
drawn from the box program.
Figure 3.9: A program to draw a 3D wedge
The procedure outlined in Figure 3.9 was
converted into the following AutoLISP program.
(defun C:3DWEDGE (/ pt1 pt2 pt3 pt4 h)
(getinfo)
(setq h (getreal "Enter height of wedge: "))
(procinfo)
(output)
(command "3dface" pt1 pt4 ".xy" pt4 h ".xy" pt1 h pt2 pt3 ""
"3dface" pt1 pt2 ".xy" pt1 h pt1 ""
"copy" "L" "" pt1 pt4
)
)
Try the following exercise to see how it works.
1. Exit AutoCAD temporarily either by
using the AutoCAD Shell command or by using the End command
to exit AutoCAD entirely.
2. Open the box1.lsp file again and add
the program listed above to the file.
3. Return to the Chapt3 AutoCAD file.
4. Load Box1.lsp again. If you had to
Exit AutoCAD to edit Box1.lsp, Load Rxy.lsp also.
5. Erase the box currently on the screen.
6. Start the C:3DWEDGE program by
entering 3dwedge at the command prompt.
7. At the Pick first corner prompt, pick
a point at the coordinate 2,3.
8. At the Pick opposite corner prompt,
pick a point so the wedge's base is 7 units wide by 5 units
wide.
9. At the Enter height prompt, enter 6. A
wedge appears.
10. Issue the hide command. The wedge
appears as a solid object.
This Wedge program is nearly identical to the
C:3DBOX program with some changes to the last expression.
(command "3dface" pt1 pt4 ".xy" pt4 h ".xy" pt1 h pt2
pt3 ""
"3dface" pt1 pt2 ".xy" pt1 h pt1 ""
"copy" "L" "" pt1 pt3
)
The first line of this expression draws a 3d
face on the top and vertical face of the wedge. It does this by
using AutoCAD's .xy point filter to locate points in the Z
coordinate. The second line draws a 3dface on the triangular
side of the wedge again using the .xy point filter. The last
line copies the triangular face to the opposite side of the
wedge. Figure 3.10 shows the entire process.
Figure 3.10: Box1.lsp with the C:3DWEDGE
program added
Now you have three programs which use as
their basic building blocks the three functions derived from
your original Box program. You also have a function, rxy, which
can be used independently to dynamically display relative x y
coordinates.
Making Your Code More Readable
The box program is quite short and simple. As
your programs grow in size and complexity, however, you will
find that it becomes more and more difficult to read. Breaking
the program down into modules help to clarify your code. There
are other steps you can take to help keep your code readable.
Using Prettyprint
The term Prettyprint is used to describe a
way to format your code to make it readable. Indents are used to
offset portions of code to help the code's readability. Figure
3.12 shows three examples of the C:3DBOX program. The first
example is arranged randomly. The second lists each expression
as a line while the third makes use of prettyprint to organize
the code visually.
(defun C:3DBOX (/ pt1 pt2 pt3 pt4 h) (getinfo)
(setq h (getreal "Enter height of box: "))(procinfo)(output)
(command "change" "Last" "" "Properties" "thickness" h
"" "3dface" pt1 pt2 pt3 pt4 "" "3dface" ".xy" pt1 h ".xy" pt2
h ".xy" pt3 h ".xy" pt4 h ""))
(defun C:3DBOX (/ pt1 pt2 pt3 pt4 h)
(getinfo)
(setq h (getreal "Enter height of box: "))
(procinfo)
(output)
(command "change" "Last" "" "Properties" "thickness" h ""
"3dface" pt1 pt2 pt3 pt4 ""
"3dface" ".xy" pt1 h ".xy" pt2 h ".xy" pt3 h ".xy" pt4 h ""))
(defun C:3DBOX (/ pt1 pt2 pt3 pt4 h)
(getinfo)
(setq h (getreal "Enter height of box: "))
(procinfo)
(output)
(command "change" "Last" "" "Properties" "thickness" h ""
"3dface" pt1 pt2 pt3 pt4 ""
"3dface" ".xy" pt1 h ".xy" pt2 h
".xy" pt3 h ".xy" pt4 h ""
)
)
Figure 3.12: Three ways to format the
3dbox program code
In the third example, notice how the listing
is written under the command function. Each new command to be
issued using the command functions is aligned with the next in a
column. This lets you see at a glance the sequence of commands
being used. Look at the RXY.lsp function in figure 3.3. As you
progress through the book, make note of how the listings are
written.
Using Comments
It often helps to insert comments into a
program as a means of giving a verbal description of the code.
Figure 3.13 shows the box program from chapter 1 including
comments. The comments start with a semicolon and continue to
the end of the line. When AutoLISP encounters a semicolon, it
will ignore everything that follows it up to the end of the
line. Using the semicolon, you can include portions of your
Pseudocode as comments to the program code.
;Function to draw a simple 2 dimensional box
;---------------------------------------------------------------------------
(defun c:BOX (/ pt1 pt2 pt3 pt4) ;define box function
(setq pt1 (getpoint "Pick first corner: ")) ;pick start corner
(setq pt3 (getpoint pt1 "Pick opposite corner: ")) ;pick other corner
(setq pt2 (list (car pt3) (cadr pt1))) ;derive second corner
(setq pt4 (list (car pt1) (cadr pt3))) ;derive fourth corner
(command "line" pt1 pt2 pt3 pt4 "c") ;draw box
) ;close defun
;Function to display relative XY coordinates in status line
;---------------------------------------------------------------------------
(defun RXY (/ pt lt x last pick lpt1)
(if (not pt1)(setq lpt1 (getvar "lastpoint"))(setq lpt1 pt1)) ;get last point
(while (/= pick t)
(setq pt (cadr (setq lt (grread t)))) ;read cursor
(if (= (car lt) 5)
(progn ;location
(setq x (strcat
(rtos (- (car pt) (car lpt1))) " x " ;get X coord
(rtos (- (cadr pt) (cadr lpt1))) " SI= " ;get Y coord
(rtos (*(- (car pt) (car lpt1)) ;get area
(- (cadr pt) (cadr lpt1))
) ;close mult
2 2) ;close rtos
) ;close strcat
) ;close setq x
(grtext -2 x) ;display status
) ;close progn
) ;close if
(setq pick (= 3 (car lt))) ;test for pick
) ;close while
(cadr lt) ;return last
) ;coordinate
Figure 3.13: Sample of code using
comments.
Using Capitals and Lower Case Letters
In programming, case sensitivity is a term
that means a programming language treats upper an lower case
letters differently. Except where string variables occur,
AutoLISP does not have any strict requirements when it comes to
using upper and lower case letters in the code. However, you can
help keep you code more readable by using upper case letters
sparingly. For example, you may want to use all uppercase
letters for defuned function names only. That way you can easily
identify user created functions within the code. You can also
mix upper and lower case letters for variable names to help
convey their meaning. This can help give the variable name more
significance while still keeping the name short to conserve
space. For example, You might give the name NewWrd for a
variable that represents a new string value. NewWrd is more
readable than say newwrd.
The only time AutoLISP is case sensitive is
where strings variables are concerned. The string "Yes" is
different from "yes" so you must take care when using upper and
lower case letters in string variable types. We will cover this
topic in more detail in the next chapter.
Dynamic Scoping
You may have noticed that in the functions
getinfo, procinfo, and output, the argument list is empty (see
figure 3-2). There are no variables local to those functions.
The variables used in the programs C:BOX1, C:3DBOX, and
C:3DWEDGE appear in their argument lists rather than in the
functions being called by these programs. A binding is created
between variables and their values within these programs so when
the program ends, the variables loose the value assigned to
them.
On the other hand, there are no variable
bindings created within the individual functions called by the
main programs so when the functions assign a value to a
variables, the variables are free to all the functions used by
the main program. This ability of a function to access variables
freely from the calling function is known as Dynamic Scoping.
Whenever a function looks for a variables
value, it will look at its own local variables first. If the
variables value is not found, it then looks to the calling
function or program for the value. Finally, if no value is found
there, the function will look at the global environment for a
value.
We saw this occur in chapter 2 with the
Adsquare function. Adsquare looked in the AutoLISP global
environment for the value of Golden since golden was not a
formal argument to Adsquare (see figure 2.10).
In the case of the C:BOX1 program, all the
variables used by the program and the functions it calls are
included in its argument list. For this reason, variables have a
binding within C:BOX1 but are free tp any of the functions
called by C:BOX1.
An interesting affect of Dynamic Scoping is
the ability to maintain two variables of the same name, each
holding different values. To see how this works, do the
following.
1. Erase the wedge currently on the
screen.
2. Enter the following expression:
3. pick a point near the coordinate 6,1.
This assigns the coordinate you pick to the variable pt1.
4. Start the C:BOX1 program.
5. At the Pick first corner prompt, pick
a point near the coordinate 2,3.
6. At the Pick opposite corner prompt,
pick a point near so the box is about 7 units wide by 5
units wide. The 2D box appears.
7. Issue the line command and at the
first point prompt, enter:
9. The line will start at the point you
selected in step 3 of this exercise.
In the above example, you assigned a point
location to the variable pt1. Then you ran the C:BOX1 program
which also assigns a value to a variable called pt1. Pt1 in the
C:BOX1 program is assigned the coordinate of the first corner
point you pick. After the box is drawn, you start the line
command and enter the variable pt1 as the starting point. You
might expect the line to start from the corner of the box since
it is the point last assigned to pt1. Instead, the line begins
at the location you had assigned to pt1 before you ran the wedge
program. When you ran the C:BOX1 program, two versions of pt1
existed, The global version of pt1 you created before you ran
C:BOX1, and the version of pt1 created by the C:BOX1 program.
The C:BOX1 version of pt1 lives and dies within that program and
has no affect on the global version of pt1 (see figure 3.13).
Figure 3.13: Dynamic Scoping
Dynamic Scoping of variables can simplify
your program coding efforts since you don't have to create an
argument list for every functions you write. It can also
simplify your management of variables. Dynamic Scoping can also
create some interesting side affects as seen in the last
exercise. For this reason, you should try and keep track of your
variables and use global variables sparingly.
Conclusion
In this chapter you examined methods for
designing your programs in an organized fashion. The box
example, though simple enough to leave as a single program,
allowed you to explore the concept of modular programming. It
also showed how a program might be structured to give a clear
presentation to both the creator of the program and those who
might have to modify it later.
|
