Jackson System Development

Jackson System Development of JSD is een lineaire softwareontwikkelmethode. De methode is er een voor het ontwikkelen van makkelijk te onderhouden software. Ze is ontwikkeld door John Cameron en Michael A. Jackson en gepubliceerd door deze laatste in het boek System Development in 1983.

Michael A. Jacksons ontwerpmethode gaat ervan uit dat het ontwerp van het systeem een extensie is van het programmaontwerp. JSD is gebaseerd op zijn JSP-methode, Jackson Structured Programming, dit omdat de gebruikte technieken bij het ontwikkelen van het programma ook van toepassing zijn op het ontwikkelen van systemen.

JSD is een gestructureerde analyse- en ontwerpmethode, vergelijkbaar met SSADM. Het is ontstaan uit het verder ontwikkelen van Jackson Structured Programming (JSP), een eerdere systeemontwikkelingsmethode van Jackson. JSD is vooral bekend vanwege het feit dat dit de eerste objectgeoriënteerde systeemontwikkelmethode was. Een computersysteem werd namelijk voorgesteld als een netwerk met communicerende sequentiële processen (objecten).

JSD werd vooral veel toegepast in de jaren 70 en 80 in Engeland en Zweden. Daarbuiten veel minder. Na 1983 is JSD nog verder ontwikkeld op basis van ervaringen in de praktijk met verschillende projecten.

Het is een van de eerste ontwikkelingsmethoden die als doel heeft de aanpasbaarheid van systemen te bevorderen. Hiervoor hanteert JSD geen functionele top-down methode, maar maakt het gebruik van Object-oriëntatie. De methode bevat geen projectmanagement activiteiten, het is alleen gericht op de technische aspecten van systeemontwikkeling.

Manier van schrijven

JSD hanteert de volgende technieken:

• Entity Structure Diagram (ESD)

Wordt gebruikt voor het beschrijven van acties in chronologische volgorde die entiteiten binnen het systeem uitvoeren.

• System Specification Diagram (SSD), ook bekend als network diagram (ND)

Wordt gebruikt voor het beschrijven van interacties tussen de processen.

• System Implementation Diagram (SID)

De manier van vastleggen

Bij JSD worden de volgende methodes gebruikt om de resultaten van de verschillende stages vast te leggen:

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

JSD is de tweede software ontwikkelingsmethode die Michael Jackson heeft ontworpen. John Cameron is een grote bijdrager geweest aan deze methode. JSD is een systeemontwikkelingsmethode die niet alleen is bedoeld voor individuele programma's, maar voor complete systemen. Zowel JSD als JSP zijn ontwikkeld in de jaren 1970 - 1980.

JSD is gebaseerd op JSP. JSD bevat vele van JSP's diagrammen, waarvan er enkele voor een ander doeleinde worden gebruikt bij JSD. Zo wordt bijvoorbeeld het action structure diagram in JSP gebruikt voor het beschrijven van data en programma structuren. In JSD worden deze diagrammen gebruikt om de levenscyclus van entiteiten te beschrijven.

Hiernaast bevat JSD nog enkele nieuwe diagrammen; zoals het network structure diagram en het system implementation diagram.

Het eerste principe achter deze methode is dat er een beschrijving wordt gemaakt van de wereld waarvoor het systeem gemaakt moet worden. Pas als dit in kaart is gebracht, wordt goed gekeken naar de functionaliteit van het systeem. Op deze manier wordt goed duidelijk wat de kijk van de gebruiker is op het te maken systeem. Ook is op deze manier betere communicatie mogelijk tussen gebruikers en ontwikkelaars.

Wanneer bepaalde dingen in de "echte wereld" sequentieel achter elkaar worden gedaan, dan moeten deze aspecten ook op deze manier worden gemodelleerd. Hieruit bestaat het tweede principe. Het wordt zodoende duidelijk in welke volgorde sequentiële processen worden uitgevoerd.

