EK9 in Depth

The whole book, a page per chapter. Every listing in it was compiled and run with the EK9 compiler, and every output shown is the output it printed.

Contents

• Copyright
• Preface
  • The decade that still runs your code
  • What the post-mortems say
  • The mapping
  • Two ideas do most of the work
  • Why this is hard to teach, and worth it
  • A word about maturity
• Where Volume 1 Left You
  • The syntax in one table
  • One program
  • The first things that trip a fluent programmer
  • A note on field style
  • What Volume 1 promised
  • The map
• Optional and Result, in Depth
  • Two ordinary objects
  • The rule
  • What keeps the proof
  • What ends it
  • You may not ignore one either
  • The cost
  • Where this stops
• Operators and Pragmatic Purity, in Full
  • A closed set with one split
  • What pure enforces
  • Copy, merge and replace
  • The re-point head
  • What it costs
  • Where this stops
• Functions as Values: the Type Hierarchy
  • From shape to type
  • Purity forks the hierarchy
  • When no shape fits
  • An abstract function as a contract
  • What it costs
  • Where this stops
• Dynamic Functions and Classes
  • A function that carries state
  • What a capture is
  • The list is the whole interface
  • Dynamic classes
  • Composable by name
  • The cost
• Stream Pipelines in Depth
  • One data set, every verb
  • JSON as a sink
  • async is a stage, not a thread
  • What the compiler measures
  • The cost
• The Dispatcher
  • Routing on what the value is
  • When two handlers fit equally
  • Exhaustiveness belongs to allow only
  • The parent's version, on purpose
  • The cost
• Write-Your-Own Generic Types and Functions
  • A generic type
  • Constraining what T can do
  • What a bare T demands
  • Generic functions
  • Constrained types over a record
  • What it costs
• Organising a Growing Codebase
  • One build, many files
  • How modules reach each other
  • Comments
  • What it costs
• Errors and Exceptions
  • Which failure is which
  • Throwing, and catching in one place
  • try as an expression
  • Resources the compiler closes
  • What a catch cannot see
  • Exceptions inside a pipeline
  • The cost
  • Where this stops
• Concurrency, Safely
  • What exists, and what does not
  • One lock over one record
  • You often do not need the lock
  • What the compiler refuses
  • What the compiler does not try to do
  • The cost
  • Where this stops
• Dependency Injection and Applications
  • A component, an application and a program
  • What the compiler checks before anything runs
  • Only an abstract component can be injected
  • The seam Volume 1 promised
  • What it costs
• Aspects
  • Advice at the registration line
  • Carrying a value from before to after
  • When the advised method throws
  • Only a component, only an Aspect
  • What it costs
• Networking: TCP and UDP
  • A server and its own client
  • Two processes: a handler that stops the server
  • UDP: everything is a packet
  • Where the addresses come from
  • The client side of HTTP
  • What the model costs
• A Web Service, Step by Step
  • Step one: the smallest service that serves
  • Step two: the model
  • Step three: state behind a lock, behind a component
  • Step four: a response that already knows its status
  • Step five: JSON in, JSON out
  • Step six: the routes
  • Running it
  • Input in, secrets out
  • What the capstone costs
  • What the notes-keeper became
• Packaging and Sharing Your Program
  • The package block is the manifest
  • -P: packaging is gated by tests
  • Declaring what a package may do
  • Depending on another package
  • What is not here yet
  • The cost
• Testing the Compiler Trusts
  • Three kinds of test, one runner
  • Test first, and what red looks like
  • What the compiler refuses to call a test
  • The gate, and what coverage cannot see
  • The cost
• Quality Built In
  • Rejected, with a figure
  • The architecture layer
  • What coverage cannot say
  • The cost
• The Payoffs: Liskov and Hoare
  • Substitution, as the compiler checks it
  • The null mistake
  • What is claimed, and what is not yet proven
  • The cost
• Coming from another language?
  • Reflex to EK9
  • By language
  • What is not here yet
• Built-in Types at a Glance
  • Values
  • Time
  • Collections and containers
  • Input, output and the system
  • Network, concurrency and security
• Where to go next
  • The debugger and the journal
  • Profiling
  • Tests nobody wants to write
  • Do your tests notice?
  • Fuzzing the compiler
  • Asking the compiler