Monetra

In de meeste software is "dicht genoeg" prima. Als een knop één pixel verschoven is, verliest niemand zijn baan. In financiën kan "dicht genoeg" duur worden.

Monetra bestaat om één reden: om financiële correctheid de standaard te maken, niet een best effort.

Wanneer geld door software beweegt, moeten drie dingen waar blijven:

1. De wiskunde moet exact zijn.
2. De regels moeten expliciet zijn.
3. De geschiedenis moet verdedigbaar zijn.

Als een daarvan faalt, krijg je het soort bugs dat niet verschijnt als een crash. Ze verschijnen als een boekhoudkundig verschil, een reconciliatienachtmerrie, of een klantenservice-escalatie.

Ik bouwde Monetra omdat veel systemen geld nog steeds als een gewoon getal behandelen. Gewone getallen zijn prima voor pixels, fysica en animatie. Ze zijn een slechte match voor centen.

Monetra is een nauwkeurig financieel systeem voor TypeScript. Het geeft engineers een veiliger set bouwstenen, en het geeft niet-technische stakeholders iets dat ze kunnen vertrouwen: een ontwerp dat het moeilijk maakt om het verkeerde te doen en gemakkelijk om te bewijzen dat je het juiste deed.

Het Probleem Dat Monetra Oplost (In Gewone Taal)

Computers zijn uitstekend in het tellen van hele dingen. Ze zijn niet van nature goed in het representeren van veel decimale breuken.

Daarom kan, in veel talen, een simpele expressie als 0.1 + 0.2 het resultaat 0.30000000000000004 opleveren. Die extra staart is klein, maar echt. Stel je nu voor dat je totalen, belastingen, kortingen, tijdsevenredige verdeling, kosten, terugbetalingen, chargebacks en buitenlandse wisselkoersen berekent over miljoenen transacties. Kleine fouten blijven niet klein.

Financiële systemen hebben een andere lat. Als je systeem zegt dat een klant $100,00 heeft betaald, moet het grootboek het eens zijn. De factuur moet het eens zijn. Het belastingrapport moet het eens zijn. De bankuitbetaling moet het eens zijn. En zes maanden later moet je nog steeds precies kunnen uitleggen hoe het getal tot stand kwam.

Monetra lost dit op door geld zich als geld te laten gedragen. Ik stel waarden voor in hun kleinste eenheid (zoals centen), pas expliciete regels toe voor elke ambigue bewerking (zoals splitsen), en leg beslissingen vast op een manier die later geverifieerd kan worden.

Wat Monetra Is (En Wat Het Niet Is)

Monetra is een financieel fundament. Het is ontworpen om ingebed te worden in producten die geld verplaatsen, opslaan of rapporteren.

Het is bewust niet:

• Een betalingsverwerker
• Een valuta-omzettingsdienst
• Een vervanging voor je boekhoudplatform

In plaats daarvan is het het stuk dat je onder die systemen plaatst om te voorkomen dat precisieproblemen in al het andere lekken.

De Monetra-Stack

Om het systeem zowel veilig als praktisch te houden, is Monetra gebouwd als een drielaagse stack. Je kunt het zien als een betrouwbaar voertuig: de motor moet nauwkeurig zijn, de bediening moet voorspelbaar zijn, en het dashboard moet de waarheid vertellen.

Laag 1 - Het Fundament (Nauwkeurigheid)

Deze laag beantwoordt een simpele vraag: wanneer de software zegt "$1.00", is het dan werkelijk één dollar?

Kernideeën:

