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

The Systems Life Cycle

The systems life cycle (SLC) is a structured approach used to develop, implement and maintain information systems. It consists of a series of stages that ensure a system meets user requirements, is reliable and can be supported over time.

Key Stages of the Systems Life Cycle

1. Feasibility Study – Assess whether the proposed system is viable technically, financially and operationally.
2. Analysis – Gather detailed user requirements and define the problem to be solved.
3. Design – Create technical specifications, data models, and system flowcharts.
4. Development – Write the program code, create databases and configure hardware.
5. Testing – Verify that the system works as intended using test runs and validation routines.
6. Implementation – Install the system, train users and migrate data.
7. Maintenance – Provide ongoing support, updates and enhancements.

Components of Technical Documentation

Technical documentation records all essential information about a system or program. It is used by developers, users, and support staff throughout the SLC.

How to Write Effective Documentation

• Use clear, concise language; avoid jargon unless it is defined.
• Number sections and subsections for easy reference.
• Include comments in the source code that explain the purpose of each major block.
• Provide diagrams (flowcharts, ER diagrams) wherever they clarify the process.
• Maintain a change log that records revisions, dates and author initials.
• Validate all sample data against the system’s validation routines to ensure consistency.

Sample Documentation Extract

Below is an example of how a portion of the documentation might be presented for a simple inventory management program.

Purpose:
To record stock levels, process sales transactions and generate inventory reports.
Limitations:
- Maximum of 10,000 items.
- Runs on Windows 10 or later; not compatible with macOS.
Program Language:
Python 3.11
Program Listing (excerpt):
1  # inventory.py
2  import csv
3  ITEMS = {}
4  
5  def load_items(filename):
6      """Read items from a CS \cdot file into the ITEMS dictionary."""
7      with open(filename, newline='') as f:
8          reader = csv.DictReader(f)
9          for row in reader:
10              ITEMS[row['code']] = {
11                  'name': row['name'],
12                  'price': float(row['price']),
13                  'stock': int(row['stock'])
14              }

Validation Routine Example

The following pseudo‑code validates a sales quantity entered by the user:

IF quantity < 1 THEN
DISPLAY "Quantity must be at least 1."
RE‑ASK for quantity
ELSE IF quantity > ITEMS[code].stock THEN
DISPLAY "Insufficient stock. Available: " + ITEMS[code].stock
RE‑ASK for quantity
END IF

Mathematical Representation of the Life Cycle

The progress through the life cycle can be expressed as a function of time \$t\$:

\$\$S(t) =

\begin{cases}

\text{Feasibility}, & 0 \le t < t_1 \\

\text{Analysis}, & t1 \le t < t2 \\

\text{Design}, & t2 \le t < t3 \\

\text{Development},& t3 \le t < t4 \\

\text{Testing}, & t4 \le t < t5 \\

\text{Implementation},& t5 \le t < t6 \\

\text{Maintenance},& t \ge t_6

\end{cases}\$\$

Review Checklist for Documentation

• All required components listed in the table are present?
• Is the purpose statement specific and measurable?
• Are limitations clearly identified?
• Does the program listing include comments and line numbers?
• Are flowcharts accurate and labelled?
• Are hardware/software requirements realistic?
• Is the file structure documented with field lengths and types?
• Are variable names meaningful and documented?
• Do input and output formats match the user interface design?
• Are sample runs comprehensive (normal, boundary, error cases)?
• Are validation routines tested and documented?