5.1.

Structured Programming

Introduction

Organizations and individuals are continually searching for more efficient ways to perform the
software development process. One way of lowering the time and cost of development is to
standardize software programs and the process of programming. The benefits of standardized
programs are that they are easier to code, maintain, debug, and modify. In recent years, many
different techniques have appeared attempting to minimize differences in the way programmers'
design and develop software

Programming Approaches: Structured Vs Non-Structured Approaches

Structured programming is a standardization technique used for software development. The

structured approach works by having all programmers use the same structured design techniques.
Structured programming is used to address the shortcomings of non-structured programming,
which frequently used the GO TO branch points to transfer from one part of the program to
another part. Using GO TO codes, one could transfer backward, forward, or anywhere else
within the program. The problem is that the connections between parts of the program by using
GO TO commands can become quite haphazard.

The haphazard and sometimes convoluted pattern of linkages between parts of the program is
called spaghetti code. This way of programming is difficult to understand and debug. Non-
structured programming is now viewed as an ineffective programming strategy. To develop good
software, developers have to carefully think out and design the programs. In the earliest days of
computing, programmers developed code according to their own whims, with the result that the
software was often confusing and difficult to work with. Software today is expected to follow
recognized design principles. The prevailing design standards are structured programming and
structured design.

Structured Programming

Structured programming makes use of the control structures (sequence, selection and repetition).
Structured programming does not use GO TO commands. The principle of sequences implies
that program instructions should be executed in the order in which they appear. The principle of
selection implies that instructions may be executed selectively using IF-THEN and/or IF-THEN-
ELSE statements. These conditional statements work in the following way. IF a condition is true
or is met, THEN a specific set of instructions will be executed.

If the condition is false, then another set of instructions will be executed. For example, if an
employee works for more than 40 hours a week, THEN calculate his gross pay based on an
overtime rate of 50% more than his normal hourly pay. If the employee work 40 hours or less a
week, THEN calculate gross pay based on the normal hourly rate of pay. IF-THEN-ELSE works
the same way, but in this case the word ELSE is substituted with a false case, a condition not
met. IF the employee works more than 40 hours a week, then calculate gross pay based on a time
and a half the rate, ELSE calculate gross pay based on the normal rate. Alternatively when there
are many options, one can employ the CASE statement. The iteration principle indicates that one
part of the program can be repeated or iterated a limited number of times. In most computer
languages, the repetition or iteration may be activated by using REPEAT ---UNTIL or using the
WHILE loop and the FOR loop.

Structured Design

According to structured design principles, a program should be designed from the top-down or
bottom-up as a hierarchical series of modules. A module is a logical way of partitioning or
subdividing a program so that each module performs one or a small number of related tasks.

5.2. Modular Programming

The Modular approach to programming involves breaking a program down into sub-components
called modules. Every module consists of an independent or self-contained set of instructions.
Modules are also called as routines, subroutines, or procedures or subprograms. Each of these
modules is designed to perform a specific task in the overall program, like calculating the gross
pay of an employee in a payroll program. The advantage of modular approach is the ability to
write and test each module independently and in some cases reuse modules in another program.
A program consists of multiple modules. Additionly, there is a main module in the program that
executes the other modules. You can use the following approaches in order to design a program
consisting of modules.

Top-Down Design or Top-Down Decomposition

One programming approach that is proven to be most productive is called top-down

