❌

Vue normale

« Utiliser l’Histoire », de Jean-Christophe Piot

Par : Alias
17 septembre 2026 à 09:00

« Utiliser l’Histoire », de Jean-Christophe Piot

Depuis le temps que je suis Jean-Christophe Piot – Padre Pio sur lérézos – et que j’apprécie son travail avec Nota Bene, je suis très content de lire un de ses bouquins, d’autant que Utiliser l’Histoire parle d’un sujet qui me tient à cœur.

Ce sujet, c’est l’utilisation de l’Histoire. Oui, sans blague. Mais, plus précisément, l’utilisation de la matière historique par les personnalités publiques, le plus souvent pour appuyer leurs argumentaires. En général, ce n’est pas un très bon signe. Je suppose qu’il doit exister des contre-exemples, mais ils ne sont pas dans ce bouquin, dont le sous-titre est « Comment les politiques manipulent le passé ».

L’idée de Jean-Christophe Piot, c’est de reprendre une trentaine de citations – un peu plus, en fait – ayant trait à l’Histoire et, pour chacune, de rétablir la réalité derrière les clichés, le roman national et autres mythes. Sans surprise, il y en a plus – BEAUCOUP plus – à droite et à l’extrême-droite qu’à gauche.

Et le moins que l’on puisse dire, c’est qu’il y a de quoi faire! Il y a quelques à-peu-près vaguement compréhensibles (tout le monde ne peut pas être spécialiste en tout, mais la plupart de ces personnages disposent de collaborateurs qui sont censés vérifier ce genre de chose), mais il y a surtout un festival du cliché, quand ce n’est pas de la falsification idéologique pure et simple.

L’organisation des chapitres est chronologique, mais par rapport au sujet mentionné. Ainsi, on commence par les citations sur l’Antiquité (Sparte, Athènes et Rome), puis le fort mal nommé Moyen-Âge (de Clovis à Jeanne d’Arc, en passant par Charles Martel), puis l’époque dite moderne, surtout centrée sur la Révolution et Napoléon, et enfin la période contemporaine.

Si vous êtes comme moi et que vous avez une petite culture historique, de préférence avec une connaissance des enjeux de l’Histoire en tant que science humaine, il y a peu de chance que vous trouviez beaucoup d’éléments surprenants dans les rappels que fait Utiliser l’Histoire. L’intérêt de l’ouvrage est sans doute ailleurs: remettre en contexte (et par l’exemple) certains mécanismes du roman national.

En soi, le roman national n’est pas un problème: les gens ont toujours aimé se raconter des jolies histoires et je suis mal placé, en tant que rôliste et auteur, de les en blâmer. Le souci vient quand il se confond, voire remplace l’Histoire factuelle. Et il ne faut pas se leurrer: un tel remplacement n’est pas gratuit, il a toujours un but idéologique.

Et c’est ce que rappelle Utiliser l’Histoire – non sans un soupçon de malice (si les calembours vaseux, les jeux de mots plus ou moins honteux et les contrepèteries éculées vous ennuient, évitez de le lire). C’est à la fois un ouvrage de déchiffrage politique et, aussi, de vulgarisation historique et je ne peux que vous le recommander.

L’article « Utiliser l’Histoire », de Jean-Christophe Piot est apparu en premier sur Blog à part.


Pour soutenir Blog à part / Erdorin:

Blog à part est un blog sans publicité. Son contenu est distribué sous licence Creative Commons (CC-BY).

Si vous souhaitez me soutenir, vous pouvez me faire des micro-dons sur Ko-Fi, sur Liberapay, sur Patreon et sur Ulule.


« Utiliser l’Histoire », de Jean-Christophe Piot was first posted on septembre 17, 2026 at 9:00 am.

Stop Treating CSS Container Queries Like Traditional Media Queries

To be completely honest with you, I missed the news when CSS Container Queries first shipped. And when I finally heard about it, my very first thought was, “Why exactly do I need this when media queries already exist?”

I’m not proud of that reaction, knowing what I know now, but it was comforting to know that I wasn’t alone. In fact, there are legions of us out there.

What baffles me is that container queries aren’t a new feature, as it currently sits at around 94% browser support. And yet, very few people are actually using it. According to the State of CSS survey, 86% of developers are aware of container queries, but only 41.4% actually use them. Surveys can be biased and not completely representative of our entire field, but this one is certainly the best indicator we’ve got.

