Jackson System Development

From Wikipedia, the free encyclopedia

Jackson System Development (JSD) is a linear software development method developed by Michael A. Jackson and John Cameron.

Contents 1 Introduction 2 Way of working 2.1 Modelling Stage 2.2 Network Stage 2.3 Implementation Stage 3 Way of writing 4 Way of documenting 5 Designing the diagrams 6 Sources 7 See also

[edit] Introduction

Jackson System Development is a method for specifying and designing systems, in which the factor of time is significant and they may be described using sequences of events. Michael A. Jackson's design method assumes the design of the system is an extension of the programme design. JSD has been based on the JSP method (Jackson Structured Programming) this is because the techniques used during program development also apply to developing systems.

There are two main differences between JSD and other system development methods. The first is that the initial area of interest for JSD is the domain of the software, not the software itself. Secondly, the method is focused on event sequencing. The domain is the set of real world events, which sequentially ordered in time. JSD was described in Jackson's book System Development (1983) and in the collection of articles JSP and JSD, edited by John Cameron (1989).

Arguably, JSD was the first "object-oriented" system design method, as its basic conception of a computer system was as a network of communicating sequential processes (objects). Between 1980 and 1983, Jackson and John Cameron evolved the core concepts of JSD. After 1983, Jackson was less involved in the development of JSD, and refinements in JSD were made based on experiences of JSD consultants on a variety of consulting projects. Updated versions of the method were described in LBMS Jackson system development method manual (Wiley, 1992) and Practical program development using JSP (Blackwell, 1987) by Ralph Storer.

[edit] Way of working

The basic principle of operation of JSD is that development must start with describing and modelling the real world, rather than specifying or structuring the function performed by the system. A system made using JSD method performs the simulation of the real world before any direct attention is paid to function or purpose of the system. The second principle states, that an adequate model of a time-ordered world must itself be time-ordered. Main aim is to map progress in the real world on progress in the system that models it. The third principle is that the way of implementing the system is based on transformation of specification into efficient set of processes. These processes should be designed in such a manner that it would be possible to run them on available software and hardware. When it was originally presented by Jackson in 1983, the method consisted of six steps.

1. Entity/Action Step
2. Initial Model Step
3. Interactive Function Step
4. Information Function Step
5. System Timing Step
6. System Implementation Step

Later, some steps were combined to create a method with only three steps.

1 Modelling Stage (Analysis)

Entity/Action Step

Entity Structures Step

2 Network Stage (Design)

Initial Model Step

Function Step

System Timing Step

3 Implementation Stage (Realisation)

Implementation Step

[edit] Modelling Stage

In the modelling stage the designer creates a collection of entity structure diagrams and identifies the entities in the system, the actions they perform, the time-ordering of the actions in the life of the entities, and the attributes of the actions and entities. Entity structure diagrams use the diagramming notation of Jackson Structured Programming structure diagrams.

Purpose of these diagrams is to create a full description of the aspects of the system and the organisation. Developers have to decide which things are important and which are not. Good communication between developers and users of the new system is very important.

Entity is any object that is important in the system, which is modelled. Each entity may have a set of actions to perform. Action may be characterized by:

1. It takes place at a point in time. A process cannot be an action, because it takes place over a period of time.
2. It must take place in the real world, outside of the system.
3. It cannot be decomposable into subactions.

Entity is characterized by:

1. It performs an action or undergoes an action in time.
2. It must exist in the real world. It cannot be a construct of the system that models the real world.
3. It must be regarded as individual.

In the Entity/Action Step we make a list of candidate entities and actions. To every action we assign an associated entity and set of attributes. Next, in the Entity Structure Step, we introduce constraints in the ordering of an entity's actions. A structure diagram is made.

This stage is the combination of the former Entity/Action Step and the Entity Structures Step.

[edit] Network Stage

In the network stage a model of the system as a whole is developed and represented as a system specification diagram (SSD) (also known as a network diagram). Network diagrams show processes (rectangles) and how they communicate with each other, either via state vector connections (diamonds) or via datastream connections (circles).

In this stage is the functionality of the system defined. Each entity becomes a process or program in the network diagram. External programs are later added to the network diagrams. The purpose of these programs is to process input, calculate output and to keep the entity processes up-to-date. The whole system is described with these network diagrams and are completed with descriptions about the data and connections between the processes and programs.

The Initial Model Step specifies a simulation of the real world. The Function Step adds to this simulation the further executable operations and processes needed to produce output of the system. System Timing Step provides synchronisation among processes, introduces constraints.

This stage is the combination of the former ‘Initial model’ step, the ‘Function’ step and the ‘System Timing’ step.

[edit] Implementation Stage

In the implementation stage the abstract network model of the solution is converted into a physical system, represented as a system implementation diagram (SID). The SID shows the system as a scheduler process that calls modules that implement the processes. Datastreams are represented as calls to inverted processes. Database symbols represent collections of entity state-vectors, and there are special symbols for file buffers (which must be implemented when processes are scheduled to run at different time intervals).

The central concern of Implementation Step is optimization of system. It is necessary to reduce the number of processes due to the fact, that it is impossible to provide each process, that is contained in specification with its own virtual processor. By means of transformation, processes are combined in order to limits their number to the number of processors.

[edit] Way of writing

JSD uses the following techniques:

• entity structure diagram

Used for describing actions in chronological order that entities carry out within the system.

• system specification diagram (SSD), also known as a network diagram (ND)

Used for describing interactions between the processes.

• system implementation diagram (SID)

[edit] Way of documenting

JSD uses the following methods to document the result of the different stages:

• Entity Structure diagram (ESD)
• System Specification diagram (SID)
• System Implementation Diagram (SID)

[edit] Designing the diagrams

Entity structure diagram (ESD)

The diagram shows how the action entities cooperate with the system. Example diagram: [1]

Entity structure diagram (ESD) notations

Entity: An entity is an object that is used on and by the system. Example diagram: [2]

Action: The actions that are carried out by entities and the actions that affect other entities. Example diagram: [3]

Construct-Sequence: The JSD construct is identical to the SSADM Entity Life History construct. Use an SequenceConstruct to illustrate actions that are applied from left to right. Example diagram: [4]

Construct-Selection: To reflect a choice between two or more actions. Mark the options in the topright corner with a "o" (option). Example diagram: [5]

Construct-Recurrence: When an action repeats, place a small asterisk (*) in the topright corner. Normally there would be only one action underneath an RecurringConstruct. Example diagram: [6]

Null component: A Null component can make sure noting happens in an IF-ELSE statement. Example diagram: [7]

Network Diagram (ND)

Network diagrams show the interaction between the processes. Sometimes they are referred to as System Specification Diagrams (SSD's). Example diagram: [8]

Network Diagram (ND) notations

Process: Processes represent system functions. A process model represents the primary system functions. It generally has a relation with an outside entity through the datastream. Example diagram: [9]

Datastream: Datastreams make relations between processes and specify what information they exchange. Example Diagram: [10]

Status vector: Status vectors are an alternative way to make a relation between processes. They specify the characteristics or status of the entity used by the process. Example diagram: [11]

[edit] Sources

• Dutch WikiPedia version
• Tutorial on JSD
• Jackson System Development Overview
• Michael A. Jackson home page
• Jackson Development Methods
• Jackson Development Methods
• A SYSTEM DEVELOPMENT METHOD, M. A. Jackson, 1982

[edit] See also

• Jackson Structured Programming (1975)
• Michael A. Jackson