Sylvain Kerkour

Location: Europe (GMT timezone) Remote: Yes (exclusively) Technologies: Go, Rust, VueJS, Typescript, VueJS GitHub: https://github.com/skerkour Blog: https://kerkour.com Résumé/CV: Upon request Email: sylvain.kerkour at gmail.com ---------------------------- After an attempt to launch my startup, I'm now looking for new technical challenges and to help make other people's lives better at the same time. In the past years I have designed and implemented a Machine Learning service (automatic product recognition), an end-to-end encrypted app, a security automation platform and APIs / Single page apps. I love open source and manage a moderately successful newsletter about it: https://kerkour.com ---------------------------- How can I help you?

Sherlock Holmes liked to say "When you have eliminated the impossible whatever remains, however improbable, must be the truth". The same is true for programming languages. When you have eliminated all the others for their fatal flaws, only Rust remains, so it's not "just a tool", it's the best tool (or less worse, depending on how you like the syntax). You can read more about the technical reasons here: https://kerkour.com/rust-software-engineering-reliability

Embassy and async Rust are probably the best things that have happened to the embedded world in the past decade! C RTOSes are conceptually nice, but such as pain to use in the real world, a lean framework like embassy is the natural evolution. The best thing is that embassy can actually be considered as a real-time "OS" (you can read more here: https://kerkour.com/introduction-to-embedded-development-with-rust).

I'm surprised the API doesn't follow the well known by now "1 write connection, n read connections" model, at least by default. See https://kerkour.com/sqlite-for-servers for that and more ideas.

There's also a great explanation of SQLite capabilities on the server and the various settings and their effects which have some overlap with Anže's settings: https://kerkour.com/sqlite-for-servers Previous (brief) HN discussion on that post: https://news.ycombinator.com/item?id=39383725 And, if this piques your interest, there was recently discussion on distributed SQLite from the same author: https://news.ycombinator.com/item?id=39975596

https://kerkour.com/sqlite-for-servers is a good read if you've not seen it before

EDIT: Paste this hacky snippet into your browser's console to save all of the links into your clipboard: (() => { let result = [...document.querySelectorAll('td a')] .map((link) => link && !link.href.includes('ycombinator') && !link.href.includes('javascript:void') ? link.href : '' ) .filter(Boolean); result = [...new Set(result)]; result.sort(); copy(result.join('\n\n')); })(); Just to help, here's a compiled-list of all of the links shared here so…

I think it would have been better to post this link, as it is easier for a casual reader to understand quickly what the project is about https://bloom.sh/ (From the Github page I wanted to know more and I initially clicked on a link to https://kerkour.com/ and from there I was lost, as that website doesn't seem to be about Bloom).

Firm disagree. Sylvain Kerkour described the problems Rust faces by having a limited standard library: "The time has come for Rust to graduate from a shadow employment program in Big Tech companies to a programming language empowering the masses of engineers (and not just "programmers") wanting to build efficient and robust sfotware. What crypto library should we use? ring, RustCrypto, rust-crypto (don't use it!), boring, aws-lc-s or openssl? Which HTTP framework? actix-web, axum, dropshot or hyper? What about a time library? time, chrono or jiff (how I'm even supposed to find this one)? You get it, if you are not constantly following the latest news, your code is already technical debt before it's even written. Fragmentation is exhausting. I just looked at the dependencies of a medium-sized project I'm working on, and we have 5+ (!) different crpyto libraries: 2 different versions of ring, aws-lc-rs, boring, and various libraries from RustCrypto. All of this because our various dependencies have picked a different one for their own cryptographic usage. This is insane, first because it introduces a lot of supply chain attack entry points, but also because there is no way that we will audit all of them" Source: https://kerkour.com/rust-stdx My moderate-sized Rust web service project requires 587 third-party crates which seems ridiculous. Fortunately, cargo makes it easy to manage the dependencies, but unfortunately I don't know how well supported or maintained the…

This is kind of missing the point. I can only speak for the company that sponsors LiteFS (I don't think any edge computing companies put 'otoolep up to doing rqlite, for instance). We love Postgres. Most of our users use Postgres. And Postgres works fine in edge/backhaul configurations; companies were doing geographically distributed Postgres read replicas long, long before we came around. That's where we got the idea. The idea of LiteFS is: * Most apps are read-heavy, and some of them are overwhelmingly read-heavy. * If you're read-heavy and can thus get away with it, there's a pretty significant performance win in replacing the networked n-tier architecture with SQLite, because Postgres round trips add up over the lifecycle of any given request. * In fact, that's so much the case that --- as Richard Hipp has been pointing out for over a decade --- you can blow off the N+1 problem and just write natural queries. I think Ben Johnson would be the first to tell you that LiteFS isn't a perfect fit for every application. We have systems that use both Postgres and LiteFS. Meanwhile, you have to dig to find it on our web page! It's an open source project that works everywhere Linux does. Dial back the cynicism a bit! :) A plug here for: https://kerkour.com/sqlite-for-servers Same author, and one of the best SQLite articles ever.

Uh, yeah, this is not the writing of someone with the experience to maintain a cryptography toolkit: https://kerkour.com/nist-cryptography-backdoor (I’m more worried about judgement calls than implementation correctness, it’s not about AI.)

