Use Python for Scripting!
"Use the right tool" is nice in theory, but not when the tool acts a bit differently from machine to machine, and isn't always installed.
hyPiRion
Blog posts by Jean Niklas L'orange (hyPiRion)
Latest posts
Making Code Generators Pleasant to Use
I feel that code generators for communication protocols are a chore to use. Let's see why that's the case, and how we can improve them.
Why I'm Not Nixing My OCaml Builds (Yet)
I could ensure my OCaml builds are 100% reproducible, but what's the cost?
Getting OCaml Through the Eye of a Needle
Let's see why OCaml isn't user friendly for web services at the moment, and how we can fix that.
Implementing System-Versioned Tables in Postgres
There's no official support for system-versioned tables in Postgres yet, and the temporal extensions aren't supported on Azure/AWS/GCP. Let's implement it ourselves with 3 triggers and an index.
Haunting Down Errors in Go
Phantom types won't revolutionise your Go debugging experience, but it can make it slightly better! Here's one way they can help out.
Go-stly Access Rights
With phantom types, we can make a static access control system in Go that will detect errors and act as easy-to-read documentation. Here's how you do it.
Spectral Contexts in Go
Go has phantom types, and we can use them to attach singletons to contexts. Here is a short post on how to do just that.
GraphQL and Type Systems
Like Go, GraphQL isn't at the forefront of type theory. Let's look at what I miss and whether it would be sensible to add them to the specification.
On Expectations and Fun
A blog usually has its style and shape, and your visitors expects that to continue on. But what do you do if you both want to keep that expectation while also making posts in a completely diferent style?
Teaching DucKey to Quack 🦆
I've wanted to get my Moonlander keyboard's duck key to print the duck emoji for a long time. Here's how I did it!
Smaller Static Sites with New Formats
Your static site is probably small enough already, but here are some tricks to make the fonts and images even smaller. I cover the things I do with fonts, as well as some utility scripts I use with Jekyll to automate the entire "convert to all the different formats"-problem new formats cause (as one needs to deal with backwards compatibility).
Type-Safe HTTP Servers in Go via Generics
When generics comes out, here's a possible way to use it for typed HTTP servers in Go. As a bonus, there's a short "rant" about how the implementation causes functional programming to be hard.
Row Polymorphism In Go?!
A thought experiment on how one could add row polymorphism to Go.
Wibbly Wobbly, Timey Wimey
Whoever assumed asymptotic complexity to be easy has not considered to test it in the real world.
A Resilient Git Dependency Algorithm
What do we do when we can't compare dependency versions?
Lock Files Are Not the Only Option
If you want to make a package manager, think before jumping straight to lock files.
From Transducers to Conduits and Back Again
By realising that transducers are conduits in disguise, we can create a transducer interface that is much easier to use than the current one.
Clojure's Transducers in Haskell
Let's implement Clojure's Transducers in Haskell!
(rationalize inlein)
This post describes what the new project Inlein bring to the table for Clojurians.
The Simplest Collection
This blogpost explores what the simplest collection type is, and whether it is useful or not.
Parsing TeX with Recursive Transducers
This blogpost experiment with recursive transducers, and how one could use them for composable nanopass parsers.
Commit Times and Work Culture
Punchcards for a collection of projects may give you some indication of work culture.
Persistent Vector Performance Summarised
The last post in the persistent vector series, explaining why 32 is chosen as branching factor and what "effectively constant time" is.
Swearjure is Turing Complete
This blog post dives into new discoveries in Swearjure, which makes it possible to prove that it is Turing complete.
Persistent Vector Performance
This is a very detailed blogpost related to persistent/transient vector performance, with benchmarks and plots.
Understanding Clojure's Transients
Ever wondered how Clojure's transients work? Or perhaps you don't know how to use transients properly? Both things will be explained in this blog post.
Improving RRB-Tree Performance through Transience
A master's thesis properly describing the persistent vector, the RRB-tree as well as optimisations on the RRB-tree.
Understanding Clojure's Persistent Vectors, pt. 3
In this blog post, we will have a look at how we reduce constant factors in the persistent vector through a tail implementation.
Advanced Clojure/Java Mixing in Leiningen
An example of a Leiningen project using several java/clojure compilation steps.
Suboptimal Optimisations
Sometimes, adding mallocs to a program increases performance.
Understanding Clojure's Persistent Vectors, pt. 2
This is part 2 of the blog series which explains Clojure's Persistent Vectors.
Understanding Clojure's Persistent Vectors, pt. 1
Ever wondered how Clojure's persistent vector actually works? This is part 1 of a blog series which aims to explain them.
Read RFC Documents in HTML Form
Finding bugs in RFCs, and why you should read them in HTML form.
Hello World in Swearjure
A working Clojure program with a minimal amount of alphanumerics.
How To Cancel A Blocking Read In Java
Cancelling blocking reads in Java is anything but sane.
A Language Without Conditionals
Can you learn anything valuable by removing programming constructs?
FBHC 2013 Intro Round in Clojure
In which an unfit language is surprisingly fit.
Swearjure - Clojure without alphanumerics
Is Clojure turing complete without alphanumeric characters?