Jackson Structured Programming (JSP) is a program design methodology developed by British software consultant Michael A. Jackson in the 1970s. It focuses on mapping the structure of a problem—specifically its data structures—directly onto the structure of the program used to solve it.
Overview of Jackson Structured Programming
JSP is designed to create programs that are easy to maintain and modify because the program’s control structure naturally handles the input and output data structures.
- Core Principle: Requirement changes are typically minor tweaks to existing data structures. By aligning program structure with data structure, small changes to inputs or outputs translate into small, manageable changes in the code.
- Methodology: The technique involves analyzing the structure of input files and output files, constructing diagrammatic representations of these, and then creating a program structure that handles both.
- Key Constructs: JSP utilizes three basic structures for both data and programs, which can be visualized as a form of regular expression:
- Sequence: A series of operations performed in order.
- Iteration: The repetition of operations until a specific condition is met.
- Selection: Choosing between different operations based on a condition.
- Diagrams: JSP uses structure diagrams rather than flowcharts to represent the design, breaking down complex tasks into smaller, simpler parts.
Detailed Historical Timeline
Early Years (1960s–1974): Conceptualization and Founding
- 1960s: Michael A. Jackson works in data processing, encountering limitations in program reliability and seeking more systematic approaches to software design.
- 1968: Jackson contributes to the early modular programming movement, collaborating with other pioneers.
- 1970: Jackson leaves John Hoskyns & Company to found Michael Jackson Systems Limited, aimed at fully developing a new design methodology.
- 1971: JSP becomes the core product of Michael Jackson Systems Limited, offering consultancy and training services.
- 1974: The name “Jackson Structured Programming” is coined by a Swedish licensee of the company.
Established Method (1975–1979): Documentation and Adoption
- 1975: Jackson publishes “Principles of Program Design,” the definitive text documenting JSP.
- 1975: Michael Jackson Systems Ltd. begins offering software tools to support JSP design for COBOL programs.
- 1977: JSP is widely recognized and adopted in Europe, the US, and Asia.
- Late 1970s: The UK government adopts JSP (under the name “SDM” – System Development Methodology) as its standard program design method.
- Late 1970s: The World Health Organization adopts JSP as a standard for program specification.
Evolution into System Design (1980s): JSD
- Early 1980s: Building on the principles of JSP, Jackson develops Jackson System Development (JSD) to address the design of entire information systems, not just individual programs.
- 1983: Jackson publishes “System Development,” formally introducing JSD.
- 1983-1989: JSD continues to evolve, with new features introduced in subsequent publications and manuals.
Maturity and Retrospective (1990s–Present)
- 1990s: Jackson develops the Problem Frames Approach, his third major methodology focusing on requirements analysis.
- 1997: Jackson receives the Stevens Award for Software Development Methods.
- 1998: Jackson receives the British Computer Society Lovelace Medal.
- 2001: At a conference, Jackson provides a retrospective analysis of JSP’s driving forces and its relevance to modern software engineering.
- Present: While overshadowed by object-oriented and agile methods, JSP principles remain useful for programming “in the small” and handling specific batch processing or embedded software tasks.
Jackson Structured Programming JSP is a program design methodology, overview and timeline
