Difference between revisions of "Boostrapping Specific Languages"

From bootstrapping
Jump to navigation Jump to search
(Created page with "== go == gcc-go lets you compile the golang implementation of go. So you can bootstrap go given just gcc.")
 
m (Minor edit)
Line 4: Line 4:
  
 
So you can bootstrap go given just gcc.
 
So you can bootstrap go given just gcc.
 +
 +
== lisp ==
 +
 +
Lisp interpreters are relatively easy to write in assembly or C, the primary issue is macros.
 +
To properly implement macros in lisp, you have two options:
 +
1) Implement lazy evaluation on top of eager evaluation (can get very ugly)
 +
or
 +
2) Implement a lazy lisp (a boatload of work) and simply use straight lambdas to provide macro functionality
 +
 +
== FORTH ==
 +
 +
FORTH interpreters are far easier to write in assembly than they are to write in any other (non-functional) language.
 +
The biggest issue ends up being what FORTH standard to follow and finding programmers willing to use/improve your FORTH.
 +
 +
== Assembly ==
 +
 +
Contrary to what you would expect, it actually ends up being far easier to implement as Macro-assembler than it is to implement an assembler without Macros.
 +
This is especially true when it comes to the easiest form of Macros, line macros.

Revision as of 23:42, 13 October 2017

go

gcc-go lets you compile the golang implementation of go.

So you can bootstrap go given just gcc.

lisp

Lisp interpreters are relatively easy to write in assembly or C, the primary issue is macros. To properly implement macros in lisp, you have two options: 1) Implement lazy evaluation on top of eager evaluation (can get very ugly) or 2) Implement a lazy lisp (a boatload of work) and simply use straight lambdas to provide macro functionality

FORTH

FORTH interpreters are far easier to write in assembly than they are to write in any other (non-functional) language. The biggest issue ends up being what FORTH standard to follow and finding programmers willing to use/improve your FORTH.

Assembly

Contrary to what you would expect, it actually ends up being far easier to implement as Macro-assembler than it is to implement an assembler without Macros. This is especially true when it comes to the easiest form of Macros, line macros.