decomposition. This is the process of breaking the overall procedure or task into component parts
(modules) and then subdividing each component module until we reach the lowest level of detail.
It is called top-down design or top-down decomposition since we start "at the top" with a general
problem and design specific solutions to its sub problems. To obtain an effective solution for the
main problem, it is desirable that the sub-problems (subprograms) should be independent of each
other. Then each sub-problem can be solved and tested by itself. The top level of the
decomposition is the level of the overall plan. Unfortunately there is no single formula that will
decompose a complex problem into individual tasks. The strategy involves top-down reduction
of the processing until a level is reached where each of the individual processes consists of one
self-contained task, which is relatively easy to understand and can be programmed in a few
instructions. This stepwise process may create multiple layers or levels of modules beginning
with a main module at the top. The middle level might contain intermediate modules, and minor
modules at the third level. From the top the program is developed in a stepwise fashion. Using
this method, a complex problem is separated into simpler parts, which can be easily
programmed. At every stage, the instructions or steps can be checked for errors in logic,
corrected or modified without any effect on the other subprograms. The result will be a truly
modular program that satisfies the requirement, which says, 'a good program can be easily
modified'. This programming strategy focuses on developing a software program conceptually
before coding commences. A programming team will likely create a diagram that looks much
like an organizational chart with the main module at the top and subordinate modules down
below connected by lines with each box representing a program module. The chart shows how
modules relate to each other but does not depict the details of the program instructions in every
module. The structure chart is often referred to as a Hierarchical Program Organization (HIPO).

Example top-down decomposition

The company's payroll system can contain the following modules or tasks

Master file

Earnings

Deductions

TaxingNet

earning

Print reports

The tasks given above can be shown by a hierarchical chart (Hierarchical Program Organization)
as shown below.
Identifying and diagramming the relationship between modules in this fashion allows
programmers to focus on the overall organization and logic of the program without getting
bogged down in the details. After the overall structure of the program is finalized, detailed
coding of individual modules can proceed. It is the set of principles that enable a problem to be
solved by breaking it down into manageable smaller parts, step by step from the overall problem
specification, in stages through to the actual code.

Bottom-up Design

Already existing facilities/designs are used/taken into consideration as a model for a new (better)
design. With the use of Bottom-up design strategy, we take an already existing computer
program as a model for our new program. We try to utilize the existing facilities or design in a
way, which gives out program a better performance.

Stepwise Refinement

Stepwise refinement is a top-down design strategy. The program is developed by successively

refining levels of procedural detail. In every refinement step, one or several instructions of the
given program are decomposed into more detailed ones. This successive decomposition or
refinement of specifications terminates when all instructions are expressed in terms of any
underlying computer or programming language. Each step of refinement implies some design
decisions. It is important that the programmer is aware of the underlying criteria.

Sub Programs

In top down design, the problem is broken down into sub-problems. The main problem is solved
by the corresponding main program. The sub-problems solutions are provided by subprograms,
known as subroutine, functions, or procedures depending on the programming language. A
subprogram executes or performs the computer instructions required to solve a given
subproblem.

User defined Sub Programs and Functions

A Sub Program is a part of a program that performs one or more related tasks, has its own name,
is written as a separate part of the program, and is accessed via a call statement. A Function
returns a value to the program and shares many of the same characteristics as a Sub Program
(e.g., has its own name, is written as a separate part of the program).

Pros and Cons of Using Procedures

Disadvantage -- Procedure calls consume execution time and memory.

Advantage -- Procedures make the program easier to write, test, debug and maintain.

Within a program we can normally identify sub-tasks that are performing a specific function.
Where program features clearly identify sub-tasks it is good practice to implement each sub-task
on its own, stand-alone, sub-program.

There are considerable advantages of a separate sub-program such as:

A stand-alone sub-program can be developed and tested independently.

Once programmed, the sub-program can be called a number of times within a program.

The sub-program is called by a meaningful name chosen by the programmer, which helps
greatly in understanding the code.

The sub-program can be re-used in subsequent programs.

The ability to reuse a sub-program is obviously useful. We can include an existing subprogram in
another program whenever you need it.

Procedures and Functions

A function or procedure is a sub-program that exists to perform a specific, single task. It has its
own inputs and its own outputs (often called parameters), it can also define its own variables. It
may return the values to the referencing or invoking program or procedure A function is a special
sort of procedure that has a single output.

Procedures

