• ✨ Restructured original NXP drivers for better modularity
• 📚 Enhanced documentation and code readability
• 🎯 Implemented clean API design for peripheral access
• 🔧 Used in teaching materials for Digital Electronics 3

📊 Real-time Network Monitoring The simulator provides a detailed dashboard of the network state, tracking performance metrics across layers:

• ⚡ Modern C++20 Engine: Leverages Concepts, Ranges, and Smart Pointers for a memory-safe, type-secure simulation core.
• 🧠 Dynamic Routing: Implements a custom Dijkstra-based engine that recalculates optimal paths in real-time based on network load and topology changes.
• 📦 Packet Reassembly Logic: Sophisticated handling of multi-packet pages with unique {Source IP, Page ID} identification and timeout management.
• 📊 Observability: Features a decoupled architecture currently being extended to support Prometheus metric exporting and real-time Grafana dashboards.
• 🛠️ Robust Engineering: Zero-warning build (Clang-Tidy/Cppcheck) with automated CI/CD for style and static analysis.
• 🗺️ Roadmap & Future Enhancements: The architecture is designed to be extensible. Current development goals include:
  • 📈 Full Observability Suite: Integration with Prometheus (Textfile Collector) and Grafana for advanced time-series analysis.
  • ⚙️ External Configuration: Moving from hardcoded parameters to JSON-based configuration for dynamic simulation setups.
  • 🧵 Multithreading Engine: Parallelizing router processing logic to handle massive network topologies (1000+ nodes).
  • 🎨 Interactive UI: Transitioning from CLI to a graphical interface using Dear ImGui or SFML.

• 🧠 The "Systems to Backend" Transition. This repository represents a strategic evolution from low-level C++ systems programming to a scalable Java-based architecture. Key improvements include:
  • Type Safety & Generics: Elimination of manual casting through a decoupled NetworkNode<T extends Stats> hierarchy.
  • Functional Telemetry: Using Java Streams and Map-Reduce patterns for real-time statistics aggregation.
  • Immutable Data Carriers: Extensive use of Java Records for thread-safe state snapshots.
• 🛠️ Tech Stack
  • Language: Java 21 (LTS)
  • Build System: Gradle (Kotlin DSL - build.gradle.kts)
  • Testing: JUnit 5 (Jupiter) & AssertJ
  • Quality: Google Java Style Guide via Checkstyle
  • CI/CD: GitHub Actions for automated verification
• 🚀 Key Features
  • Dynamic Dijkstra Routing: Real-time routing table recalculation based on network load and buffer congestion.
  • Packet Reassembly Logic: Sophisticated tracking of multi-packet Page objects with unique {Source IP, Page ID} identification and timeout/quarantine management.
  • Fluent Builder Pattern: A specialized NetworkStats.Builder for incremental, error-resistant accumulation of global metrics.
• 🧪 Testing & Reliability. The project maintains high standards of reliability with a comprehensive JUnit 5 test suite:
  • Unit Testing: Individual logic verification for Dijkstra edge cases (isolated nodes, 1-node networks).
  • Integration Testing: Full-cycle simulation tests verifying that packetsSent at source equals packetsReceived + packetsDropped + packetsTimedOut.
  • Property Validation: Record-level validation using compact constructors to ensure network invariants.
• 🗺️ Backend Roadmap. I am evolving this simulator into a professional Backend showcase:
  • Spring Boot REST API: Expose simulation control and stats via HTTP endpoints.
  • Persistence (JPA/Hibernate): Store simulation history in PostgreSQL.
  • Observability: Integration with Prometheus and Grafana for real-time monitoring.
  • Concurrency: Implementation of Java 21 Virtual Threads to scale to 100k+ nodes.

• 🏗️ Architectural Decoupling. The system is strictly divided into three specialized domains to ensure maintainability:
  • Logic Engine: Pure mathematical representation of the Petri Net (Incidence matrices, firing rules, and marking invariants).
  • Layout Engine: Orthogonal (Manhattan) and curved path routing for clear visualization of complex topologies.
  • Workspace Manager: A "Master Config" system that allows switching between different models (Producer-Consumer, Dining Philosophers, Resource Allocation) via JSON injection.
• 🚀 Advanced Java 21 Features
  • Domain Modeling with Records: Extensive use of deeply nested Java Records to handle immutable configuration states (Layouts, Waypoints, and Petri Logic).
  • Functional Pipelines: Leveraging Java Streams and Optionals for robust configuration loading and error handling.
  • Modern JavaFX UI: Custom rendering engine that uses PathTransition and ParallelTransition to animate tokens across multi-segment paths.
• 🛠️ Key Technical Milestones
  • Flexible JSON Configuration: Moving from hardcoded parameters to a fully externalized JSON system, enabling "hot-swapping" of network models.
  • Concurrency & Events: Event-driven communication between the simulation relay and the UI layer to ensure smooth animations without blocking the engine's logic.
• 🗺️ Roadmap & Evolution
  • Observability Suite: Integration with Prometheus and Grafana to monitor transition firing rates and place congestion in real-time.
  • Persistence Layer: Implementation of SQLite to log simulation history and enable "Time-Travel" debugging/replay.
  • Interactive Designer: Transitioning from JSON-only setups to a Drag & Drop GUI for real-time Petri Net modeling.

• 📈 Collects system metrics from /proc filesystem
• 🔍 Integrates Prometheus for metrics storage
• 📊 Creates Grafana dashboards for visualization
• ⚡ Demonstrates understanding of Linux internals and monitoring best practices

• 🎓 Hands-on exercises for LPC1769 microcontroller
• 📝 Comprehensive documentation and learning materials
• 🔨 Practical examples of peripheral usage (GPIO, timers, UART, etc.)

• 🖥️ Built from scratch in C
• ⚙️ Process creation and management
• 🔀 Pipeline and redirection support