How romanbulgac/tsp works
Project Type and Purpose
• This is a full‐stack Clean Architecture application for solving the Traveling Salesman Problem (TSP) using a pluggable Genetic Algorithm engine.
• Frontend: Blazor WebAssembly (TspLab.Web).
• Backend/API: ASP.NET Core 8 minimal API with SignalR (TspLab.WebApi).
• Core logic: Domain, Application, Infrastructure layers.
• Testing: Unit tests and performance benchmarks (TspLab.Tests).
• Containerization and CI/CD: Docker / Docker Compose, GitHub Actions.
File Structure Analysis
• Top-level projects correspond to Clean Architecture layers:
• TspLab.Domain: Entities (City, Tour), interfaces (ICrossover, IMutation, IFitnessFunction), config/result models.
• TspLab.Application: Services (GeneticEngine, TspSolverService, StrategyResolver), use-case models.
• TspLab.Infrastructure: Implementations of crossover, mutation, fitness. DI extension.
• TspLab.WebApi: HTTP endpoints, SignalR hub (TspHub), minimal API setup, static Blazor assets.
• TspLab.Web: Blazor UI pages, API/SignalR clients, static assets (Chart.js visualization).
• TspLab.Tests: Unit tests and BenchmarkDotNet benchmarks.
• Build & deploy: Dockerfile, docker‐compose.yml, GitHub Actions workflow, nginx.conf.
Key Architectural Patterns
• Clean Architecture (six layers).
• Dependency Injection resolves strategy implementations.
• Real-time streaming via SignalR.
• Blazor WASM served by WebApi static hosting.
• Multi‐threaded fitness evaluation in GeneticEngine.
• Web Client (Blazor WASM)
• API Server (ASP.NET Core minimal API + SignalR Hub)
• Application Layer (Business logic)
• Domain Layer (Entities & Interfaces)
• Infrastructure Layer (Crossover/Mutation/Fitness)
• External Libraries/Services (Chart.js, Tailwind CSS)
• Web Client → HTTP API (GET /api/…, POST /solve)
• Web Client ↔ SignalR Hub (real-time progress)
• API Server → Application Layer (invoke use cases)
• Application → Infrastructure (strategy resolution & algorithm operations)
• Application → Domain (entities & config models)
• Infrastructure → Domain (consume City/Tour entities)
• Tests → All layers (unit & benchmark calls)
c. Architectural Patterns & Principles:
• Layered separation: no direct Web → Domain see DI flows.
• Pluggable strategies via interfaces and DI container.
• Single responsibility per project.
• Bounded contexts: Domain vs Application vs Infrastructure.
d. Technologies & Libraries:
• ASP.NET Core 8 minimal APIs, SignalR
• Blazor WebAssembly, Chart.js, Tailwind CSS
• BenchmarkDotNet, Docker, GitHub Actions
Essential Details to Capture
• Clean Architecture layering
• Frontend ↔ Backend communication channels (HTTP vs SignalR)
• DI strategy resolution path (Application → Infrastructure)
• Real-time visualization (Chart.js) served by WebApi static assets
• Benchmarking module as an orthogonal slice