![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_082925_d_e_kl.jpg\")
<\/p>\n
The Past, Present, and Future of AI for Application Developers \u2014 Steve Sanderson<\/h2>\n
Steve Sanderson begon zijn sessie met een simpele constatering: \u201cAI makes work better.\u201d<\/em> En dat is nauwelijks overdreven. Twee jaar geleden gebruikte nog vrijwel niemand AI tijdens het ontwikkelen, nu ligt dat gebruik al rond de vijftig procent. De vraag is niet langer of<\/em> we AI gaan gebruiken, maar hoe<\/em> we ermee beginnen. In 1950 stelde Alan Turing zijn beroemde vraag: \u201cCan machines think?\u201d<\/em> Hij bedacht de zogenaamde imitation game<\/em>, later bekend geworden als de Turingtest \u2014 een manier om te bepalen of een machine menselijk genoeg kan converseren. Daarna ging hij nog verder terug. In 1913 beschreef Andrey Markov de kans dat een volgende letter of woord afhangt van de vorige \u2014 de basis voor wat we nu Markov chains<\/em> noemen. \n\u201cPro tip,\u201d grapte Steve. \u201cEverything is legitimate for AI.\u201d Pas in 2017 kwam de echte revolutie: de Transformer-architectuur. Die maakte het mogelijk om context op veel grotere schaal te begrijpen. Sindsdien is de groei van AI-modellen explosief. Om te laten zien hoe AI leert, trainde Steve live een kleine versie van GPT-2. \n\u201cIt\u2019s just predicting the next token,\u201d zei Steve. Maar moderne AI gaat verder dan tekstvoorspelling. Met function calling kan een model nu echte methodes aanroepen of data uit de echte wereld ophalen. Vervolgens stapte hij over naar de praktijk: AI integreren in .NET. Steve liet ook multimodale toepassingen zien \u2014 modellen die niet alleen tekst, maar ook beelden begrijpen. Aan het einde van zijn sessie benadrukte Steve dat de toekomst van AI niet alleen draait om grotere modellen, maar om betere<\/em> modellen \u2014 systemen die begrijpen wat ze doen. Jeff Prosise stapte het podium op met een energieke glimlach en de belofte van \u201clots of demos.\u201d<\/em> Hij hield woord. Het volgende uur stond in het teken van een nieuwe golf binnen AI: autonome agents \u2014 systemen die niet alleen reageren, maar ook samenwerken, plannen en handelen.<\/p>\n \n\u201cThink of them as microservices for AI,\u201d zei Jeff. Een AI-agent is in de basis een wrapper rondom een LLM (Large Language Model). Maar in plaats van simpelweg tekst te genereren, krijgt de agent autonomie en tools om specifieke taken uit te voeren: data ophalen, bestanden doorzoeken, berekeningen uitvoeren of zelfs API\u2019s aanroepen. Hij liet vier populaire frameworks zien die deze manier van werken mogelijk maken:<\/p>\n Om te laten zien wat dat betekent, bouwde Jeff live een prototype. \n\u201cOne agent reads the resumes, another compares them to the job description, a third composes the response,\u201d legde hij uit. De workflow verscheen als een soort chatinterface waarin agents met elkaar communiceerden. Jeff vroeg de AI zelfs om een rejection letter in the style of Dr. Seuss<\/em> \u2014 en het werkte.<\/p>\n Achter de schermen gebeurt er veel. Agno bevat ingebouwde tools voor o.a. samenvatten, rekenen, het ophalen van data (zoals via yfinance) en zelfs het genereren van afbeeldingen. Alles via function calling<\/em> \u2014 waarbij de LLM een JSON-beschrijving van de gewenste functie opstelt, die vervolgens echt wordt uitgevoerd.<\/p>\n Daarna ging het over MCP (Model Context Protocol), een nieuwe standaard die LLM\u2019s in staat stelt om functies en API\u2019s te importeren alsof het lokale tools zijn. Agno heeft zijn eigen MCP-server en ondersteunt multi-agent orchestration met vector databases en deelbare context.<\/p>\n Tot slot liet Jeff een indrukwekkende demo zien van meerdere agents die samenwerkten aan een data-analyse. Jeff sloot af met een vooruitblik: \n\u201cWe\u2019re entering the era of AI orchestration,\u201d zei hij. De sessie begon rustig, met een simpele titel op het scherm: \u201cUnderstanding MCP.\u201d<\/em> Maar al snel werd duidelijk dat dit niet zomaar een technische uitleg zou worden \u2014 dit was een kijkje in wat velen de nieuwe ruggengraat van AI-integratie noemen.<\/p>\n Roelant trapte af met een glimlach: \u201cMCP is nog geen jaar oud, maar het zorgt nu al voor flink wat buzz.\u201d<\/em> Hij grapte over de USB-analogie \u2014 \u201cI hate this analogy, it had nine connectors\u201d \u2014 maar gebruikte het toch om te illustreren wat MCP wil zijn: \u00e9\u00e9n universele standaard voor hoe taalmodellen met externe systemen praten.<\/p>\n LLM\u2019s, legde Roelant uit, kennen jouw wereld niet.<\/em> Ze hebben geen toegang tot je documenten, API\u2019s of databases. Ze genereren tekst, maar zonder context weten ze niet wat relevant of actueel is.<\/p>\n \n\u201cContext is everything to the model,\u201d zei hij. MCP (Model Context Protocol) is ontworpen om dat probleem op te lossen. Het combineert memory, state en access \u2014 zodat een model kan werken met externe informatie op een veilige, gestandaardiseerde manier.<\/p>\n MCP werd ge\u00efntroduceerd in november 2024 en is een open-source standaard die sterk doet denken aan bestaande protocollen als REST, LSP (Language Server Protocol) en JSON-RPC. Het is flexibel, webgebaseerd en bedoeld om de interactie tussen LLM\u2019s, applicaties en tools te standaardiseren.<\/p>\n Tijdens de demo opende hij Visual Studio Code en liet hij zien hoe GitHub Copilot, via MCP, kon communiceren met externe services. \n\u201cEvery LLM used to need its own interface,\u201d zei Roelant. \u201cMCP replaces all of that.\u201d\n<\/p><\/blockquote>\n Hij toonde een GitHub MCP registry , waar al honderden servers beschikbaar zijn \u2014 van Playwright tot Hugging Face.<\/p>\n MCP draait om drie kerncomponenten:<\/p>\n Een MCP client roept tools aan of vult prompts in, terwijl een MCP server die tools en bronnen beschikbaar stelt. Hij onderscheidde twee typen verbindingen:<\/p>\n STDIO is snel en betrouwbaar voor lokale agents; HTTP is ideaal voor cloudgebaseerde of remote toepassingen.<\/p>\n De eerste slide was al in Pokemon stijl.<\/p>\n \n\u201cIt will make sense later,\u201d had hij aan het begin gezegd \u2014 en dat deed het.\n<\/p><\/blockquote>\n Hij legde de analogie uit:<\/p>\n Een speelse, maar effectieve manier om te laten zien hoe MCP een ecosysteem vormt waarin clients, servers en tools samenwerken.<\/p>\n Omdat MCP toegang kan krijgen tot gevoelige data, is veiligheid cruciaal. \n\u201cMCP is only as secure as you make it,\u201d zei hij. \u201cKeep it updated, and follow best practices.\u201d\n<\/p><\/blockquote>\n Tot slot liet hij zien hoe eenvoudig het is om een eigen MCP-server te bouwen. \n\u201cJust HTTP,\u201d benadrukte hij. \u201cNo magic.\u201d\n<\/p><\/blockquote>\n Amber opent met een voetbalclip \u2014 een bal die n\u00e9t over de doellijn gaat. De zaal reageert meteen: herkenning, frustratie, discussie. Ze glimlacht: \u201cOutrage in football. What do we do in situations like this?\u201d<\/em><\/p>\n Amber is voormalig sportcoach en nu actief in tech leadership. Ze neemt het publiek mee door de geschiedenis van technologie in de sport \u2014 en wat we daarvan kunnen leren als softwareontwikkelaars.<\/p>\n In 1731 verscheen de eerste stopwatch. Daarna kwam de elektronische klok, de \u2018photo finish\u2019 en automatische scorebepaling bij bowlen. In 1995 deed video-refereeing zijn intrede en in 2001 kwam AI de sport binnen via cricket \u2014 het beroemde Hawk-Eye<\/em> systeem dat met zes tot tien camera\u2019s de balbeweging volgt.<\/p>\n De technologie verbeterde de kijkervaring , maar bracht ook vragen over eerlijkheid en vertrouwen. Tennis volgde in 2006 met real call video assistance<\/em>. In 2010 zagen we het bekende WK-moment tussen Engeland en Duitsland: een doelpunt dat niet werd toegekend. Twee jaar later voerde de FIFA doeltechnologie in en in 2018 werden videoreferees officieel gebruikt tijdens het WK. Volgens FIFA lag de nauwkeurigheid toen op 99,3%.<\/p>\n In 2022 kwam daar semi-automatische buitenspeltechnologie bij: twaalf camera\u2019s, twintig datapunten per speler. Amber stelt de vraag: \u201cDo we even need human referees anymore?\u201d<\/em><\/p>\n Maar: zonder context is er geen vertrouwen. Het publiek accepteert een menselijke fout nog eerder dan een kil technisch besluit van een systeem. Ze laat een reeks beelden zien van gebeurtenissen waar technologie \u201ctechnisch correct\u201d handelde, maar menselijk gezien faalde \u2014 van persoonlijke tragedies tot Dieselgate bij Volkswagen. Een \u201cdefeat device\u201d liet auto\u2019s anders presteren tijdens tests, waardoor ze voldeden aan regels, maar de werkelijkheid maskeerden. Amber benadrukt dat goede code reviews \u2014 net als goede arbitrage \u2014 niet alleen gaan over correctheid , maar over kritisch denken , empathie en communicatie. Ze illustreert dit met voorbeelden uit het onderwijs en uit het dagelijks leven.<\/p>\n Wie bij een auto-ongeluk eerst vraagt \u201choe erg is de schade?\u201d in plaats van \u201cben je ok\u00e9?\u201d, laat zien welke waarde prioriteit krijgt. Amber vertelt over haar ervaring in India, waar ze een voetbalacademie leidde. De spelers waren taakgericht: ze wachtten op instructies en feedback, zonder het grotere spel te zien. Ze leerden een vaardigheid, maar misten context en creativiteit. AI kan ons helpen, maar zonder context mist het systeem menselijkheid. Ze toont beelden van vertrouwen en samenwerking en stelt de vraag: Goede code reviews, net als goede scheidsrechters, vragen om datzelfde evenwicht tussen correctheid en context. Amber eindigt met een persoonlijke anekdote: een jonge speler die \u201cpass!\u201d riep, maar niet wist waarom. Pas toen ze samen de bedoeling achter de actie begrepen, ontstond er echt spelinzicht. Richard Campbell, bekend van DotNetRocks<\/em> en RunAs Radio<\/em> (samen goed voor bijna tweeduizend afleveringen), nam het publiek mee op een reis door de tijd \u2014 van de begindagen van de cloud tot aan de toekomst van softwareontwikkeling in het komend decennium.<\/p>\n Richard dook vervolgens de geschiedenis van hardware in: van Fairchild Semiconductor in 1960 tot Intel\u2019s vroege RAM-chips. Moore\u2019s Law \u2014 de observatie dat het aantal transistors op een chip ongeveer elke twee jaar verdubbelt \u2014 heeft decennialang onze vooruitgang gedragen. Maar, zei hij: \u201cWe\u2019re at the end of that curve.\u201d<\/em> Richard liet een lijst van talen en tools zien die developers de afgelopen decennia hebben gebruikt: Python, Java, C#, JavaScript, Swift, Go, Kotlin, Rust, TypeScript. Richard noemde \u201cAI\u201d het slechtste marketingwoord ooit. Op het scherm verscheen de Gartner Hype Cycle. Richard vergeleek de huidige AI-golf met de dotcom-bubbel van de jaren negentig. Richard ging daarna dieper in op generatieve AI buiten tekst en code. Hij noemde AlphaFold 3<\/em> \u2014 dat eiwitstructuren voorspelt \u2014 als voorbeeld van AI die wetenschappelijke vooruitgang versnelt. Tot slot nam Richard het publiek mee naar de wereld van quantum computing. \n\u201cWe\u2019re in the big time now. We get to make the future.\u201d\n<\/p><\/blockquote>\n Alice Meredith, met dertig jaar ervaring in leiderschap en verandermanagement, bracht in haar sessie een frisse, menselijke kijk op werk, communicatie en verandering. Haar carri\u00e8re begon ooit bij Blockbuster Video , daarna werkte ze in HR-leiderschap bij Best Buy en ging daarna trainingen geven bij Pluralsight, waar ze inmiddels meer dan dertig leiderschapscursussen ontwikkelde. Haar missie: mensen helpen de menselijke kant van werk<\/em> te beheersen \u2014 om niet alleen functioneel aanwezig te zijn, maar ook echt verbinding te maken, te reflecteren en bewust te reageren.<\/p>\n \n\u201cSoft skills aren\u2019t soft,\u201d zei ze. \u201cThey\u2019re the hard stuff that makes the hard skills matter.\u201d\n<\/p><\/blockquote>\n Om effectiever te zijn in ons werk, moeten we eerst begrijpen hoe we zelf \u2018geprogrammeerd\u2019 zijn \u2014 ons menselijk besturingssysteem , zoals zij het noemde: een verzameling van levenservaringen, overtuigingen en automatische patronen die we soms zelf hebben gekozen, maar vaak gewoon hebben overgenomen. Ze vergeleek onze sterke kanten met een huis met een balkon en een kelder:<\/p>\n \n\u201cOp het balkon schitteren je kwaliteiten; in de kelder schieten ze door en worden ze je valkuil.\u201d\n<\/p><\/blockquote>\n Het doel is om jezelf in realtime te herkennen en terug naar het balkon te bewegen \u2014 naar balans.<\/p>\n In het deel Relate<\/em> vertelde ze een verhaal over een 14-jarige jongen die ze ooit ontmoette aan het strand van Venice Beach. Hij deed stunts op zijn skateboard, terwijl dat daar eigenlijk niet mocht. Toen ze hem aankeek en simpelweg zei: \u201cI see you\u201d<\/em>, veranderde zijn houding compleet.<\/p>\n \n\u201cBeing seen makes people feel they matter.\u201d\n<\/p><\/blockquote>\n In organisaties werkt het net zo. Mensen willen zich gezien en gehoord voelen. Kleine gebaren kunnen daar groot verschil in maken. Alice moedigde leiders aan om \u201cconnection bombs\u201d te planten \u2014 spontane, menselijke interacties op de werkvloer die relaties versterken. Ze vertelde hoe ze ooit, tijdens een lunchwandeling, een toevallige ontmoeting had over een Journey-concert. Dat leidde tot een halfuur gesprek, nieuwe inzichten en een langdurige samenwerking.<\/p>\n \n\u201cEvery small conversation expands your network and builds trust.\u201d\n<\/p><\/blockquote>\n Verbinding ontstaat niet in vergaderingen of KPI\u2019s, maar in de tussenruimte<\/em> \u2014 de momenten waarin mensen zichzelf mogen zijn.<\/p>\n Het derde onderdeel draaide om responsiviteit \u2014 hoe we reageren in situaties van spanning of feedback. Ze benadrukte dat conflictstijlen niet statisch zijn: we kunnen leren om flexibel te schakelen, afhankelijk van de context.<\/p>\n Zo eindigde de sessie zonder duidelijke conclusie met veel persoonlijke anektotes.<\/p>\n Bart de Smet, Principal Software Engineer bij Microsoft en bekend gezichten binnen de .NET-community, nam het publiek mee in een snelle maar diepgaande tour door de nieuwste features van C# 13 , de aankomende verbeteringen in C# 14 en zelfs een voorproefje van wat daarna nog in de pijplijn zit. C# 13 breidt de bekende Een van de meest zichtbare verbeteringen is de nieuwe Console-API\u2019s ondersteunen nu de Unicode escape \nKleine verbeteringen, groot gemak \u2014 \u201cless hexadecimal guessing,\u201d aldus Bart.\n<\/p><\/blockquote>\n Een meer geavanceerde toevoeging: iterators ( C# 13 breidt partial classes verder uit met partial members \u2014 niet alleen methodes, maar ook indexers, properties en constructors kunnen nu als partial<\/em> worden gedefinieerd. De nieuwe Een subtiele maar belangrijke verandering: C# 13 introduceert een nieuw De grootste verandering die eraan komt, zijn extension members \u2014 niet alleen methodes, maar ook properties, indexers en zelfs operators kunnen worden uitgebreid. De feature wordt nog verder uitgewerkt, maar de potentie is groot \u2014 zeker voor domeinspecifieke API\u2019s.<\/p>\n C# 14 introduceert ook custom compound assignments zoals De welbekende Tot slot gaf Bart een vooruitblik op toekomstige concepten \u2014 zoals unbound generic names, lambda-parameters met modifiers en verdere uitbreiding van partial members. \n\u201cWe\u2019re not done evolving,\u201d sloot Bart af. \u201cC# keeps growing with the developers who use it.\u201d\n<\/p><\/blockquote>\n Dennis Doomen \u2014 bekend van zijn Fluent Assertions<\/em>-library en zijn expertise in clean architecture \u2014 deelde in deze sessie zijn meest beproefde adviezen voor het onderhouden van een gezonde, schaalbare en begrijpelijke C#-codebase. Hij begon met een observatie over hoe veel teams onnodig complexe architecturen cre\u00ebren. Niet elke toepassing heeft microservices nodig, benadrukte hij:<\/p>\n \n\u201cIf you don\u2019t need independent scaling, merge those microservices back into a modular monolith.\u201d\n<\/p><\/blockquote>\n Het is volgens hem beter om eerst te kijken waar<\/em> je daadwerkelijk moet schalen \u2014 en pas daarna de architectuur daarop aan te passen. Microservices zijn een middel, geen doel. Een terugkerend thema: structuur. \n\u201cThe folder structure should explain your architecture at a glance.\u201d\n<\/p><\/blockquote>\n Daarnaast: hou concrete implementaties intern ( Automatisering is essentieel om kwaliteit te bewaken. Dennis liet zien hoe EditorConfig , Prettier en .NET analyzers kunnen helpen bij consistente formatting en statische code-analyse. \n\u201cLet tools do the boring work so you can focus on design.\u201d\n<\/p><\/blockquote>\n Zelfs AI kan hierbij helpen \u2014 hij noemde Copilot en Sonnet als voorbeelden van assistenten die mee kunnen denken<\/em> bij refactoring, zolang je hun output nog steeds als je eigen code beschouwt.<\/p>\n Veel documentatie schiet tekort omdat ze uitlegt wat<\/em> de code doet, niet waarom<\/em> ze zo is opgebouwd. \n\u201cExplain the purpose, not the procedure.\u201d\n<\/p><\/blockquote>\n Gebruik beschrijvende titels en laat de code zelf het werk doen. Tools zoals GhostDoc kunnen helpen bij basisdocumentatie, maar het echte werk zit in de intentie.<\/p>\n Versiebeheer is volgens hem een onderschat onderdeel van clean code. \n\u201cA clean commit history is a clean story of your code.\u201d\n<\/p><\/blockquote>\n Hij toonde voorbeelden in GitKraken hoe kleine, goed getitelde commits het reviewproces aanzienlijk verbeteren.<\/p>\n Een schoon systeem is een los systeem. \n\u201cEvery dependency is a liability \u2014 treat it like one.\u201d\n<\/p><\/blockquote>\n Een opvallend advies dat vaak tot discussie leidt:<\/p>\n \n\u201cDuplicate before you abstract.\u201d\n<\/p><\/blockquote>\n Dennis legde uit dat je pas moet abstraheren wanneer je dezelfde code minstens drie keer nodig hebt. \n\u201cIf it\u2019s too complicated to reuse, maybe it\u2019s not worth reusing.\u201d\n<\/p><\/blockquote>\n Hij verwees naar het principe van de \u201cRule of Three\u201d en de YAGNI<\/em>-filosofie (You Ain\u2019t Gonna Need It<\/em>).<\/p>\n Refactoring hoort een natuurlijke gewoonte te zijn, geen project op zich. \n\u201cAlways leave the code cleaner than you found it.\u201d\n<\/p><\/blockquote>\n De sessie was een praktische gids vol nuchtere adviezen:<\/p>\n Of zoals Dennis het zelf zei:<\/p>\n \n\u201cClean code isn\u2019t a style \u2014 it\u2019s a culture. Build it, live it, and your future self will thank you.\u201d\n<\/p><\/blockquote>\n Het was best druk toen Jimmy Bogard begon aan zijn talk. Z'n presentatie was: demo-heavy<\/em>, geen theoretisch verhaal. Hij startte met een herkenbaar beeld \u2014 een project zonder tests, tot de eerste bug opdook. En dan de pijnlijke realiteit: hoe later je een bug ontdekt, hoe duurder het wordt. Toch blijven veel teams hangen bij unit tests of, erger nog, helemaal geen automatische tests. \n\u201cStop aiming for the testing diamond \u2014 embrace integration tests. They\u2019re slower, yes, but they give you confidence that your system actually works.\u201d<\/em>\n<\/p><\/blockquote>\n
\nOm die vraag te beantwoorden, nam Steve het publiek mee op een reis door de tijd \u2014 terug naar het begin van het begrip \u201ckunstmatige intelligentie\u201d.<\/p>\nVan Turing tot Eliza<\/h3>\n
\nIn de jaren zestig ontstonden de eerste chatbots. Steve toonde live een klassieker: Eliza , een programma dat met simpele stringvervanging reageerde op wat je zei. Als je iets intypte, herhaalde Eliza het gewoon in de vorm van een vraag. Het werkte niet echt, maar het was een fascinerende illusie. Steve lachte: \u201cPeople process it as intelligence \u2014 but it\u2019s just string replacement.\u201d<\/em><\/p>\nDe fundamenten van voorspellende tekst<\/h3>\n
\nEn in 1948 legde Claude Shannon met zijn informatietheorie de basis voor moderne taalmodellen. Hij liet zien hoe je op basis van letterfrequenties een tekst kunt laten \u201cgokken\u201d wat erna komt.<\/p>\n
\nEn inderdaad: zelfs iets eenvoudigs als een letterrooster kan de kiem zijn van een taalmodel.\n<\/p><\/blockquote>\nDe doorbraak: Transformers<\/h3>\n
\nSteve toonde een overzicht van bekende modellen \u2014 van GPT-1 met 117 miljoen parameters tot GPT-4 , waarvan naar schatting 1,7 biljoen parameters onder de motorkap zitten. Daar tegenover staan open modellen als LLaMA en DeepSeek R1 , die ook snel aan terrein winnen.<\/p>\nHoe een taalmodel leert<\/h3>\n
\nNa \u00e9\u00e9n iteratie was de output pure chaos.
\nNa honderd iteraties begon het model taalpatronen te herkennen.
\nNa vijfhonderd iteraties produceerde het zinnen die grammaticaal klopten.<\/p>\n
\n\u201cChat completion is simply token prediction shaped into something we want to hear.\u201d\n<\/p><\/blockquote>\nFunction calling en echte intelligentie<\/h3>\n
\nZo ontstaat een brug tussen tekstbegrip en praktische actie.
\nHij liet zien hoe dat werkt in toepassingen als:<\/p>\n\n
C# in actie<\/h3>\n
\nMet Microsoft.Extensions.AI en IChatClient demonstreerde hij hoe je een AI-model eenvoudig laat samenvatten, vertalen of classificeren.
\nEen voorbeeld met een vastgoedapplicatie liet zien hoe een AI automatisch eigenschappen uit een beschrijving kon extraheren en in JSON kon teruggeven.<\/p>\nVision en reasoning<\/h3>\n
\nMet GPT-4o-mini en lokale modellen via Hugging Face (een site waar veel AI modellen op staan) demonstreerde hij beeldclassificatie, zelfs draaiend in WebAssembly.
\nDaarna ging het over reasoning models<\/em>: AI die niet alleen voorspelt, maar nadenkt \u2014 patronen herkent, context begrijpt en keuzes maakt.
\nHij liet praktische voorbeelden zien:<\/p>\n\n
Tot slot<\/h3>\n
\nAI wordt niet meer alleen een tool die code aanvult of tekst genereert, maar een integraal onderdeel van hoe we software bouwen. De lijn tussen mens en machine vervaagt en voor ontwikkelaars ligt daar niet een bedreiging, maar een kans: om slimmer, sneller en creatiever te bouwen dan ooit tevoren.<\/p>\n![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_083835_d_e_kl.jpg\")
<\/p>\nAgents of Change: Building AI Agents that Work (and Think) for Us – Jeff Prosise<\/h2>\n
\n\u201cEach agent does one thing extraordinarily well. Together, they can solve problems far more complex than any single model could.\u201d\n<\/p><\/blockquote>\nWat zijn AI-agents eigenlijk?<\/h3>\n
\nJeff legde het uit als een soort bouwteam: jij levert de bouwstenen, AI zorgt voor de workflow en het framework biedt de infrastructuur voor communicatie tussen de agents.<\/p>\nAgentic frameworks: de bouwstenen van deze nieuwe golf<\/h3>\n
\n
De praktijk: agents die denken, plannen en samenwerken<\/h3>\n
\nOp het scherm verscheen een fictieve vacature voor een CEO. Een agent analyseerde cv\u2019s, beoordeelde kandidaten en gaf scores tussen 1 en 10 \u2014 allemaal in natuurlijke taal.<\/p>\n
\n\u201cThey pass information dynamically \u2014 one by one \u2014 like a team.\u201d\n<\/p><\/blockquote>\nHoe werkt dat technisch?<\/h3>\n
\nLLM\u2019s zijn stateless, dus een agent-framework moet zelf geheugen bijhouden. Jeff liet zien hoe dat werkt met een eenvoudige in-memory database of met SQLite of MongoDB.
\nHij demonstreerde Agno, waarin agents eenvoudig worden gedefinieerd met een paar regels Python-code.
\nEen agent heeft:<\/p>\n\n
MCP \u2013 de nieuwe standaard voor agentcommunicatie<\/h3>\n
\nBedrijven zijn druk bezig hun diensten via MCP beschikbaar te maken \u2014 van PayPal tot Salesforce.
\nDe voordelen:<\/p>\n\n
Multi-agent samenwerking in actie<\/h3>\n
\nEen Database Agent haalde gegevens op, een Quant Agent verwerkte ze en een Visualization Agent genereerde de grafiek \u2014 alles binnen een teamstructuur, aangestuurd door een Team Lead Agent.
\nIn Python definieerde hij een Team<\/code>-klasse met een members<\/code>-property. Door share_member_interactions=True<\/code> te zetten, konden de agents onderling informatie delen. Het resultaat verscheen als een live gegenereerde plot op het scherm.<\/p>\nDe toekomst van agentic AI<\/h4>\n
\nAI-agents zullen binnenkort samenwerken zoals menselijke teams dat doen \u2014 met rollen, taken en context. De ontwikkelaar definieert het speelveld, maar de agents bepalen de uitvoering.<\/p>\n
\n\u201cWhere you don\u2019t just build models \u2014 you build teams.\u201d\n<\/p><\/blockquote>\n![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_102217_d_e_kl.jpg\")
<\/p>\nUnderstanding Model Context Protocol (MCP) \u2014 Roelant Dieben<\/h2>\n
De opkomst van MCP<\/h3>\n
\nZijn agenda was overzichtelijk:<\/p>\n\n
Waarom MCP nodig is<\/h3>\n
\n\u201cGood context makes agents smarter \u2014 and safer.\u201d\n<\/p><\/blockquote>\nWat is MCP?<\/h3>\n
Demo: MCP in actie<\/h3>\n
\nHij vroeg: \u201cAre there new papers on Hugging Face?\u201d<\/em> Copilot stuurde de vraag via een MCP server , die op zijn beurt de informatie ophaalde. Geen custom plugin meer nodig, geen API-sleutels overal verstopt \u2014 gewoon \u00e9\u00e9n gestandaardiseerde interface. <\/p>\nHoe MCP werkt<\/h3>\n
\n
\nDe communicatie verloopt via JSON-RPC , met endpoints zoals \/tools\/list<\/code> en \/tools\/invoke<\/code>.
\nRoelant liet met de MCP Explorer zien hoe je de beschikbare tools kunt inspecteren, tokens kunt toevoegen en direct met servers kunt praten.<\/p>\nLokale vs. externe MCP communicatie<\/h3>\n
\n
Pok\u00e9mon: een verrassende analogie<\/h3>\n
\n
Beveiliging en authenticatie<\/h3>\n
\nHet protocol gebruikt OAuth 2.1 en OpenID Connect , met nadruk op \u201cleast privilege\u201d en tokenvalidatie.
\nRoelant legde uit dat OAuth 2.1 inmiddels veiliger en consistenter is dan zijn voorganger en dat Microsoft werkt aan Entra Agent ID als mogelijke uitbreiding voor agentic identity management.<\/em><\/p>\nZelf een MCP-server bouwen<\/h3>\n
\nIn Visual Studio voegde hij via NuGet het ModelContextProtocol<\/code>-pakket toe.
\nMet slechts zes regels code registreerde hij een HTTP-client naar de Pok\u00e9API \u2014 en maakte zo een simpele, werkende MCP-server met een eigen tool.<\/p>\nKey takeaways<\/h3>\n
\n
![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_114241_d_e_kl.jpg\")
<\/p>\nVAR, AI Referees, and the Future of Code Reviews – Amber Vanderburg<\/h2>\n
\nDaarna maakt Amber de overstap naar software: de toekomst van code reviews.<\/p>\n
\nDe les: context en intentie doen ertoe.<\/em><\/p>\n
\nZe zegt: \u201cThe questions you ask reveal your values.\u201d<\/p>\n
\nHetzelfde geldt bij code reviews: de vragen die we stellen sturen het gedrag van een team.<\/p>\n
\nNa jaren training begreep ze dat haar taak niet was om hen n\u00f3g beter te laten uitvoeren, maar om hen te leren denken in systemen \u2014 de bigger picture<\/em> te zien.
\nTot slot maakt ze de sprong naar AI in coaching en code reviews.<\/p>\n
\n\u201cHow are you building trust \u2014 with your team, your tools, your AI?\u201d<\/em>
\nVertrouwen, zegt ze, bestaat uit competence, character en communication.
\nJe kunt iemand vertrouwen met een geheim, maar niet met je auto \u2014 omdat vertrouwen domeinspecifiek is.<\/p>\n
\nHet is niet genoeg dat iets werkt \u2014 het moet kloppen binnen de waarden van het team en de gebruikers.<\/p>\n
\n\u201cReviewing code,\u201d zegt ze, \u201cisn\u2019t about shouting instructions \u2014 it\u2019s about helping others see the field.\u201d<\/p>\n![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_134853_d_e_kl.jpg\")
<\/p>\nThe Next Decade of Software Development – Richard Campbell<\/h2>\n
Het einde van Moore\u2019s Law<\/h3>\n
\nDe afstanden tussen transistors worden nu gemeten in nanometers en zelfs picometers. Chips worden 3D en fabrikanten als Intel en TSMC werken aan 2nm-processors. Ondertussen komen ARM-processors op in de cloud, terwijl Apple\u2019s M5-chips met 16 cores en neurale netwerken krachtige lokale AI-taken draaien.
\nZijn punt: hardwareontwikkeling verandert niet alleen in tempo, maar ook in karakter.
\nDe toekomst ligt in specialisatie \u2014 quantum, neuromorfisch, edge \u2014 in plaats van simpelweg sneller en kleiner.<\/p>\nDe evolutie van software<\/h3>\n
\n\u201cNone of them are perfect,\u201d zei hij. \u201cThey\u2019re just the current answers.\u201d
\nHij besprak de verschuiving van client naar cloud, van Windows naar Linux en van traditionele apps naar browsers en PWAs.
\n\u201c.NET is 20 years old,\u201d herinnerde hij het publiek, \u201cand .NET 10 is around the corner.\u201d
\nEr volgde een snelle tour door de wereld van low-code tools \u2014 Power BI, Power Apps, Power Automate, Power Virtual Agents \u2014 en de manier waarop ze traditionele ontwikkelcycli versnellen. Toch, benadrukte hij, blijft de kern hetzelfde: \u201cGood software is still about solving real problems.\u201d<\/em><\/p>\nAI: het slechtste goed bedachte woord<\/h3>\n
\nHij lachte: \u201cIf it doesn\u2019t work, we call it AI. Once it works, we rename it.\u201d<\/em>
\nHij verwees naar HAL 9000 uit 2001: A Space Odyssey<\/em>, naar de angst voor machines die ons vervangen \u2014 en naar de ironie dat moderne AI vooral ons werk makkelijker maakt.
\nHij beschreef de opkomst van OpenAI, Google Brain, de ruzies over financiering en de samenwerking tussen Microsoft en OpenAI die leidde tot ChatGPT en GitHub Copilot.
\nToch waarschuwde hij: \u201cCopilot is your copilot \u2014 but if the plane crashes, it\u2019s still your fault.\u201d<\/em>
\nAI kan code genereren, workflows versnellen en documentatie doorspitten, maar het neemt geen verantwoordelijkheid over.<\/p>\nTechnologiehypes en wat blijft<\/h3>\n
\nToen ook kwam er een stortvloed aan investeringen en hoewel veel bedrijven verdwenen, bleef de infrastructuur: de netwerken, servers, browsers en standaarden waarop het internet vandaag nog steeds draait.
\n\u201cBubbles come and go,\u201d zei hij, \u201cbut the foundations remain.\u201d
\nHij noemde zeven grote bedrijven die nu de wereld van AI en cloud domineren en sprak over de groeiende energiebehoefte van datacenters, de verschuiving van banen en het ontstaan van nieuwe rollen rondom AI-veiligheid, ethiek en auditing.<\/p>\nVerder dan generatieve AI<\/h3>\n
\nHij sprak over batterijen waarvan we nog niet precies begrijpen waarom ze werken, over landbouw waar sensoren en drones bemesting optimaliseren en over de manier waarop machine learning ons helpt zulke complexe systemen te modelleren.
\nHij benadrukte dat innovatie niet altijd zichtbaar is. \u201cPhones haven\u2019t changed much,\u201d zei hij, \u201cbut what happens behind<\/em> the glass is revolutionary.\u201d
\nHij noemde Apple Vision Pro en Meta\u2019s nieuwe brillen als stappen in de richting van \u201csee-through computing\u201d \u2014 maar gaf toe dat we de echte killer use-case voor kenniswerkers nog moeten vinden.<\/p>\nQuantum en de grenzen van kennis<\/h3>\n
\nHij sprak over IBM\u2019s Quantum Eagle<\/em>, Microsoft\u2019s Majorana<\/em>-processor en de bizarre omstandigheden waarin deze machines functioneren \u2014 gekoeld met helium, zwevend in vacu\u00fcm, trillingsvrij tot op atomaire schaal.
\nHij vergeleek de huidige fase van quantum computing met de begindagen van de transistor.
\n\u201cBack then,\u201d zei hij, \u201cwe didn\u2019t even know what digital meant yet. Now we\u2019re staring at the next revolution \u2014 and just like then, the unreliable will eventually make the reliable.\u201d
\nHij eindigde met een optimistische blik:<\/p>\n![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_143132_d_e_kl.jpg\")
<\/p>\nRelate. Reflect. Respond. – Alice Meredith<\/h2>\n
De menselijke kant van werk<\/h3>\n
\nWe draaien allemaal met een eigen set \u2018apps\u2019: persoonlijkheidstypologie\u00ebn zoals DISC, MBTI, Big Five enneagram en Gallup Strengths. Geen enkele is perfect, maar samen geven ze inzicht in onze kern<\/em>.
\nVolgens Alice bestaat die kern uit vier fundamentele drijfveren:<\/p>\n\n
Relate: de kracht van echt zien<\/h3>\n
\nZe gaf een voorbeeld van haar tijd bij Best Buy, waar ze een interne HR-e-mail herschreef die aanvankelijk formeel en afstandelijk was. In twintig seconden maakte ze de boodschap warmer, persoonlijker, menselijker \u2014 \u201cYou matter\u201d<\/em> in plaats van \u201cYou must.\u201d<\/em><\/p>\nReflect: het bouwen van verbindingen<\/h3>\n
Respond: omgaan met conflicten en verandering<\/h3>\n
\nAlice haalde het Thomas-Kilmann-conflictmodel aan, met vijf stijlen:<\/p>\n\n
Rommelig einde<\/h3>\n
![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_163206_d_e_kl.jpg\")
<\/p>\nWhat\u2019s new in C# 13, 14, and beyond – Bart de Smet<\/h2>\n
\nZoals altijd deed hij dat met zijn kenmerkende combinatie van precisie, snelheid en diepgang.<\/p>\nParams reimagined<\/h3>\n
params<\/code>-functionaliteit eindelijk uit. Waar params<\/code> sinds de begintijd alleen arrays accepteerde, kunnen ze nu ook werken met andere collection types \u2014 denk aan IEnumerable<T><\/code>, IList<T><\/code>, ImmutableArray<T><\/code>, of zelfs custom types die IEnumerable<\/code> implementeren.<\/p>\nLocking: eenvoudiger en veiliger<\/h3>\n
lock<\/code> syntax. In plaats van expliciet te werken met Monitor.Enter<\/code> en Monitor.Exit<\/code>, introduceert C# 13 een veiligere, moderne variant<\/p>\nEscape sequences: een kleine maar fijne update<\/h3>\n
\\e<\/code> (in plaats van het oude \\x1B<\/code>), wat code leesbaarder maakt bij het werken met ANSI-color output of terminal-besturing.<\/p>\nRef en unsafe in iterators<\/h3>\n
yield return<\/code>) kunnen nu werken met ref<\/code> en unsafe<\/code> contexten , zonder onnodige heap-allocaties.
\nHierdoor worden iterators effici\u00ebnter bij performancekritische code, bijvoorbeeld bij Span<T><\/code>-operaties.
\nref struct<\/code> types blijven wel beperkt tot de stack \u2014 ze kunnen dus niet naar de heap of interfaces worden gecast \u2014 maar dankzij nieuwe compilerondersteuning kun je ze nu combineren met IDisposable<\/code> via het allow ref structs<\/code>-attribuut.<\/p>\nPartial members en de
field<\/code> keyword<\/h3>\nfield<\/code> keyword maakt het bovendien eenvoudiger om in properties expliciet naar het backing field te verwijzen: Een elegante oplossing voor wie vaak boilerplate in properties moest schrijven.<\/p>\nOverload resolution attributes<\/h3>\n
[OverloadResolutionPriority]<\/code> attribuut, waarmee library-ontwikkelaars de prioriteit van overloads kunnen sturen \u2014 zonder binary-breaking changes. Vooral nuttig bij API\u2019s die ReadOnlySpan<T><\/code> ondersteunen.<\/p>\nC# 14 \u2013 de volgende stap<\/h3>\n
Extension members<\/h3>\n
\nDat betekent dat je bijvoorbeeld dit kunt doen:<\/p>\nextension StringExtensions on<\/span> string<\/span>\r\n{\r\n int<\/span> WordCount => this<\/span>.Split(' '<\/span>).Length;\r\n}\r\n<\/code><\/pre>\nUser-defined compound assignment<\/h3>\n
+=<\/code> of ++<\/code> in structs. Zo kun je zelf bepalen hoe samengestelde bewerkingen zich gedragen \u2014 een krachtig hulpmiddel voor bijvoorbeeld numerieke types of matrixklassen.<\/p>\nNull-conditional assignment<\/h3>\n
?.<\/code> operator krijgt een zusje: de null-conditional assignment.
\nWaar je vroeger alleen kon lezen met ?.<\/code>, kun je nu ook veilig toewijzen:<\/p>\nperson?.Address<\/span> ??= new Address<\/span>();\r\n<\/code><\/pre>\nBeyond: de horizon van C<\/h3>\n
\nDe focus blijft volgens hem op type safety, performance en expressiviteit \u2014 drie pijlers waar C# al twintig jaar om bekendstaat.<\/p>\n![\"Techorama\"](\"https:\/\/media.qdraw.nl\/log\/techorama-2025\/500\/20251028_175745_d_1_e_kl.jpg\")
<\/p>\nPractical tips for keeping your C# code base clean – Dennis Doomen<\/h2>\n
\nZijn boodschap was duidelijk: \u201cClean code isn\u2019t about writing less code \u2014 it\u2019s about writing code that everyone wants to work with.\u201d<\/em><\/p>\nKeep it simple: fight unnecessary complexity<\/h3>\n
\nDe Gartner Hype Cycle kwam voorbij: technologie\u00ebn worden vaak te vroeg geadopteerd. Dennis moedigde aan om pragmatisch te blijven \u2014 eenvoud boven hype.<\/p>\nOrganiseer de codebase logisch<\/h3>\n
\nDe mapstructuur van je project moet de architectuur weerspiegelen, niet de technologie. Geen \u201cControllers\u201d-, \u201cServices\u201d- en \u201cRepositories\u201d-mappen, maar verticale slices zoals Orders<\/em>, Payments<\/em>, Users<\/em>.<\/p>\ninternal<\/code>) en exposeer alleen interfaces waar nodig. Door conventie en tooling kun je afdwingen dat interne onderdelen niet per ongeluk publiek worden.<\/p>\nGebruik tooling om consistent te blijven<\/h3>\n
\nOok JetBrains Inspect, SonarQube en Roslyn analyzers noemde hij als hulpmiddelen om vroegtijdig problemen te detecteren.<\/p>\nDocument the why<\/em>, not the how<\/em><\/h3>\n
\nDennis pleitte voor korte, doelgerichte commentaren die context toevoegen:<\/p>\nSlimme commit- en branchstrategie\u00ebn<\/h3>\n
\nKies \u00e9\u00e9n bekende branchstrategie \u2014 zoals GitHub Flow of GitFlow \u2014 en houd je eraan.
\nBelangrijker nog:<\/p>\n\n
Reduce dependencies and coupling<\/h3>\n
\nGebruik Central Package Management om versies te beheren en afhankelijkheden te minimaliseren.
\nWanneer code herbruikbaar moet zijn, publiceer het als een NuGet-pakket in plaats van losse binaries.
\nVerder:<\/p>\n\n
Dupliceer liever dan te vroeg te abstraheren<\/h3>\n
\nTe vroege generieke oplossingen leiden tot onnodige complexiteit en onbegrijpelijke code.<\/p>\nRefactoring and scouting rule<\/h3>\n
\nKleine verbeteringen mogen continu gebeuren, mits goed afgescheiden in commits.
\nDennis sloot af met het \u201cScouting Rule\u201d-principe:<\/p>\nSamenvattend<\/h3>\n
\n
Building the Ultimate Safety Net with Integration Tests \u2014 Jimmy Bogard<\/h3>\n
\nBogard haalde de testing pyramid<\/em> erbij om dat punt te illustreren. Unit tests zijn snel en goedkoop, maar vaak te ver verwijderd van het echte proces. UI-tests zijn daarentegen traag en breekbaar. Integration tests \u2014 die het geheel samenbrengen \u2014 zijn trager dan unit tests, maar leveren w\u00e9l de meeste waarde op, juist omdat ze de echte componenten gebruiken.
\nHij liet een eenvoudig voorbeeld zien met een applicatie die queries uitvoert, business-logica afhandelt en data opslaat. In de praktijk zijn de meeste systemen complexer: veel interacties met de database, mocks die verouderen en test suites die vooral vertrouwen vernietigen in plaats van opbouwen. Zijn boodschap was duidelijk: \u201cMocks can lie. Integration tests don\u2019t.\u201d
\nUnit tests kunnen je een vals gevoel van veiligheid geven. Ze zijn vaak te sterk gekoppeld aan implementatiedetails, breken bij refactoring en vangen zelden echte regressies. Bogard pleitte ervoor om minder te \u201cmocken\u201d en meer te testen met echte afhankelijkheden \u2014 zonder externe tools, tenzij het echt niet anders kan.
\nDaarna kwam de live demo. Hij gebruikte een Microsoft.AspNetCore.Mvc.Testing library<\/em> en WebApplicationFactory<\/em> met xUnit. Een simpele HTTP-client maakte in-process calls naar de applicatie, controleerde responses en voerde assertions uit. De test draaide in slechts 282 ms \u2014 volledig end-to-end, zonder mocks.
\nDe volgende stap: integratie met een echte database. Met FastEndpoints<\/em> en Testcontainers<\/em> liet hij zien hoe je PostgreSQL in Docker kunt starten voor elke test, onafhankelijk en schoon. Database-seeding, migraties en configuratie gebeurden automatisch. Door in-memory configuraties te gebruiken in plaats van appsettings.json, bleven de tests licht en flexibel.
\nHij liet zien hoe belangrijk het is om logs direct in de testoutput te tonen, zodat fouten beter traceerbaar zijn. Daarna ging hij verder met meer geavanceerde scenario\u2019s: authenticatie en externe API-calls. In plaats van auth uit te schakelen, introduceerde hij een TestJWT provider<\/em> voor gecontroleerde tokens. Voor externe API\u2019s gebruikte hij fakes<\/em> \u2014 eenvoudige singleton-klassen die de complexiteit laag houden maar de logica realistisch nabootsen.
\nZelfs Razor Pages kwamen voorbij: een test die de HTML-output controleert om te verifi\u00ebren dat de juiste data wordt weergegeven. De kern van zijn verhaal bleef overeind: test het systeem zoals het echt draait.
\nAan het einde sloot hij af met een duidelijke boodschap:<\/p>\n