
An Intro to Compilers (2017) - memexy
https://nicoleorchard.com/blog/compilers
======
the_duke
While somewhat irrelevant for a majority of developers, it feels great to
understand how computers actually work.

Even many higher education IT programs often barely cover the underpinnings
anymore.

I'm currently embarking on a fun little "from first principles" challenge:

Imagine a post-apocalyptic world where computers are a relic of the past.

You stumble upon a functioning device with a screen and keyboard. When powered
on, all you get is a bare metal "assembly interpreter". You can type in
riscv64 assembly instructions and they are executed. You can print to the
screen via a UART. So you don't even get an assembler/linker to build on.

From there you have to build up an entire new software stack, with a proper
language with compiler/vm, an operating system, a standard library, basic
userspace tools, a UI, ...

Simulating the device and console is easy with qemu-system-riscv64 and a a bit
of assembly.

It's very challenging, but also rewarding to study up/relearn and implement
all the basic underpinnings of computers, all the way from hardware (CPU,
memory, IO devices, ISAs) up to a GUI stack.

Hacking together a simple OS isn't actually all that hard when your hardware
is constrained to a specific device. And writing a very simple language in
assembly also isn't that bad. You can build progressively better languages on
top of that.

I'd love to turn this into a somewhat guided, interactive learning experience
that runs in the browser via tinyemu [1] or similar, but I won't have time for
that.

[1] [https://bellard.org/tinyemu/](https://bellard.org/tinyemu/)

~~~
p4bl0
> _Even many higher education IT programs often barely cover the underpinnings
> anymore._

Really? A compiler course seems quite standard in any licence/bachelor CS
degree.

~~~
hazz99
I go to a pretty good uni (not elite, but global top 30) and they don’t have a
compilers course, which I was very disappointed by. It’s even a theory heavy
degree!

~~~
chrisseaton
This really surprises me - looking down the THE and QS global rankings, I know
that at least all the universities outside the Far East teach compilers. I
guess you're not saying which university you're at to keep it anonymous, but
I'd be interested to hear which it was.

~~~
derangedHorse
Which universities are you looking at? Mine technically had a compilers course
but it wasn't required coursework and was generally offered every 2-3 years or
so

~~~
chrisseaton
The top 30 in QS and THE. Most of them have major compiler research groups,
even.

------
perfect5th
I took a couple of compiler courses in university, and I think for the most
part it made me a better programmer, mainly because it enforced understanding
of how specific programming concepts and constructs are generally implemented.
That, and a more intense look at the "heap of abstractions" you're generally
working with when you write a higher-level language.

I've always advocated that, if you want to really understand the tools you are
using, you need to understand at least one level below the "surface
abstraction" that you are working if. Even better if you can understand two or
three levels down.

There's a great talk from game developer Jonathan Blow [1] that describes how
knowledge is lost "generationally" due to our lack of understanding of the
black boxes we build things on top of. Not sure I 100% agree with his
thoughts, but it's an interesting take.

[1] [https://www.youtube.com/watch?v=pW-
SOdj4Kkk](https://www.youtube.com/watch?v=pW-SOdj4Kkk)

------
shpongled
I'm currently working on a compiler from scratch for fun/learning. Currently
just compiling Standard ML without modules because it presents an interesting
challenge, compilation-wise.

I'm self taught (but have been programming 10+ years) so it's been a really
interesting experience - I've gotten exposure/actual use of some different
data structures and algorithms that I've never used before.

If you're into this kinda thing, I suggest checking out the
ProgrammingLanguages subreddit, there's a discord server as well.

------
peacefulhat
I spent a couple days writing a compiler for a custom shader language. It's a
very simple lisp with minimal features, but enough to do everything I use in
graphics. I compile this into glsl + a struct and functions for cpu side. A
lot faster to prototype when I only have to modify my shader, and I can switch
out the backend between webgl and opengl. Should be quick to add support for
vulkan/metal/dx12 when I need that. I never would have thought to do this
solution if I didn't already know how to write compilers. Somebody might say
"oh, you could have used ____" \- maybe, but it wasn't much effort and I can
make it work in a convenient way for me.

(in position f2) (in uv f2) (all sprite tex) (all color f4)

(vert (position 0.0 1.0))

(frag (* (sprite uv) color))

------
parenthesis
Even if you never write or work on a compiler in the sense of a program that
turns source code text into assembly, many programs (or parts thereof) are
compilers in the sense of turning data or code in one form into another form.

~~~
lou1306
This is especially true of "code generators" or "source-to-source"
transformation tools. I did write one of each recently, and often had to look
up the compiler literature to go forward.

------
stevekemp
That's pretty topical for me, last week I challenged myself to write a
brainfuck compiler in 24 hours or less.

The end result worked out pretty well, and took less time than I expected:

[https://github.com/skx/bfcc/](https://github.com/skx/bfcc/)

------
dang
Discussed at the time:
[https://news.ycombinator.com/item?id=15005031](https://news.ycombinator.com/item?id=15005031)

------
exdsq
I’m writing a simple Lisp compiler with Bash at the moment. It’s fun to find
all the things you really miss from other languages!

