Getting Started with EK9

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
  • Nothing here is new — and that is the point
  • Who this book is for
  • What you need
  • How to read this book
  • How code looks
  • How this book was made
• How to use this book
  • How the chapters work
  • Conventions
  • Getting set up
• 1. Hello, EK9
  • The one big idea
  • Your first program
  • Reading the program, line by line
  • No braces, no semicolons
  • Doing a little more
  • Try it yourself
  • Recap
• 2. Values and the Three States
  • Names for values
  • The built-in value types
  • Putting values inside text
  • New lines, tabs and other characters
  • Set and unset
  • Asking whether a value is set
  • Naming the type yourself
  • Changing a value later
  • Try it yourself
  • Recap
• 3. Making Decisions and Repeating Work
  • Making a choice with if
  • Giving a program a value
  • The same idea, spelled when
  • Joining conditions
  • Choosing among many values with switch
  • Repeating with a range
  • Repeating while something is true
  • Running at least once: do / while
  • The features that are not here
  • A map of what is coming
  • Try it yourself
  • Recap
• 4. Functions
  • Your first function
  • Calling a function
  • More than one input
  • Functions can use other functions
  • Sometimes there is nothing to return
  • pure: a promise not to change things
  • require: saying what must be true first
  • One value out
  • Try it yourself
  • Recap
• 5. Testing as You Go
  • Why test, and why early
  • A function worth checking
  • Where tests live
  • Running the tests
  • Covered is not the same as tested
  • When a test fails
  • assert is for tests only
  • Writing the test first
  • Try it yourself
  • Recap
• 6. Reading the Compiler's Guidance
  • An error is an instruction
  • The anatomy of a message
  • Four errors you will meet
  • Asking the compiler for the full explanation
  • Guide, not gatekeeper
  • Try it yourself
  • Recap
• 7. Text, Numbers, Time and Money
  • The ones you already know
  • Money
  • Dates, times and durations
  • Measures, colours and more
  • The common thread
  • Naming fixed values
  • Try it yourself
  • Recap
• 8. Speaking Every Language
  • Why translation usually goes wrong
  • Text in the language itself
  • Letting the user choose
  • Formatting values, the local way
  • Placement, and the trouble with placeholders
  • The compiler keeps every language complete
  • Adding a language with the IDE and an AI
  • Unicode throughout
  • Try it yourself
  • Recap
• 9. Collections
  • A list of things
  • A dictionary of pairs
  • Putting them together
  • An empty collection is set, not missing
  • How EK9 works out a collection's type
  • Where the promotion comes from
  • Straight to JSON
  • Two very small collections
  • Try it yourself
  • Recap
• 10. Guards and Safe Code
  • The pattern that keeps repeating
  • The guard: check and use in one step
  • The same pattern, everywhere
  • Setting a value only if it is missing
  • Coalescing: choosing the set one
  • The safe smallest and largest
  • Control flow that gives back a value
  • Why EK9 does this
  • Try it yourself
  • Recap
• 11. Optional and Result
  • Optional: zero or one
  • Result: this worked, or it did not
  • The compiler is watching
  • Why it matters when the check happens
  • Try it yourself
  • Recap
• 12. Streams and Pipelines
  • A first pipeline
  • The functions a pipeline expects
  • The shopping basket again
  • Small pieces you can trust
  • Why this replaces break and continue
  • There is more than this chapter shows
  • Try it yourself
  • Recap
• 13. Two Ways to Build: Data, Functions and Objects
  • Two traditions
  • EK9 does not make you choose
  • Which should you reach for?
  • Protecting data without freezing it
  • Try it yourself
  • Recap
• 14. Records and Enumerations
  • A record is a bundle of data
  • Building one in a single step
  • Or build it blank, and fill it in later
  • Giving data a little behaviour
  • Plain data is a virtue
  • Enumerations: a fixed set of names
  • An enumeration comes with operators
  • The switch that cannot forget
  • Try it yourself
  • Recap
• 15. Constrained Types
  • Declaring one
  • Building one, the direct way
  • It is not an Integer with a label
  • When the value is wrong
  • Building one, the safe way
  • Try it yourself
  • Recap
• 16. Classes
  • The smallest class
  • Why hide anything?
  • Guarding real state
  • Sealing the empty back door
  • The anaemic class: a record in disguise
  • The leak nobody mentions
  • Try it yourself
  • Recap
• 17. Abstract Types, Subtypes and Polymorphism
  • A type that cannot stand alone
  • Fulfilling the contract: subtypes
  • One question, many answers
  • Why it is safe to substitute
  • No casts — on purpose
  • Not only classes
  • Try it yourself
  • Recap
• 18. Traits and Composition
  • Behaviour that cuts across a hierarchy
  • Composition without the boilerplate
  • When two traits collide
  • Sealing a family
  • Try it yourself
  • Recap
• 19. Components
  • Hiding types, not just values
  • Why hide the types
  • Coupling, cohesion, and a compiler that keeps score
  • Try it yourself
  • Recap
• 20. Using Generics
  • One definition, every type
  • The parameter is a promise
  • The family you already know
  • Two ways to "work for many types"
  • Try it yourself
  • Recap
• 21. Using Operators
  • A fixed, named set
  • Giving your own type operators
  • Write what is special, default the rest
  • Turning a value into text, and into JSON
  • Promotion: one more look at #^
  • Keep the meaning
  • The deeper half is in the second volume
  • Recap
• 22. Programs, Input and Output
  • Giving a program its instructions
  • Reading options with GetOpt
  • Two ways out: Stdout and Stderr
  • A path is just a path
  • Making the file — and being made to check
  • Reading and writing the notes
  • Running it
  • Running it as its own command
  • A setting from the environment: a web address
  • Try it yourself
  • Recap
• 23. Build a Game, End to End
  • A plan that fits in your head
  • A line on the board: the Score record
  • One game in progress: the Game class
  • The small helpers
  • The program: a thin shell
  • Running the tests
  • Playing it
  • Where to take it next
  • Try it yourself
  • Recap
• A. The Operator Reference
  • Comparing
  • Arithmetic
  • Arithmetic that assigns
  • Converting
  • Asking about state
  • Copying and merging
  • Logic and bits
  • The rest
  • Operators you use, but never define
• B. Constructs at a Glance
• C. The Evidence: the research behind the rules
  • No null; values are absent, unset, or set
  • No return; name the result instead
  • No break or continue; use streams and guards
  • No fall-through in switch
  • Copy at the boundary; no leaking your insides
  • Traits, not tangled inheritance
  • The compiler measures coupling and cohesion
  • Named, typed message placeholders
  • More sources cited in the chapters
  • The two big payoffs
• D. Installing and Running EK9
  • Installing EK9
  • The EK9 IDE
  • Under the hood: Java 25
  • Running from the command line
  • Getting the examples
• E. Glossary