"Bootstrapping the Web with Scala Native" by Richard Whaling

### Overview In this talk, Richard Whaling explores low-level systems and server programming using Scala Native, an ahead-of-time (AOT) LLVM-backed compiler plugin for Scala that produces compact native binaries without the JVM runtime. Whaling addresses the architectural challenges of bootstrapping web and network services in an emerging language lacking massive ecosystem frameworks like Netty or Akka HTTP. The presentation demonstrates iterative approaches to building high-performance web applications, starting from basic Berkeley socket programming and classic Common Gateway Interface (CGI), moving to multiplexed protocols via FastCGI, and concluding with multiplexed asynchronous I/O using libuv.

### Key Topics - **Scala Native Fundamentals & C Interop**: How Scala Native compiles Scala directly to native executables (typically 5–10 MB), providing C interoperability constructs including C struct tuples, raw pointer arithmetic, `stackalloc`, dynamic linking stubs via `@extern`, and memory management with `malloc` and `free` alongside a built-in garbage collector. - **Network Server Architecture**: The mechanics of UNIX socket programming (`socket`, `bind`, `listen`, `accept`, `read`, `write`), operating system TCP connection backlogs, and traditional process-per-connection concurrency using the `fork` system call, alongside the operational pitfalls of zombie processes, porting challenges, and testing complexity. - **Separation of Infrastructure and Application Logic**: Offloading complex HTTP parsing and connection handling to battle-tested proxies and web servers (such as Apache, NGINX, Envoy, or custom Go proxies) instead of embedding massive HTTP frameworks inside newly developed applications. - **Multiplexed Protocols vs. Multiplexed I/O**: Strategies to avoid process-creation overhead via FastCGI binary framing and persistent connections over a single socket, compared to event-driven, non-blocking I/O multiplexing across multiple sockets.

### Technical Details - **CGI Baseline**: Whaling implements a minimal CGI web handler in Scala Native running under Apache. Because Scala Native compiles down to a small native binary, the CGI app achieved a mean response time of 40 ms under light load and peaked around 400 requests per second (outperforming Python CGI at 136 ms, though trailing a trivial Node.js Express setup running at ~7 ms and ~2,000 req/sec). - **FastCGI Implementation**: To avoid spawning processes on every request, Whaling implemented FastCGI parsing in Scala Native using unsafe pointer indexing, bitwise operations (`& 0xFF` to handle Java signed bytes), and manual 8-byte frame header extraction. Because open-source NGINX does not easily constrain connections to a single backend socket without NGINX Plus, he built an 80-line Go proxy to route traffic over a single persistent socket using blocking I/O, achieving 4 ms mean response times under light load and peaking near 1,500 req/sec. - **Direct Multiplexed I/O with libuv**: Whaling linked Scala Native directly to `libuv` (`@link("uv")`), the C event loop library behind Node.js that runs on OS-specific primitives like Linux `epoll`. Utilizing Scala Native's C function pointer callbacks, he configured non-blocking socket handling over UNIX domain sockets. Under a Gatling benchmark simulating 500 users and 25,000 requests, this architecture achieved 4,166 requests per second, a 56 ms median response time, and an error rate far below 1%.

### Takeaways - Scala Native provides viable C interoperability for low-level systems programming, allowing developers to safely leverage existing C libraries like `libuv` when standard JVM-based networking libraries are unavailable. - Offloading HTTP protocol parsing to proxies and communicating via lightweight multiplexed protocols like FastCGI allows applications in emerging runtimes to achieve solid performance without maintaining complex HTTP RFC parsers. - Combining non-blocking multiplexed event loops with compact native binaries yields throughput and latency competitive with or exceeding established frameworks like Node.js.