# Jackson system development

Il Jackson system development (JSD) è una metodologia lineare di sviluppo del software sviluppata da Michael A. Jackson e John Cameron negli anni 80.

## Storia

Il JSD venne presentato da Michael A. Jackson nel 1982, in un saggio chiamato A System Development Method e nel 1983 in System Development. Il Jackson System Development (JSD) è un metodo di sviluppo che copre il ciclo di vita del software o direttamente o fornendo un framework in cui applicare tecniche più specializzate. Il JSD può iniziare da un progetto il cui stato è limitato ad un insieme di requisiti, ma molti progetti lo hanno utilizzato anche in stati di sviluppo più avanzati, estrapolando i primi step dalla documentazione esistente piuttosto che direttamente dagli utenti. Il primo metodo di Jackson, Jackson Structured Programming (JSP), è usato per produrre il codice del sistema finale. Il prodotto dei primi step del JSD consiste in un set di design del programma. La manutenzione è anch'essa gestita tramite i primi step.
Il JSD continuò la sua evoluzione e nella collezione di saggi del 1989 di John Cameron, JSP and JSD vennero introdotte alcune nuove funzionalità, confermate successivamente dalla seconda versione del metodo nel manuale del Learmonth & Burchett Management Systems (LBMS) del 1992.
Lo sviluppo del JSD raggiunge la conclusione nei primi anni '90 con la sua trasformazione in Problem Frames Approach con la pubblicazione di Software Requirements and Specifications (1995) e Problem Frames: Analyzing and Structuring Software Development Problems (2000).

## Principi

I tre principi base del SD sono:
* Lo sviluppo deve iniziare con la descrizione e la modellazione del mondo reale, piuttosto che specificando o strutturando la funzione del sistema. Un sistema sviluppato utilizzando JSD effettua la simulazione del mondo reale prima che ogni attenzione venga posta alla funzione o allo scopo del sistema.
* Un modello adeguato di un mondo time-ordered deve anch'esso essere time-ordered. Lo scopo principale è di mappare i progressi del mondo reale sui progressi del sistema che lo modella.
* Un modo di implementare il sistema è basato sulla trasformazione delle specifiche in efficienti set di processi. Questi processo devono essere progettati in modo da essere eseguibili sul software e sull'hardware disponibile.

## Passaggi del JSD

Quando venne originariamente presentato nel 1982, il metodo consisteva di sei passaggi:
* Entità/azione
* Modello iniziale
* Funzione interattiva
* Funzione informativa
* System timing
* Implementazione del sistema
Successivamente, alcuni passaggi vennero combinati in modo da ridurli a tre:
* Fase di modellazione (analisi): entità/azione
* Fase di network (design): comprende modello iniziale, funzione interattiva e funzione informativa, system timing
* Fase di implementazione (realizzazione): implementazione

## Fase di modellazione

Nella fase di modellazione, il designer crea una collezione di diagrammi di struttura dell'entità e identifica le entità del sistema, le azioni che esse svolgono, l'ordine nel tempo delle azioni e gli attributi di azioni ed entità. Ogni diagramma di struttura usa la notazione della Jackson Structured Programming. Lo scopo di questi diagrammi è creare una descrizione completa degli aspetti del sistema e della sua organizzazione.
Gli sviluppatori devono decidere quali aspetti sono importanti e quali no. Una buona comunicazione tra sviluppatori ed utenti del sistema è fondamentale.

## Fase di network

Nella fase di network, un modello del sistema è sviluppato e rappresentato tramite un diagramma di specifica del sistema (SSD, system specification diagram, noto anche come network diagram). Il diagramma di network mostra i processi (rettangoli) e come essi comunicano tra di loro tramite state vector connections (rombi) o tramite connessioni datastream (cerchi). In questa fase è definita la funzionalità del sistema. Ogni entità diventa un processo o un programma del diagramma di network. Lo scopo di questi programmi è di processare l'input, calcolare l'output e mantenere le entità dei processi aggiornate. L'intero sistema è descritto con questi diagrammi ed è completato con descrizioni riguardo ai dati e alle connessioni tra processi e programmi.
Il modello iniziale specifica una simulazione nel mondo reale. Le fasi di funzione aggiungono alla simulazione ulteriori operazioni eseguibili e processi necessari a produrre l'output del sistema. La fase di system timing fornisce la sincronizzazione dei processi ed introduce i vincoli.

## Fase di implementazione

Nella fase di implementazione, il modello di network è convertito in un sistema fisico, rappresentato dal diagramma di implementazione del sistema (SID, system implementation diagram). Il SID mostra il sistema come un processo scheduler che chiama i moduli che implementano i processi. I flussi di dati sono rappresentati come chiamate ai processi invertiti. Il database dei simboli rappresenta collezioni di entità stato-vettore, con simboli speciali per i buffer dei file (che defono essere implementati quando l'esecuzione di un processo è programmata ad intervalli di tempo diversi).
Lo scopo principale della fase di implementazione è ottimizzare il sistema. È necessario ridurre il numero di processi perché è impossibile fornire ad ogni processo un proprio processore virtuale. In termini di trasformazione, i processi sono combinati in modo da limitarsi al numero di processori disponibili.

## Design dei diagrammi
### Entity structure diagram (ESD)

Il diagramma mostra come le entità di azione cooperano con il sistema.
* Entità: un'entità è un oggetto che è utilizzato sul sistema e dal sistema.
* Azione: le azioni che sono svolte dalle entità e le azioni che influenzano altre entità.
* Construct-sequence: il costrutto JSD è identivo al costrutto SSADM Entity Life History. Usa un SequenceConstruct per illustrare azioni che vengono applicate da sinistra verso destra.
* Construct-selection: per rappresentare una scelta tra due o più azioni. Si segna l'opzione nell'angolo in alto a destra con una "o" (opzione)
* Construct-recurrence: quando un'azione si ripete la si segna con un asterisco (*) nell'angolo in alto a destra. Normalmente ci dovrebbe essere solo un'azione sotto un RecurringConstruct.
* Null component: un componente nullo permette di verificare che nulla venga eseguito in una istruzione IF-ELSE.

### Network diagram (ND)

Il diagramma mostra l'interazione tra i processi. A volte ci si riferisce a questi come diagrammi di specifica del sistema (SSD).
* Processo: un processo rappresenta una funzione del sistema. Un modello del processo rappresenta la sua funzione primaria nel sistema. Generalmente ha una relazione con un'entità esterna tramite il flusso di dati.
* Connessione datastream: in una connessione datastream, il processo A (entità che scrive il flusso di dati) invia informazioni attivamente al processo B.
* Ispezione state vector: in una connessione state vector, il processo B legge l'informazione state vector da un'altra entità A.
La differenza tra una connessione state vector e il data stream sta in quale processo è attivo. In una connessione datastream il processo con l'informazione (A) è il processo attivo; esso invia attivamente i messaggi al lettore datastream B in un istante selezionato da A. Nel vettore state inspection, il processo con l'informazione (A) è passivo; non fa nulla, ma lascia che il processo lettore (B) ispezioni il proprio state vector. Il processo che esegue l'ispezione (B) è il processo attivo; esso decide quando leggere l'informazione da A. Approssimativamente, il connettore datastream è un'astrazione di scambio di messaggi, mentre l'ispezione dello state vector è un'astrazione per interrogazione e lettura da datbase.