Chapter 4 – Design Tools: Jackson Structured Programming (JSP)

4.1 Three Structured Constructs

All programs can be constructed using only the three basic constructs. It is the concept of structured programming that a program should be developed using only these three basic constructs. It is not wrong to use the GOTO structure but it is discouraged, because programs with the GOTO structure are often classified as unstructured. The three basic constructs are:

1. Sequence

2. Selection

3. Iteration/Repetition

4.1.1 Sequence Construct

In a sequence construct, the way the statements are placed implies the order in which the computer will execute the statements. The computer will interpret the statements in a left to right, top to bottom fashion. Consider the following:

Calculate-Average Module DO Get Two Numbers Calculate Sum Determine Average Print Average ENDDO
The sequence for the above module is straightforward. You get the two numbers, calculate the sum, determine the average and print out the result. If the statements are not in that sequence, the result obtained will not be the answer intended!

Figure 4-1: Simple sequence

The Calculate Average module is not a separate module away from the rest of the four modules below it. But it actually contains all the four modules.

Each process (a rectangle) represents a component with their function/action stated in the function list. If the component does not contain or form other constructs (i.e. other sequences, selections or iterations), it is regarded as an elementary component. The diagram should be interpreted in a top-down, left to right manner. The Calculate-Average Module has four elementary components. Each time it is activated, it will activate the Input Number module, Calculate Sum module, Determine Average module and the Print Result module in that order. Consider another example:

Figure 4-2: Complex sequence

The sequence of activation for the above will be: A, B, E, F, C, D, G, I, J, H

4.1.2 Selection Construct

The selection construct consists of condition(s) and one or more components. Based on the outcome for the condition(s), only one of the components will be selected. All the other components will not be selected. Consider the following:

Check-Age Module DO IF Age < 21 Then DO Teenage module ENDDO ELSE DO Adult module ENDDO ENDIF ENDDO

When the Check-Age module is activated, the Teenage module will be performed if condition is true (i.e. Age or = 21), then the Adult module will be performed. So, the condition determines which component is to be performed. There will never be the case where both modules are activated in the same run.

Using the JSP method, the Section construct is represented as follows:

Figure 4-3: Simple selection

Take note of the convention. For the selection construct, the process box is slightly different from the normal process box. It has a small circle (“o”) at the top right corner of the process box indicating that it is a selection construct. There is also the condition that must be placed on the left branch of the construct. It can be the actual condition itself or a number from a conditions list.

Consider another example:

CAL-NO-HOLIDAY IF YEARS-WORKED > 14 THEN DO CAL-EXTRA-HOLIDAY ENDDO ENDIF

When the CAL-NO-HOLIDAY module is activated, based on the condition (YEARS-WORKED > 14), the CAL-EXTRA-HOLIDAY module will be activated if the condition is true. Otherwise, it will do nothing.

JSP representation:

Figure 4-4: Selection without ELSE

A multiple choice selection could be expressed in schematic logic as:

CHECK TOTAL POINTS MODULE IF TOTAL-POINTS >= 90 THEN DO A-Module ENDO ELSE IF TOTAL-POINTS >= 80 THEN DO B-Module ENDO ELSE IF TOTAL-POINTS >= 70 THEN DO C-Module ENDO ELSE IF TOTAL-POINTS >= 60 THEN DO D-Module ENDO ELSE DO F-Module ENDO ENDIF ENDIF ENDIF ENDIF

Note: The square brackets show you the ‘nesting’ structure of a multiple selection.

JSP representation:

Where: C1 is total points >=90 C2 is total points >=80 C3 is total points >=70 C4 is total points >=60
Figure 4-5: Multiple selections

From the JSP representation, when Check Total Points Module is activated, depending on the condition, one of the modules (either A, B, C, D or F) will be activated. If the condition Total Points >= 90 is true, A-Module will be activated and the process will continue at the next module after the Check Total Point Module (not shown here). If the condition is not true (i.e. false), it will then check the condition Total Points >= 80. If the condition is true, B-module will be activated and the process will continue at the next module after the Check Total Points >= 70 and so on. The F-module does not have a condition associated with it because it takes the “default” condition. If all the above mentioned conditions turn out to be false, F-module will be activated.

4.1.3 Iteration Construct

The iteration construct provides a way for the programmer to repeat a certain/whole portion of the program until certain condition(s) is met. (Also known as looping or repetition construct.) The latter (certain condition) is important as it will ensure that the program loop will not go on indefinitely.

The schematic logic for iteration could be written as:

Main-Process Module DO WHILE Not End Of File DO Detail-Process Module ENDDO ENDDO
Each time the Main-Process Module is activated, the Detailed-Process Module will be executed zero to n times depending on the condition (Not End Of File).

Figure 4-6: Looping/Iteration/Repetition

Take note of the convention. For the iteration construct, the process box is slightly different from the normal process box. It has an asterisk (“*”) at the top right corner of the process box, indicating that it is an iteration construct. There is also the controlling condition. It can be the actual condition itself or a number from a conditions list.

Each time the Main-Process Module is activated, it will activate the Detail-Process Module that may contain other sub-modules depending on the controlling condition (Not End Of File). When the Detail-Process Module is completed, it will then check the controlling condition again. If it is still Not End Of File, Detail-Process Module will be activated again. If the controlling condition returns a false value, it will go on to the next module (not shown here).

4.2 Stepwise Refinement

Stepwise refinement is a process to sub-divide (refine) the main program function into sub-functions. This is done progressively at each level until the lowest level functions can be represented in a programming language.