Kevin Powell also talked about this at SmashingConf Amsterdam 2026: Container Queries adoption has been terrible. And that is so strange to me, knowing that the ability for components to adapt to the size of their outer container has been at the top of so many CSS wishlists over the years.

I’m not particularly interested in how many people are using container queries as much as in how they are using them. I can’t account for everyone, but from what I’ve seen — including in my own early attempts — many of us are using them wrong.

The bottom line is that incorrect use comes down to the same impression I had when learning about them: they absolutely look just like media queries at first glance. And since they look similar, it’s easy to assume they serve similar purposes and work the same way.

They don’t.

Note: I should state up front that what I’m focusing on in this article is using container size queries, i.e., a responsive design technique for responding to the size of a particular container. There are also container style queries that respond to a container’s computed styles (and are experimental at the time of this writing). You can catch up on those in Juan Diego’s piece here on Smashing Magazine where he examines their possible use cases.

Media Queries Look Outward

The viewport is a proxy. It always has been. Media queries are what gave us the illusion that screen width alone is responsible for how responsive apps adapt to their environment.

Ask yourself this: When you write @media, what are you asking the browser?

@media (min-width: 1024px) {
  .card {
    display: flex;
  }

I, like most developers, am asking the browser: How wide is the screen right now? That’s it.

Media queries answer that beautifully, but what happens when this .card component is placed in a grid cell that’s 300px wide on a 1920px desktop screen?

The media query doesn’t care; it does its job. The viewport is still 1920px, so min-width: 1024px fires and the matched query styles are applied, even though the card only has 300px of space to work with. Eventually, everything in the card deforms, overflows, or cramps up.

“Media queries are dumb. Not dumb in terms of the concept, but dumb in that they don’t know very much. In fact, most people assume that they know more than they do.”

— Kevin Powell

It’s common to think of responsive design purely as a system for updating complete page layouts, like going from two columns on a large screen to a single column on a small screen.

Container Queries Look Inward

Container queries are smarter than that. They make responsive layouts more reliant on what’s happening inside a component rather than on the outer context that has no insight into a component’s contents. It is more like: “How much space is available for me in this specific spot, right now?”

Here is the same card code example we looked at in the last section, but with a container query:

.card-wrapper {
  container-name: card;
  container-type: inline-size;
}

@container card (min-width: 450px) {
  .card {
    display: flex;
    flex-direction: row;
  }
}

This changes everything. The card isn’t influenced by the viewport; its only concern is whether the .card component’s parent wrapper has at least 450px of inline (i.e., horizontal in a left-to-right writing mode) space. If that condition is true, the component goes horizontal; if not, it goes to its default block display.

The logic works like this:

  1. When there’s enough room, both items (.flex-item) sit side-by-side, each exactly half the parent container’s width.
  2. When there is limited space, the second item wraps to the next line.
  3. Because flex-grow is active on each item, the wrapped items stretch to fill most of the parent’s width.
  4. If the item is a container itself, it detects the sudden width expansion and fires.
/* The flex parent */
.flex-layout {
  display: flex;
  flex-wrap: wrap;
}

/* Register a flex item as a container */
.flex-item {
  container-type: inline-size;
  flex: 1 1 390px; /* Grow to fill space, wrap at 390px */
}

/* Default Card Styles (narrow / side-by-side) */
.card {
  display: flex;
  flex-direction: column;
  background: #f4f4f4;
}

/* Once there's enough room for a full row */
@container (min-width: 600px) {
  .card {
    flex-direction: row;
    align-items: center;
    background: #e2f0d9;
  }
}

This works. As the parent size shrinks and the cards wrap to two lines, the card item expands, the container query fires, and applies the necessary styles.

Conclusion

At the end of the day, the core reason why container queries look incredibly similar to media queries is simply familiarity. They’re not exactly “new”, but they are way less understood and adopted than media queries. But media queries have plenty of their own limitations; otherwise, we wouldn’t need container queries to fill those gaps.

What we have is a more effective feature for detecting when a specific component’s context changes and a means for adjusting styles based on its content, as it should be when that component can exist in multiple contexts.

❌