https://gendignoux.com/blog/ Official website of Guillaume Endignoux Wed, 04 Mar 2026 17:51:11 +0000 https://gendignoux.com/blog/2026/03/02/swiss-marriage-tax.html https://gendignoux.com/blog/2026/03/02/swiss-marriage-tax.html This Sunday – incidentally on International Women’s Day – Swiss citizens will vote on an initiative about taxes for married couples: if it passes, married couples with tax residence in Switzerland will file taxes individually rather than jointly. The rationale behind this proposal is that married couples currently pay a different level of tax than if they weren’t married, due to how the tax formulas are set up. The current situation is sometimes referred to as “marriage tax”, because many couples pay more tax when they are married. And indeed, I know couples who choose not to marry because of this. Mon, 02 Mar 2026 00:00:00 +0000 https://gendignoux.com/blog/2025/03/03/rust-interning-2000x.html https://gendignoux.com/blog/2025/03/03/rust-interning-2000x.html This week-end project started by browsing the open-data repository of Paris’ public transport network, which contains various APIs to query real-time departures, current disruptions, etc. The data reuse section caught my eye, as it features external projects that use this open data. In particular, the RATP status website provides a really nice interface to visualize historical disruptions on metro, RER/train and tramway lines. Mon, 03 Mar 2025 00:00:00 +0000 https://gendignoux.com/blog/2024/12/02/rust-data-oriented-design.html https://gendignoux.com/blog/2024/12/02/rust-data-oriented-design.html This post is the second part of my adventures to optimize a Rust workload running on multiple threads. In the first post, I explored how the rayon parallelism framework works, and explained how I designed a faster replacement for my use case. Mon, 02 Dec 2024 00:00:00 +0000 https://gendignoux.com/blog/2024/11/18/rust-rayon-optimized.html https://gendignoux.com/blog/2024/11/18/rust-rayon-optimized.html In a previous post, I’ve shown how to use the rayon framework in Rust to automatically parallelize a loop computation across multiple CPU cores. Disappointingly, my benchmarks showed that this only provided a 2x speedup for my workload, on a computer with 8 CPU threads. Worse, the total “user” and “system” times increased linearly with the number of threads, meaning potentially more wasted work. Even Python was only twice slower than my Rust code, when Rust is typically 10x to 100x faster than Python. Mon, 18 Nov 2024 00:00:00 +0000 https://gendignoux.com/blog/2024/06/17/const-array-from-fn.html https://gendignoux.com/blog/2024/06/17/const-array-from-fn.html Writing const functions has been supported since Rust 1.31 in 2018. These functions can be evaluated at compile time, which is for example useful to shift expensive calculations before the program runs. Knowing values at compile time is also necessary for const generic parameters, a feature available since Rust 1.51 in 2021. Mon, 17 Jun 2024 00:00:00 +0000 https://gendignoux.com/blog/2024/04/08/xz-backdoor.html https://gendignoux.com/blog/2024/04/08/xz-backdoor.html Many discussions about open source dependencies and maintenance happened in the last month. Two posts caught my eye in the Rust ecosystem: Sudo-rs dependencies: when less is better about the Rust rewrite of sudo trimming its dependency graph, and On Tech Debt: My Rust Library is now a CDO about a Rust package being flagged as unmaintained, triggering complaints across downstream projects failing CI. And by now, you’ve likely heard about the backdoor in the xz-utils compression project. Mon, 08 Apr 2024 00:00:00 +0000 https://gendignoux.com/blog/2024/03/14/website-refresh.html https://gendignoux.com/blog/2024/03/14/website-refresh.html It’s been almost 8 years since I started this blog, and 3 years since my last behinds-the-scenes post when I had to reinstall my website due to a datacenter fire, so it’s high time for another update. In recent years, I decided to finally add a dark mode, which browsers have now supported for 5 years. However, this was easier said than done, as I first needed to inventory all the colors defined by layers of CSS frameworks, blog templates and my own additions. I ended up going down the rabbit hole and optimizing many other aspects of my website. Thu, 14 Mar 2024 00:00:00 +0000 https://gendignoux.com/blog/2023/03/27/single-transferable-vote.html https://gendignoux.com/blog/2023/03/27/single-transferable-vote.html In this blog post, I’m announcing STV-rs, a Rust implementation of Single Transferable Vote (STV) algorithms. STV is a voting method that allows voters to rank the candidates, with an iterative counting process that automatically re-distributes votes when candidates get elected or defeated. For example, considering the ballot “Alice > Bob > Charles”, if the candidate ranked first (Alice) loses the election (because she obtained the least number of votes), then the vote gets re-attributed to the candidate ranked next (Bob). A perhaps more surprising behavior of STV is that if Alice becomes elected, then some part of this vote is transferred to Bob as well. Mon, 27 Mar 2023 00:00:00 +0000 https://gendignoux.com/blog/2023/01/05/rust-arm-simd-android.html https://gendignoux.com/blog/2023/01/05/rust-arm-simd-android.html This blog post is the last one of a series exploring SIMD support with Rust on Android. In the previous two posts, I introduced how to compile Rust libraries for Android and detect SIMD instructions supported by the CPU at runtime. Thu, 05 Jan 2023 00:00:00 +0000 https://gendignoux.com/blog/2022/11/09/rust-simd-detect-arm-android.html https://gendignoux.com/blog/2022/11/09/rust-simd-detect-arm-android.html This post is the second of a series on testing Rust’s support of SIMD instructions on ARM with Android. In the first post, we’ve seen how to compile Rust libraries for Android with the command-line tools, and tested that we could reliably detect the CPU architecture. Wed, 09 Nov 2022 00:00:00 +0000 https://gendignoux.com/blog/2022/10/24/rust-library-android.html https://gendignoux.com/blog/2022/10/24/rust-library-android.html In a previous blog post, I mentioned how to use CPU-specific instructions in Rust to speed up the Shamir’s Secret Sharing algorithm. In my initial implementation, I only wrote an optimized version for Intel CPUs, but ARM supports similar instructions, so I mentioned that it would be nice to add an optimized implementation for it as well. Mon, 24 Oct 2022 00:00:00 +0000 https://gendignoux.com/blog/2022/01/31/rust-benchmarks.html https://gendignoux.com/blog/2022/01/31/rust-benchmarks.html In a previous blog post, I described some benchmarks I wrote for a program written in Rust. While presenting the results, I mentioned a strange behavior: things that should have been very fast (a few nanoseconds) were reported as instantaneous. I wrote that it was probably fine given that the bigger benchmarks (above 10 nanoseconds) were seemingly working well, following the expected asymptotic behavior. However, this prompted me to dig deeper to understand what was going on under the hood. Mon, 31 Jan 2022 00:00:00 +0000 https://gendignoux.com/blog/2021/11/01/horcrux-2-implementation.html https://gendignoux.com/blog/2021/11/01/horcrux-2-implementation.html In the previous blog post, I’ve described how Shamir’s Secret Sharing works from a mathematical point of view. In this blog post, I’ll focus on my Rust implementation. The motto of the Rust programming language is “empowering everyone to build reliable and efficient software”. I’ll therefore discuss how this applies to mathematical algorithms and cryptography, illustrated by my Horcrux implementation, which you can find on GitHub. Mon, 01 Nov 2021 00:00:00 +0000 https://gendignoux.com/blog/2021/11/01/horcrux-1-math.html https://gendignoux.com/blog/2021/11/01/horcrux-1-math.html As I mentioned in a previous blog post, I think that Rust is a good programming language to implement cryptographic algorithms, thanks to its memory safety, strong type system, ease of unit testing, and high performance. I’ve already experimented with that some years ago with the Gravity-SPHINCS algorithm that I designed during my master’s thesis. I recently wanted to try Rust again to implement a less niche algorithm, and notably see how more recent features of the language such as const generics can help with cryptography. I settled to write an implementation of Shamir’s Secret Sharing, which I you can find on GitHub under the codename Horcrux. Mon, 01 Nov 2021 00:00:00 +0000 https://gendignoux.com/blog/2021/04/08/rust-async-streams-futures-part2.html https://gendignoux.com/blog/2021/04/08/rust-async-streams-futures-part2.html In the previous blog post, we’ve learned how to use asynchronous streams in Rust. We’ve seen how to overcome the sometimes puzzling compilation errors that arise when we use the async keyword incorrectly, then studied how to buffer asynchronous queries in a stream to reduce overall latency, and in particular how unordered buffering can improve latency even further. Thu, 08 Apr 2021 00:00:00 +0000