In the example above (Figure 4-6), it would be difficult for the programmer to start coding the Detail-Process Module as it lacks too many details/steps required in the target programming language. Further refinement of the steps involved will have to be carried out. Hence the name Stepwise Refinement. On refinement, the Detail-Process Module will have a few other sub-modules. (Figure 4-7)

Figure 4-7: Repetition with sub-modules

4.3 Functions and Conditions List

The functions listed in the functions list serve as a further refinement to the module it is representing. It is normally represented as a sequence of actions that is achievable in the target programming language. One should take note that at this stage, we are more concerned with the design of the program rather than how to code the program. As JSP is most suited for a High Level design, the functions listed in the functions list will normally be generalized statements. Sample entries in the functions list:

Functions list

1. Open files 2. Read a record 3. Output all required headings 4. Calculate average mark 5. Set EOF-Flag to 1

As for the conditions list, all conditions associated with selections and iterations are listed separately from the structured diagram. These conditions are cross-referenced using condition numbers C1, C2, C3, etc. Sample entries in the conditions list:

Conditions list

C1. EOF-Flag is NOT 1
C2. Hrs-worked > 44
C3. Average mark >= 50

Both the functions and conditions can be used, ( i.e., if at some part of the JSP diagram, you need to perform or test the same condition again) you just have to state the correct action/condition number. Your JSP diagram will look neater without the full conditions/actions written in full, on it.

4.4 Case Study

A program is needed to help a local college to grade its students. A total weighted score is determined for students from two midterm exam scores both weighted at 30%, and a final exam score at 40%. A grade is assigned on the following basis:

|Total weighted score |Grade |
| | |=60 |and |=70 |and |=80 |and |=90 | | |A |

For each student, the program is to output the student number, the total weighted score and the grade assigned. It is also required to count the number of students receiving each of the five grades. The input will be in the form of a record, each consisting of Student Number, Midterm Test 1, Midterm Test 2 and Final Test mark. The iteration is to be terminated by a suitable dummy record. The summary will then be printed showing the distribution of the grades. Draw the JSP.

As the first step, list down all the main functions that are needed to carry out the tasks as mentioned in the problem.

1. Initialize variables (counters, accumulators) 2. Getting records 3. Check loop termination condition 4. Calculate total weight score 5. Check grade 6. Assign grade 7. Increase various appropriate grade counter accordingly 8. Check page control (using line counter) 9. Output headings 10. Output result for each student 11. Get next record 12. Output summary 13. Stop program
With the main functions listed, we can start to draw the JSP. Not all the functions listed will be represented with a module (process box). Some of the functions can be combined to form one module. For a start most programs have the following structure at the 1st level. (Figure 4-8)

Figure 4-8: 1st level JSP

The main control module will control three modules, namely the Initial, Body and End modules. The Initial module could contain functions 1 and 2 while the End module functions 11 and 12. We also need a looping structure for the unknown number of students. The controlling condition will be a suitable dummy record. The dummy record is of a form that can be identified by your program (e.g. one with a negative student number). (Figure 4-9)

Figure 4-9: Detailed process

The detail process module can be further broken down into other sub modules: calculate total score, check grade, page control, output and read next module.

Figure 4-10: 3rd level JSP

Further refinement will result in the following diagram.

Conditions List

C1. Not EOF
C2. Total Points >= 90
C3. Total Points >= 80
C4. Total Points >= 70
C5. Total Points >= 60
C6. Total Outprint >= 20
Figure 4-11: 4th level JSP

Add in all the functions and conditions for a complete JSP.

EOF represents End of File.

|Functions List |Conditions List |
|Initialize All Variables |C1. Not EOF |
|Read First Record |C2. Total Points >= 90 |
|Calculate Total Weighted Score |C3. Total Points >= 80 |
|Assign Grade |C4. Total Points >= 70 |
|Increase A-counter |C5. Total Points >= 60 |
|Increase B-counter |C6. Total Outprint >= 20 |
|Increase C-counter | |
|Increase D-counter | |
|Increase F-counter | |
|Output Headings | |
|Reset Outprint-counter | |
|Output Results | |
|Increase Outprint-counter | |
|Read Next Record | |
|Output Distribution Summary | |
|End Program | |

Figure 4-12: Complete JSP

-----------------------
Calculate Average

Input Number

Calculate Sum

Process

Determine Average

Print Result

A

B

C

Postal Code

E

F

G

H

I

D

J

Check
Age Module

If C1

o
Teenage Module

o
Adult
Module

Where C1 is Age 14

If C1

CAL-NO-HOLIDAY

o
CAL-EXTRA-HOLIDAY

o
--

If C4

If C2

Check
Total Points

o
B

o
C

o
F

Main
Process

o
D

If C1

o
A

While C1

If C3

*
Detail Process

Where C1 is Not End Of File

Main Control

End

Cal Total

Update

Initial

Output and Read Next

While C1

Detail Process*

Check Total

Where C1 is Not End Of File

Main Process

Body

End

Main Control

Initial

Body

*
Detailed Process

While C1

while C1

Cal Total Score

Page Control

Output and Read Next

*
Detailed Process

Check Grade

Cal Total Score

Page Control

Output and Read Next

*
Detailed Process

Check Grade

If C4

If C2

o
A

o
D

If C5

o
F

If C3

o
Output Headings

o
B

o
C

If C6

o
--

End

Main Control

Initial

Body

o
Output Headings

If C6

o
-

If C4

If C2

o
A

o
D

If C5

o
F

If C3

o
B

o
C

While C1

Cal Total Score

Page Control

Output and Read Next

*
Detailed Process

Check Grade

1,2,10

15,16

3

12,13,14

4,8

4,7

4,6

4,5

4,9

10,11