Top 7 best practices voor softwareontwikkeling [2020]

De ontwikkeling van software van hoge kwaliteit werkt volgens een eenvoudig principe: pak de hoofdoorzaken aan die van invloed zijn op het softwareontwikkelingsproces om de symptomen van foutieve software te elimineren en blijf elke keer kwaliteitssoftware ontwikkelen en onderhouden. Om precies dat te bereiken, worden best practices voor softwareontwikkeling gebruikt. Ze gaan over het toepassen van beproefde en bewezen praktijken op het softwareontwikkelingsproces en houden niet op bij alleen het oplossen van problemen, maar gaan onder de oppervlakte en behandelen de onderliggende oorzaak van software van slechte kwaliteit.

In onze ervaring zijn de meest effectieve best practices voor softwareontwikkeling:

1. Iteratieve softwareontwikkeling
2. Analyse van vereisten
3. Gebruikmakend van op componenten gebaseerde architecturen
4. Visualisatie van modelsoftware
5. Strikt kwaliteitsbeheer
6. Volg de voortgang regelmatig
7. Gecontroleerde afwijkingen van gedefinieerde eis

Laten we deze in meer detail bekijken.

Iteratieve softwareontwikkeling

Klassieke softwareontwikkelingsprocessen volgen het watervalmodel, waarbij het softwareontwikkelingsproces lineair verloopt van vereistenanalyse via ontwerp, testen en implementatie. Hoewel het probleem met het watervalmodel eenvoudig en gedefinieerd is, is het dat elke fout en elk risico naar de volgende fase wordt geduwd, zodat hoe dichter je bij de implementatie komt, hoe moeilijker en duurder het is om fouten uit eerdere fasen ongedaan te maken. Het oorspronkelijke ontwerp kan bijvoorbeeld zelf gebrekkig zijn met betrekking tot de belangrijkste vereisten, en de late ontdekking ervan kan leiden tot dure overschrijdingen of zelfs het annuleren van projecten.

Iteratieve ontwikkeling van software is een veiliger, slimmer alternatief voor het watervalmodel. Het omvat continue ontdekking, uitvinding en implementatie, waarbij elke iteratie wordt gescand op fouten en hiaten die later tot problemen kunnen leiden.

Iteratieve best practices voor softwareontwikkeling pakken verschillende hoofdoorzaken van problemen met softwareontwikkeling aan:

• Elke miscommunicatie wordt vroeg in de levenscyclus duidelijk wanneer het mogelijk is om de situatie recht te zetten
• Gebruikersfeedback wordt aangemoedigd om de echte vereisten van het systeem te achterhalen
• Het iteratieve model dwingt het ontwikkelteam om zich te concentreren op de meest kritieke problemen, terwijl het een lagere prioriteit geeft aan problemen die niet kritiek zijn of een ernstig risico vormen voor het succes van het project
• Continu, iteratief testen maakt een objectieve beoordeling mogelijk en maakt vroege detectie mogelijk van afwijkingen van eisen, ontwerp- of testfouten, inconsistenties, enz.
• De werklast van het ontwikkelteam wordt gelijkmatig verdeeld over de ontwikkelcyclus, terwijl de belanghebbenden een duidelijker beeld kunnen krijgen van de projectstatus

Analyse van vereisten

We weten allemaal dat in elk softwareontwikkelingsproject het begrijpen en beheren van klantvereisten geen gemakkelijke taak is. Ze zijn meestal dynamisch en kunnen vaak veranderen in de loop van de ontwikkelingscyclus. Het is essentieel om wijzigingen in deze vereisten te evalueren en hun impact op het project te beoordelen, en vervolgens de daaruit voortvloeiende afwegingen en beslissingen te plannen. Vereisten moeten worden geprioriteerd, gefilterd en gevolgd, zodat inconsistenties gemakkelijker kunnen worden opgespoord. Het is ook belangrijk om de grotere zakelijke doelen van de klant te begrijpen en je voor te stellen hoe het softwareproduct dat wordt gemaakt de klant daar sneller kan krijgen.

Ondertussen is het analyseren van de werkelijke functies en mogelijkheden van een systeem een continu proces, omdat het bijna onmogelijk is om de vereisten van een systeem gedurende het hele proces volledig te kennen. Tegelijkertijd moet het systeem klaar zijn om aan de projectvereisten te voldoen. Daarom moet het ontwikkelteam de vereiste functionaliteit en beperkingen van het systeem actief beoordelen en documenteren. Analyse van vereisten is een van de essentiële best practices voor softwareontwikkeling.

Gebruikmakend van op componenten gebaseerde architecturen

Elk project heeft meerdere belanghebbenden (zoals ontwikkelaars, testers, analisten, eindgebruikers, technische schrijvers, enz.), en elk van hen heeft een andere verwachting van een project. Dan kijken ze natuurlijk allemaal anders naar het project en het systeem. Om hun verschillende verwachtingen te beheren en tegelijkertijd de iteraties in het ontwikkelingsproces te beheersen, blijkt een op componenten gebaseerde architectuur van het systeem het meest effectief te zijn. Dus welke beslissing maakt de architectuur mogelijk? Hier is een korte lijst:

