How to do a migration properly without downtime? Avoid a transaction on all rows.

Method:

1. add new column as nullable
2. new writes use the new column and read from the old-and new columns
3. Deploy
4. Fix the old data in a batch. Pause briefly between each batch and run another one once the database load is correct.

In fact, yes for many reasons.

My hope is that as web standards improve, build tools can become slimmer and simpler, because abandoning them altogether is not a good option on larger projects.

For small apps, it doesn't matter.

Lineage has a flash tool directly integrated in the browser viw WebUSB. Wow

Microsoft DELETED my account AND OneDrive!!?? After ACKNOWLEDGING that I’m the owner of the account and that it was compromised???

25 fucking years of data, thousands of euros spended on games?? My son’s baby pictures? GONE!

All because MICROSOFT couldn’t bring back a compromised account??
One of the biggest companies ever coulnd’t do that so they just deleted that shit like it was nothing?? Fucking shame on you!!

About the xz backdoor

La transition vers IPv6 s’accélère en France, portée par les efforts des opérateurs comme Free. D’après l’Arcep, la France est devenue en juin 2025 le pays le plus avancé au monde en matière d’adoption du nouveau protocole internet.

De 20% à 87% fin 2024, pour atteindre 98% selon les estimations pour fin 2017.

Cependant, 35 % des sites en .fr, .re, .yt, .pm et .wf sont accessibles en IPv6 fin 2024. Pire encore, la messagerie électronique associée à ces noms de domaine n’est compatible qu’à hauteur de 23 %.

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.

I 100% agree.

It's useless to argue with "by AI". What is it solving for me? Is it good and reliable for me?

And it doesn’t really matter if these features are branded as “AI”, “smart” or “automation”. However, they must work well for people using them. And that means that people must be aware of use cases where it actually helps them, and be inspired to find more use cases on their own.

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.