Er is nog een derde principe waar deze methode voor staat. Het gaat om het implementeren van de specificaties. Deze worden vertaald naar een set met processen die zijn aangepast aan de beschikbare hardware en software. Erg belangrijk hierbij is om goed aandacht te besteden aan scheduling. Zodoende kunnen de processen efficiënt worden ingezet op de beschikbare processoren.

JSD omvatte eerst de volgende zes stappen en is onderverdeeld in 3 fases:
Modellering (analyse):

1. Entity/Action step
   In deze en de volgende stap wordt een abstracte beschrijving van de "echte wereld" gegeven, in termen van entiteiten die acties uitvoeren of ondergaan. In deze stap worden de entiteiten en hun acties beschreven.
2. Entity Structures step
   In deze stap wordt vervolgens de sequentiële volgorde van de gevonden acties bepaald. Ook worden sequentiële structuren gespecificeerd in de vorm van processen.

Network Stage (Ontwerp):

1. Initial Model step
   Nu wordt een simulatie van de "echte wereld" gespecificeerd.
2. Function step
   Aan de simulatie van de vorige stap worden nu uitvoerbare operaties toegevoegd, evenals processen die nodig zijn om de output van het systeem te produceren.
3. System Timing step
   Nu alle processen bekend zijn, wordt in deze stap de synchronisatie tussen deze processen bepaald. Deze stap eindigt met een specificatie die eigenlijk al klaar is om uitgevoerd te kunnen worden op het systeem.

Implementation (Realisatie):

1. Implementation step
   Vaak is na de vorige stap echter nog een soort optimalisatiestap nodig. Wanneer het systeem bestaat uit vele miljoenen processen, dan zal het geheel niet vloeiend draaien. Daarom kan het nog nodig zijn om sommige processen samen te voegen zodat er uiteindelijk minder zijn. In het ideale geval zijn er evenveel processen als dat er processoren aanwezig zijn, door bijvoorbeeld processen zo samen te voegen dat het voor de processor lijkt alsof het één enkel proces is.

Dit stappenplan is dus later aangepast tot een 3-fasenplan door sommige stappen samen te voegen.

In deze fase maken de ontwikkelaars een beschrijving van de zakelijke aspecten waar het systeem rekening mee moet gaan houden. Om deze beschrijving te maken moeten ze de organisatie analyseren en rekening houden met wat er belangrijk is en wat niet. Ook moet er rekening worden gehouden dat het ontwerp over de situatie gaat zoals die moet worden en niet zoals die op dit moment is. De beschrijving moet zo nauwkeurig mogelijk geschreven worden, dit dwingt de ontwikkelaars goede vragen te stellen. Hierdoor ontstaat er betere communicatie en begrip tussen de ontwikkelaars en de gebruikers van het nieuwe systeem.

De modelbeschrijving bestaat uit acties, entiteiten en overige aanverwante informatie. Een actie is een gebeurtenis die voor het systeem relevant is. Er wordt een lijst met acties met definities en bijbehorende attributen gemaakt. De diagrammen beschrijven of het opdracht geven tot of het verband tussen de acties. De diagrammen beschrijven ook de entiteiten, mensen of dingen waarop de actie betrekking heeft.

De gegevens die voor elke entiteit worden opgeslagen worden ook in deze fase bepaald. Het resultaat van deze fase is een reeks lijsten, definities en diagrammen die in gebruikerstermen beschrijven wat er precies in de organisatie gebeurt en wat er moet worden geregistreerd door het systeem.

In de netwerkfase wordt er precies opgesteld wat het systeem uiteindelijk moet doen en hoe het eruit moet komen te zien voor de gebruiker. Deze beschrijving is een netwerk van programma’s. Voor elke entiteit is er een programma aanwezig in het netwerk, later worden er meerdere programma’s aan toegevoegd. Deze programma’s hebben als doel input te verwerken en de entiteitenprogramma’s up-to-date te houden of om output te berekenen. Het netwerk wordt dan opgebouwd door programma’s toe te voegen en te verbinden met het bestaande netwerk. De meeste nieuwe programma’s kunnen rechtstreeks met de entiteitenprogramma’s worden verbonden.

