Initial version of the site

Author: dibyendumajumdar

_sources/compiler-books.rst.txt

@@ -0,0 +1,4 @@
+Compiler Books
+==============
+
+I own a bunch of compiler books that I have purchased over the years.

_sources/index.rst.txt

@@ -0,0 +1,96 @@
+================================
+Welcome to Compiler Programming!
+================================
+
+This site aims to bring together practical knowledge regarding the design and implementation of optimizing compilers
+and interpreters for Programming Languages. 
+
+There are a number of books on Compilers and Interpreters however only a very few of them are accompanied by
+source code that implements the topics covered by the book. See below for a list of useful 
+learning projects that do include source code.
+
+In recent years, thanks to LLVM, new programming language design has become a fertile space. New Language implementations
+tend to focus on the language front-end, leveraging LLVM as the back-end for code optimization and code generation. 
+While this is beneficial if you only care about the language design aspects, it is unhelpful for the industry 
+as a whole, because the back-end of an optimizing compiler is a very interesting component, with a rich history of 
+algorithms and data structures, and is a subject worthy of study on its own.
+
+We will cover both front-end and back-end techniques. We will implement a small scale language as a way
+to learn various techniques, see what the common challenges are and how to address them.
+Language design not being our goal, we will keep the language as simple as possible so that it allows us to
+focus on important implementation issues.
+
+Initially we will start with a procedural language. Later we will add features such as closures from functional languages 
+and classes and objects from OOP languages. We will also look at advanced front end techniques such as type inference and
+generics.
+
+The language will be statically typed to start with because this allows us to investigate the traditional compiler
+optimization pipeline. Dyamically typed languages have their own interesting engineering problems.
+We will eventually look at gradual typing and dynamic typing.
+
+Preliminaries
+=============
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Preliminaries
+
+   prelim-impl-lang
+
+Basic Front-End techniques
+==========================
+
+* Lexical analysis
+* Parsing
+* Abstract Syntax Trees
+* Type Systems
+* Semantic Analysis
+
+Basic Back-end techniques
+=========================
+
+* Stack based vs register based Intermediate Representation
+* Control flow graphs and Basic Blocks
+* Bytecode VM with simple garbage collection
+
+Basic Optimization techniques
+=============================
+
+* Dominators and Control Flow Graph
+* Data Flow Analysis, Type Lattices, Abstract Interpretation
+* Peephole Optimizations
+* Static Single Assignment
+* Sea of Nodes Representation
+* Code generation and Register Allocation
+
+Language Tools
+==============
+
+* Debuggers 
+* Language IDEs
+
+Advanced Front-end techniques
+=============================
+
+* Type inference
+* Classes and objects
+* Closures
+* Exception handling
+* Gradual typing
+* Generics
+
+
+Some Useful Projects
+====================
+
+
+Book Reviews
+============
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Reviews
+
+   compiler-books
+
+

_sources/intro.rst.txt

@@ -0,0 +1,4 @@
+Welcome!
+========
+
+This is work in progress

_sources/prelim-impl-lang.rst.txt

@@ -0,0 +1,31 @@
+Implementation Language
+=======================
+
+A compiler can be implemented in any language we choose. For a pedagogical project it is more convenient
+to choose a language that is widely used, has garbage collection, and comes with excellent tools such 
+as IDEs and Debuggers.
+
+Production quality compilers are often written in C, C++ or Rust. For us these languages are too difficult
+to work with.
+
+Lisp and Python appear to be popular languages in teaching projects. Lisp is not as widely used
+as we would like our implementation language to be, and dynamically typed languages such as Python are 
+harder to work with as the project grows.
+
+Compared to C, C++ and Rust, the programming language D appears to be much more suitable for this project,
+from a technical standpoint, that is. It is a garbage collection language that has less friction and is pleasant to 
+work with. The main negatives are that it is not a popular language, and the tooling is not up to 
+the standards of other languages.
+
+Go would be a good candidate except that its an opinionated language that forces a certain programming model,
+whereas we would like a language that offers least resistance.
+
+Java, Kotlin, Swift and C# seem like good candidates. Java has some limitations that make it harder to write memory optimized
+code that is often necessary in a production compiler, but we don't care so much about that. 
+
+I decided to use Java because it is the language I am most familar with, has great tooling, and despite some
+short comings, is widely understood by developers around the world. My first choice would have been D if it was 
+purely a question of technical preference.
+
+The use of Java biases the implementation towards using some Object Orientation; this is just a consequence of the
+most comfortable way of expressing some designs in Java.