Beyond Objects
Dit artikel betoogt dat het kernprincipe van objectgeoriënteerd programmeren, waarbij systeemfunctionaliteit direct wordt gekoppeld aan domein-individuen, inherent gebrekkig is en tot fragmentatie leidt, en stelt in plaats daarvan voor om objectgeoriënteerdheid op te geven ten gunste van een benadering die domein-individuen loskoppelt van functionele modules.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
Het Grote Idee: De "One-Size-Fits-All" Fout
Stel je voor dat je een huis bouwt. De afgelopen 50 jaar was de standaardregel in de softwarebouw: "Elke kamer in het huis moet worden beheerd door de persoon die er woont."
In de wereld van software wordt dit Object-Oriented Programming (OOP) genoemd. Het idee is dat als je een "User" (Gebruiker) hebt in de echte wereld, je een "User Object" in de code maakt. Dat object is bedoeld om alle gegevens over die gebruiker vast te houden (hun naam, wachtwoord) en al het werk dat met hen te maken heeft te doen (inloggen, recensies schrijven, tafels boeken).
Daniel Jackson stelt dat deze regel een valstrik is. Het klinkt logisch, maar in de praktijk dwingt het software om een verwarrende knoop te worden. Hij suggereert dat we moeten stoppen met proberen elke taak in de "persoon" te proppen en in plaats daarvan software te organiseren op basis van wat er gebeurt (de acties), niet op basis van wie het doet (de individuen).
Het Probleem: Het "Zwitsers Zakmes" vs. Het "Gespecialiseerde Gereedschap"
Jackson zegt dat het dwingen van elke taak op een enkel "User Object" twee grote hoofdpijnproblemen veroorzaakt:
1. Het "Zwitsers Zakmes" Probleem (Conflatie)
Stel je voor dat een User Object een Zwitsers zakmes is. Het heeft een mesje, een schroevendraaier, een kurkentrekker en een tandenstoker.
- Het probleem: Als je de kurkentrekker wilt gebruiken (om een wachtwoord van een gebruiker af te handelen), moet je het hele zware mes meeslepen. Als je het mesje wilt veranderen (een bug in het recensiesysteem oplossen), kun je per ongeluk de kurkentrekker kapot maken.
- In software: Een "User" object eindigt met het bevatten van het wachtwoord van de gebruiker, hun recensiegeschiedenis, hun notificatie-instellingen en hun boekingslogica, allemaal in één groot bestand. Als je wilt veranderen hoe recensies werken, moet je door de code van wachtwoorden graven. Het is rommelig en moeilijk te repareren.
2. Het "Te Veel Handen" Probleem (Fragmentatie)
Stel je een taak voor zoals "Een tafel reserveren."
- Het probleem: Wie moet het doen? De Gebruiker? Het Restaurant? De Tafel? De Reservering?
- In software: Omdat de regel zegt "ken de taak toe aan het object," raakt de code versnipperd. Het "User" object controleert of de gebruiker een boeking heeft. Het "Restaurant" object controleert of de tafel vrij is. Het "Reservation" object maakt het ticket aan.
- Het resultaat: Om een enkele reservering te maken, moet de computer drie verschillende mensen in drie verschillende kamers laten draaien en hen met elkaar laten praten. Als één persoon de ander vergeet te informeren, gaat het systeem kapot. Dit wordt fragmentatie genoemd.
De Analogie: De Restaurantreservering
Jackson gebruikt een restaurant om dit uit te leggen.
De Oude Manier (Object-Georiënteerd):
Je hebt een "User" object en een "Restaurant" object.
- Wanneer Alice een tafel wil boeken, vraagt ze het aan haar "User" object.
- Het User object vraagt aan het "Restaurant" object of er een tafel vrij is.
- Het Restaurant object vraagt het aan het "Slot" object.
- Het "Reservation" object wordt aangemaakt.
- De chaos: Als je de regel wilt veranderen naar "Alice kan niet twee tafels tegelijk boeken," moet je het User object, het Restaurant object en het Reservation object bijwerken. Ze zijn allemaal met elkaar verstrengeld.
De Nieuwe Manier (Concepten):
In plaats van te vragen "Wie is de eigenaar hiervan?", vragen we: "Waar gaat deze groep regels over?"
Jackson stelt voor om software te organiseren in Concepten. Denk aan een Concept als een gespecialiseerd team of een afdeling in een bedrijf, in plaats van een persoon.
- Concept 1: "Reserveren"
- Dit team handelt alle regels af over het maken van toezeggingen. Het geeft niet om wie de gebruiker is; het geeft alleen om de daad van het reserveren. Het houdt de lijst bij van wie wat heeft geboekt.
- Concept 2: "Beschikbaarheid"
- Dit team handelt de daad af van het controleren of een tafel open is. Het geeft niet om wie er boekt; het geeft alleen om de slots.
- Concept 3: "Gebruikersauthenticatie"
- Dit team controleert simpelweg of de persoon is wie hij zegt dat hij is.
Hoe ze samenwerken:
In plaats van dat het User object het Restaurant object aanroept, praten deze "Concepten" met elkaar via Synchronisaties (zoals een verkeerslicht).
- Regel: "Wanneer een Verzoek binnenkomt, controleer of Beschikbaarheid 'Ja' zegt, en als Authenticatie 'Doorgaan' zegt, dan kan Reserveren de boeking maken."
Waarom dit beter is
- Geen verstrengelde knopen: Het "Reserveren" team hoeft niet te weten hoe je een wachtwoord controleert. Het "Authenticatie" team hoeft niet te weten hoe je een tafel controleert. Ze zijn gescheiden.
- Geen discussies over "Wie is de eigenaar?": Je hoeft niet te discussiëren of de "annuleer"-knop bij de Gebruiker of de Reservering hoort. Je plaatst de "annuleer"-logica gewoon in het Concept dat de status van de reservering beheert.
- Duidelijkere kaarten: Als je naar de code kijkt, zie je de bedrijfsregels (Reserveren, Beschikbaarheid) duidelijk, in plaats van een verwarrende kaart van wie welke data bezit.
Het "Concept" vs. Het "Object"
- Object: Een kleine machine die probeert alles te zijn (Data + Logica + Identiteit). Het is als een persoon die tegelijkertijd chef, ober en kassier probeert te zijn.
- Concept: Een module die een specifieke taak of relatie afhandelt. Het is als een gespecialiseerde afdeling. De "Chef-afdeling" regelt het koken; de "Ober-afdeling" regelt het serveren. Ze coördineren, maar ze versmelten niet tot één persoon.
De Conclusie
Jackson zegt niet dat we alle software weg moeten gooien. Hij zegt dat de kernregel van Object-Oriented Programming — "Ken elke taak toe aan de persoon die erbij hoort" — de bron van het probleem is.
Door over te schakelen naar Concepten, stoppen we met proberen de software te laten lijken op een verzameling mensen. In plaats daarvan organiseren we het als een verzameling regels en relaties. Dit maakt de code gemakkelijker leesbaar, gemakkelijker te repareren en minder kansrijk om kapot te gaan wanneer je één klein ding probeert te veranderen.
Het is een terugkeer naar een oudere, eenvoudigere manier van denken (zoals relationele databases), maar dan geüpdatet voor moderne softwarebehoeften, waardoor we systemen kunnen bouwen die minder fragiel en logischer zijn.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.