Geschiedenis van Agile – De Agile aanpak is ontstaan in de IT wereld in de jaren tachtig en negentig. Op dat moment was er behoefte aan een meer praktijkgerichte aanpak in vergelijking met de traditionele waterval methode. Winston W. Royce (1929-1995), de benoemde bedenker van de watervalmethode, ontwikkelde in 1970 de methode met sequentiële stappen om software binnen budget en tijd te kunnen leveren. Wanneer een fase werd afgerond ging dit gepaard met een grote hoeveelheid documentatie. Een afgeronde fase kon niet meer worden aangepast en werd als voltooid beschouwd. Kritiek op deze waterval methode was dat het weinig flexibel was met betrekking tot veranderende wensen tijdens het ontwikkelproces. Het Waterval model gaat ervan uit dat wat van tevoren is vastgesteld niet meer aan verandering onderhevig is (Venneman, 2013). De praktijk leerde echter dat, mede door de lange doorlooptijd, de eisen van de opleveringen gedurende het traject aan verandering onderhevig zijn (De Jonge, 2009). Hierdoor kon het zijn dat de opgeleverde software aan het eind van het traject niet meer voldeed aan de wensen en eisen van de eindgebruiker. Ook werd de uitgebreide documentatie als een verspilling van tijd gezien, in plaats van dat het een ondersteunend hulpmiddel tijdens het ontwikkelproces was (Boehm, 1988). Het per fase afronden van een specificatie werd als een grote belemmering ervaren, doordat verkregen feedback achteraf niet meer in de betreffende specificatie verwerkt kon worden (Sommerville, 1996).

Als reactie hierop werden er een aantal lichtgewicht software methoden ontwikkeld, zoals Extreme Programming (XP), Crystal, Scrum en Adaptive software development (ASD). Kenmerkend voor de aanpak binnen deze methoden is het klein en simpel houden van het aantal regels en voorschriften (Thomas et al., 2001). Een aantal softwareontwikkelaars die deze methoden gebruikten, kwamen op een gegeven moment bij elkaar om op informele wijze hun gedachten en ervaringen te delen.Tijdens deze bijeenkomst kwam de groep tot de ontdekking dat ze over veel dingen hetzelfde dachten met betrekking tot softwareontwikkeling en de aanpak die ze hierin gebruikten. De waarden die zij hierin deelden hebben zij ondergebracht in het Agile Manifest. Het Agile Manifest bestaat uit een omschrijving van de, door de zeventien auteurs, gedeelde waarden en een twaalftal principes die deze waarden ondersteunen.

Het Agile Manifest

Wij laten zien dat er betere manieren zijn om software te ontwikkelen
door in de praktijk aan te tonen dat dit werkt
en door anderen ermee te helpen. Daarom verkiezen we:

Mensen en hun onderlinge interactie boven processen en hulpmiddelen
Werkende software boven allesomvattende documentatie
Samenwerking met de klant boven contractonderhandelingen
Inspelen op verandering boven het volgen van een plan

Hoewel wij waardering hebben voor al hetgeen aan de rechterkant staat vermeld,
hechten wij méér waarde aan wat aan de linkerzijde wordt genoemd.

Achter het Agile Manifest schuilen een aantal principes die worden gevolgd.

  • Onze hoogste prioriteit is het tevredenstellen van de klant door het vroegtijdig en voortdurend opleveren van waardevolle software.
  • Verwelkom veranderende behoeftes, zelfs laat in het ontwikkelproces.
  • Agile processen benutten verandering tot concurrentievoordeel van de klant.
  • Lever regelmatig werkende software op. Liefst iedere paar weken, hooguit iedere paar maanden.
  • Mensen uit de business en ontwikkelaars moeten dagelijks samenwerken gedurende het gehele project.
  • Bouw projecten rond gemotiveerde individuen. Geef hen de omgeving en ondersteuning die ze nodig hebben en vertrouw erop dat ze de klus klaren.
  • De meest efficiënte en effectieve manier om informatie te delen in en met een ontwikkelteam is door met elkaar te praten.
  • Werkende software is de belangrijkste maat voor voortgang.
  • Agile processen bevorderen constante ontwikkeling. De opdrachtgevers, ontwikkelaars en gebruikers moeten een constant tempo eeuwig kunnen volhouden.
  • Voortdurende aandacht voor een hoge technische kwaliteit en voor een goed ontwerp versterken agility.
  • Eenvoud, de kunst van het maximaliseren van het werk dat niet gedaan wordt, is essentieel.
  • De beste architecturen, eisen en ontwerpen komen voort uit zelfsturende teams.
  • Op vaste tijden, onderzoekt het team hoe het effectiever kan worden en past vervolgens zijn gedrag daarop aan.

Geschiedenis van Agile

Agile betekent letterlijk: “behendig, lenig”. In de ICT wereld staat het voor het ontwikkelen van software in korte en overzichtelijke perioden. Deze perioden heten ‘iteraties’ en zijn als het ware kleine projecten, waarin telkens werkende software wordt opgeleverd. Het betrokken team werkt bij agile ontwikkeling zeer intensief samen, communiceert continu in persoon, met elkaar en met andere betrokkenen van het project. Het team probeert aan het einde van iedere iteratie vrijwel altijd iets bruikbaars op te leveren. Na iedere iteratie heroverwegen de ontwikkelaars, dankzij feedback van de klant, de tussentijds opgeleverde resultaten en passen deze, waar nodig, aan.

Intussen heeft agile ook haar weg gevonden buiten de ICT. De focus op klantwaarde, zelforganiserende teams en het opleveren van tussentijdse resultaten blijken organisatie breed van toegevoegde waarde te kunnen zijn. Agile kan prima naast bijvoorbeeld Lean en Six Sigma worden toegepast. Waar Lean de focus heeft op het elimineren van verspilling en Six Sigma de focus op procesverbetering, heeft agile de focus op het continu leveren van zoveel mogelijk klantwaarde door in iteraties waardevolle producten of diensten te leveren.

Meer informatie over de toegevoegde waarde van Agile is te vinden in  ‘De kritische succesfactoren van agile’.

Bronnenlijst:
Boehm, B. W. (1988). A spiral model of software development and enhancement. Computer, 21(5), 61–72. IEEE Computer.
Gerrits, T., Groot, R. de. & Venneman, (2013). Agile, pocketguide voor wendbare organisaties. Zaltbommel: Van Haren Publishing.
Jonge, M. de. (2009). Agile webontwikkeling. http://naarvoren.nl/artikel/agile_webontwikkeling/.
Royce, W. (1970). Managing the development of large software systems. In Proceedings of IEEE Westcon.
Sommerville, L. (1996). Software process models. ACM Computing Surveys. 28 (1), 269-71.
Thomas, D. et al (2001). Agile manifestohttp://agilemanifesto.org.