• Kleinste eenheid opslag: Geld wordt opgeslagen als de kleinste eenheid (centen, pennies, satoshi's of aangepaste eenheden). Dit vermijdt de hele categorie van decimale afrondingsdrift.
• Onveranderlijkheid: Eenmaal gecreëerd, verandert een geldwaarde niet. Bewerkingen produceren nieuwe waarden. Dat klinkt academisch totdat je een productieprobleem moet debuggen en beseft dat een muteerbaar object op drie verschillende plekken is gewijzigd.
• Valutabewustzijn: "10" is betekenisloos zonder context. 10 USD is niet 10 EUR. Monetra maakt valuta expliciet zodat per ongeluk mengen veel moeilijker wordt.

Waarom het ertoe doet (niet-technisch):

• Totalen veranderen niet op mysterieuze wijze.
• Rapporten komen overeen met facturen.
• Je kunt vertrouwen dat het getal op het scherm het getal is dat in het systeem is opgeslagen.

Waarom het ertoe doet (engineers):

• Deterministische rekenkunde.
• Minder edge cases waar "bijna gelijk" een bug wordt.
• Een kleiner oppervlak voor precisiegerelateerde regressies.

Laag 2 - De Logica (Financiële Bewerkingen)

Zodra geld veilig is, kun je er echt werk mee doen.

Deze laag richt zich op financiële bewerkingen die teams typisch opnieuw bouwen of in spreadsheets onderhouden:

• Leningen en betalingen: Voorspelbare maandelijkse betalingsberekeningen en schema's.
• Waarde over tijd: Concepten zoals de Tijdswaarde van Geld, waarbij $100 vandaag niet gelijk is aan $100 volgend jaar.
• Afschrijving van activa: Standaardmethoden om te modelleren hoe een actief waarde verliest.

Dit is de laag die Monetra transformeert van "veilige wiskunde" naar "bruikbare financiële engineering".

Laag 3 - De Audit (Vertrouwen en Verificatie)

Financiën vereisen niet alleen correcte getallen. Ze vereisen verklaarbare getallen.

Deze laag richt zich op controleerbaarheid:

• Grootboek: Een gestructureerd overzicht van geldbewegingen. Elke betaling, terugbetaling, vergoeding of overdracht wordt een traceerbare vermelding.
• Manipulatiebestendigheid: Records kunnen worden verzegeld met cryptografische hashing. Als iemand het verleden probeert te herschrijven, verifieert de keten niet meer.

Waarom het ertoe doet (niet-technisch):

• Je kunt "waar ging het geld naartoe?" met vertrouwen beantwoorden.
• Je kunt manipulatie detecteren in plaats van hopen dat het nooit gebeurt.

Waarom het ertoe doet (engineers):

• Integriteitscontroles worden een eersteklas gereedschap.
• Je kunt systemen ontwerpen die niet afhankelijk zijn van blind vertrouwen tussen diensten.

Engineeringproces: Hoe Monetra Werd Gebouwd

Monetra is niet per ongeluk gebouwd. Het is gebouwd door dezelfde discipline toe te passen die ik gebruik bij het werken met AI-tooling: diepe context, strikte regels en een weigering om ambiguïteit te shippen.

1) Definieer de niet-onderhandelbaren

Voordat ik code schreef, schreef ik op wat altijd waar moet zijn:

• Een cent kan niet worden gecreëerd of vernietigd.
• Elke bewerking met ambiguïteit moet expliciet zijn.
• Het systeem moet deterministisch zijn over alle omgevingen.
• Auditing moet mogelijk zijn zonder speciaal gereedschap.

Die beperkingen zijn aanvankelijk ongemakkelijk. Ze redden je ook later.

2) Kies saaie, stabiele primitieven

Monetra geeft prioriteit aan stabiliteit en portabiliteit:

• Het is geschreven in TypeScript.
• Het is ontworpen om te draaien in Node.js, browsers en edge runtimes.
• Het houdt afhankelijkheden tot een minimum.

Dit is een bewuste afweging. In financiën is betrouwbaarheid een feature.

3) Maak afwegingen expliciet

Elk serieus systeem heeft afwegingen. Het verschil is of je ze erkent.

Hier zijn er een paar die Monetra vormden:

Explicietheid vs gemak

De meeste bibliotheken proberen te raden wat je bedoelt. Monetra weigert te raden. Als je geld verdeelt en er is een rest, vereist het systeem dat je kiest hoe af te ronden.

• Gemakskosten: ontwikkelaars schrijven iets meer code.
• Veiligheidswinst: afrondingsbeslissingen zijn opzettelijk en controleerbaar.

Onveranderlijkheid vs ruwe snelheid

Muteerbare objecten kunnen sneller zijn in microbenchmarks. Onveranderlijke objecten zijn gemakkelijker om over te redeneren.

• Snelheidskosten: meer objectcreatie.
• Veiligheidswinst: minder "wie heeft deze waarde veranderd?"-mysteries.

Controleerbaarheid vs opslag

Het vastleggen van meer detail kost ruimte.

• Opslagkosten: grotere records.
• Veiligheidswinst: een systeem dat je onder controle kunt verdedigen.

4) Test tegen edge cases

Financiële bugs zijn meestal edge cases. Monetra gebruikt meerdere lagen van testing om de val te vermijden van alleen happy paths testen.

• Voorbeeld-gebaseerde tests: de traditionele "gegeven X, verwacht Y"-aanpak.
• Eigenschap-gebaseerde tests: het systeem wordt geoefend met brede reeksen waarden om regels te valideren zoals "optellen en dan aftrekken brengt je terug naar de oorspronkelijke waarde".
• Mutatietesting: de code wordt opzettelijk gemuteerd om te garanderen dat de tests falen om de juiste redenen.

Dit gaat niet om ijdelheidsmetrieken. Het gaat om het verdienen van vertrouwen.

Obstakels Die Ik Tegenkwam (En Hoe Ik Erdoor Werkte)

Elk project dat geld aanraakt, raakt dezelfde muur: complexiteit die klein lijkt totdat het productie is.

Monetra hield stand omdat de aanpak niet "snel bewegen en later repareren" was. Het was "bewust bewegen zodat later geen crisis wordt".

Obstakel: Geld eerlijk verdelen

Verdelen is bedrieglijk moeilijk. Mensen accepteren dat $10 in drieën gedeeld niet perfect gelijk kan zijn. Computers, als ze aan hun standaardinstellingen worden overgelaten, lekken precisie of verliezen stilletjes resten.

