Ainsi, les eaux de la Vienne affichent 28,49 °C en amont de la centrale et « seulement » 27,93 °C en aval, après avoir été mélangées à une eau rejetée à 24,65 °C.

TL;DR yes.

• creates-mirror
• cargo doc
• cargo add <crate> --offline from the global cache registry

The short version: one file, one process, and the heaviest page in the app served 315 million requests a day on a M1-laptop. For almost anything you are building, SQLite in WAL mode is enough, and the Postgres container you spun up out of habit was never needed.

The SQLite setup:

const db = new Database('chirp.db');
db.pragma('journal_mode = WAL');       // readers and the writer stop blocking each other
db.pragma('synchronous = NORMAL');     // fsync at checkpoints, not on every commit
db.pragma('busy_timeout = 5000');      // wait for the write lock instead of throwing
db.pragma('foreign_keys = ON');        // off by default, which surprises people
db.pragma('cache_size = -64000');      // 64MB of page cache

Under WAL, across every scenario, zero SQLITE_BUSY errors. Not "few." Zero.

Limits of SQLite:

• Reads stop scaling once anything writes.
• There is only one writer.
• One machine: the recovery time is always the time needed to restore a file.

Reach for Postgres when you have many writers contending on the same rows, when you need read replicas or automatic failover, when you need a real analytics engine over hundreds of millions of rows, or when your team genuinely needs the extension ecosystem. Those are real reasons."

Advantages of SQLite:

• Backups are a file copy. From the shell: sqlite3 chirp.db "VACUUM INTO 'backup-$(date +%F).db'"
• Local development is one file.
• Resetting the database is rm
• Tests get a real database each
• Deploys are a binary and a file
• There is nothing to operate

To optimize SQLite:

• focus on single-core speed
• buy enough RAM to hold the database: wait for GBs
• local NVMe. Never put SQLite on network storage.
• Pay for a dedicated core if you care about p99.
• Use strict tables
• Only INT, INTEGER, REAL, TEXT, BLOB, and ANY are allowed, and ANY is there when you actually want a key-value column. Store your JSON in a TEXT column and use the JSON functions on it.
• Prepare every query on startup. Making it on every request is a way to make SQLite look slow

The hardest part is user acquisition either way. Don't loose time on operations.

The reflex to start with a database server is a habit, not an engineering decision. It made sense when SQLite did lock the whole file on every write. That stopped being true a long time ago, and the tooling caught up: WAL for concurrency, STRICT for type safety, Litestream for replication.

But after programming in Rust for 10 years, I think that your coding style has the biggest impact on how your Rust code will look and feel.

People often say Rust’s syntax is ugly, but I’d argue the syntax is the least interesting thing about Rust. The semantics (the bits and pieces the language provides to express your ideas and how those bits combine to build interesting things) are much more important.

Parsing a .env can be clunky in basic algorithm, but elegant in Rust.

Tips:

• read_to_string() instead of using a path, opening a file, creating a vector, adding the content to the vector to make a string
• Use type inference: let mut cfg = HashMap::new()
• Lean into the typesystem:
  • .lines() to split strings safely and iterates over the lines
  • split_once() to get each key-value pair for each lines
• leverage error handling: use an enum to list all possible errors with important values and thiserror can handle the error message

fn parse_config_file(path: &str) -> Result<HashMap<String, String>, ParseError> {
    let content = read_to_string(path)?;

    let mut config = HashMap::new();
    for line in content.lines() {
        match KeyValue::try_from(line) {
            Ok(kv) => { config.insert(kv.key, kv.value); },
            Err(ParseError::InvalidLine(_)) => continue, // Skip invalid lines
            Err(e) => return Err(e), // Fail on any other error
        }
    }

    Ok(config)
}

and why this code structure offers more extensibility!

Rust’s beauty is in its semantics and the core mechanics it provides: ownership, borrowing, pattern matching, traits, and so on. If you merely look at its (admittedly foreign) syntax, you overlook the real elegance of the language.

If there is anything that makes Rust “ugly”, it isn’t its syntax but the fact that it doesn’t hide the complexity underneath. Rust values explicitness and you have to deal with the harsh reality that computing is messy. Turns out our assumptions about a program’s execution are often wrong and our mental models are flawed.

