[serene] Re: Bootstrapping the compiler

  • From: Sameer Rahmani <lxsameer@xxxxxxx>
  • To: serene@xxxxxxxxxxxxx
  • Date: Fri, 30 Oct 2020 09:23:22 +0000

Pouya Abbassi <abbassi.pouya@xxxxxxxxx> [2020-10-30, 04:33 +0330]:

Hey buddy,
Beards are growing? ;)

You mentioned "interpreter for serene to bootstrap the compiler".
Does that mean something like SBCL compiler?
AFAIK, SBCL is basically an interpreter that can "snapshot" the
current RAM state and put it in a binary file so user can restore that
snapshot into their own computer's RAM.
No, This interpreter will be a language that exposes LLVM C API and we
will use that API to create the compiler in Serene itself.

1. Oh come on! Not C++ again! If C/C++ is "enough", Rust must be more
than enough!
I Don't think that we should switch back but the point is that a c/c++
is on almost every machine and we should be able to bootstrap from
there.

Take a look at Rust's bootstrap process and it's history, They have so
many steps in there bootstrap. But personally I'm fine with relying on
Rust to compile the bootstrap stage. So when someone wants to compile
Serene from source they either have to have Rust installed or install it
from source or just download a prebuilt bootstrap stage (which in that
case Rust is redundant).

2. Maybe we can start off with Lambda Calculus and expanding it into a
LISP. This way, it's super simpler to begin with, and we already have
a spec for our first step.
We need more than Lambda Calculus to begin with but I'm totally with you
on building a bare minimum. What ever we do we have to make sure that
document the Spec carefully.


On 10/30/20 1:24 AM, Sameer Rahmani wrote:

Hey folks,
Hope you're doing well. I had to come out of my cave and travel for 5km
to get to a internet cafe in order to send this email :)).

Today I was reading about the principles of computing systems and all of
a suddent a light bulb popped up above my head and a wide smile on my
face. So basically I have to say that I've missed something really
simple  but really important that I worked on it a lot as well and yet
surprising enough I forgot about. Till now, the plan was to create a
compiler for Serene in Rust or C++ and use that compiler to bootstrap a
self hosted compiler for Serene. But why can't we just create an
Interpreter for Serene to bootstrap the compiler ??? After all Serene is
a Lisp and it is in its nature to have an "interpreter" or a JIT.

Many languages are using the same approach (Specially Lisps) to
bootstrap the main compiler and eventually this bootstrap
compiler/interpreter is going to get outdated and replaced by the actual
compiler.

So, I think we have to shift our mindset from writting the compiler in
Rust and start creating the interpreter first. This way, will be closer
to have a working copy of Serene and closer to our far away goal. But in
order to implement this interpreter we have to think about couple of
important points:

1. Bootstrapping a compiler from the source should be easy. Many experts
say that a C/C++ compiler should be enough to bootstrap a new
language. So in this case Rust might not be the best tool for
us. Personally I think it's fine but we need to think deeper.

2. We need to come up with the spec of Serene (or a minimal version of
it) much earlier.


Please share your feed back and thoughts.

Cheers
Sameer


Other related posts: