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 non-structured 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
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 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.
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 self-contained 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
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
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.
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
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
Sub-program A
Sub-program B
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) {
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 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, 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) {
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 i i n n
b a b
a b a b a B
A product
1 1 1 2 2
