Welcome to my blog! This blog is a digital garden of ideas and tutorials.
These ideas can really be separated into buckets, in increasing order of “completeness”. I guess one way of viewing this blog is as a learn-in-public incubator of ideas.
I’ve also written two series of posts: on understanding the maths behind deep learning and writing your own programming language
How can we train machine learning models to preserve privacy? I'll explain what differential privacy is, and the differentially-private stochastic gradient descent (DP-SGD) algorithm.
The techniques I used to get up to speed quickly when switching to iOS development, despite never having written any apps before, iOS or Android, nor having written any Objective C.
5 years ago, in 2016, I asked myself the same question. Here's briefly what I'd suggest, based on my personal experiences.
My experience of joining Facebook as a new software engineer, including bootcamp, team selection and relocating to London
I think most videos on this get this wrong.
There are surprising few "new" things to learn when learning a new programming language.
A snippet about keys in React
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 software engineering internships. 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.
No, this isn't one of those toy languages. In this series we'll cover objects, concurrency, generics and inheritance, amongst other more complex language features.
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.
Sharing my experience interning at Facebook in the summer of 2019.
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?