Het systeem wordt beschreven door een reeks netwerkdiagrammen. Alle diagrammen vertegenwoordigen het gehele systeem. De diagrammen worden ondersteund met teksten die de inhoud van de gegevensstromen en verbindingen beschrijven. De programma’s worden opgesteld op een manier die gebruikmaakt van de methode JSP (Jackson Structured Programming), wat onderdeel is van JSD.

Het doel van deze fase is het opleveren van het uiteindelijke systeem. Hier worden dataontwerpen gemaakt (databases, files). Het ontwerp van de data is het ontwerp van dossiers van gegevensbestanden. De details van het gegevensbestandontwerp hangen af van het DBMS (Database Management System) dat wordt gebruikt.

Ook wordt in deze fase het netwerk geoptimaliseerd. Het resultaat van de netwerkfase is een verdeeld netwerk van programma’s. Deze fase wil zeggen dat veel programma's worden omgezet naar subroutines om het netwerk overzichtelijk te houden. Hierdoor verandert het netwerk van een vorm voor specificatie naar een vorm voor implementatie.

Enitity Structure Diagram (ESD)

• Het diagram laat zien hoe de acties entiteiten met het systeem samenwerken.

Entity Structure Diagram (ESD) notaties

• Entiteit: Een entiteit is een object dat op en door het systeem gedraaid wordt.
  De root van ESD de parent-child tree is één enkele entiteit.
• Actie: De acties worden uitgevoerd door entiteiten en de acties beïnvloeden andere entiteiten.
  Zij zijn verbonden aan de rootentiteit en elkaar in een parent-childhiërarchie.
• Construct - Opeenvolging: De JSD-construct is identiek aan de SSADM Entity Life History construct.
  Gebruik een opeenvolgingsconstruct om acties te illustreren die in orde van links naar rechts worden uitgevoerd.
• Construct - Selectie: Om een keus tussen twee of meer acties aan te geven.
  Merk de acties met kleine “o” (option) in de rechterbovenhoek.
• Construct - Herhaling: Als een actie wordt herhaald, plaats een kleine asterisk (*) in de rechterbovenhoek.
  Er is normaal gesproken slechts één actie onder een herhalingsconstruct.
• Null component: In een if-else statement, kan een null component ervoor zorgen dat er niets gebeurt.

Network Diagram (ND)

• Netwerkdiagrammen laten interactie tussen de verschillende processen zien.
  Soms wordt er naar verwezen als System Specification Diagrams (SSDs).

Network Diagram (ND) notaties

• Proces: Processen representeren systeemfuncties.
  Een modelproces representeert de primaire systeem functies.
  Het heeft meestal een relatie met een buitenentiteit via de datastroom.
• Datastroom: Datastromen maken relaties tussen processen en specificeren wat voor een informatie naar elkaar kan worden doorgegeven.
• Statusvector: Statusvectoren zijn een alternatieve manier voor het maken van een relatie tussen processen. Zij specificeren de karakteristieken of de status van de entiteit die gebruikt wordt bij het proces.

• John R. Cameron (1989).The Jackson Approach to Software Development, IEEE Computer Society Press, Silver Spring.
• Decision systems Inc. (2002), Jackson System Development.
• Stephen Ferg (2003). The Jackson Software Development Methods.
• Michael A. Jackson (1982). A systems development method
• Michael A. Jackson (1983). System development, Prentice Hall, Englewood Cliffs, New Jersey, 1983. (In het Nederlands gepubliceerd in 1989 bij Academec Service onder de titel: Systeemontwikkeling volgens JSD.)
• SmartDraw (2005). How to draw Jackson System Development (JSD) Diagrams)
• M. Verhelst (1982). Objectgerichte systeemontwikkeling, Een praktische aanpak met J.S.D. en MERODE, Kluwer Bedrijfswetenschappen.
• S.F.N. van 't Veld. 16 Methoden voor systeemontwikkeling, Uitgeverij Tutein Nolthenius.

• Jackson Structured Programming
• Warnier-voorstelling

• Decision systems Inc. (2002), Jackson System Development.
• SmartDraw (2005). How to draw Jackson System Development (JSD) Diagrams