De Waardigheid van Programmeren Moet Herbouwd Worden

——Geschreven voor degenen die nog steeds code respecteren

Samenvatting

Van Knuth's ideaal tot de afwijking van de werkelijkheid, in 40 jaar verviel programmeren van kunst tot afval. Unix v6 slechts 9000 regels, nu 500 regels voor één knop, de programmeergeest vervalt; Boeing 737 Max' tragedie waarschuwt dat codekwaliteit levens kost. We moeten terugkeren naar de essentie van programmeren — eenvoud, helderheid, elegantie. Aan alle echte programmeurs: SLAPS is geen revolutie, maar terugkeer. Terug naar structuur, naar verantwoordelijkheid, naar die regels code die we oorspronkelijk liefhadden.

Context uit Vorige Hoofdstukken

"Document is Code" toonde de revolutionaire verandering in programmeerparadigma's — van elke regel met de hand schrijven naar documentgestuurde AI-programmering. Maar wanneer programmeren zo "gemakkelijk" wordt, verliezen we dan iets belangrijkers? Het is tijd om over de waardigheid van programmeren zelf te praten.

1984 zei Donald Knuth: "Programma's zijn geschreven voor mensen om te lezen, en bijkomstig voor machines om uit te voeren."

2024 is de werkelijkheid: "Programma's zijn geschreven voor mezelf om te lezen, hoe minder anderen begrijpen hoe beter."

Wat hebben we in 40 jaar verloren?

De obsessie met eenvoud, het respect voor structuur, de fatsoenlijke behandeling van collega's.

Van Kunst naar Afval

Herinner je Unix v6? De complete besturingssysteemkernel, 9000 regels code. Dennis Ritchie en Ken Thompson creëerden met de meest beknopte expressie een meesterwerk dat tot vandaag invloed heeft.

Nu? Een knopklik-event kan 500 regels zijn. Niet vanwege complexiteit, maar omdat "dit me professioneel laat lijken".

Ik heb te veel van dit soort code gezien:

def calculate_sum(a, b):
    # Initialiseer resultaatvariabele
    result = None
    # Controleer invoerparameters
    if a is not None and b is not None:
        # Voer optelling uit
        try:
            # Voor robuustheid moeten we verzekeren...
            if isinstance(a, (int, float)) and isinstance(b, (int, float)):
                # Overweeg mogelijke overflow...
                # Hier meer controles toevoegen...
                result = a + b
            else:
                raise TypeError("Parametertype fout")
        except Exception as e:
            # Foutafhandeling
            print(f"Berekeningsfout: {e}")
            result = None
    return result

Alleen om op te tellen!

Programmeertalen zijn 's werelds meest gestructureerde talen, de grote weg is eenvoudig. Maar we maken gewoontegetrouw eenvoudige problemen complex, heldere logica vaag, wat in één regel kan in honderd regels.

Waarom? Omdat hoe complexer de code, hoe meer "alleen ik kan het onderhouden".

Van Oplossing naar Probleem Zelf

Boeing 737 Max, weet je? 346 levens.

Ongevallenonderzoek toonde dat een belangrijke oorzaak de kwaliteit van uitbestede code was. Wanneer programmeren van "problemen oplossen" verandert in "problemen creëren", zijn rampen onvermijdelijk.

Dit is geen geïsoleerd geval. Kijk om ons heen:

• Medische systemen crashen omdat code te complex is, niemand durft te wijzigen
• Banksystemen vallen uit omdat historische schuld te zwaar is, niet te wijzigen
• Overheidswebsites haperen omdat laag na laag uitbesteding, elke laag "ingrediënten toevoegt"

Elke regel slechte code is een misdaad tegen het nageslacht.

Elke kopieer-plak verlaagt de kredietrating van deze industrie.

Elke berg stront is verraad aan de beschaving.

Van Gerespecteerd naar Zelfspot als Codeboer

"Wat doe je?"

"Codeboer."

Achter deze zelfspot ligt het verlies van waardigheid van een hele industrie.

Het zelfspottende "codeboer" werd geleidelijk het standaardlabel van de industrie, na verloop van tijd vergaten zelfs wij dat: code eigenlijk de ultieme vorm van taal is.

Welke programmeur uit het klassieke tijdperk was geen gerespecteerd object? Ze schreven complete systemen met 64K geheugen, elke regel code doordacht, elk algoritme strevend naar ultieme elegantie. Hun respect voor code en structuur was instinctief.

Linus Torvalds zei: "Talk is cheap, show me the code." Maar nu wordt talk steeds meer, code steeds slechter.

Waarom zo?

Omdat het hele programmeursveld zakt. De drempel is verlaagd, maar de standaarden ook. Kopiëren-plakken en je durft te zeggen dat je programmeur bent, API's aanroepen en je denkt dat je geweldig bent.

Echte programmeurs doen het niet zo. Ze weten:

• Eenvoud is deugd, geen luiheid
• Leesbaarheid is verantwoordelijkheid, geen keuze
• Elegantie is streven, geen opschepperij

Als het Tij Zich Terugtrekt, Wie Zwemt Naakt?

Nu is AI er.

Wanneer je requirements aan AI geeft, is de code die het in 10 seconden schrijft helderder dan waar je 3 dagen over tobde. Terwijl jij nog de 15e try-catch laag toevoegt "voor robuustheid", heeft AI het probleem al op de eenvoudigste manier opgelost.

SLAPS wil programmeurs niet vervangen, maar programmeren dwingen terug te keren naar essentie.

Dit is drempelhervorming. Niet mensen buiten AI houden, maar elke regel code verantwoordbaar maken.

