See also https://jpegxl.info/art/

Also called german strings. This is a great data structure that explains how handling strings can be diverse.

Read ahead of time of the safety bound of the kernel...

An optimisation that I don't really understand.

10 to 20% performance boost... that's great!

About running Blue Dwarf

A lightweight 70 KB implementation of the Jinja template engine. It was 130MB with the python environment and moustache divided the payload size by 1857! It is useful to run it for CI/CD pipelines if a subset of Jinja is needed.

How to configure SQLite for

Using a simple INT with Unix millisecond timestamps is the best for performance.
COUNT is slow, so it can be useful to keep track of them in a separate table.

Distributed SQLite databases can be achieved the same way as PostgresSQL: one writer and multiple replicated readers.

Great insights too :)

I created a Cargo subcommand called cargo-wizard that simplifies the configuration of Cargo projects for maximum runtime performance, fastest compilation time or minimal binary size.

Avoid a round trip for the slow start TCP algorithm. Depending of the internet connexion it can save 100s of ms.

Some tricks the author uses and explains:

1. using <link rel="preload" as="ROLE" href="URL">` to download
2. lazy-loading the search index (and this feature) as it is not used widely, and costs bandwidth (1.8MB)
3. Reducing the cost of webfonts: shrinking the typeset of the font (especially for titles) + combining css files

The author reduced the page load from 11 seconds to 4 seconds with these.

There’s a standard way to make part of a page not visible until the user requests it: the

tag. You may have seen this on big code examples in some of my other posts.

All that we did to get this speedup is implement the Serialize trait using one line for the body of the serialize method!

But implementing the trait directly loses the possibility to serialize the structure with the #derive(Serialize) macro.

Instead, you should implement it on wrapper types that act like formatters.

Also for efficiency: format_args! doesn't allocate or even apply the formatting! It only returns Arguments which is a formatter that borrows its arguments.

Even after applying various default filters and providing a GUI to search and filter the remarks, there is still a lot of data to go through.

Understanding the remarks is quite challenging. What even is FastISelFailure or SpillReloadCopies? How can I change my Rust code to resolve these remarks? Hard to say if you’re not a LLVM expert.

How class encapsulation or closure can reduce the bundle size