• De organisatie van het softwaresysteem
• Selectie als de structurele elementen en interfaces waaruit het systeem bestaat
• De samenstelling van het structurele element van een systeem
• Het selecteren van de verschillende architecturale stijlen die betrokken zijn bij het ontwikkelingsproces

De architectuur van een software omvat de structuur, het gedrag, het gebruik, de functionaliteit, de prestaties, de veerkracht, het hergebruik, de begrijpelijkheid, de esthetiek en de technologische beperkingen en katalysatoren. Op componenten gebaseerde architecturen zijn veerkrachtig en stellen projectmanagers in staat om het werk te verdelen over alle betrokken teams, hardware te isoleren en softwareafhankelijkheden te identificeren. Het ondersteunt ook het hergebruik of de aanpassing van bestaande componenten uit de veelheid aan commercieel beschikbare bronnen. Bovendien maakt de op componenten gebaseerde architectuur iteratieve best practices voor softwareontwikkeling mogelijk door een continue evolutie van de systeemarchitectuur mogelijk te maken en het gemakkelijk te maken om eventuele risico’s te identificeren en op te lossen.

Visualisatie van modelsoftware

Het “bouwen” van een modelsoftware helpt ontwikkelaars, belanghebbenden en het hele projectteam om beter te visualiseren en te begrijpen wat er wordt gemaakt. Ze kunnen een beter idee krijgen van hoe het softwareproduct zich zal gedragen in een echte omgeving en ook de meest geschikte en best presterende systeemarchitectuur documenteren. Het helpt er ook voor te zorgen dat de software net zo efficiënt werkt in een grotere omgeving en naast andere systemen kan bestaan als in een zelfstandige opstelling.

Met visuele modelleringstools zoals de Unified Modeling Language kunnen ontwikkelaars een model maken volgens hun specificaties en indien nodig functies verbergen/blootstellen. Het creëren van modelsoftware helpt de consistentie tussen projectvereisten, ontwerpen en implementaties te behouden, eventuele wijzigingen in de architectuur beter te communiceren en de complexiteit van de software te verminderen.

Strikt kwaliteitsbeheer

Als de software eenmaal is geïmplementeerd, kan het tienduizenden of zelfs miljoenen kosten om de bugs te vinden en te repareren, waardoor kwaliteitsbeheer de meest kritische best practice wordt. Ontwikkelteams moeten continu de kwaliteit van software beoordelen met betrekking tot functionaliteit, betrouwbaarheid, applicatieprestaties en systeemprestaties. De belangrijkste testactiviteit is gericht op het maken van tests voor elk sleutelscenario, dwz individuele aspecten van het verwachte gedrag van de software. Bij een test wordt de functionaliteit van de software beoordeeld door na te gaan welke aspecten niet werken en waarom. Gecombineerd met het iteratieve ontwikkelingsmodel waarbij elke wijziging wordt getest, kun je een robuust stuk software klaar krijgen.

Volg de voortgang regelmatig

In softwareontwikkelingsprojecten kunnen dingen heel snel veranderen. De projectmanager moet wekelijks nieuwe functies, vereisten en updates beoordelen en evalueren en ervoor zorgen dat ze binnen het beloofde budget en leveringsschema blijven. Dit helpt klanten ook om volledige transparantie te garanderen en brengt instabiliteit in het ontwikkelingsproces.

Gecontroleerde afwijkingen van gedefinieerde eis

Een veelvoorkomende uitdaging bij softwareontwikkeling is dat er meerdere ontwikkelaars bij betrokken zijn, en dat ze zich in een ander team of zelfs op verschillende locaties kunnen bevinden, waardoor het voor hen moeilijker wordt om samen te werken en meerdere iteraties, versies, releases, producten en platforms te beheren. Zonder gedisciplineerde controle ontaardt het ontwikkelingsproces in chaos.

Het is daarom belangrijk om de artefacten van ontwikkelaars en teams te controleren en te coördineren door herhaalbare workflows voor beheer in te stellen. Hierdoor kunnen projectmanagers resources beter toewijzen op basis van de prioriteiten van een project. Ook wordt het makkelijker om veranderingen te monitoren, zodat je actief problemen kunt ontdekken en erop kunt reageren. Coördinatie en controle van iteratie en releases vereist dat je na elke iteratie een geteste baseline vastlegt, het gemakkelijker maakt om verschillende releases in de software te volgen en de impact van verandering actief in evenwicht te brengen.

Laatste gedachten

Hoewel we enkele van de belangrijkste best practices hebben gedeeld, is softwareontwikkeling succesvol wanneer de klant, de ontwikkelaars en de projectmanager nauw samenwerken aan een gemeenschappelijk doel. Onthoud ook dat best practices voor softwareontwikkeling niet alleen gaan over het schrijven van code. Het gaat om het leveren van een product dat helpt bij het oplossen van echte problemen en niet alleen kortetermijnoplossingen.