Know and understand components of technical documentation including purpose of the system/program, limitations of the system, program listing, program language, program flowcharts/algorithms, system flowcharts, hardware and software requirements, fil

7. The Systems Life Cycle – Technical Documentation (ICT 0417)

Objective

Know and understand the components that must appear in the technical documentation for a system or programme, as required by Cambridge IGCSE ICT (Section 7.5). The notes also show how each component supports the relevant stage of the Systems Development Life Cycle (SDLC) and how to record an evaluation of the finished solution.

What is Technical Documentation?

Technical documentation is a written record that describes a system or programme in sufficient detail for developers, users and maintainers to understand, use, test, modify and evaluate it. It is produced during several SDLC stages – mainly Analysis, Design, Development & Testing, Implementation and Evaluation – and is examined in the practical papers.

How the Documentation Components Fit the SDLC

Components of Technical Documentation

Detailed Explanation of Each Component (Payroll Example)

1. Purpose of the System / Programme

Answer “Why does this system exist?” and “What does it achieve?”.

Purpose: To calculate the monthly payroll for a small business (up to 20 employees). The programme computes gross pay, tax deductions, National Insurance and net pay, and generates a printable payslip for each employee.

2. Limitations of the System

List known constraints in a clear table.

3. Program Language

Language: Python 3.11 (IDLE 3.11.4) – requires the datetime standard library.

4. Program Listing

Full, commented source code (indentation shown).

# payroll.py – Python 3.11
# Calculates monthly payroll for a small business
import datetime
# ---------- Validation routines ----------
def validate_name(name):
"""Name must be 1‑30 alphabetic characters (spaces or hyphens allowed)."""
import re
return bool(re.fullmatch(r"[A-Za-z\s\-]{1,30}", name))
def validate_hours(hours):
"""Hours must be a float between 0.0 and 200.0."""
return 0.0 <= hours <= 200.0
def validate_rate(rate):
"""Rate must be a float between £5.00 and £100.00."""
return 5.00 <= rate <= 100.00
# ---------- Core calculation functions ----------
def calculate_gross(hours, rate):
"""Return gross pay for given hours and hourly rate."""
return hours * rate
def calculate_tax(gross):
"""Apply 20 % tax if gross > £1 000, otherwise 10 %."""
return gross * (0.20 if gross > 1000 else 0.10)
# ---------- Main programme ----------
if name == "main":
# Input – with validation
employee = input("Enter employee name: ").strip()
while not validate_name(employee):
print("Invalid name – 1‑30 letters, spaces or hyphens only.")
employee = input("Enter employee name: ").strip()
hrs = float(input("Hours worked: "))
while not validate_hours(hrs):
print("Invalid hours – must be between 0.0 and 200.0.")
hrs = float(input("Hours worked: "))
rate = float(input("Hourly rate (£): "))
while not validate_rate(rate):
print("Invalid rate – must be between £5.00 and £100.00.")
rate = float(input("Hourly rate (£): "))
# Calculations
gross = calculate_gross(hrs, rate)
tax   = calculate_tax(gross)
net   = gross - tax
# Output – printable payslip
print("\n-------------------------------------------------")
print(f"          PAYSLIP – {datetime.date.today():%B %Y}")
print("-------------------------------------------------")
print(f"Employee : {employee}")
print(f"Gross Pay: £{gross:,.2f}")
print(f"Tax ({'20%' if gross > 1000 else '10%'}): £{tax:,.2f}")
print(f"Net Pay  : £{net:,.2f}")
print("-------------------------------------------------")

5. Program Flowchart / Algorithm

Standard flow‑chart symbols (process, decision, input/output, connector) are used. Below is a concise pseudo‑code version that satisfies the syllabus.

START
READ employee, hours, rate
WHILE name invalid      → DISPLAY error → RE‑READ name
WHILE hours invalid     → DISPLAY error → RE‑READ hours
WHILE rate invalid      → DISPLAY error → RE‑READ rate
gross ← hours × rate
IF gross > 1000 THEN tax ← gross × 0.20
ELSE tax ← gross × 0.10
net ← gross – tax
DISPLAY payslip (employee, gross, tax, net)
END

6. System Flowchart

High‑level diagram (textual representation) showing the interaction between user, programme, files and printer.

[User] ──► (Input screens) ──► [Payroll Programme] ──► (Read/Write) ──► [employees.csv]
│
└─► [payroll.log]
│
└─► (Print) ──► [Printer] → Payslip

7. Hardware and Software Requirements

8. File Structures

Describe every file and provide a simple layout diagram for each.

• config.ini – INI format; sections [General] and [Paths]. Stores default folder locations.
• employees.csv – Comma‑separated values; one record per employee.
• payroll.log – Plain‑text log file; one line per programme run.

employees.csv layout (ASCII diagram)

+--------------------------------------------------------------+
| Record (1 line)                                              |
+-------------------+-------------------+---------------------+
| EmpID (5 chars)   | Name (30 chars)   | Hours (5,2) | Rate |
| (e.g., 00001)     | (e.g., John Smith)| (e.g., 160.00) | 12.50|
+-------------------+-------------------+---------------------+
Fields are separated by commas:
00001,John Smith,160.00,12.50

payroll.log layout

YYYY‑MM‑DD HH:MM:SS – Processed 23 records – Success
2025‑03‑31 14:22:10 – Processed 23 records – Success

9. List of Variables

10. Input Format

11. Output Format

Sample payslip printed to screen (or printer).

-------------------------------------------------
PAYSLIP – March 2025
-------------------------------------------------
Employee : John Smith
Gross Pay: £1 250.00
Tax (20%): £250.00
Net Pay  : £1 000.00
-------------------------------------------------

12. Validation Routines (All Input Fields)

def validate_name(name):
import re
return bool(re.fullmatch(r"[A-Za-z\s\-]{1,30}", name))
def validate_hours(hours):
return 0.0 <= hours <= 200.0
def validate_rate(rate):
return 5.00 <= rate <= 100.00

13. Sample Runs / Test Cases

14. User Documentation (Step‑by‑Step Guide)

1. Ensure Python 3.11 is installed (check with python --version).
2. Download payroll.py and place it in a folder together with employees.csv (if you wish to use batch input).
3. Double‑click payroll.py or run python payroll.py from a command prompt.
4. When prompted, enter the employee name, hours worked and hourly rate exactly as described in the Input Format table.
5. If an error message appears, correct the data and press Enter again.
6. After successful entry, the programme prints a formatted payslip on the screen and writes a log entry to payroll.log.
7. To print the payslip, copy the screen output into a text file and send it to a printer, or modify the programme to use a printer library.

15. Evaluation of the Solution

16. Version Control Details

Date: 05‑01‑2026
Author: A. Teacher
Revision: 1.0
Changes: Initial production of technical documentation for payroll system.

Checklist for a Complete Technical Document

• Purpose and scope clearly stated.
• All limitations listed (performance, hardware, legal/security, user‑skill).
• Exact programme language and version, including required libraries.
• Full, well‑commented source code.
• Program flowchart or pseudo‑code.
• System flowchart showing interactions with users, hardware and files.
• Hardware & software requirements (minimum + recommended) in a table.
• File‑structure diagrams for every file used.
• Complete variable table.
• Input specification table with validation rules.
• Output layout example (screen/report).
• Validation routine code for each input field.
• Test‑case table (normal, boundary, error) with actual results.
• User guide (installation, running, error handling).
• Evaluation table covering functionality, performance, usability, security and cost‑benefit.
• Version control information (date, author, revision, change summary).