- De conceptuele scheiding tussen hardware en instructies zorgden ervoor dat de software als een onafhankelijk bezit werd behandeld.
- Tussen de jaren 60 en 70 vond er een professionalisering plaats: softwarecrisis, software engineering en aparte facturering.
- Processen en modellen (waterval, incrementeel, spiraal) ondersteunen de kwaliteit van een immaterieel product.
Begrijpen wanneer en waarom we software als een product zijn gaan behandelen Het vereist het bewandelen van een pad dat begint met mechanische berekeningen en eindigt in clouddiensten. In slechts enkele decennia zijn we van enorme machines met fysieke instructies geëvolueerd naar immateriële programma's die gelicentieerd, bijgewerkt en zelfs als dienst gebruikt worden.
Op deze reis zult u, met voorbeelden en historische context, hoe de begrippen hardware en instructies werden gescheidenHoe is het idee ontstaan om software onafhankelijk te gaan verkopen? Hoe is de productie ervan geprofessionaliseerd? En welke bedrijfs- en licentiemodellen hebben de sector gevormd, van propriëtaire software naar vrije software en SaaS?
Van machine naar programma: van de fysieke wereld naar de instructies
Eeuwenlang werden berekeningen geautomatiseerd met fysieke apparaten: van de abacus en analoge mechanismen tot machines zoals het Jacquard-weefgetouwwaarbij ponskaarten het gedrag definieerden zonder een volledige scheiding tussen structuur en instructies.
De conceptuele scheiding begon vorm te krijgen met Charles Babbage en Ada LovelaceBabbage bedacht de analytische machine als een programmeerbaar apparaat, en Lovelace beschreef hoe verschillende kaarten verschillende programma's bevatten. Daarmee ontstond het idee dat er onderscheid gemaakt kon worden tussen wat er gedaan moest worden en waarmee iets gedaan moest worden.
De grote sprong kwam in de 20e eeuw met Alan Turing en de architectuur van von NeumannTuring formaliseerde een universele machine die elk algoritme kon uitvoeren; von Neumann stelde voor om programma's en gegevens in hetzelfde geheugen op te slaan, waardoor instructies gewijzigd konden worden zonder dat de hardware werd aangetast.
Al in de jaren 40 en 50, assemblers en hogere programmeertalen zoals Fortran en Cobol Ze versterkten het idee: iedereen kon een programma schrijven dat op verschillende compatibele machines zou draaien, zonder de fysieke componenten opnieuw te hoeven ontwerpen.
Wat is software en wat houdt het eigenlijk in?
Het woord software werd populair in de late jaren vijftig, en onder dat label werden de volgende zaken gegroepeerd: alles wat ongrijpbaar is en wat een computersysteem verwerktProgramma's, gegevens en de bijbehorende documentatie. John W. Tukey gebruikte de term al in deze betekenis in 1957.
Dit idee gaat verder dan het uitvoerbare bestand: Software omvat ook handleidingen, specificaties, te verwerken gegevens en gebruikersinformatieUiteindelijk is het het niet-fysieke aspect dat betekenis en functionaliteit aan hardware geeft.
Traditioneel worden er drie hoofdtypen onderscheiden: systeem software (besturingssystemen(controllers, hulpprogramma's en servers), software programmering (editors, compilers, interpreters, linkers, debuggers en IDE's) en toepassingssoftware (zakelijk, educatief, medisch, CAD, databanken, videogamestelecommunicatie, enz.).
Van add-on tot product: softwaretijdperken en het omslagpunt
In de eerste tijdperk, 1950-1965De software werd gezien als een add-on. Programmeren gebeurde met een code-en-fix-aanpak, met weinig of geen documentatie, beperkte methoden en trial and errorDe ontwikkeling was maatwerk en de auteur gebruikte en onderhield zijn programma zelf.
La tweede tijdperk, 1965-1972Dit markeert de beslissende verandering: multiprogrammering en multi-user-omgevingen verschijnen en het wordt een succes. de tijd echt en populair worden de eerste databasebeheersystemenBovenal begint software gezien te worden als een product dat aan honderden of duizenden klanten gedistribueerd kan worden, en De zogenaamde softwarecrisis begint naarmate de complexiteit en de onderhoudskosten de pan uit rijzen.
In deze context is de Software engineering in 1968Techniek, de discipline die technische principes toepast op het ontwerp, de bouw, de werking en het onderhoud van programma's. Ook in opkomst is C-taal in 1972 voor algemene systemen, met een lage efficiëntie en capaciteit.
La derde tijdperk, 1972-midden jaren 80Het brengt gedistribueerde systemen, lokale en wereldwijde netwerken en het gebruik van microprocessoren met zich mee. Deze geven aanleiding tot microcomputers en persoonlijke computersen talen zoals Basic die leren en programmeren democratiseren.
In de vierde tijdperk, 1985-2000, collectieve impact heerst: mondiale netwerken, client-serverarchitecturen, objectgeoriënteerde technologieën, expertsystemen, neurale netwerken e IA. Verschijnt Java begin jaren 90 met objectgeoriënteerd ontwerp en draagbaarheid, en mijlpalen zoals Deep Blue Ze laten de sprong voorwaarts zien in computerkracht en software, en producten zoals Microsoft Encarta Ze illustreren de marketing van de software.
La vijfde tijdperk, 2000-hedenHet web, mobiele telefoons en de enorme hoeveelheden data. De alomtegenwoordigheid van internet en smartphones versnelt continue levering, clouddiensten en inteligencia kunstmatigewaardoor software het middelpunt van de digitale economie wordt.
Tegelijkertijd gingen fabrikanten als IBM van het verkopen van machines en software als geheel naar apart in rekening brengen voor hardware en softwareEn bedrijven die zich uitsluitend toelegden op het ontwikkelen en distribueren van softwareproducten floreerden. Deze stap verstevigde de positie van software als een verhandelbaar product, met eigen licenties, updates en ondersteuning.
Hoe een softwareproduct te produceren: processen en modellen
Om een betrouwbaar product te maken, is een proces nodig. Vastleggen en specificeren van eisen Dit markeert het begin: het is noodzakelijk om vast te leggen, af te spreken en te documenteren wat het systeem moet doen en onder welke beperkingen. Dit resulteert in de SRS (Software Requirements Specification).
Daarna volgen de fasen van ontwerp, codering, testen, installatie en onderhoudHoewel de namen kunnen variëren, bestaan deze fasen flexibel, afhankelijk van de gebruikte methodologie. En hier komen procesmodellen om de hoek kijken.
Het model trapsgewijs De sequentiële lineaire aanpak houdt in dat er door fasen heen wordt gegaan met weinig ruimte voor terugdraaien, wat nuttig is in rigide projecten met duidelijke eisen, hoewel het zelden in zijn pure vorm wordt toegepast. De praktijk omvat feedback tussen fasen om het ontwerp en de eisen aan te passen wanneer er onduidelijkheden of veranderingen ontstaan.
Om rekening te houden met de evolutionaire aard van software, zijn er modellen ontstaan iteratief incrementeel en spiraalvormigBij de incrementele aanpak wordt uitgegaan van het leveren van gedeeltelijke, maar operationele versies, die elk voortbouwen op de vorige. Hierdoor krijgt de klant al snel bruikbaarheid en wordt het risico op grote aanpassingen beperkt.
El Boehm-spiraalmodel Het combineert iteratie met expliciet risicomanagement. Het definieert taakgebieden zoals communicatie, planning, risicoanalyse, constructie en feedbackverzameling, en heeft varianten geïnspireerd zoals de Win-Win-spiraal, die onderhandeling over de voorwaarden voor de overwinning voor zowel klant als leverancier.
De cijfers van de sector onderstrepen de uitdaging: Een aanzienlijk aantal grote projecten mislukt of loopt ernstige vertraging opVaak zijn de oorzaken niet zozeer technische problemen, maar eerder gebrekkige methodologieën of een gebrekkig beheer van de eisen en risico's. Daarom zijn disciplinaire processen zo belangrijk.
Van code tot levering: artefacten, testen en installatie
Tijdens het programmeren doorloopt het product verschillende toestanden. broncode Dit is wat de ontwikkelaar schrijft. Een compiler kan het omzetten in objectcode intermediair, dat later met bibliotheken wordt verbonden om de uitvoerbaarAls de taal op een geïnterpreteerde manier wordt uitgevoerd, is er mogelijk vooraf geen objectcode of uitvoerbaar bestand.
La Debuggen gaat gepaard met coderenEn daarna komen de formele tests. Unittests valideren kleine onderdelen; integratietests verifiëren dat modules en subsystemen correct samenwerken. Later volgt een periode van bètatest onder realistische omstandigheden, om defecten op te sporen die aan eerdere fasen zijn ontsnapt.
De installatie brengt de software over naar de doelomgeving: implementatie, configuratie en operationele verificatieVoor complexe producten zijn mogelijk specialisten en gedistribueerde topologieën nodig, terwijl consumentensoftware begeleide installateurs voor de eindgebruiker biedt.
Dan komt de langste fase: het onderhoudHet omvat corrigerende, perfectieve, adaptieve en evolutionaire veranderingen. De kwaliteit van het ontwerp en de documentatie bepalen de kosten; met slechte documentatie kan onderhoud net zo duur zijn als helemaal opnieuw beginnen.
Continue evolutie: de wetten van Lehman
De gebruikte software verandert of verslechtert. Lehman's evolutiewetten Ze vatten observaties over gebruikte systemen samen: verandering is een continu proces, de complexiteit neemt toe tenzij je investeert in de beheersing ervan, en de functionaliteit moet worden uitgebreid om de tevredenheid van de gebruiker te behouden.
Zij stellen onder andere dat Kwaliteit neemt af als er geen aanpassingen worden gedaanDeze aannames zijn dat evolutionaire processen feedback bevatten en dat de organisatie relatief constante ontwikkelingsniveaus bereikt. Deze aannames helpen bij het plannen van versies en het begroten van onderhoudsinspanningen.
Vereisten: de kern van wat er gebouwd wordt
Requirements engineering biedt methoden en hulpmiddelen voor Begrijp het probleem, valideer met de klant en garandeer de specificatiesEr wordt onderscheid gemaakt tussen gebruikers- en systeemvereisten, functionele, niet-functionele en domeinvereisten, met subtypen zoals organisatorische of externe, juridische en ethische vereisten.
Goede praktijken omvatten: definieer het universum van het discoursBereid elicitatieworkshops voor, prioriteer doelstellingen en detecteer onduidelijkheden. Er zijn meerdere benaderingen: van uitgebreide lexicons en scenario's tot meer orthodoxe methodologieën die vallen onder standaarden zoals IEEE 830-1998 of CMMI-achtige verbeteringskaders.
Bedrijfsmodellen en licenties: van propriëtair naar open source en SaaS
Toen software als product werd gevestigd, ontstond het volgende licentiemodellen Verschillende. Eigendomslicenties definiëren gebruiksvoorwaarden, rechtentoewijzingen en de reikwijdte van de geldigheid. Open licenties daarentegen staan kopiëren, wijzigen en herdistribueren toe, wat leidt tot open gemeenschappen en ecosystemen.
Vanaf de jaren 80 en 90 waren er normenoorlogen in besturingssystemen en platforms: Unix en zijn varianten, Windows, de opkomst van vrije software met het GNU-project en Linuxen het versterken van de rol van de gebruiker bij de keuze van niet alleen hardware, maar ook van systemen en applicaties.
De meest recente sprong in het leveringsmodel is Software als een service, SaaSDe wortels ervan gaan terug tot de timesharingsystemen uit de jaren 60, maar de moderne populariteit kwam met de komst van internet en de cloud. Eerder, in de jaren 80, verschenen de eerste CRM-systemen die klantgegevens deelden, en in de jaren 90 overtrof de softwaregroei soms de beschikbare hardware, waardoor er weer meer behoefte was aan gecentraliseerde hosting.
Met het nieuwe millennium is de combinatie van alomtegenwoordige web- en cloudgegevens Het maakte SaaS tot een dominante optie: abonnementsbetalingen, continue updates, elastische schaalbaarheid en apparaatonafhankelijke toegang. Tegenwoordig bestaat het naast traditionele licenties, freemium-modellen, microtransacties en advertenties.
Economische en sociale impact: waarom het belangrijk is om er een product van te maken
Het behandelen van de software als een op zichzelf staand product is toegestaan specialisatie, schaalvoordelen en waardeketens Specifiek. Pure softwarebedrijven werden meer waard dan veel hardwarefabrikanten, en levenscycli, API's en frameworks maakten complete ecosystemen van derden mogelijk.
Maar er kwamen ook risico's naar boven. Slechte ontwikkeling had kunnen leiden tot kosten in de miljoenen of ernstige gevolgenVan fouten in reserveringssystemen die verliezen veroorzaken tot storingen in kritieke omgevingen met valse alarmen of verkeerde beslissingen die gevolgen hebben voor mensen: het professionaliseren van het proces is geen gril, maar een noodzaak.
Als reactie hierop heeft de industrie haar positie versterkt goede praktijken, rigoureuze tests en risicobeheerIn omgevingen met een hoog risico of een hoge mate van beveiliging zijn modellen zoals de spiraal, met de nadruk op risico's en kwaliteitsnormen, bijzonder geschikt. In andere gevallen worden iteratieve en incrementele benaderingen gebruikt om snelheid en controle in evenwicht te brengen.
Om bruikbaar te blijven, moet het softwareproduct evolueren met hun omgevingAanpassen aan nieuwe platforms, prestaties verbeteren, nieuwe functies implementeren en inspelen op veranderende regelgeving. En natuurlijk het bijhouden van accurate documentatie, zodat onderhoud geen doolhof wordt.
Deze hele historische, technische en economische reis legt uit waarom software tegenwoordig zo goed verkoopt. Het wordt gelicentieerd of aangeboden als een dienstmet statistieken over succes, ondersteuning, versies en geplande uitfasering. Het onderscheid tussen hardware en software vormt de basis van hoe we moderne technologie bedenken en op de markt brengen.
Terugkijkend wordt het duidelijk dat De overgang naar software als product vond plaats in de jaren 60 en 70.Gedreven door toenemende complexiteit, de behoefte aan methodologieën, aparte prijsstelling ten opzichte van hardware en de opkomst van gespecialiseerde bedrijven, is de sector sindsdien gegroeid. Talen zoals Fortran, Cobol, C, Basic en Java, mijlpalen zoals microprocessoren, internet, personal computing en AI, en procesmodellen zoals waterval, incrementeel en spiraal hebben een sector gevormd die nu ook floreert in de cloud en op mobiele apparaten.
Gepassioneerd schrijver over de wereld van bytes en technologie in het algemeen. Ik deel mijn kennis graag door te schrijven, en dat is wat ik in deze blog ga doen: je de meest interessante dingen laten zien over gadgets, software, hardware, technologische trends en meer. Mijn doel is om u te helpen op een eenvoudige en onderhoudende manier door de digitale wereld te navigeren.