Veel softwareontwikkelaars maken de dingen graag ingewikkeld. Ze krijgen iets dat eenvoudig en gemakkelijk zou kunnen zijn en, als gevolg van wat de meeste mensen op het internet vertellen, maken het ingewikkeld.
Software zou eenvoudig moeten zijn. Dat gezegd hebbende, is het makkelijk te begrijpen waarom zoveel ontwikkelaars er moeite mee hebben om software vanaf de grond op te bouwen. In hun hoofd is het iets heel ingewikkelds en moeilijks en ze lopen midden in het proces helemaal vast.
Dus, de vraag is… Hoe bouw je software vanaf nul?
Transcript van de video
John Sonmez:
Hey, wat is er? John Sonmez van simpleprogrammer.com. Vandaag heb ik een vraag over het bouwen van software vanaf nul. Dit is een vraag die ik vaak heb gekregen van veel verschillende mensen omdat dit iets is dat moeilijk is om te doen als je een beginner bent, om erachter te komen hoe je dit ooit zou kunnen doen.
Deze vraag komt van Akash en hij zegt, “Hé John, je video’s zijn geweldig en ik waardeer je advies zeer. Een probleem waar ik tegenaan loop is dat wanneer het aankomt op het bouwen van een grote software, ik niet kan bedenken hoe ik het hele ding vanaf nul moet ontwerpen. Zeg maar, hoe het geheel op te splitsen in mini sub-taken en dan elke sub-taak te implementeren en ze allemaal samen te voegen om het te laten werken. Het zou erg fijn zijn als u me kunt helpen dit probleem op te lossen. Bij voorbaat dank.”
Wat ik zou willen zeggen, Akash, is dat je moet denken – in plaats van te denken aan het nemen van een heel systeem, een soort top-down benadering, breek het af tot al deze stukjes, zet al deze stukjes in elkaar en kijk hoe ze in elkaar passen, en bouw deze enorme Transformer of Legos van – deze enorme Legos. Je moet softwareontwikkeling meer zien als evolutie.
Wat ik daarmee bedoel is dat je moet beginnen met iets heel eenvoudigs. Begin met het simpelste ding dat mogelijk zou kunnen werken en dat niet veel mogelijkheden heeft en ontwikkel dat dan tot waar je heen wilt in plaats van wat ze noemen een groot ontwerp vooraf te doen. Het betekent niet dat je nooit zou mogen nadenken over de algemene architectuur van het ding en dat je de ontwerpen en bepaalde dingen niet op voorhand moet hebben. In veel gevallen hoef je niet zoveel te doen als je denkt dat je nodig hebt.
Nu, als je software ontwerpt die in een elektronisch apparaat moet worden ingebed en een hardware-ingenieur moet de schakelingen of een chip op maat ontwikkelen, of iets dergelijks om dat te laten werken, dan zul je waarschijnlijk veel van die dingen vooraf moeten ontwerpen en dat zul je waarschijnlijk ook moeten doen. Je zou daar zelfs beperkt kunnen zijn. Voor de meeste software die we vandaag de dag bouwen, vooral webapplicaties en dat soort dingen of mobiele applicaties, kunnen we iets bouwen dat heel erg basaal is en het dan evolueren, veranderingen aanbrengen om het te laten groeien en complexiteit toe te voegen als dat nodig is.
Eén ding – één reden waarom dit zo belangrijk is, is omdat de vloek van software ontwikkeling, één van de ergste dingen in software ontwikkeling complexiteit is. Dit kanaal heet Simple Programmer en mijn bedrijf gaat over het eenvoudig maken van het complexe, want dat is wat we moeten doen. Als software ontwikkelaars is een van je belangrijkste taken het bestrijden van complexiteit, omdat complexiteit in het systeem komt en het moeilijk maakt om het te onderhouden en het moeilijk maakt om het te begrijpen. Het maakt de kans op bugs en op falen groter. We willen de complexiteit zo veel mogelijk verminderen. We willen vereenvoudigen. We moeten zo eenvoudig mogelijk beginnen, wat is het eenvoudigst mogelijke dat zou kunnen werken?
In de ondernemerswereld noemen ze dit vaak een MVP of een minimal viable product. Wat kun je doen als je probeert een groot softwaresysteem te bouwen of wat je kunt doen is heel klein beginnen. Begin met een heel, heel klein ding. Ik probeer te herinneren aan het boek, maar ik las een heel goed boek over iets, ik denk dat het test gestuurde ontwikkeling stap-voor-stap was of iets dergelijks. In het boek, ontwierp hij een Notepad app of zoiets. Hij begon met een zeer, zeer incrementele – hij deed dit op een zeer incrementele manier en hij begon met, ik denk, zijn applicatie had een database nodig, maar hij begon met geen database te hebben. In plaats daarvan sloeg hij de data op in tekstbestanden die hij las uit de tekstbestanden. Toen kwam hij op het punt dat hij het in een database moest stoppen, en toen wijzigde hij het programma en liet het dezelfde gegevens lezen, maar hij creëerde een abstractie om uit de database te lezen.
Dat is de natuurlijke evolutie van dingen en dat is hoe je deze complexe software kunt bouwen. Ik garandeer je dat de meeste complexe software die vandaag de dag wordt gebouwd, op deze manier tot stand komt. Veel ervan is niet helemaal van te voren ontworpen en dan bouw je al die stukjes en hoopt en bidt dat ze werken. Anders loopt het uit op een veel te hoog budget en een veel te hoog tijdschema. Helaas, dat gebeurt. Als u succesvol wilt zijn, als u dit wilt kunnen doen, begin dan met iets kleins. Er is niets dat moeilijk is in deze wereld. Er is niets dat ingewikkeld is. Het is alleen dat het is samengesteld uit een stel eenvoudige dingen die het complex doen lijken.
Je kunt de meest complexe architectuur bouwen. Je kunt een enorm ding bouwen, maar je moet beginnen met het simpele. Het is allemaal opgebouwd uit simpele dingen. Dan in plaats van te proberen om al die stukken te nemen, gewoon beginnen. Evolueer het ding. Begin. Bouw iets. Wat is het kleinste simpele ding dat je kunt maken dat ook maar in de buurt komt van de functionaliteit? Begin dan met het toevoegen van functies. Terwijl je de functies toevoegt, voeg je de architectuur toe om ze te ondersteunen en creëer je abstracties.
Een boek dat ik je zal aanraden dat je waarschijnlijk zou helpen om dat te doen heet Clean Code. Het is een van mijn favoriete boeken van Robert Martin. Ik raad je dat boek zeker aan, maar je wilt je architectuur laten evolueren. Het andere wat ik hierover zou willen zeggen is dat als je dingen ontwikkelt, je abstracties gaat maken om het simpel te houden zodat je nooit die enorme, enorme complexiteit hebt. Soms kan het zelfs zo zijn dat je het hele ding moet herschrijven of delen ervan, maar dat is prima. Dat is hoe de evolutie van software werkt. Het is beter dan complexiteit toe te voegen.
Vaak willen software-ontwikkelaars voortijdig optimaliseren. Ze willen dingen extreem flexibel maken. Ze optimaliseren de software voortijdig, omdat ze proberen een zeer robuust systeem te bouwen. Dat mislukt vaak omdat we niet weten wat we niet weten. We weten niet wat we nodig zullen hebben, dus is het beter om niet te proberen te anticiperen, maar gewoon te zeggen, “Oké. Nu, ik moet deze nieuwe functie toevoegen of dit op deze manier laten werken. Hoe kan ik dat ontwikkelen?”
Bedenk wel, software-ontwikkeling is niet als een brug. Het is niet zo dat je beton hebt gestort en nu de architectuur van het huis gaat veranderen. Software is kneedbaar. Het is als klei. Je kunt het veranderen. Het heeft geen hoge, hoge kosten voor u om dat aan te passen en te veranderen. Je moet zoveel mogelijk gebruik maken van het voordeel van dat medium, dat zich leent voor een evolutionair proces om software te ontwikkelen, in tegenstelling tot een groot ontwerp vooraf.
Ik hoop dat je er iets aan hebt, Akash. Goede vraag. Ik denk dat veel mensen hier in het verleden al naar gevraagd hebben. Als je een vraag voor me hebt, kun je mailen naar [email protected]. Als je deze video leuk vindt, ga je gang en klik op die grote knop Abonneren hieronder als je nog niet geabonneerd bent. Als je dat al gedaan hebt, waardeer ik dat. Blijf kijken tot de volgende keer. Hou je haaks.