1. Structured Programming
Defn: This is an approach to program development that produces programs of high quality that are easy to test, debug, modify and maintain. This technique emphasizes the modular approach to program development.
Modular Programming: Using this approach a large complex problem is broken up into sub-problems, and if necessary these are further divided until the tasks to be solved are simpler or easier for programming code to be developed. – Top Down Design
ADD A
MEMBER
SEARCH FOR A
MEMBER
DELETE A
MEMBER

2. Structured Programming
Defn: A structure chart is ideally a map of your program which shows how variables pass data between modules in a program. It helps the programmer to produce a top-down design of the program
Steps:
Place the main module as the root of an upside-down tree
Determine the set of tasks necessary for solving the problem.
Place these below the root and connect the root to each task
Break down each task into even smaller tasks if necessary.
Eventually the program is broken down to a point where the “leaves” of the structure chart “tree” represent simple modules that can be coded with just a few statements.

3. Structure Charts Automatic Teller Activate Customer Accounts
Handle transactions
Validate
Customer
Pull customer
record
Check Transactions
Savings Transactions
Exit
Transactions
Get Valid
Card #
Get Valid
Code #
Handle
Queries
Handle
Deposits
Handle
withdrawals
Fig 2. A structure chart,. Each box (node) in the chart represents a block of code called a module. The root node (box at the top) represents the main section of the program. Each connecting line represents a call to a module. The connecting lines could be variables (data) which are passed to and from modules.

4. Structured Programming
Most of the programs written at the ordinary and advanced level courses are likely to be short; however, in the IT arena most problems will require thousands, if not millions of lines of code. (Windows 2000 – over 35 millions lines of code). The importance of splitting a problem into a series of self-contained modules then becomes obvious. A module should not exceed 100 lines, and preferably short enough to fit on a single page or screen.
ADVANTAGES OF MODULAR PROGRAMMING
Allows a problem to be split in stages and for a team of programmers to work on the problem, also enabling a faster solution.
Senior programmers can be given the more complex modules to write, and the junior programmers the simpler ones.
Program modification is easier since changes can be isolated to specific modules.
Modules can be tested and debugged independently.
Since a module performs a specific well defined task, it is possible to develop and place commonly used modules in a user library so that they can be accessed by different programs. (e.g. Validation, Uppercase, Text color…Pascal)
If a programmer cannot continue through the entire project, it is easier for another programmer to continue working on self contained modules.

5. Structured Programming
In the Pascal programming language the concept of structured programming is expressed using Procedures and Functions.
Procedures are portions of code that perform a specific task such as draw a square on screen, prompt a user to enter values, display results on screen etc. They can exist as independent statements e.g. textcolor(red), inc(x), clrscr;
Functions are also portions of code that perform a specific task. However, they return a value or result, such as an integer, a real number, a string , etc. Consequently, they can only be used as components of statements e.g. ch:=upcase (ch); y:= abs(z);
Consider the following simple example.
Program Example1:
Procedure open_screen;
Begin
writeln(‘ Welcome to Cyber Core….’);
end;
open_screen;
End.
Program header
Procedure header
End of Procedure
Start of main program
Calling the procedure open_screen
End of program

6. Structured Programming
Examine the Pascal program below which prompts a user for two names and outputs the one that is alphabetically smaller. The program uses a procedure which creates a border (of 20 asterisks) before and after the output. Note also that the procedure is called twice from the main program and that procedures and functions are written before the main program.
Program smaller_name;
Var name1,name2:string;
Procedure Border;
Var i:integer;
Begin
for i:= 1 to 20 do
write(‘*’);
writeln;
End;
writeln(‘ Enter two names ‘):readln(name1,name2);
Border;
If (name1<name2) then
writeln(name1)
else
writeln(name2);
End.
Program header
Global Variables
Local Variable
End of Procedure
Start of main program
Call Procedure
Call Procedure again

7. Structured Programming
Notice that the procedure will only print 20 asterisks, no more and no less. If 10 or even 40 asterisks are required then the same procedure can be used, though some modification will be required. This can be achieved with the use of a parameter list with one variable, say Num_asterisks . The procedure now looks as follows:
Procedure Border(Num_asterisks:integer);
Var i:integer;
Begin
for i:= 1 to Num_asterisks do
write(‘*’);
writeln;
End;
On examining the new format the number of asterisks is passed to the procedure through the parameter list in the procedure header. Consequently, when the procedure needs to be called, the value of the parameter is placed in brackets. So calls in the main program would look like Border(10); or Border(40) ; for printing 10 or 40 asterisks respectively.
Global variables exist throughout the scope of a program. They are declared at the start of the program and values may be accessed at any time and position during the execution of the program.
Local Variables are declared within a procedure or function. They are created when the subroutine is started and only exist when that portion of code is executed. When the procedure or function is exited the memory space which was reserved for the local variables is released for other use.
N.B to minimize the constraints for the running of a program more local declarations should be made where possible.
Parameter List

8. Structured Programming
In the Pascal programming language Functions are very similar to Procedures except that they return a value. The golden rule is that if a value is not to be returned then a procedure should always be used. When programming the reserved word Function is used instead of the word Procedure and the data type of the returning value must be stated.
Format of a Pascal Function
Function Name _of _function (parameter_listing) :datatype
Var any_local_variables;
Begin
statement1;
statement2;
Name_of_Function:= value;
End;
Function is_even (num : integer):boolean;
if (num mod 2 = 0) then
is_even:=true
else
is_even:= false;
end
Integer, string, char, boolean
Must be given a value consistent
with the data type stated

9. Structured Programming
Consider the Pascal program below and answer the questions that follow.
Program test1;
Var ans, num:integer;
Procedure cubed(num: integer; var ans:integer);
Begin
ans:= num * num * num;
End;
Writeln(‘Enter number : ‘); readln (num);
cubed(num , ans);
Writeln(‘Number Cubed : ‘,ans);
readln;
End.
What is the name of the program?
Write the names of the global and local variables.
State the parameter list in the procedure.
For each parameter , identify whether it is a variable or value parameter and why.
What will be the output if the following numbers are entered (a) 4 (b) 3.2 ?
Do you think cubed should be written as a Function? If so why?
Assume you decide to write cube as a Function, rewrite the above portion of code.
Program test1;
Var num:integer;
Function Cubed(num: integer) :integer;
cubed:=num * num * num;
Begin writeln (‘Enter number : ‘); readln (num);
writeln(‘Number Cubed : ‘, cubed(num));

10. Structured Programming
Consider writing a program where a user is required to enter integer values M and N and to calculate and output M raised to the power N. In analyzing the problem, three cases need to be considered:
the case of N being Zero
the case of N being positive and
finally the case of N being negative
The modular breakdown of the problem now looks as follows:
Power Raising
M + n
M -n M0
It is now possible to focus on one module at a time and to develop the internal workings (stepwise refinement).
For the Zero case the body of the module would need only contain the statement setting the answer to 1
(Any number raised to the power of Zero equals 1!)
For the Positive Case the following portion of code could be used
ans:= 1;
for i:= 1 to N do
ans:= ans * M
For the Negative Case it is observed that M – n is equal to that of 1/ M + n. Thus, use could be made of previously written code for the positive case. (all that is necessary is for the procedure to be appropriately called)