Wat ik deed:

• Ik bouwde toewijzingsalgoritmen die behoud van waarde garanderen.
• Ik dwong selectie van afrondingsstrategie af zodat de regel niet verborgen is.

Resultaat:

• Behoud van waarde wordt afgedwongen.
• Resten worden expliciet afgehandeld.
• De beslissing is controleerbaar.

Obstakel: Gemengde valuta's en het "MoneyBag"-probleem

Teams willen vaak een enkel "totaal" over valuta's heen. Dat totaal is niet zinvol tenzij conversieregels zijn gedefinieerd.

Wat ik deed:

• Ik introduceerde het idee van een "MoneyBag" - een veilige container die USD, EUR, GBP of aangepaste tokens kan bevatten zonder vroegtijdige conversie.

Resultaat:

• Je kunt veilig over valuta's heen accumuleren.
• Conversie wordt een expliciete grens waar bedrijfsregels kunnen worden toegepast.

Obstakel: Correctheid uitleggen, niet alleen claimen

Zeggen "het is nauwkeurig" is gemakkelijk. Het bewijzen is moeilijker.

Wat ik deed:

• Ik bouwde verificatie in de filosofie en de toolchain in.
• Ik gebruikte tests die grote ruimtes van inputs verkennen.
• Ik ontwierp het grootboek om manipulatiebestendig te zijn.

Resultaat:

• Correctheid is een eigenschap van het systeem, niet een marketinguitspraak.

Obstakel: Bouwen zonder op te branden

Er is een specifieke psychologische val bij het bouwen van financiële tooling: hoe dieper je gaat, hoe meer edge cases je ontdekt. Het kan oneindig voelen.

De weg erdoor is proces:

• Definieer wat in scope is.
• Bouw het volledig.
• Test het agressief.
• Ship het.
• Itereer.

Monetra is een product van die discipline.

Waar Monetra Past (Echte Gebruikscases)

Monetra is gebouwd voor omgevingen waar precisie en verantwoording niet optioneel zijn.

E-commerce en abonnementen

• Totalen met kortingen en belastingen
• Tijdsevenredige berekening voor upgrades, downgrades en terugbetalingen
• Kostenberekeningen die moeten overeenkomen met factuurdetails

Fintech en interne boekhouding

• Grootboek-gebaseerde verplaatsing van geld tussen rekeningen
• Reconciliatieworkflows waar getallen over systemen heen moeten kloppen
• Audittrails die controle kunnen doorstaan

Crypto- en tokensystemen

• Tokens met hoge precisie (veel decimalen)
• Multi-asset wallets en interne boekhouding
• Deterministische rekenkunde die niet kan afdrijven

Voor Engineers (Zonder Er een Handleiding Van Te Maken)

Monetra is ontworpen zodat je simpel kunt beginnen en diep kunt gaan wanneer nodig.

Het mentale model is:

• Geldwaarden zijn nauwkeurig en onveranderlijk.
• Valuta's zijn expliciet.
• Elke ambigue bewerking vereist een expliciet beleid.
• Grootboekvermeldingen kunnen worden geverifieerd.

Als je ermee bouwt, verwacht dat de bibliotheek terugduwt wanneer je iets onveiligs probeert. Dat is een feature.

Afrondingsmodi bestaan omdat echte financiën verschillende regels gebruiken in verschillende contexten. Monetra ondersteunt meerdere strategieën, waaronder:

• Half omhoog
• Half omlaag
• Half even (bankiersafronding)
• Vloer
• Plafond
• Afkappen

Het belangrijke deel is niet de namen. Het belangrijke deel is dat de keuze niet verborgen is.

Toekomstige Roadmap

Monetra beweegt van "een sterk TypeScript-fundament" naar "een cross-language financieel fundament".

• Python-bibliotheek met volledige pariteit: Een eersteklas Python-implementatie met dezelfde kernconcepten en veiligheidsgaranties. Dit is belangrijk voor data science, analytische pipelines en backend-diensten die dezelfde financiële regels moeten delen.
• Andere taalframeworks: Na verloop van tijd wil ik dezelfde systeemniveau-strengheid beschikbaar maken in andere ecosystemen, zodat productteams niet in taalspecifieke compromissen worden gedwongen.
• Belastingmodules: Plug-and-play modules voor belastingregels. Het doel is om belastingafhandeling expliciet, testbaar en onderhoudbaar te maken in plaats van verspreid over applicatiecode.
• Gemiddeld tot geavanceerde financiële wiskunde: Voorbij basisleningen plan ik uit te breiden naar investerings- en analysetools (bijvoorbeeld NPV, IRR en andere industriestandaardmodellen) met dezelfde nadruk op correctheid en expliciete aannames.

Veelgestelde Vragen

Monetra transformeert een van de hoogste-risico onderdelen van een financiële applicatie - de wiskunde - in een van de meest betrouwbare.