A procedure has a header, followed by declarations of variables used within the procedure known
as local variables (identifiers) and finally statements that are to be performed when the procedure
is invoked. The procedure header is the mechanism used to give a name to the procedure. The
procedure header also may contain the values that can be communicated between the procedure
and its invocation known as parameters.

The common structure for defining a procedure (in C++) is:

void Procedure_Name(parameter)

. //List of Statements.

Example:

void WelcomeNote ()

Cout<<Say Hello to Programming Concepts;

Procedures in c++ start with the keyword void.

Functions

The general structure for defining a function (in C++) is:

Data_type Function_Name(parameter)

Return statement;

Example:

float Cube (float x)

float product;

product = x*x*x;

return product;

The most important thing to note is that the function must have a result type which dictates what
type of value the function represents.

A function is a special sort of sub-program - it is used when a sub-program is needed which takes
a number of inputs and returns a single output value (as with cube above). This is typical of
many algebraic functions (sine, cosine, exp, log, cube) but is otherwise fairly unusual since the
sub-programs that we want to define quite often have either no output at all or very many outputs
- in these cases we use a procedure.

Parameters

As we've seen, procedures and functions can take a list of quantities called parameters. Initially
you might like to regard the parameters as the inputs to the module (but this is not always true).

For example:

void sumAndDifference( float a, float b)