Binnen het SLAPS-kader:

• Je kunt AI niet bedriegen — onduidelijke structuur begrijpt het niet
• Je kunt geen strontbergen bouwen — onredelijk ontwerp zal AI direct bevragen
• Je kunt niet mysterieus doen — elke beslissing moet heldere redenen hebben

Dit is "gedwongen elegantie". Je schrijft ofwel helder, eenvoudig, onderhoudbaar ontwerp, ofwel AI helpt je helemaal niet met implementatie.

Die programmeurs die hun baan beschermen met complexiteit gaan inderdaad kapot.

Maar dit is geen slechte zaak, dit is zelfzuivering van de industrie.

Laat Programmeren Weer een Trotse Carrière Worden

Ik geloof dat echte programmeurs AI niet vrezen, maar omarmen. Omdat AI hen van "codearbeiders" weer "systeemarchitecten" maakt.

Denk erover na:

• Niet meer tobben over syntaxdetails, focus op architectuurontwerp
• Niet meer wielen opnieuw uitvinden, focus op innovatief denken
• Niet meer gevangen in debugging-hel, focus op bedrijfswaarde

Dit is hoe programmeren zou moeten zijn.

Wanneer programmeren terugkeert naar essentie, kunnen juist mensen die niet kunnen coderen betere systemen creëren. Omdat ze geen "programmeursslechte gewoonten" hebben, willen ze alleen problemen oplossen, niet vaardigheden tonen.

Een productmanager die business doorgrond begrijpt, kan met SLAPS beter presteren dan een "codeboer" met 10 jaar ervaring. Omdat hij weet "wat hij wil", niet tobt over "hoe te schrijven".

De Nieuwe Waardigheid van Programmeren

De toekomst behoort aan:

• Mensen die helder intentie kunnen uitdrukken
• Mensen die eenvoud en elegantie nastreven
• Mensen die echte problemen oplossen
• Mensen die code én mensen respecteren

Toekomstige programmeurs schrijven geen code maar contracten; debuggen geen bugs maar consensus.

Dit is niet het einde der tijden voor programmeurs, dit is de wedergeboorte van programmeren.

Wanneer SLAPS elke regel code betekenisvol moet maken, wanneer AI de poortwachter van codekwaliteit wordt, wanneer "aanmodderen" niet meer mogelijk is, wordt programmeren weer een respectabel ambacht.

We hebben geen mensen meer nodig die strontbergen kunnen schrijven, we hebben mensen nodig die begrijpen "waarom schrijven".

We hebben geen complexere frameworks nodig, we hebben helderder denken nodig.

We hebben achterstand niet te beschermen, we moeten vooruitgang omarmen.

Wanneer code niet langer de slotgracht van eigenbelang is, wordt denken de echte concurrentiekracht.

Tot Slot

29 jaar geleden typte ik regel voor regel code met EditPlus. Geen slimme hints, geen syntax highlighting, maar ik kende de betekenis van elke regel code.

Vandaag, wanneer ik zie dat AI in 40 minuten 1150 regels hoogwaardige code schrijft, voel ik geen paniek maar opluchting. Want deze code belichaamt precies wat ik altijd nastreefde: heldere structuur, eenvoudige logica, duidelijke intentie.

Sommigen zeggen dat dit veel programmeurs werkloos maakt. Ja, zoals de drukpers kopiisten werkloos maakte. Maar de drukpers creëerde ook schrijvers, redacteuren, uitgevers. SLAPS laat "codearbeiders" verdwijnen, maar creëert "AI-protocolarchitecten".

De waardigheid van programmeren wordt niet behouden door achterstand te beschermen, maar herbouwd door vooruitgang te omarmen.

Laat code weer poëzie worden, laat programmeurs weer ingenieurs worden, laat programmeren weer de kracht worden die de wereld verandert.

De echte hackergeest ligt niet in techniek, maar in intentie. Geconfronteerd met AI is het slimste niet weerstand, maar vragen: hoe kan ik ermee samenspannen?

Dit is wat we doen.

─────────────────────────────────────────────

Aan alle echte programmeurs: SLAPS is geen revolutie, maar terugkeer. Terug naar structuur, naar verantwoordelijkheid, naar die regels code die we oorspronkelijk liefhadden.

Juni 2025, Lissabon

─────────────────────────────────────────────

Over de auteur

Wang Xiao is AI-protocolarchitect, auteur van System and Freedom, maker van Danbing AI Protocol / SLAPS Framework en initiatiefnemer van OathAI.

Zijn werk richt zich op mens-AI-cocreatie, protocol governance, semantische verankering en langdurige kenniscontinuïteit, en onderzoekt hoe menselijke kennis en samenwerkingsstructuren in het AI-tijdperk bewaard, gekalibreerd en geërfd kunnen worden.

Disclaimer

Dit essay weerspiegelt de huidige observaties en methodologische reflecties van de auteur, gebaseerd op persoonlijke praktijk, onderzoek en ervaring in mens-AI-samenwerking. De aan Danbing / SLAPS / OathAI verbonden methoden worden nog geordend en ontwikkeld. Hun praktische effecten kunnen variëren afhankelijk van taakcontext, modelcapaciteit, uitvoeringsomgeving en inzetniveau.

Dit essay vormt geen juridisch, investerings-, medisch, professioneel of technisch implementatieadvies of garantie. Lezers die deze methoden in echte projecten toepassen, moeten op basis van hun eigen situatie zelfstandig oordelen en verantwoordelijkheid nemen voor concrete resultaten.