michael-lehn / not-abc

# not-abc
`not-abc` is a tiny, self-hosting programming language and compiler. The
language is deliberately minimal: it has only 64-bit values, no static type
checking, and only a handful of built-in functions. The entire compiler is
written in `not-abc` itself.
The project is intended for educational purposes. It demonstrates that a
surprisingly small language is sufficient to implement a complete compiler.
**Note:** This project uses hard tabs with a tab width of 8. If the code looks
misaligned on GitHub, append `?ts=8` to the URL or configure your GitHub tab
width accordingly.
## A note on the name
Why *not-abc*? Because it is not ABC.
Well, not quite.
ABC (*A Better C*) is my educational programming language, implemented in C++
with an LLVM backend. *not-abc*, on the other hand, is a deliberately minimal
language and a self-hosting compiler developed for my undergraduate HPC course.
The original compiler was written in ABC, so the two projects are closely
related after all.
The naming follows a long tradition of confusion: Bell Labs had B, CWI developed
an unrelated language originally called B (later ABC), and I developed yet
another unrelated ABC.
Now there is *not-abc*, which is related to my ABC but insists on not being it.
Any remaining confusion is entirely intentional.
## Teaching Material
I am currently translating the teaching material for my undergraduate course
**Introduction to High Performance Computing (HPC0)** into English. This is an
ongoing effort and will take some time, but I try to make regular progress
whenever my schedule allows.
The translated worksheets, lecturer notes, and additional teaching material can
be found here:
- HPC0 Sessions
 - Session 00 – Getting Ready
 - Session 01 – Top-Down: Experiments with ABC
 - Session 02 – Bottom-Up: Logic Gates
 - Session 03 – Top-Down: Control Flow and Function Calls
 - Session 04 – Bottom-Up: Building a simple ALU (Part 1 of 2)
 - Session 05 - Top-Down: Control Structures, Arrays and Local Variables
 - Session 06 – Bottom-Up: Building a simple ALU (Part 2 of 2)
 - Session 07 – Top-Down: Pointers, Structs, Lists, ...
 - Session 08 – Bottom-Up: ULM (Ulm Lecture Machine) on Paper
 - Session 09 – Top-Down: Building a Symbol Table
 - Session 10 – Bottom-Up: Assembly & Code Generation
 - Session 11 - Not A Bloody Compiler Project: Let There Be a Lexer
 - Session 12 - Top-Down: Strings, Pointers, and Unique String
 - Session 13 - Not A Bloody Compiler Project: Let There Be Trees … and a Parser
 - Session 14 – Bottom-Up: Function Calls and the Stack
 - Session 15 – Not A Bloody Compiler Project: Build System & Pimpin' the Grammar
 - Session 16 - Top-Down: Unions, Memory Layout, and Type Design
 - Session 17 - Not A Bloody Compiler Project: From Parsing to Code Generation
 - Session 18 - Not A Bloody Compiler Project: From Expressions to Programs
 - Session 19 - Bottom-Up: Calling Conventions (Part II)

 - Session 20 - Not A Bloody Compiler Project: Variables and Return Statements
 - Se