DevCraft Labv1.0
Monorepo
DevCraft Lab — Polyglot Monorepo

From Enterprise Java to Modern Fullstack Mastery.

DevCraft Lab bridges the gap for 5-year Java veterans transitioning into cutting-edge distributed systems: Combining Java 21 Project Loom, high-concurrency Go 1.23 engines, and modern Next.js 15 Server Components on GCP Cloud Run.

Live Concurrency Telemetry LabExplore ArchitectureCompetency Roadmap
Java 21 Loom
1,000,000
Virtual Threads / Instance
Go Coroutines
< 5 ms
Cold boot & telemetry speed
Next.js 15 RSC
0 kB
Client JS for static views
GCP Cloud Run
Scale to 0
True serverless economics
Dual-Engine Distributed Architecture

How The Services Interlock

Select a tier to inspect technical capabilities, runtime characteristics, and architectural comparisons for senior engineers.

Sync Mode: Asynchronous RPC & SSE

Next.js 15 Web & Edge

React 19 / App Router

Server Components (RSC) rendering dynamic UI at the edge with zero client bundle overhead for static views.

Core Responsibilities

  • SSR & Streaming with React Suspense
  • Route Handlers as Backend-For-Frontend (BFF)
  • Dynamic client hydration and state management
Java 5-Yr Veteran Perspective

Replaces legacy JSP / Thymeleaf & heavy client-only SPAs with hybrid server-driven rendering.

Runtime Specs

RenderingHybrid Server/Client
StylingTailwind CSS v3
ProtocolHTTP/3 & Fetch Cache
Deployment Target
GCP Cloud Run Serverless
Live Concurrency Telemetry Lab

Java 21 Loom vs Go 1.23 vs Platform Pool

Interactive benchmark simulation testing massive parallel I/O blocking. Compare user-mode fibers, kernel threads, and work-stealing schedulers side-by-side.

Quick Workload Presets
1,000req
1002,5005,000 tasks
50ms
20ms100ms200ms sleep
50threads
1050100 OS pool
Project Loom & Goroutines Throughput Advantage14.8x Faster than Platform Pool

Tested at 1,000 tasks with 50ms I/O blocking against a 50-thread OS pool.

Project Loom
Edge Telemetry Simulation

Java 21 Virtual Threads

M:N User-Mode Fibers

Fibers unmount from carrier threads on blocking I/O, allowing a handful of OS workers to handle millions of tasks with negligible memory overhead.

Execution Time72 ms
Wall-clock durationPeak Throughput
Throughput13,888.89 req/sec
OS Kernel Threads8 (Carrier Workers)
User Fibers / Coroutines1,000 Active Fibers
Memory Footprint Delta+1.18 MB
Architectural Analysis & Loom Insight:“Dispatched 1000 virtual threads simultaneously. Virtual threads unmounted from carrier threads during the 50ms sleep, allowing 8 ForkJoinPool worker threads to process the entire workload in 72ms (13888.89 req/sec) with zero thread pool queuing latency.”
Java 21 LTS (Temurin) / Project Loom
Traditional Pool
Edge Telemetry Simulation

Java Platform Threads

1:1 Kernel Threads

Fixed OS thread pool bounded by kernel memory. Excessive concurrent requests queue up, causing sequential wave execution and severe starvation.

Execution Time1,064 ms
Wall-clock durationPool Saturation
Throughput939.85 req/sec
OS Kernel Threads50 (Fixed Pool)
User Fibers / CoroutinesNone (OS Blocked)
Memory Footprint Delta+0.83 MB
Architectural Analysis & Loom Insight:“Dispatched 1000 tasks onto a fixed pool of 50 platform threads. Tasks suffered severe queuing starvation: 20 sequential waves of 50ms each resulted in 1064ms total wall time (theoretical min ~1000ms). Contrast this with Virtual Threads which eliminate pool saturation entirely.”
Java 21 LTS (Temurin) / Traditional Concurrency
Go Runtime
Edge Telemetry Simulation

Go Goroutines

M:N GMP Work-Stealing

Lightweight coroutines managed by Go's GMP runtime. Parked on netpoller during sleep with lock-free local runqueues and dynamic ~2KB stacks.

Execution Time60 ms
Wall-clock durationPeak Throughput
Throughput16,666.67 req/sec
OS Kernel Threads8 (Carrier Workers)
User Fibers / Coroutines1,000 Active Fibers
Memory Footprint Delta+2.29 MB
Architectural Analysis & Loom Insight:“Launched 1000 concurrent goroutines across 8 logical processors (GOMAXPROCS). Goroutines parked on the runtime netpoller timer heap during 50ms sleep, consuming merely ~2KB initial stack each and completing in 60ms (16666.67 req/sec).”
Go 1.23+ (gc)

Scheduler Architecture & Mechanics

Telemetry stream dynamically routed through microservice with zero-scale edge simulation fallback.
ForkJoinPool (Carrier Work-Stealing)M:N User Fibers

Work-Stealing with Continuation.yield() on blocking syscall / sleep

Carrier Workers:8 ForkJoin Threads
Stack Cost:~1 KB dynamic frame
Context Switch:User-Space Continuation
OS Kernel Preemptive Scheduler1:1 Kernel Threads

OS Time-slicing with synchronous kernel-level context switching

Fixed Pool Size:50 OS Threads
Stack Cost:~1,024 KB reserved virtual
Context Switch:OS Kernel Interrupt / Trap
Go Runtime GMP SchedulerGMP Work Stealing

Lock-free local runqueues (256-cap) + 50% work-stealing from peer Ps on idle

GOMAXPROCS (P):8 Processors
Stack Cost:~2 KB resizable stack
Preemption:Async SIGURG signals
5-Year Senior Transition Tracker

Interactive Competency Matrix

Track key breakthroughs bridging enterprise Java depth with modern reactive frontend and microservice speed.

Mastered
7 / 12
In Flight
5
Production-Mastery
In Flight

Project Loom & Virtual Threads

Replace reactive complexity with blocking synchronous code on lightweight green threads.

Core Pattern
Thread.ofVirtual().start() - 1 million threads consuming only KB each.
Advanced
Mastered

Pattern Matching & Record Patterns

Type deconstruction and sealed interface exhaustive switch handling.

Core Pattern
if (obj instanceof Order(var id, var total)) { ... }
Production-Mastery
In Flight

Generational ZGC Garbage Collection

Sub-millisecond pause times across multi-gigabyte heaps with generational collection.

Core Pattern
-XX:+UseZGC -XX:+ZGenerational

Tip: Click any skill card to toggle its completion status.

Real-Time Health & Telemetry

Live Polyglot Node Monitors

Monitored health checks simulating continuous heartbeat across the monorepo services.

All 3 Runtimes Active
apps/web
PORT 3000
FrameworkNext.js 15.0
Rendering EngineReact 19 Server Components
RoutingApp Router (Nested)
services/spring-boot-core
PORT 8080
RuntimeJava 21 (Temurin LTS)
ConcurrencyVirtual Threads Enabled
Actuator HealthUP (Database & Disk)
services/go-engine
PORT 8081
CompilerGo 1.23 CGO_ENABLED=0
Memory Usage< 18MB Base RSS
Container Size14.2 MB Distroless