Fortunately, we can encapsulate a lot of the complexity behind ergonomic abstractions; it just takes some effort! So don’t worry: once you start to confront your bad habits and look around for better abstractions, Rust stops being ugly.

That’s also the reason NaN !== NaN. If NaN behaved like a number and had a value equal to itself, well, you could accidentally do math with it: NaN / NaN would result in 1, and that would mean that a calculation containing a NaN result could ultimately result in an incorrect number rather than an easily-spotted “hey, something went wrong in here” NaN flag.

How to check the value can be used for a calculation?

• typeof theValue === "number": to me too, it feels clunky th compare strings in order to use a number
• Number.isNaN() does exactly what it means: it checks for the NaN
• but the global function isNaN() returns true "“if I tried to make you into a number, would that work, or would you end up being NaN?"

Démarrer Firefox dans Firefox.

Pour les développeurs, il est donc possible de fabriquer une miniature de page ou prévisualiser du HTML directement chez le visiteur:

import { Gecko } from 'gecko.js';

const gecko = new Gecko({ canvas: document.querySelector('canvas')! });
await gecko.init();
await gecko.load('data:text/html,# hello from Gecko
');

(par https://simonwillison.net/2026/Jul/16/firefox-in-webassembly/)

Du coup, vous vous demandez peut-être pourquoi ces deux sites collectionnent les TLD les plus improbables du registre. Hé bien c'est pas du folklore, c'est une réponse directe à l'ARCOM. À chaque fois que les FAI français appliquent une salve de blocages DNS , les opérateurs enregistrent un nouveau domaine et redirigent leur public via des pages d'atterrissage et des canaux Telegram. La Belgique hérite donc d'un stock de domaines cramés par la France, et les bloque consciencieusement, un par un, avec plusieurs coups de retard.

Les TLD changent en quelques minutes. C'est fort.

Source: https://torrentfreak.com/pirate-sites-domain-hopping-habit-undermines-belgiums-new-blocking-order/

L’application stricte de cette conformité par « géofencing » valide d’ailleurs le constat de Mozilla : le respect du choix de l’utilisateur est actuellement conditionné par la pression réglementaire locale plutôt que par la philosophie de conception.

Simple white paint sprayed on the side of the rails can bring down temperatures 11 °C

Évidemment que Netflix, Amazon, Google et Meta concentre 49% du trafic en nombnre d'octets puisque la vidéo pèse plus lourd.

Il faut donc être conscient de cette limite en nombre d'octets: le transfert d'une vidéo sera toujours plus important qu'un PDF.

Les blocages comportent des erreurs

A simple strategy to build subproceses that does one thing and one thing well.

Ils attribuent en effet le rejet du distanciel au narcissisme des employeurs, qui essayent ainsi d’affirmer leur pouvoir et leur statut social.

https://www.lefigaro.fr/decideurs/management/les-besoins-des-narcissiques-et-des-machiaveliques-sont-differents-les-quinze-comportements-du-dark-leadership-20260221

Auprès du média américain, les trois scientifiques plaident finalement pour une hybridation du travail, en combinant des moments de concentration à la maison et des temps de collaboration dans l’open space. Ils incitent à des jours commun de présence, des moments de qualité plutôt qu’une présence constance et l’adaptation des règles aux besoins des métiers et des profils. Ils encouragent en définitive à ne pas mélanger des considérations d’ego avec des politiques d’entreprises, en conseillant aux dirigeants de ne pas imposer leur préférence personnelle mais de considérer les évolutions du travail et des attentes des collaborateurs. Quitte à renoncer à des formes traditionnelles de pouvoir.

Et vive les prix de licences, les données personnelles et l'enfermement.

Comment peut-il y a avoir des décisions aussi contradictoire ?

À l’issue de leur scolarité, les élèves deviennent propriétaires de leur machine.

Ok, mais quel est aussi le coût ? 23 millions.

Il souligne aussi que plusieurs matières du lycée, comme NSI, SNT, physique ou SI, nécessitent de la programmation et parfois l’usage du terminal d’un système d’exploitation libre, un usage que ChromeOS ne permet pas nativement.

Puisque c'est une porte ouverte à l'ensauvagement des données https://www.wired.com/story/denmark-google-schools-data/

An stdx