Het begon als een manier om een database in 3D te bekijken. Inmiddels heeft het de naam JAM-City en kunnen we er met collega’s doorheen lopen, samen het datamodel bespreken én er op kantoor een multiplayer game in spelen. Hoe is dat zo gekomen?

Bij JAM-IT zijn we dagelijks bezig om complexe processen overzichtelijk te maken. Voor onze klanten bouwen we applicaties waarin informatie, processen en gebruikers op een logische manier samenkomen. Maar ook tijdens het ontwikkelen zelf zoeken we voortdurend naar manieren om beter te begrijpen wat er onder de motorkap gebeurt. Soms begint zoiets met een heel praktische vraag. En soms loopt het vervolgens behoorlijk uit de hand. In dit geval begon het met een idee waar Armando al langer mee rondliep:

Wat als je het datamodel van een applicatie niet alleen in een schema kunt bekijken, maar als een 3D-wereld kunt zien?

Dat idee besloot hij te bouwen. Inmiddels kunnen we door het datamodel van applicaties heen lopen, er met meerdere collega’s tegelijk in rondkijken, tabellen aanwijzen en samen de structuur bespreken. Inmiddels is het zelfs mogelijk om een jetpack pakken en er een multiplayer game van maken. Hoe zijn we daar terechtgekomen?

Complexe informatie vraagt soms om een andere manier van kijken

Het idee stond niet helemaal op zichzelf. Binnen verschillende projecten experimenteren we met manieren om complexe structuren visueel inzichtelijk te maken. Bijvoorbeeld door routes en afhankelijkheden binnen vragenlijsten zichtbaar te maken. Je kunt dan letterlijk zien welk antwoord tot welke vervolgvraag leidt en hoe verschillende routes door een proces lopen. Het principe daarachter bleek ook interessant voor een veel technischer vraagstuk: hoe krijg je overzicht in een groot datamodel?

Wat als een database geen diagram is, maar een landschap?

Bij migraties en het werken aan bestaande applicaties wil je goed begrijpen hoe een applicatie is opgebouwd. Neem een datamodel. Een applicatie kan een gebruikerstabel hebben, organisaties, checklists en allerlei andere objecten. Die onderdelen staan niet los van elkaar, maar hebben onderlinge relaties.

Bij een grotere applicatie kan dat uitgroeien tot een model met honderden tabellen. Traditioneel kun je zo’n structuur natuurlijk visualiseren in een diagram. Maar bij JAM-IT liepen we al jaren rond met een ander idee: Wat als we van dat model een 3D-wereld maken? Niet alleen een plaatje waarop je van een afstand naar honderden objecten kijkt, maar een omgeving waar je daadwerkelijk doorheen kunt bewegen, dat werd het startpunt van het experiment.

Op basis van de structuur van het datamodel wordt een visuele omgeving gegenereerd. Tabellen worden afzonderlijke objecten en de relaties ertussen vormen verbindingen door het landschap. Het draait daarbij om de technische structuur en onderlinge relaties, niet om de inhoudelijke data in die tabellen. Daardoor kun je niet alleen zien dát er veel tabellen en relaties zijn, maar het model ook vanuit verschillende perspectieven bekijken. Inmiddels hebben we simulaties gemaakt met modellen van rond de 500 tabellen, waar je zowel in 2D als 3D doorheen kunt navigeren. En toen kwam natuurlijk de volgende vraag.

Als je een wereld bouwt, wil je er ook doorheen kunnen lopen?

Alleen door een 3D-model navigeren was niet genoeg. We wilde er letterlijk in kunnen staan. Dus kwam er een karakter waarmee je door het databaselandschap kunt lopen. Daarmee veranderde ook het technische vraagstuk. Want zodra je een karakter door een virtuele wereld laat bewegen, krijg je ineens met dingen te maken waar we als softwareontwikkelaars normaal gesproken niet dagelijks mee bezig zijn.

Hoe moet zo’n karakter lopen? Hoe voelt een sprong natuurlijk aan? Wat gebeurt er bij het landen? En als we dan toch bezig zijn: hoe zou een jetpack moeten werken? Juist daar werd AI interessant. We gebruikte AI onder andere om kennis en best practices uit game development te onderzoeken. Achter iets ogenschijnlijk eenvoudigs als springen en landen blijken allerlei principes, berekeningen en bewegingsmechanismen te zitten. Met behulp van AI konden we die kennis sneller eigen maken en toepassen binnen onze eigen omgeving. AI werd hier dus niet alleen gebruikt om sneller code te schrijven. Het hielp om kennis uit een ander vakgebied toegankelijk te maken en daarmee verder te experimenteren. En dat experiment was nog niet klaar.

Wat als we samen door dezelfde applicatie kunnen lopen?

