Roadmap

What I'm working on, what's next, and what I plan to tackle later.

Planned Tactical DDD: Aggregate, Value Object, Domain Event
Planned Strategic DDD: bounded context, context mapping, anti-corruption layer
Planned Repository pattern + Unit of Work
Planned CQRS + MediatR example
Planned MediatR pipeline behavior: validation, logging, transaction
Planned CQRS + event sourcing
Planned Outbox pattern (transactional messaging)
Planned Idempotency-key API design
Planned Vertical slice architecture
Planned Modular monolith vs microservice trade-off
Planned Clean / Hexagonal architecture skeleton repo
Planned Result pattern vs exception
Planned Unit testing: AAA, mocking, testable design
Planned GC: Server vs Workstation, Concurrent GC, csproj settings, DATAS (.NET 8)
Planned Span<T> / Memory<T> / ref struct / stackalloc / ArrayPool<T>
Planned High-performance logging: LoggerMessage source generator
Planned ValueTask vs Task, async state machine pooling
Planned BenchmarkDotNet methodology: mean, allocation, disassembly diagnoser
Planned Object pooling: ObjectPool<T>, RecyclableMemoryStream
Planned readonly struct / in parameter / defensive copy pitfall
Planned Writing a source generator (kill reflection)
Planned Native AOT + trimming
Planned System.Text.Json source generator, Utf8JsonReader
Planned Race conditions: real examples, Interlocked, memory barrier
Planned async/await internals: state machine, ConfigureAwait(false)
Planned System.Threading.Channels: producer/consumer
Planned Deadlock: sync-over-async, .Result / .Wait() pitfall
Planned SemaphoreSlim / ReaderWriterLockSlim / lock-free
Planned Parallel.ForEachAsync, concurrency throttling
Planned .NET memory model: volatile, false sharing
Planned EF Core: configuration, relationships, AsNoTracking, performance
Planned Value converter + column encryption (protected data), Always Encrypted
Planned Compiled queries
Planned Query splitting vs cartesian explosion
Planned Interceptor (SaveChanges / command)
Planned ExecuteUpdate / ExecuteDelete (set-based, .NET 7+)
Planned Global query filter: multi-tenancy / soft delete
Planned Owned types for DDD value object mapping
Planned Zero-downtime migration: idempotent script, production strategy
Planned SSL/TLS, mTLS, Kestrel HTTPS, certificate pinning
Planned Symmetric vs asymmetric keys: when to use which, usage in .NET
Planned Data Protection API: key ring, key rotation, persistence
Planned Resource-based authorization: AuthorizationHandler + IAuthorizationRequirement
Planned Secret management: user-secrets, Azure Key Vault
Planned JWT validation internals, refresh token flow
Planned ASP.NET Core Localization: multi-language with IStringLocalizer
Planned OpenTelemetry: trace + metric + log (three pillars)
Planned System.Diagnostics.Metrics, dotnet-counters / trace / dump
Planned Correlation id + distributed tracing
Planned Structured logging: Serilog enricher
Planned JIT, tiered compilation, ReadyToRun, dynamic PGO
Planned AssemblyLoadContext / plugin loading
Planned Reflection vs source generator vs expression tree performance

Planned Ownership / borrow / lifetimes deep dive
Planned Traits, generics, trait objects: dyn vs impl, associated types
Planned Smart pointers: Box / Rc / Arc / RefCell / Cell, interior mutability
Planned Error handling: Result, ?, thiserror / anyhow, custom errors
Planned Pattern matching, enums, exhaustiveness
Planned Drop / RAII, no-GC memory model
Planned Threads, Send / Sync, Arc<Mutex>, mpsc channels
Planned Data parallelism with rayon
Planned Async: tokio, futures, Pin, Stream
Planned Unsafe Rust: raw pointers, FFI, when / why
Planned Macros: macro_rules!, procedural / derive macros
Planned Zero-cost abstractions, benchmarking with criterion
Planned WASM target
Planned Calling Rust from .NET (C ABI / P-Invoke)
Planned Real project: CLI (clap), parser, network service (axum)

Planned Index internals: B+ tree, covering, composite, column order
Planned Reading execution plans: Postgres EXPLAIN ANALYZE, SQL Server actual plan
Planned Transaction isolation: read committed / repeatable read / serializable / snapshot
Planned MVCC internals (Postgres), vacuum / bloat
Planned Locking: row/page/table, deadlock, lock escalation
Planned WAL (write-ahead log), durability
Planned Partitioning & sharding
Planned Replication: sync/async, read replica, failover
Planned Connection pooling, prepared statements, N+1 detection
Planned MongoDB: document model, aggregation pipeline, indexing, sharding, embedding vs referencing
Planned Redis: cache patterns, data structures, pub/sub, persistence (RDB/AOF), eviction
Planned Time-series: TimescaleDB / InfluxDB - hypertable, continuous aggregate, retention, downsampling
Planned Columnar / OLAP: ClickHouse - analytics workloads
Planned Search: Elasticsearch - inverted index, relevance
Planned Vector DB: pgvector, embeddings (AI link)
Planned CAP, consistency models (strong / eventual / causal)
Planned Caching strategies: cache-aside, write-through, write-behind, invalidation
Planned CDC (change data capture), Debezium
Planned Polyglot persistence: picking the right DB
Planned Zero-downtime migration, schema change at scale

Planned Process / thread / signal, /proc
Planned Virtual memory, paging, OOM killer
Planned Networking: TCP/IP, sockets, ss, iptables
Planned Performance tooling: strace, perf, vmstat, iostat
Planned cgroups + namespaces (the basis of containers)
Planned systemd, journald
Planned Docker: images, layers, multi-stage build, volumes, networking
Planned Image optimization: distroless, security scanning
Planned Docker Compose
Planned Architecture: control plane, kubelet, etcd, scheduler
Planned Pod / Deployment / StatefulSet / DaemonSet
Planned Service / Ingress / CNI networking
Planned ConfigMap / Secret, resource requests/limits, QoS
Planned Autoscaling: HPA / VPA / cluster autoscaler (scale up/down)
Planned Liveness / readiness probes
Planned Storage: PV / PVC / StorageClass
Planned Helm / Kustomize
Planned RBAC, security context, network policy
Planned Rollout: rolling / blue-green / canary
Planned Observability: Prometheus + Grafana, logging stack
Planned Horizontal vs vertical scaling, scale-down / cost strategy
Planned Load balancing: L4 vs L7, algorithms
Planned Message queues: Kafka / RabbitMQ - when to use which
Planned Rate limiting, backpressure, circuit breaker
Planned Distributed consensus: Raft / Paxos (concept)
Planned Design for failure: retry, timeout, bulkhead, idempotency
Planned CDN, API gateway, service discovery
Planned Terraform (infra as code)
Planned GitOps: ArgoCD / Flux