Im currently in the first stages to implement my first ever lisp. And like every good lispy language, closures are a realy important part of the language and it's versatility. And as I choose to implement my lisp for the time being without any fancy tracing gc, only with good old ARC (Atomic reference counted), there arise some serious problems when trying to implement colsures.

Currently, the lapyst language works like the following:

1. Lex and parse the sourcecode into an AST
2. Enhance the AST via scope information and interfered types for (nearly) each node
3. Walk the AST to generate LLVM IR
4. Let LLVM do it's magic, with some LLD sprinkled in so we get a fully linked result
5. Profit!

The problem with this is the second and third steps; not only store we some non-sourcecode related informations inside the AST, but we face problems when we want to transform the AST, being it inefficenties in the AST creation or be it simple loosing the ability to reason about the AST.

I finally took this problem head on in an attempt to finally solve it, and thats what I want to write today about.

Some thing that frustates me about react is that every single tutorial out there just executes some script (i.e. create-react-app or CRA for short) that generates a bunch of files and everything it does under the hood isn't reallly explained. Also i feel it's the begin of the bloat that comes with many of the available javascriptframeworks out there. So today lets look at a simple project bootstrap without CRA!

The windows symbol-store; a technology so simple, yet there are nearly no sources how the store actually work. So let's get started!