Looks like it's that, plus vibe coding (in areas like crypto!) - https://kerkour.com/stdx

I'll stick to this advice: https://kerkour.com/rust-backend-services-problems

ESP32-S3 may be the worse model to run Rust on due to the XTensa cores that makes the toolchain unnecessarily complicated. The newer model, C3, C6, C5 all have RSIC-V cores which make it a dream to run Rust (basically: rustup target add riscv32imac-unknown-none-elf). Here is a good introduction: https://kerkour.com/introduction-to-embedded-development-with-rust

> countless articles explaining what should be done instead (e.g. https://kerkour.com/rust-stdx) Don't make me tap the sign: https://news.ycombinator.com/item?id=41727085#41727410 > Centralized package managers only add a layer of obfuscation that attackers can use to their advantage. They add a layer of convenience. C/C++ are missing that convenience because they aren't as composable and have a long tail of pre-package manager projects. Java didn't start with packages, but today we have packages. Same with JS, etc.

Technically SQLite can only have 1 writer at any given moment, but it can appear like it works across multiple writers and let it serialize the calls for you. By default SQLite will not do what you want out of the box. You have to turn on some feature flags(PRAGMA) to get it to behave for you. You need WAL mode, etc read: * https://kerkour.com/sqlite-for-servers * https://zeroclarkthirty.com/2024-10-19-sqlite-database-is-locked My larger question is why multiprocessing? this looks like an IO heavy workload, not CPU bound, so python asyncio or python threads would probably do you better. multiprocessing is when your resource hog is CPU(probably 1 python process per CPU), not IO bound.

I understand the frustration, I bought it too. But the man is very clear: https://kerkour.com/cloudflare-for-speed-and-security > Estimated date of final publication: 2025 (soon ™) If I'm not wrong, we're still in 2025 :)

There is a good chance this is the article the author mentioned reading: https://kerkour.com/sqlite-for-servers

There are some configurations that can allegedly allow SQLite to be more suited to higher and more concurrent load. I have never had to use them but people have written about it like at: https://kerkour.com/sqlite-for-servers

Why on earth would you link to a reddit post instead of the actual article? https://kerkour.com/rust-crate-backdoor#/

I encourage you to read this then: https://go.dev/blog/supply-chain. Edit: along with the authors own blog explaining their take: https://kerkour.com/supply-chain-attacks-and-backdoored-dependencies. The short version is, it's better to have a centralised (though proxyable, and opt-outable) central store of hashes of module content, but then provide flexibility over distribution. The concern is that a central package manager adds complexity and opportunity for security vulnerabilities without adding much value.

Hi author here. Logging is hard but you can't avoid it (https://kerkour.com/post/logging) so I'm trying to create an improved experience across all programming languages, let me introduce to you: Astroflow - The unified logging layer. An unified API for fast and configurable logging libraries. There is currently the Go version: https://github.com/astrocorp42/astroflow-go and the JavaScript version: https://github.com/astrocorp42/astroflow-js

https://www.jendrikillner.com/tags/weekly - Graphics Programming weekly https://halisavakis.com/category/technically-art - Technically Art weekly https://us17.campaign-archive.com/home/?u=ac8ab0580c321574fe178a646&am… - Blender Guru Newsletter https://twitter.com/search?q=Creative%20Code%20News%20(from%3AsableRap… - Creative Code News rarely: https://tympanus.net/codrops/collective - Codrops - web design news, resources https://speckyboy.com/?s=Weekly+News - Speckyboy - designers news https://kerkour.com/tags/newsletter - Kerkour - favorite links https://habr-com.translate.goog/ru/search/?q=%D0%B4%D0%B0%D0%B9%D0%B4%… - habr ru - various technical weekly news bookmarked: https://www.datascienceweekly.org/newsletters - Data Science Weekly https://this-week-in-rust.org - This Week in Rust https://www.fightaging.org/archives - Fight Aging

> Serve Stale Content While Revalidating (Not Working as Expected) > This is the only thing that I was not able to figure out. For good reason, because (at the last time I tried this earlier this year) Cloudflare documents stale-while-revalidate as if it's supported [1], but it isn't [2], [3]. Cloudflare instead has a different behaviour [4], [5] which helps in some circumstances but not all. I use Fastly's free CDN plan to get round this. 1. https://developers.cloudflare.com/cache/concepts/revalidation/ 2. https://community.cloudflare.com/t/support-for-stale-while-revalidate/… 3. https://community.cloudflare.com/t/when-will-cloudflare-fully-support-… 4. https://kerkour.com/cloudflare-stale-while-revalidate 5. https://stackoverflow.com/questions/48124415/does-cloudflare-support-s…

If you read the article you would know that this is just about changing defaults. You already could achieve this by editing your project's Cargo.toml. As is documented and discussed in several places over the years (google "shrink rust binary size"). The `strip` was added to rust nightly in 2020. 1: https://github.com/johnthagen/min-sized-rust 2: https://kerkour.com/optimize-rust-binary-size 3: https://rustrepo.com/repo/johnthagen-min-sized-rust 4: https://sing.stanford.edu/site/publications/rust-lctes22.pdf 5: https://arusahni.net/blog/2020/03/optimizing-rust-binary-size.html