{

a = a+b;

b = a-b;

cout<<"The sum is "<<a;

cout<<"The difference is"<<b;

Both total and difference are local variables and only exist within the procedure, as soon as the
procedure finishes they and their values disappear. The following program is an example of the
main program:

void main()

float val1, val2;

val1=2;

val2=4;

sum_and_difference(val1,val2);

cout<<val1;

The values of val1 and val2 are simply copied into the variables a and b of the procedure
sumAndDifference. At the end of the procedure the values are not copied back! The value of val1
that the final output statement displays is therefore 2 (not 0).

Sometimes however, we would like the values to be copied back at the end of the procedure.
This is particularly true if there is more than one output of the procedure, as in the case of
sumAndDifference. The sum and difference cannot be passed back together as the return value of
a function, as a function can return only a single value.

void sumAndDifference( float a, float b, float &s, float &d)

s =a+b;
 d =a-b;

void main()

float val1, val2;

float total, difference;

val1=2;

val2=4;

sum_and_difference(val1,val2, total, difference);

cout<<The sum is <<total;

cout<<The difference is<<difference;

The symbol & in the procedure parameter list instructs the computer to copy back any changes to
the values of a and b once the procedure has completed. In summary, if you want to write a sub-
program that has a number of inputs and a single output, write a function. If you want many
outputs from the sub-programs, use a number of var parameters in a procedure.

Built in functions

While most programming languages enable you to write your own functions (as above), most
also provide a library of common functions ready for you to use (e.g. sine, cosine).

A common example of built-in function is the Printf function in C language. (Or any function
used for printing out values in console in any language; System.Out.Println function in case of
Java). This function is implemented and is available to the programmer to use any time he wants.
Normally, the programmer is not bothered how the function is implemented in the framework or
how the compiler of the language work with this function.
MT 512: Programming Design Page no: 38
4. PROGRAMMING APPROACHES
Organizations and individuals are continually searching for more efficient ways to
perform the software development process.
One-way of reducing the time and cost of development is to standardize software
programs and the programming process. The benefits of standardized programs are that
they are easier to code, maintain, debug, and modify.
In recent years, a variety of techniques have appeared attempting to minimize differences
in the way programmers' design and develop software. A few of the most commonly used
techniques for standardization are described in this lesson.
Programming Approaches: Nonstructured Vs. Structured Approaches
Structured programming is a standardization technique used for software development.
This approach works by having all programmers use the same structured design
techniques. Structured programming was invented to address the shortcomings of
nonstructured
programming, which frequently employed GO TO branch points to transfer
from one part of the program to another part. Using GO TO codes, one could transfer
backward, forward, or anywhere else within the program. The problem is that the
connections between parts of the program by using GO TO commands can become quite
haphazard.
The haphazard and sometimes convoluted pattern of linkages between parts of the
program has been called spaghetti code. This type of programming is difficult to
understand and debug. Non-structured programming of this nature is now viewed as an
ineffective programming strategy.
To develop good software, developers have to carefully think out and design the
programs. In the earliest days of computing, programmers wrote software according to
their own whims, with the result that programs were often confusing and difficult to work
with. Software today is expected to follow recognised design principles. The prevailing
design standards are structured programming and structured design.
4.1 STRUCTURED PROGRAMMING
Structured programming makes use of the control structures (sequence, selection and
repetition). Structured programming does not use GO TO commands. The sequence
principle implies that program instructions should be executed in the order in which they
appear. The selection principle implies that instructions may be executed selectively
using IF-THEN and/or IF-THEN-ELSE statements. These statements work in the
following way. IF a condition is met or is true, THEN a specific set of instructions will be
executed. If the condition is false, then another set of instructions will be executed.
MT 512: Programming Design Page no: 39
For example, IF an employee works 40+ hours a week, THEN calculate gross pay based
on an overtime rate of time and a half. If the employee does not work 40+ hours a week,
THEN calculate gross pay based on the normal hourly pay rate. IF-THEN-ELSE works in
a similar way, but in this case the word ELSE is substituted for a false case, a condition
that is not met. IF the employee works 40+ hours a week, then calculate gross pay base
on a time and a half pay rate, ELSE calculate gross pay based on the normal rate.
Alternatively when there are many options, one can employ the CASE statement.
The iteration principle indicates that one part of the program can be repeated or iterated a
limited number of times. In most computer languages, the iteration may be activated by
using REPEAT ---UNTIL or using the WHILE loop and the FOR loop.
4.2 STRUCTURED DESIGN
According to structured design principles, a program should be designed from the topdown
or bottom-up as a hierarchical series of modules. A module is a logical way of
partitioning or subdividing a program so that each module performs one or a small
number of related tasks.
4.2.1 Modular Programming
The Modular Approach to programming involves breaking a program down into
subcomponents called modules. Each module is composed of an independent or selfcontained
set of instructions. Modules are also referred to as routines, subroutines, or
subprograms or procedures. Each module is designed to perform a specific task in the
overall program, such as to calculate the gross pay of an employee in a payroll program.
The advantage of modular programming is the ability to write and test each module
independently and in some cases reuse modules in other programs. A program consists of
multiple modules. In addition, there is a main module in the program that executes the
other modules.
You can use the following approaches in order to design a program consisting of
modules.
4.2.2 Top-Down Design or Top-Down Decomposition
One programming approach that has proven to be most productive is called top-down
decomposition. Top-down decomposition is the process of breaking the overall procedure
or task into component parts (modules) and then subdivide each component module until
the lowest level of detail has been reached. It is called top-down design or top-down
decomposition since we start "at the top" with a general problem and design specific
solutions to its sub problems. In order to obtain an effective solution for the main
MT 512: Programming Design Page no: 40
problem, it is desirable that the subproblems (subprograms) should be independent of
each other. Then each sub-problem can be solved and tested by itself.
The top level of the decomposition is the level of the overall plan. Unfortunately there is
no single formula that will decompose a complex problem into individual tasks. The
strategy involves top-down reduction of the processing until a level is reached where
each of the individual processes consists of one self-contained task, which is relatively
easy to understand and can be programmed in a few instructions.
This stepwise process may create multiple layers or levels of modules beginning with a
main module at the top. The second level might contain intermediate modules, and the
third level minor modules. The program is developed from the top in stepwise fashion.
Using this method, a complex problem is separated into simpler parts, which can be
programmed easily. At each stage, the instructions or steps can be checked for errors in
logic, corrected or modified without any effect on the other subprograms. The result will
be a truly modular program that satisfies the requirement, which says a good program
can be modified easily.
This programming strategy focuses on developing a software program conceptually
before coding begins. A programming team will likely create a diagram that looks much
like an organisational chart with the main module at the top and subordinate modules
down below connected by lines with each box representing a program module. The chart
shows how modules relate to each other but does not depict the details of the program
instructions in each module. The structure chart is usually referred to as a Hierarchical
Program Organisation (HIPO)
Example top-down decomposition
The payroll system of a company can contain the following modules or tasks
Master file
Earnings
Deductions
Taxing
Net earning
Print reports
The tasks given above can be depicted in a hierarchical chart (Hierarchical Program
Organisation) as shown below.
MT 512: Programming Design Page no: 41
Identifying and diagramming the relationship between modules in this fashion allows
programmers to focus on the overall organisation and logic of the program without
getting bogged down in the details. Once the overall structure of the program is finalised,
detail coding of individual modules can proceed.
It is the set of principles that enable a problem to be solved by breaking it down into
manageable parts, step-by-step from the overall problem specification, in stages through
to the actual code.
4.2.3 Bottom-up Design
Already existing facilities/designs are used/taken into consideration as a model for a new
(better) design. Using Bottom-up design strategy, we take an already existing computer
program as a model for our new program. We try to utilise the existing facilities or design
in a way, which gives out program a better performance.
4.2.3 Stepwise Refinement
Stepwise refinement is a top-down design strategy. The program is developed by
successively refining levels of procedural detail. In each step of the refinement, one or
several instructions of the given program are decomposed into more detailed instructions.
This successive decomposition or refinement of specifications terminates when all
instructions are expressed in terms of any underlying computer or programming
language.
Every refinement step implies some design decisions. It is important that the programmer
is aware of the underlying criteria.
PAYROLL PROBLEM
Master File Earnings Deductions Taxing
Create
Master
File
Update
Master
File
Create
Earning
File
Update
Earning
File
Create
Deduction
File
Update
Deduction
File
Create or
update Tax
File
MT 512: Programming Design Page no: 42
4.3 SUB-PROGRAMS
In top down design, the problem is broken down into sub-problems. The main problem is
solved by the corresponding main program. Solutions to the sub-problems are provided
by subprograms, known as procedures, functions, or subroutine depending on the
programming language. A subprogram performs or executes the computer instructions
required to solve a given subproblem.
4.3.1 User defined Sub Programs and Functions
A Sub Program is a part of a program that performs one or more related tasks, has its own
name, is written as a separate part of the program, and is accessed via a call statement.
A Function returns a value to the program and shares many of the same characteristics as
a Sub Program (e.g., has its own name, is written as a separate part of the program).
Pros and Cons of Using Procedures
Disadvantage -- Procedure calls consume execution time and memory.
Advantage -- Procedures make the program easier to write, test, debug and
maintain.
Within a program we can normally identify sub-tasks that are performing a specific
function. Where program features clearly identify sub-tasks it is good practice to
implement each sub-task in its own, stand-alone, sub-program.
The advantages of a separate sub-program are considerable:
A stand-alone sub-program can be written and tested independently.
Once written, the sub-program can be called a number of times within a
program.
The sub-program is referred to by a meaningful name chosen by the
programmer, which helps greatly in understanding the code.
The sub-program can also be used in subsequent programs.
The ability to reuse a sub-program is obviously useful. We can include an existing
subprogram in another program whenever you need it.
Main Problem
Subproblem
A
Subproblem
B
Subproblem
C
Main Program
Subprogram
A
Subprogram
B
Sub-
Program C
MT 512: Programming Design Page no: 43
4.3.2 Procedures and Functions
A function or procedure is a sub-program that exists to perform a specific, single task. It
has its own inputs and its own outputs (often called parameters), it can also define its own
variables. It may return the values to the referencing or invoking program or procedure A
function is a special sort of procedure that has a single output.
Procedures
A procedure has a header, followed by declarations of variables used within the
procedure known as local variables (identifiers) and finally statements that are to be
performed when the procedure is invoked.
The procedure header is the mechanism used to give a name to the procedure. The
procedure header also may contain the values that can be communicated between the
procedure and its invocation known as parameters.
The general structure for defining a procedure (in C++) is:
void Procedure_Name(parameter)
{
.
//List of Statements.
}
Example
void WelcomeNote ()
{
Cout<<Welcome to Programming Concepts;
}
Procedures in c++ start with the keyword void.
Functions
The general structure for defining a function (in C++) is:
Data_type Function_Name(parameter)
{
.
.
Return statement;
}
Example
float Cube (float x)
{
float product;
product = x*x*x;
return product;
}
The principle thing to note is that the function must have a result type which dictates
what type of value the function represents.
MT 512: Programming Design Page no: 44
A function is a special sort of sub-program - it is used when a sub-program is needed
which takes a number of inputs and returns a single output value (as with cube above).
This is typical of many algebraic functions (sine, cosine, exp, log, cube) but is otherwise
fairly unusual since the sub-programs that we want to define quite often have either no
output at all (as with manythanks) or very many outputs - in these cases we use a
procedure.
Parameters
As weve seen, procedures and functions can take a list of quantities called parameters.
Initially you might like to regard the parameters as the inputs to the module (but this is
not always true, as we shall see). For example:
void sum_and_difference( float a, float b)
{
float total, difference;
total =a+b
difference =a-b
cout<<The sum is <<total;
cout<<The difference is <<difference;
}
Both total and difference are local variables and only exist within the procedure, as soon
as the procedure finishes they and their values disappear.
The following program is an example of the main program:
void main()
{
float val1, val2;
val1=2;
val2=4;
sum_and_difference(val1,val2);
cout<< val1;
}
The values of val1 and val2 are simply copied into the variables a and b of the procedure
sum_and_difference. At the end of the procedure the values are not copied back!!!! The
value of val1 that the final output statement displays is therefore 2 (not 0).
Sometimes however, we would like the values to be copied back at the end of the
procedure. This is particularly true if there is more than one output of the procedure, as in
the case of sum_and_difference. The sum and difference cannot both be passed back as
the return value of a function, since a function can return only a single value.
void sum_and_difference( float a, float b, float & s, float & d)
{
s =a+b;
d =a-b;
}
MT 512: Programming Design Page no: 45
void main()
{
float val1, val2;
float total, difference;
val1=2;
val2=4;
sum_and_difference(val1,val, total, difference);
cout<<The sum is <<total;
cout<<The difference is <<difference;
}
The symbol & in the procedure parameter list instructs the computer to copy back any
changes to the values of a and b once the procedure has completed.
In summary, if you want to write a sub-program that has a number of inputs and a single
output, write a function. If you want many outputs from the sub-programs, use a number
of var parameters in a procedure
4.3.3 Built in functions
While most programming languages enable you to write your own functions (as above),
most also provide a library of common functions ready for you to use (e.g. sine, cosine).
Exercise
1. Devise the pseudcode for a program that will accept names and marks of each student in
the class of 100 students, and then calculate the average of all marks. The program
should make sure the entered marks entered are valid (in the range of 0 and 100). Use
the idea of modular programming.
2. Write pseudcode for a program that will read two matrices and then display their sum.
3. The scalar product (also called the inner product or the dot product) of the two
vectors (one-dimensional arrays) A and B with n elements is defined as
Write a pseudocode program, which references a Function with three parameters, A,
B, N. The main program should input N and the two arrays A and B. The Function
subprogram should have a name called Product and it should compute the scalar
product according to the formula given
=

===+++
n
i
iinn product A B a b a b a b a b
1
1122 . ...