Docs: Translate README to Dutch and add Author Tiëndo Welles

Author: parvenuprompting

README.md

@@ -1,50 +1,50 @@
 # ⚡ High-Performance Streaming Log Analyzer (C++17)
 
-A production-grade, streaming log analysis engine built with modern C++17 and a responsive ImGui frontend. Designed for high throughput, low latency, and zero-copy parsing.
+Een productie-waardige, streaming log analyse engine gebouwd met modern C++17 en een responsieve ImGui frontend. Ontworpen voor hoge doorvoer, lage latency en zero-copy parsing.
 
 ![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)
 ![C++](https://img.shields.io/badge/std-c%2B%2B17-blue.svg)
 ![License](https://img.shields.io/badge/license-MIT-green.svg)
 ![Build Status](https://github.com/parvenuprompting/log-analyzer/actions/workflows/ci.yml/badge.svg)
 
-## 🎯 Project Goals & Philosophy
-This project serves as a **Core Infrastructure Portfolio Piece**, demonstrating:
-*   **Zero-Copy Architecture**: Extensive use of `std::string_view` to minimize heap allocations.
-*   **Streaming Pipeline**: Processes logs line-by-line using `O(1)` memory, regardless of file size (tested with 10GB+ files).
-*   **Modern tooling**: Catch2 v3 for testing, CI/CD via GitHub Actions, and deterministic sorting strategies.
-*   **Dual Frontend**: A headless CLI for scripting and a hardware-accelerated GUI (ImGui) for interactive analysis.
+## 🎯 Project Doelen & Filosofie
+Dit project dient als een **Core Infrastructure Portfolio Piece**, en demonstreert:
+*   **Zero-Copy Architectuur**: Uitgebreid gebruik van `std::string_view` om heap allocaties te minimaliseren.
+*   **Streaming Pipeline**: Verwerkt logs regel-voor-regel met `O(1)` geheugen, ongeacht de bestandsgrootte (getest met 10GB+ bestanden).
+*   **Moderne Tooling**: Catch2 v3 voor testing, CI/CD via GitHub Actions, en deterministische sorteerstrategieën.
+*   **Dual Frontend**: Een headless CLI voor scripting en een hardware-versnelde GUI (ImGui) voor interactieve analyse.
 
-## ✨ Key Features
+## ✨ Belangrijkste Kenmerken
 
 ### Core Engine
-*   **High-Performance Parsing**: Custom `find()`-based parser (no Regex) processing **~2 million lines/sec**.
-*   **Robust Timestamp Handling**: Strict calendar validation (leap years, days-per-month logic) using `std::from_chars`.
-*   **Pluggable Analyzers**: interface-based design allowing easy addition of new metrics.
+*   **High-Performance Parsing**: Custom `find()`-based parser (geen Regex) die **~2 miljoen regels/sec** verwerkt.
+*   **Robuuste Timestamp Afhandeling**: Strikte kalendervalidatie (schrikkeljaren, dagen-per-maand logica) met `std::from_chars`.
+*   **Pluggable Analyzers**: Interface-based ontwerp waarmee eenvoudig nieuwe metrieken toegevoegd kunnen worden.
     *   `LevelCountAnalyzer`
     *   `KeywordHitAnalyzer`
-    *   `TopErrorAnalyzer` (Bounded-space algorithm for "Top N" problems)
+    *   `TopErrorAnalyzer` (Bounded-space algoritme voor "Top N" problemen)
 
-### Modern GUI
-*   **Responsive**: Analysis runs in a background thread, keeping the UI at 60 FPS.
-*   **Interactive**: Sortable tables, real-time progress bar, and cancellation support.
-*   **Visuals**: Custom-drawn charts and "Dark Coral" theme.
-*   **Dependency-Lite**: Custom file picker using C++17 `<filesystem>` (no heavy external libs).
+### Moderne GUI
+*   **Responsief**: Analyse draait in een achtergrond-thread, waardoor de UI op 60 FPS blijft draaien.
+*   **Interactief**: Sorteerbare tabellen, real-time voortgangsbalk en ondersteuning voor annuleren.
+*   **Visuals**: Custom-drawn grafieken en een "Dark Coral" thema.
+*   **Dependency-Lite**: Custom file picker gebruikmakend van C++17 `<filesystem>` (geen zware externe libs).
 
 ## 📊 Performance Benchmark
-Processing a generated log file with **1,000,000 lines** (approx 100MB):
+Verwerking van een gegenereerd logbestand met **1,000,000 regels** (ongeveer 100MB):
 
-| Metric | Result |
+| Metriek | Resultaat |
 |--------|--------|
-| **Execution Time** | **0.52s** |
-| **Throughput** | **~1.92M lines/sec** |
-| **Memory Usage** | **< 10MB** (constant) |
+| **Executietijd** | **0.52s** |
+| **Doorvoer** | **~1.92M regels/sec** |
+| **Geheugengebruik** | **< 10MB** (constant) |
 | **Platform** | macOS M1, Single Thread |
 
-*Benchmark run via `make log_analyzer` on 2026-01-05*
+*Benchmark uitgevoerd via `cmake build` op 2026-01-05*
 
-## 🏗 Architecture
+## 🏗 Architectuur
 
-The system follows a strict **Layered Architecture**:
+Het systeem volgt een strikte **Gelaagde Architectuur**:
 
 ```mermaid
 graph TD
@@ -56,18 +56,18 @@ graph TD
     PIPELINE --> ANALYZERS[Analyzer Collection]
 ```
 
-*   **Core**: Domain types (`LogEntry`, `Timestamp`) and stateless logic.
-*   **IO**: RAII wrappers for file streaming.
-*   **Analysis**: Stateful analyzers implementing `IAnalyzer`.
-*   **App**: Orchestration layer handling errors (`AppResult`, `AppStatus`).
-*   **GUI/CLI**: Thin adapters calling the App layer.
+*   **Core**: Domeintypes (`LogEntry`, `Timestamp`) en stateloze logica.
+*   **IO**: RAII wrappers voor file streaming.
+*   **Analysis**: State-houdende analyzers die `IAnalyzer` implementeren.
+*   **App**: Orchestratie-laag die foutafhandeling beheert (`AppResult`, `AppStatus`).
+*   **GUI/CLI**: Dunne adapters die de App-laag aanroepen.
 
 ## 🚀 Quick Start
 
-### Prerequisites
+### Vereisten
 *   C++17 compliant compiler (Clang/GCC/MSVC)
-*   Make
-*   GLFW (for GUI only): `brew install glfw` (macOS) or `apt-get install libglfw3-dev` (Linux)
+*   CMake (3.14+)
+*   GLFW (alleen voor GUI): `brew install glfw` (macOS) of `apt-get install libglfw3-dev` (Linux)
 
 ### Build & Run
 ```bash
@@ -91,27 +91,28 @@ make
 ctest
 ```
 
-## 🛠 Design Decisions & Trade-offs
+## 🛠 Ontwerpkeuzes & Trade-offs (Design Decisions)
 
 ### 1. `std::string_view` vs `std::string`
-**Decision:** Used `string_view` for all parsing interfaces.
-*   **Pro:** Zero allocation during parsing. A line is read into a reusable buffer, and fields are just pointers into that buffer.
-*   **Con:** Requires careful lifetime management (views are invalid after next line read).
-*   **Mitigation:** `LogEntry` owns its data (deep copy) only when stored for "Top N" aggregation, but statistical analyzers don't need storage.
+**Keuze:** Gebruik van `string_view` voor alle parsing interfaces.
+*   **Pro:** Nul allocaties tijdens parsing. Een regel wordt in een herbruikbare buffer gelezen en velden zijn slechts pointers naar die buffer.
+*   **Con:** Vereist zorgvuldig levensduurbeheer (views zijn ongeldig na het lezen van de volgende regel).
+*   **Mitigatie:** `LogEntry` neemt eigendom over van data (deep copy) alleen wanneer opgeslagen voor "Top N" aggregatie, maar statistische analyzers hebben geen opslag nodig.
 
 ### 2. Custom Parser vs Regex
-**Decision:** Hand-written parser using `find()` and `from_chars`.
-*   **Reason:** Regex is convenient but orders of magnitude slower for simple log formats. `from_chars` (C++17) provides the fastest integer conversion available.
+**Keuze:** Handgeschreven parser met `find()` en `from_chars`.
+*   **Reden:** Regex is handig maar ordes van grootte trager voor eenvoudige logformaten. `from_chars` (C++17) biedt de snelst mogelijke integer conversie.
 
 ### 3. Immediate vs Deferred Sorting
-**Decision:** "Lazy Sorting" for Top Errors.
-*   **Mechanism:** `TopErrorAnalyzer` accumulates counts in a `std::map`. Sorting happens only once at `finalize()`, ensuring `O(N)` insertion and `O(K log K)` final sort (where K is unique error messages, not total lines).
+**Keuze:** "Lazy Sorting" voor Top Errors.
+*   **Mechanisme:** `TopErrorAnalyzer` accumuleert tellingen in een `std::map`. Sorteren gebeurt pas eenmalig bij `finalize()`, wat zorgt voor `O(N)` insertie en `O(K log K)` uiteindelijke sortering (waarbij K unieke foutmeldingen zijn, niet het totaal aantal regels).
 
 ## 🧪 Testing
-The project uses **Catch2 v3** for reliable unit testing:
-*   **Coverage:** 12 Test Cases, 47 Assertions.
-*   **Scope:** Parser edge cases, Timestamp validation, Analyzer determinism, Integration tests.
-*   **CI:** Automated testing on every push via GitHub Actions.
-
-## 👥 Author
-Built as a high-performance C++ portfolio project.
+Het project gebruikt **Catch2 v3** voor betrouwbare unit testing:
+*   **Coverage:** 15 Test Cases, 50+ Assertions.
+*   **Scope:** Parser randgevallen (edge cases), Timestamp validatie, Analyzer determinisme, Integratie tests.
+*   **CI:** Geautomatiseerde testing bij elke push via GitHub Actions.
+
+## 👥 Auteur
+**Tiëndo Welles**
+*High-Performance C++ Portfolio Project*