serene-rust-implementation/dev.org

• Parser
• Considerations
  • Hashmaps
    • DOS attack
• Resources
  • Lisp
  • Rust
  • LLVM
  • Data structures
  • Other languages
  • Cranelift
• Possible solutions
  • Garbage collection
  • JIT
• Features to implement
  • Compiler
    • Branch instructions
    • Execution Instrumentation
  • Lang

Parser

First of all you need to read All you need to know about Parser algorithms. Then here is the list or parsers that we have considered

Rust parser combinator framework

https://github.com/Geal/nom/

LR(1) parser generator for Rust

https://github.com/lalrpop/lalrpop

A parser combinator library for Rust

https://github.com/Marwes/combine

Parsing Expression Grammar (PEG) parser generator for Rust

https://github.com/kevinmehall/rust-peg

General purpose parser

https://pest.rs/

Considerations

Hashmaps

DOS attack

• https://www.anchor.com.au/blog/2012/12/how-to-explain-hash-dos-to-your-parents-by-using-cats/
• https://en.wikipedia.org/wiki/Collision_attack

Resources

For a generic list of resources on compiler design take a look at https://tomassetti.me/resources-create-programming-languages/

Lisp

Make a Lisp

https://github.com/kanaka/mal/blob/master/process/guide.md

Rust

The Rust book

https://doc.rust-lang.org/book/ https://www.reddit.com/r/rust/comments/2s1zj2/the_rust_programming_language_book_as_epub/

LLVM

Brief overview of LLVM

https://www.infoworld.com/article/3247799/what-is-llvm-the-power-behind-swift-rust-clang-and-more.html

A bit in depth details on LLVM

https://aosabook.org/en/llvm.html

Rust binding

https://crates.io/crates/llvm-sys

Official LLVM tutorial C++

https://llvm.org/docs/tutorial/

Rust LLVM tutorial

https://github.com/jauhien/iron-kaleidoscope

Data structures

Pure functional datastructures papaer

https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf

Dynamic typing: syntax and proof theory

https://reader.elsevier.com/reader/sd/pii/0167642394000042?token=CEFF5C5D1B03FD680762FC4889A14C0CA2BB28FE390EC51099984536E12AC358F3D28A5C25C274296ACBBC32E5AE23CD

Representing Type Information in Dynamically Typed Languages

https://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.4394

An empirical study on the impact of static typing on software maintainability

https://www.researchgate.net/publication/259634489_An_empirical_study_on_the_impact_of_static_typing_on_software_maintainability

Other languages

Julia: A Fresh Approach toNumerical Computing

https://julialang.org/research/julia-fresh-approach-BEKS.pdf

Cranelift

Source tree

https://github.com/bytecodealliance/wasmtime/tree/master/cranelift

Possible solutions

Garbage collection

• https://v8.dev/blog/high-performance-cpp-gc

JIT

• https://asmjit.com/

Features to implement

Compiler

Branch instructions

It would be cool to have macro to instruct the compiler about the likelyhood of a branch in a conditional. Something similar to kernel's likely and unlikely macros

Execution Instrumentation

The compiler should be able to embed some code in the program to collect data about the different execution paths or function instrumentation and other useful data the can help the compiler to optimize the program even further. For example Imagine a scenario which we compile a program with out any optimization ( in debug mode ) and using some test cases or real usage of the program in several iteration we collect data about the compiled application in a file (let's call it the ADF short for Analytic Data File), and the we can pass that ADF file to the compiler to let it compile and optimize the program by using the usual passes alonge side with some extra passes that operate on ADF

Lang