Compiler courses

http://www.cse.chalmers.se/edu/year/2017/course/TDA283/lectures/

http://www.cs.columbia.edu/~sedwards/classes/2017/4115-fall/index.html

http://www.cs.dartmouth.edu/~mckeeman/cs48/index.html

http://www.cl.cam.ac.uk/teaching/1718/CompConstr/materials.html

===============================

Pictures from the Starting Forth book

https://www.forth.com/starting-forth/2-stack-manipulation-operators-arithmetic/

--------------------------------

Java Byte Code for SCALA

https://www.toptal.com/scala/scala-bytecode-and-the-jvm

------------------

Yeti - ML for the JVM

https://mth.github.io/yeti/

http://dot.planet.ee/yeti/intro.html

------------------

Ocaml for LLVM

https://github.com/artagnon/rhine-ml 

---------------

Type inference 

http://www.calebh.io/Type-Inference-by-Solving-Constraints/

JVM languages

https://en.wikipedia.org/wiki/List_of_JVM_languages

https://www.codeproject.com/Articles/50377/Create-Your-Own-Programming-Language

Scheme

https://wespiser.com/writings/wyas/home.html

http://peter.michaux.ca/index#Scheme

assmebly (calculator RPN)

https://dere.github.io/2017-02-12/beginners-assembly-part1/

webassembly

https://sourceware.org/ml/binutils/2017-03/msg00044.html

https://hacks.mozilla.org/2017/02/a-cartoon-intro-to-webassembly/

https://webassembly.github.io/spec/

webassembly explorer

https://mbebenita.github.io/WasmExplorer/

ARM

https://azeria-labs.com/writing-arm-assembly-part-1/

JVM

https://www.toptal.com/scala/scala-bytecode-and-the-jvm

Growing a compiler

http://www.cs.dartmouth.edu/~mckeeman/cs48/mxcom/gem/html/GrowingCompiler.html

free books

https://github.com/vhf/free-programming-books/blob/master/free-programming-books.md

https://john.cs.olemiss.edu/~hcc/csci658/notes/Free_Prog_Lang_Textbooks.html

MIPS

http://courses.missouristate.edu/kenvollmar/mars/

PEG

https://github.com/taocpp/PEGTL

Parser

https://www.reddit.com/r/programming/comments/615hoz/how_to_write_a_recursive_descent_parser/

https://www.reddit.com/r/ProgrammingLanguages/comments/60gmgc/writing_a_recursive_descent_expression_parser/

http://www.craftinginterpreters.com/parsing-expressions.html

small languages

https://github.com/Michael2109/cobalt

http://www.red-lang.org/p/about.html

http://craftinginterpreters.com/contents.html

https://michaelhaywoodblog.wordpress.com

https://ruslanspivak.com/lsbasi-part1/

http://selfie.cs.uni-salzburg.at

https://academy.realm.io/posts/tryswift-samuel-giddins-building-tiny-compiler-swift-ios/

https://legacy.gitbook.com/book/luxlang/the-lux-programming-language/details

https://github.com/rhysd/gocaml

https://github.com/aalhour/awesome-compilers#educational-and-toy-projects

https://rsms.me/hue-intro

automata

https://www7.in.tum.de/um/courses/auto/ws1314/script/autonotes.pdf

Reges helpers

https://regex101.com

http://www.regular-expressions.info/tutorial.html

Regex performance benchmark

https://rust-leipzig.github.io/regex/2017/03/28/comparison-of-regex-engines/

https://github.com/k-takata/Onigmo

Sulzmann

https://github.com/pippijn/dreml/

Scala parser

http://enear.github.io/2016/03/31/parser-combinators/

ANTLR megatutorial

https://tomassetti.me/antlr-mega-tutorial/

From regex to LLVM

https://www.youtube.com/watch?v=Ukqb6nMjFyk

Static code analysis

https://medium.com/@Coder_HarryLee/videos-about-static-code-analysis-7654b40f9a3b

Brainfuck compiler

https://github.com/PurpleMyst/bf_compiler

https://www.reddit.com/r/programming/comments/8371tk/a_brainfuck_to_llvm_ir_compiler_written_in_python/

http://www.wilfred.me.uk/blog/2015/02/21/my-first-llvm-compiler/

===============================

A simple recursive regular expression matcher written in Scala.

https://github.com/marconilanna/RegexMatcher

===============================

A neat little tool to build presentations using the Scala REPL

https://github.com/marconilanna/REPLesent

======================

Minimal Static Single Assignment Form

Max Wagner and Denis Lohner

This formalization is an extension to "Verified Construction of Static Single 

Assignment Form". In their work, the authors have shown that Braun et al.'s 

static single assignment (SSA) construction algorithm produces minimal SSA form 

for input programs with a reducible control flow graph (CFG). However Braun et 

al. also proposed an extension to their algorithm that they claim produces 

minimal SSA form even for irreducible CFGs.

In this formalization we support that claim by giving a mechanized proof.

As the extension of Braun et al.'s algorithm aims for removing so-called 

redundant strongly connected components of phi functions, we show that this 

suffices to guarantee minimality according to Cytron et al..

https://www.isa-afp.org/entries/Minimal_SSA.shtml

=========================

How Clang compiles a function

https://blog.regehr.org/archives/1605