Nicolas Chagnet's Homepage

I've looked far and wide for a goot dotfiles management system, but a bare git repo is just the easiest and it's already present on every system!

This is possibly the most complete reference on graphs and GNN I have seen.

This is a very thorough review on the statistics behind the various measures used to select features when building a predictive model.

A foray into what real data science looks like.

I always found SIMD quite confusing to apply and generally just cross my fingers that auto-vectorization will just do it for me.

This post showcases all the reasons why I love and use DuckDB.

This paper brings a very geometric approach to LLM hallucinations evaluation.

A description of how DuckDB has slowly become my unified interface to data everywhere.

A practical comparison between Postgres and DuckDB, if you're curious to see where each should be used.

Error handling is one of the most important aspect of writing good code which is why it's also a difficult thing to do well.

I am launching a new series of posts explaining some complex physics concepts.

A post demystifying quantum mechanics and the math behind it.

This is how I replaced my git workflow with jujutsu and why I'm not going back.

A useful formula for computing running variance and avoid difficult numerical inaccuracies.

I've rediscovered the joy of blogging, and this post is a great summary of why.

This article is a fantastic explanation of why symplectic manifolds are the right abstraction for classical dynamics.

This is a gorgeous explanation why momentum works in gradient descent.

This article will show you how forming your Pokémon team can be turned into a mathematical optimization problem.

This article is a wonderful reminder that when people rewrite software in Rust, the performance gains are rarely due to the language only, but mostly from the benefits of a full rewrite.

I've had some hand-on experience recently with cache and memory access being the bottleneck in my project.

If you've ever been curious about how to design a programming language from scratch this is for you!

I love stupid puzzles, I like Pokémon, so when a friend shared this with me, I immediately loved it!

An opinionated piece on what makes Rust my favourite language.

Let's face it, logging is tough.

This is a pretty well-known website in the Rust community, and the first place I head to when I need to choose a crate for a project.

I always struggle to find the right setup to resize images to use as assets.

I learnt CSS nearly 15 years ago and stopped paying attention to it 5 years later.

A very interesting article on the Decimal type in the finance industry.

This is a great guide to the newtype pattern in Rust.

This is a fascinating article on dimensionality reduction and how to use local similarity structure to extract as much information as possible.

This is a really interesting (and long) exploration of computational linear algebra in Rust.

This is a very interesting article about information theory, with great visuals!

This is a really cool project.

I love hearing about other devs' workflows and quirks.

Or how I finally found a better solution than grub.

I've been trying out devcontainers recently, and this article really helped understanding exactly how useful they can be.

A really great introduction to the importance of SIMD optimisations using a real example use case.

This is a really cool way to analyze the probabilities of minesweeper states from a statistical physics perspective.

If instead you prefer your error-handling to be more manual, the `derive_more` crate is a great way to remove boilerplate when defining enum wrappers for custom Errors.

This is an interesting error-handling crate mixing the good parts from `thiserror` and `anyhow`.

This is an excellent article about multi-agent structure.

When picking up a new tool like jujutsu, it's always useful to have a guided introduction with the previous tool as a reference.

I love writing in Rust for fun, and I have to write in Python for work where I tend to miss some of Rust's features.

This article brings forth an interesting aspect of documentation: making it "load bearing" ensures it is maintained more regularly.

As I keep going on my discovery journey with jj, I like finding articles like this one which gives you a bird's eye view of a full workflow.

Everything you've ever wanted to know about handling time in computer systems, and then some.

The title of the article feels a bit clickbait-y, but the content is very interesting and takes you through a whole performance improvement journey.

I always find the logging module in Python to be quite complex and hard to use.

Useful Rust crate to work with complex Enums and automatically build a 'Kind' Enum.

Rust's ownership system can sometimes feel a bit complex, but this article does a really good job at explaining why it is how it is and how each data structure plays a role in this.