Program Design — structure charts, state-transition diagrams

A structure chart (also called a hierarchy chart) shows the static structure of a program — how it breaks down into modules (procedures/functions) and how they call each other.

Elements:

• Rectangle = module (procedure or function)
• Lines/arrows = calling relationship (top calls bottom)
• Arrowheads on lines show data flow (parameters passed)
  • Down arrow (↓) = parameter passed by value (input to called module)
  • Up arrow (↑) = parameter passed by reference (output from called module)
  • Double arrow (↕) = both directions (by reference, read and write)

Purpose:

• Visualise modular decomposition — break a problem into manageable sub-tasks
• Show module interfaces — what data each module needs and returns
• Support top-down design — start with main module, refine downwards
• Aid team development — modules can be assigned to different programmers

Step-by-step:

1. Identify the main task (top-level module)
2. Decompose into major sub-tasks (first-level modules)
3. Continue decomposing until each module is small and focused (single responsibility)
4. For each call, identify what data is passed and direction
5. Draw the chart with consistent layout (top-down, left-to-right)

Example: Calculate average of student marks

              ┌─────────────┐
              │   MAIN      │
              └──────┬──────┘
                     │
        ┌────────────┼────────────┐
        ▼            ▼            ▼
   ┌──────────┐ ┌──────────┐ ┌──────────┐
   │GetMarks  │ │ CalcAvg  │ │Display   │
   └────┬─────┘ └────┬─────┘ └────┬─────┘
        │            │            │
   marks[]↑      marks[]↓        avg↑
              avg↑

• GetMarks returns marks[] (output, by reference ↑)
• CalcAvg receives marks[] (input, by value ↓), returns avg (output ↑)
• Display receives avg (input ↓)

Deriving pseudocode from a structure chart:

• Each module → a procedure or function
• Parameters match the arrows (direction and name)
• Call sequence follows the chart top-down

A state-transition diagram (state machine diagram) shows the dynamic behaviour of an algorithm or system — how it moves between states in response to events/inputs.

Elements:

• Circle/rounded rectangle = state (a condition or situation)
• Arrow = transition (change from one state to another)
• Label on arrow = event/guard/action — event [guard] / action
  • Event: what triggers the transition (input, condition)
  • Guard: condition that must be true (optional)
  • Action: what happens during transition (output, assignment)
• Filled circle = initial state (start)
• Double circle = final/accepting state (end)

Purpose (per syllabus):

• Document the logic flow of an algorithm, especially those with complex decision paths
• Show all possible states and valid transitions — catches missing cases
• Useful for validation logic, protocol handlers, game loops, menu systems
• Complementary to flowcharts (which show sequence) and structure charts (which show static decomposition)