Toen je eenmaal zelf door het datamodel kon bewegen, ontstond een nieuwe gedachte.

Wat als we hier met meerdere mensen tegelijk in kunnen staan?

Daarmee werd het idee ineens interessanter voor de serieuze toepassing waarmee het allemaal begon. Stel dat je met collega’s een complex datamodel wilt bespreken. Normaal deel je een scherm en probeer je met je muis een onderdeel van een groot diagram aan te wijzen. Nu kun je dezelfde omgeving betreden. Je loopt samen naar een gedeelte van het model, wijst een specifieke tabel of relatie aan en bespreekt ter plekke hoe dat onderdeel van de applicatie in elkaar zit. Vervolgens loop je vanuit daar verder door de structuur. De database wordt daarmee niet alleen iets waar je naar kijkt, maar een gedeelde omgeving die je samen kunt verkennen en bespreken.

Ook bij het uitleggen van technische concepten zien we interessante mogelijkheden. Voor iemand die net begint met softwareontwikkeling kunnen begrippen als tabellen, objecten en onderlinge relaties behoorlijk abstract zijn. In deze omgeving kun je laten zien hoe zo’n structuur eruitziet en er letterlijk samen doorheen bewegen.

En toen werd het per ongeluk een multiplayer game

Tot dit punt kunnen we nog doen alsof dit allemaal onderdeel was van een zorgvuldig uitgedacht plan. Dat was het niet. Want toen we eenmaal met meerdere mensen tegelijkertijd door een virtuele wereld konden lopen, kwam vanzelf de volgende gedachte:

Kunnen we hier dan ook een spel van maken?

Dus kwam er een game mode. Met verschillende spelmechanismen. Met jetpacks. En ja, ook met wapens waarmee we elkaar kunnen beschieten. Daarmee is een experiment dat ooit begon met:

“Het zou handig zijn als we een database in 3D kunnen bekijken.”

inmiddels geëindigd met collega’s die op kantoor multiplayer door een databaselandschap vliegen. Niet direct de uitkomst die we vooraf op een roadmap hadden kunnen zetten. Maar misschien juist daarom wel een van de leukste onderdelen van het project.

Serieus naar software kijken. En daarna even spelen.

Het bijzondere is dat beide kanten inmiddels naast elkaar bestaan. Aan de ene kant zit er een serieuze gedachte achter. Complexe technische structuren worden op een andere manier zichtbaar en je kunt ze samen verkennen en bespreken. Aan de andere kant kun je na zo’n inhoudelijke discussie overschakelen naar game mode en dezelfde omgeving gebruiken om even met collega’s te spelen.

De game is natuurlijk niet nodig om een database beter te begrijpen. Maar hij laat wel mooi zien wat er kan gebeuren wanneer je een experiment niet direct begrenst tot het oorspronkelijke probleem. Iedere nieuwe stap riep weer een nieuwe vraag op.

“Als we het kunnen visualiseren, kunnen we er dan ook doorheen bewegen?” “Als we erin kunnen lopen, kunnen we dat dan samen doen?” “Als we er samen in staan, kunnen we er dan ook iets leuks mee doen?“

En voordat je het weet heb je een multiplayer game gebouwd bovenop het datamodel van een applicatie.

Soms moet je een idee gewoon gaan bouwen

Het oorspronkelijke doel was niet om een nieuw product te ontwikkelen of een game te bouwen. We wilden onderzoeken of we meer overzicht konden creëren door een abstracte technische structuur ruimtelijk te maken. Onderweg bleek dat idee steeds meer mogelijkheden te krijgen. We kunnen samen door een datamodel bewegen en technische structuren bespreken. We kunnen abstracte concepten op een andere manier zichtbaar maken. En AI hielp ons om tijdens het bouwen kennis uit een vakgebied waar we normaal minder mee werken snel toe te passen.

Er was geen opdrachtgever die om een multiplayeromgeving vroeg. Geen businesscase voor jetpacks. En al helemaal geen requirement waarin stond dat we elkaar tussen databasetabellen moesten kunnen beschieten. Er was vooral nieuwsgierigheid. En doordat we zijn blijven bouwen en iedere keer opnieuw de vraag stelden “wat als dit óók kan?”, staat er nu iets wat we vooraf waarschijnlijk nooit zo hadden bedacht.

Waar het uiteindelijk naartoe gaat? Dat ontdekken we vanzelf. Maar één ding heeft het experiment ons al wel laten zien: soms ontstaat een compleet nieuwe manier van kijken naar software simpelweg door een idee te bouwen en te blijven experimenteren. Complexiteit niet alleen uitleggen, maar ervaarbaar maken. Dat was niet het oorspronkelijke plan. Maar het beschrijft inmiddels verrassend goed wat we hebben gebouwd.