Table of Contents

1.  Acknowledgments
2.  Foreword
3.  Preface
   1. Who This Book Is For
   2. What’s In This Book
   3. Working with the Code
   4. Online Resources
4.  Systems Programming in the Twenty-First Century
   1. What Is Systems Programming?
   2. Moving Toward Modern Systems Programming
   3. Why Scala Native?
   4. What Makes Scala Native Different
5. Part I. Foundations of Systems Programming
   1. 1. The Basics: Input and Output
      1. Working with Output
      2. Working with Input
      3. Case Study: Google NGrams
      4. What’s Next
   2. 2. Arrays, Structs, and the Heap
      1. The Stack and the Heap
      2. Structs, Arrays, and Sorting
      3. Sorting an Array
      4. Aggregation at Scale
      5. What’s Next
   3. 3. Writing a Simple HTTP Client
      1. Defining Terms
      2. Working with TCP
      3. Making a TCP Connection
      4. Testing Network Code with Netcat
      5. Introducing HTTP
      6. Implementing HTTP
      7. Testing Our Code
      8. What’s Next
   4. 4. Managing Processes: A Deconstructed Shell
      1. Running a Program
      2. Introducing exec
      3. What Went Wrong?
      4. Introducing Concurrency with fork() and wait()
      5. Supervising Multiple Processes
      6. Working with Pipes
      7. What’s Next
   5. 5. Writing a Server the Old-Fashioned Way
      1. Understanding How a Server Works
      2. Building Our Server
      3. Creating a Minimum Viable Server
      4. Handling HTTP
      5. Performance Testing with Gatling
      6. What’s Next
6. Part II. Modern Systems Programming
   1. 6. Doing I/O Right, with Event Loops
      1. Blocking and Polling
      2. Introducing libuv
      3. Working with Asynchronous TCP Sockets
      4. Building an Asynchronous HTTP Server
      5. What’s Next
   2. 7. Functions and Futures: Patterns for Distributed Services
      1. Designing an Asynchronous API
      2. Introducing Futures
      3. Implementing Futures
      4. Implementing an ExecutionContext
      5. Futures and Promises
      6. Introducing libcurl
      7. Asynchronous curl
      8. What’s Next
   3. 8. Streaming with Pipes and Files
      1. Looking at Streams, Files, and Descriptors
      2. Streaming Pipe Input in libuv
      3. Streaming File Input in libuv
      4. Streaming File Output in libuv
      5. Stream Processors
      6. What’s Next
   4. 9. Durability: An Embedded Key-Value Database with LMDB
      1. Introducing Embedded Storage
      2. Defining LMDB Concepts
      3. Working with the LMDB API
      4. Serialization and Deserialization with JSON
      5. Putting LMDB on the Web
      6. What’s Next
   5. 10. Services: Encapsulation and Abstraction for Modern Designs
      1. Services and Distributed Systems
      2. Parsing, Revisited
      3. Moving from Server to Service
      4. Implementing an Idiomatic Service DSL
      5. Integrations and Ecosystems
      6. The Way Forward
7. A1. Setting Up the Environment
   1. Running Scala Native on Mac OS
   2. Why Use Containers?
   3. Installing and Configuring Docker
   4. Running Scala Native in Docker

Copyright © 2020, The Pragmatic Bookshelf.