small medium large xlarge

Modern Systems Programming with Scala Native: Write Lean, High-Performance Code without the JVM


Cover image for Modern Systems Programming with Scala Native

Modern Systems Programming with Scala Native

Write Lean, High-Performance Code without the JVM


Access the power of bare-metal systems programming with Scala Native, an ahead-of-time Scala compiler. Without the baggage of legacy frameworks and virtual machines, Scala Native lets you re-imagine how your programs interact with your operating system. Compile Scala code down to native machine instructions; seamlessly invoke operating system APIs for low-level networking and IO; control pointers, arrays, and other memory management techniques for extreme performance; and enjoy instant start-up times. Skip the JVM and improve your code performance by getting close to the metal.

Choose Your Format(s)

  • $24.95 In Stock
    • Beta: What do I get?

  • Ebooks are DRM free.

  • Ebook delivery options.

About this Title

Pages: 230 (est)
Published: 2019-11-10
Release: B8.0 (2019-12-26)
ISBN: 978-1-68050-622-8

Developers generally build systems on top of the work of those who came before, accumulating layer upon layer of abstraction. Scala Native provides a rare opportunity to remove layers. Without the JVM, Scala Native uses POSIX and ANSI C APIs to build concise, expressive programs that run unusually close to bare metal. Scala Native compiles Scala code down to native machine instructions instead of JVM bytecode. It starts up fast, without the sluggish warm-up phase that’s common for just-in-time compilers. Scala Native programs can seamlessly invoke operating system APIs for low-level networking and IO. And Scala Native lets you control pointers, arrays, and other memory layout types for extreme performance.

Write practical, bare-metal code with Scala Native, step by step. Understand the foundations of systems programming, including pointers, arrays, strings, and memory management. Use the UNIX socket API to write network client and server programs without the sort of frameworks higher-level languages rely on. Put all the pieces together to design and implement a modern, asynchronous microservice-style HTTP framework from scratch.

Take advantage of Scala Native’s clean, modern syntax to write lean, high-performance code without the JVM.

What You Need

A modern Windows, Mac OS, or Linux system capable of running Docker. All code examples in the book are designed to run on a portable Docker-based build environment that runs anywhere. If you don’t have Docker yet, see the Appendix for instructions on how to get it.

Contents & Extracts

This book is currently in beta, so the contents and extracts will change as the book is developed.

  • Preface
  • Foundations of Systems Programming
    • The Basics: Input and Output
      • Working with Output
      • Working with Input
      • Case Study: Google NGrams
      • What’s Next
    • Arrays, Structs, and the Heap
    • Writing a Simple HTTP Client
      • Defining Terms
      • Working with TCP
      • Making a TCP Connection
      • Testing Network Code with Netcat
      • Introducing HTTP
      • Implementing HTTP
      • Testing Our Code
      • What’s Next
    • Managing Processes: A Deconstructed Shell
    • Writing a Server the Old-Fashioned Way
      • Understanding How a Server Works
      • Building Our Server
      • Creating a Minimum Viable Server
      • Handling HTTP
      • Performance Testing with Gatling
      • What’s Next
  • Modern Systems Programming
    • Doing IO Right, with Event Loops
      • Polling, In General
      • LibUV
      • Asynchronous TCP Sockets
      • A High-Performance HTTP Server
      • What’s Next
    • Functions and Futures: Patterns for Distributed Services
      • Designing an Asynchronous API
      • Implementing Futures
      • Implementing an ExecutionContext
      • Futures and Promises
      • Introducing libcurl
      • Asynchronous curl
      • What’s Next
    • Data, Data, Data: A Lightweight Map-Reduce Framework
      • Introducing Map-Reduce
      • Processes, Parallelism, and Blocking
      • Serialization and Deserialization with JSON
      • Pipes, Streams, and Data
      • Multiplexing on Pipes with poll()
      • What’s Next
    • Durability: An Embedded Relational Database
    • Where Do We Go From Here?


Richard is a data engineer at M1 Finance in Chicago, where he designs large data pipelines using Scala-based technologies like Akka and Spark. He’s made open-source contributions to Scala Native and Apache Kafka, and he blogs and speaks frequently about Scala and other functional programming topics.