Samenvatting

Met deze code uitlegger zet je een codefragment om in een duidelijk Nederlands overzicht: de programmeertaal, elke functie en wat de naam suggereert, een complexiteitsscore, en waarschuwingen zoals lege catch-blokken, eval-aanroepen en hardcoded secrets. Het is een regel-gebaseerde lezer, geen taalmodel, dus het beschrijft structuur in plaats van intentie. Complexiteit volgt McCabes maat, waarbij 10 of minder per functie de aanbevolen limiet is. De analyse draait in je browser en je code wordt nooit ergens heen verzonden.

Code uitleggen: plak je code, krijg een duidelijk overzicht

Code uitleggen gaat snel: plak een functie of bestand in je browser en dit tool geeft je terug welke taal het is, welke functies het bevat, hoe complex het is, en waar de risico's zitten. De analyse draait volledig in je browser—je code wordt nooit ergens heen verzonden.

Leg mijn code uit
Ingenieur leest onbekende code op een monitor met een schetsnotitie van functiediagrammen naast het toetsenbord

Code uitlegger

Plak een functie of kort bestand. Het overzicht wordt bijgewerkt terwijl je typt. Niets verlaat je browser.

Walkthrough

    Things to check

      Het overzicht lezen

      Hoe je het overzicht gebruikt

      1. 1

        Plak het fragment

        Eén functie of één bestand werkt het beste. Plak meer dan een paar honderd regels en het overzicht wordt een lijst in plaats van een samenvatting.

      2. 2

        Lees de inleiding

        Daarin staan de programmeertaal, aantal functies en complexiteitsscore. Een score boven 10 betekent dat de code te veel verschillende paden heeft om tegelijk vast te houden.

      3. 3

        Lees de rondleiding

        Elke functie krijgt één regel: wat de naam suggereert, hoe lang het is, hoeveel paden het heeft, en of het loopt, wacht of fouten verwerkt.

      4. 4

        Open eerst de rode vlaggen

        Als de tool een lege foutafhandeling of een string die op inloggegevens lijkt vermeldt, begin daar. Dit zijn de regels die je later het meest kunnen opbreken.

      Hoe het werkt

      Wat de uitlegger werkelijk meet

      Structuur uit syntaxis

      Het verwijdert opmerkingen en strings en zoekt dan naar functiedefinities, imports, klassen, lussen en takken voor de gedetecteerde taal. Geen gissingen over wat de code doet, alleen wat het bevat.

      Complexiteit die je kunt verifiëren

      De score is cyclomatic complexiteit: één plus elke if, lus, case, catch en boolean operator. Dit is dezelfde telling die een linter geeft, en het NIST structured testing rapport stelt voor om een functie op 10 of minder te houden.

      Rode vlaggen die echte bugs wijzen

      Eval of exec aanroepen, lege catch blokken, geharde secrets, TODO-notities, nesting voorbij vier niveaus en functies over 40 regels. Elke regel bestaat omdat het naar code wijst die gemakkelijk verkeerd kan worden gelezen.

      Waar het stopt

      Een fragment-uitlegger antwoordt op 'wat zit hier in', niet 'waarom zit dit hier'

      De vraag die een junior ingenieur stelt is zelden 'wat doet deze lus'. Het is 'waarom roept de facturatie-service deze functie aan, en wie is er nog meer van afhankelijk'. Een geplakt fragment kan dat niet beantwoorden, omdat het antwoord in andere bestanden zit. Deze tool is gebouwd voor de eerste stap: je hebt een functie open, je hebt vijf minuten, en je wilt weten of het een tien-regel helper is of een wirwar met zes exit-paden. Het geeft je dat in een seconde en vertelt je waar het risico zit. Voor de tweede vraag heb je zoeken in de hele repository nodig. Dat is de kloof tussen één functie lezen en begrijpen hoe een systeem is bedraad, en daar gaat het meeste onboarding-tijd heen.

      • Gebruik het op een enkele functie of bestand, niet op een hele service
      • Behandel de rode vlaggen als aanleiding om dieper te kijken, niet als bevindingen
      • Schakel over naar zoeken in het hele repo wanneer de vraag over aanroepers en afhankelijkheden gaat
      Twee ingenieurs bij een laptop, één wijst naar een regel broncode terwijl de ander meekijkt

      Vragen over de code uitlegger

      Is deze code uitlegger gratis en verlaat mijn code mijn browser?
      Het is gratis en vereist geen aanmelden. De analyse draait volledig in je browser met gewone JavaScript. Je fragment wordt nooit naar een server verzonden, dus je kunt interne code plakken zonder veiligheidscontrole. Het enige dat wordt opgenomen is een anonieme telling dat de tool werd gebruikt.
      Is dit een AI-model dat mijn code begrijpt?
      Nee. Het is een regel-gebaseerde lezer. Het detecteert de taal, vindt functies, imports, takken, lussen en foutafhandeling, en beschrijft ze met behulp van de namen en structuur die het ziet. Dit maakt het snel en voorspelbaar, maar het kan geen intentie kennen. Als een functie 'process()' heet en iets verrassends doet, weet de tool dat niet.
      Hoe wordt de complexiteitsscore berekend?
      Het telt beslissingspunten (if, elif, for, while, case, catch of except, boolean and/of operators, ternaries) en telt er één bij op. Dit is de cyclomatic complexiteit maat die McCabe in 1976 voorstelde. Een score van 10 of minder is de limiet die het NIST structured testing rapport aanbeveelt voor een enkele functie.
      Welke talen ondersteunt het?
      Python, JavaScript, TypeScript, Java, Go en Rust. Auto-detect kijkt naar trefwoorden en syntaxis. Als het op een kort fragment fout raadt, kies je de taal uit het dropdown-menu. Andere C-stijl talen werken vaak, maar functiedetectie is minder betrouwbaar.
      Waarom markeert het dingen als lege catch-blokken en TODO-opmerkingen?
      Dit zijn de plekken waar een lezer zich later het meest verbaast. Een lege catch verbergt fouten, een TODO markeert een bekende leemte, en een lange of diep geneste functie is moeilijk te testen. De rode vlaggen zijn aanleiding om dieper te kijken, geen vonnissen.
      Wat is het verschil tussen dit en vragen stellen aan een AI-chat over mijn code?
      Een chat-model kan over intentie redeneren, maar alleen over wat je plakt. Deze tool toont structuur in seconden zonder model-betrokken. Geen van beide weet hoe het fragment zich tot je hele repo verhoudt. Daarvoor heb je een tool nodig die de hele codebase heeft geïndexeerd.
      Kan ik het gebruiken om een pull request te reviewen?
      Ja. Kies de reviewer-optie en plak de gewijzigde functie. Je krijgt een checklist met takken, foutafhandeling en rode vlaggen, die je vertelt waar je aandacht het best besteed is voordat je het volledige diff opent.

      Begrijp de hele repo, niet alleen één fragment

      codebasechat beantwoordt vragen over je codebase in het Nederlands, met de bestanden en aanroepsites die elk antwoord ondersteunen.

      Probeer codebasechat gratis