Learn. Make. Blog. Repeat

Adding more models to our pipeline isn't the solution.

In case you're wondering why the blog isn't getting as much love. I'll update this post with major milestones.

You can't have a proper Java-style object-oriented programming language without inheritance and overriding. We'll augment the type-checker and implement overriding using vtables in LLVM IR.

Generic classes <T> let us reuse the same class with different types. We'll implement generics in Bolt, taking inspiration from C++ templates!

A review of the blog in 2020. No, the blog hasn't taken off (yet) but that's fine - let me tell you why it's still a success!

Let's bootstrap our language's runtime with C library functions. To do this we'll inspect C files' LLVM IR, and dive deeper into LLVM's type system. In the second half of the post, we'll implement Bolt's finish-async concurrency construct.

We'll explain the concepts underlying LLVM IR, and how you can use the LLVM C++ API in your programming language's compiler.

What are React hooks? We'll cover all the core React hooks and even how you can write your own hooks!

Some thoughts and lessons learnt when working on my dissertation.

React is a JavaScript library that makes it super easy to create interactive UIs. We'll build it up from first principles.

They're the bedrock of e-commerce and sharing economies, but do they really work and have they crossed a line?

AI is not a panacea. Deploying AI poses both socio-technical and security risks which we must handle. The solution? We're already doing it elsewhere...

I've learnt a lot from my internships at Facebook. Here are 17 tips I wish I'd known at the start of my first internship.

We have our lovely type definitions and language data structures in OCaml, but we want to use them in our C++ backend. The solution? Serialise them using Protocol Buffers, a language-independent binary format.

So far we've talked about checking our Bolt program is correct, but now we're moving on to actually running it. One problem though, a lot of our high-level constructs like objects and methods don't exist in LLVM IR - we need to map them to simpler constructs.

In this post, we'll look at flow-sensitive type-checking rules - and implement our own version of "Non Lexical Lifetimes" used in Rust's borrow checker.

How do you check if an expression is an int or string? How do we formally define a type system? How do we implement it in a compiler? All answered in this tutorial.

The first stage of a compiler is to represent our Bolt program in a structured format. In this post, I explain how lexing and parsing work, and how we use OCamllex and Menhir to generate the lexer and parser for Bolt. I'll also cover how to fix cases in Menhir where there are ambiguous parses.

It's one thing to understand how a compiler works. It's another to set up the project repo - in this post we'll talk about which languages to use, what the design tradeoffs are, and how the Bolt repository is structured.

Writing your own programming language helps you build the right mental models when programming. I introduce the fundamental concepts behind compilers and explain where Bolt fits in.

I walk through how to convert the standard Gatsby starter blog to use ReasonML!

We'll cover 3 different testing libraries - Alcotest, QCheck and PPX Expect, each with different styles of testing - unit tests, property-based tests and expect-tests respectively. We then look at how you'd integrate them and compute test coverage in a CI workflow.

Dune is simple, fast and interoperates really well with the rest of the OCaml/ReasonML ecosystem.

Thinking of interning at Facebook? This post will give you a better insight of what it is like as well as some advice on how to do well in the internship!

How Gatsby transformed my website, and why you too should make the switch!

A beginner's guide to testing and enforcing good code style across multiple languages.

An comprehensive guide to Docker, Flask and PostgreSQL, with an accompanying real-world Python database server repository with code examples.

A one-stop guide with the most useful commands in Git explained with diagrams and animated code gifs - whether you're a beginner looking to get started, or want to learn more advanced techniques to manage your Git history.

How we can generalise Backprop to any neural network - see how TensorFlow and Keras compute their partial derivatives! We'll use the LSTM cell as an example

Neural networks optimised for NLP and sequences - the RNN, GRU and LSTM networks

We'll look at the internals of a CNN, derive the backpropagation equations, and implement it in code.

Neural networks optimised for Computer Vision

Training, validation and test error - is our model really learning or is it just memorising?

How we can make gradient descent even better.

The magic sauce behind neural networks - how they learn!

Designing our first neural network!

Diving into how machine learning algorithms "learn"

We get our hands dirty with our first machine learning algorithms!

There are a lot of different neural networks out there. We start the series by breaking down commonly used terminology.

Motivation for the series - why bother with the maths behind deep learning?