Revue des différents moyens de protéger son serveur contre les bots IA.

JSON module imports became baseline: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import/with:

import data from './data.json' with { type: 'json' };

and lazy-load it with:

const { default: data } = await import('./data.json', {
  with: { type: 'json' },
});

It makes sense to use JSON module imports for local static JSON resources where you need all/most of the data within. Particularly since bundlers can understand JSON imports, and bundle the object with other modules. That isn't possible with fetch(), unless you use some pretty hacky plugins.

Generally, I try to turn any "fetch-and-process" logic into a Vite/Rollup plugin, so it happens at build time rather than runtime.

1. Keep things short and remove filler content
2. Don't ask for too much.
3. Presume people are busy.
4. If a request blocks you, you're asking too late.
5. Absolutely never make it personal.
6. Be descriptive and don't presume prior knowledge.

Examples are provided after these rules.

Building up means starting with a tiny core and gradually adding functionality. Sanding down means starting with a very rough idea and refining it over time.

There are a few rules I try to follow when building up:

• Focus on atomic building blocks that are easily composable and testable.
• Build up powerful guarantees from simple, verifiable properties.
• Focus on correctness, not performance.
• Write the documentation along with the code to test your reasoning.
• Nail the abstractions before moving on to the next layer.

The alternative approach, which I found to work equally well, is “sanding down.” In this approach, you start with a rough prototype (or vertical slice) and refine it over time. You “sand down” the rough edges over and over again, until you are happy with the result. [...] I find that this approach works well when working on creative projects which require experimentation and quick iteration.

When using this approach, I try to follow these rules:

• Switch off your inner perfectionist.
• Don’t edit while writing the first draft.
• Code duplication is strictly allowed.
• Refactor, refactor, refactor.
• Defer testing until after the first draft is done.
• Focus on the outermost API first; nail that, then polish the internals.

Both variants can lead to correct, maintainable, and efficient systems. There is no better or worse approach. However, it helps to be familiar with both approaches and know when to apply which mode. Choose wisely, because switching between the two approaches is quite tricky as you start from different ends of the problem

Les entreprises d'IA majoritaires gèrent l'infrastructure et le développement de l'IA. Cela profite aux monopoles, et aux États-Unis. Même si d'autres entreprises émergent, les

Les IA sont instables, puisqu'elles ne peuvent permettre la confidentialité des données traitées. Le cas de Signal est pris en exemple: l'agent peut divulguer des messages confidentiels s'il y a accès.

Les entreprises d'IA sont valorisées, mais elles ne font aucun bénéfices.

Que faire? Premièrement, appliquer le RGPD.

Cache-Group-Invalidation invalidate a cache by name.

Pour maximiser la réutilisation et la transparence, tout logiciel développé conjointement est par défaut publié sous licence libre et open source.

Et pendant le prix

Bruxelles défend la concurrence, alors qu'elle saborde EDF.

EDF a racheté sa propre électricité a prix fort à ses concurrents qu'elle leur a vendu au rabais pendant la crise de la Covid.

L'Arenh hydroélectrique est aussi ajouté: 30% de la production hydroélectrique doit être revendu.

It was one of those moments where something you once knew suddenly clicks again with fresh significance. Here was a URL doing far more than just pointing to a page. It was storing state, encoding intent, and making my entire setup shareable and recoverable. No database. No cookies. No localStorage. Just a URL.

Good candidates for URL state:

• Search queries and filters
• Pagination and sorting
• View modes (list/grid, dark/light)
• Date ranges and time periods
• Selected items or active tabs
• UI configuration that affects content
• Feature flags and A/B test variants --> I never though about this one

Anti-Patterns to avoid:

• state only in memory SPAs
• sensitive Data in URLs
• inconsistent or opaque naming
• overloading URLs with complex state
• breaking the back button

A scroll-driven experience

La portée symbolique est grande.

Another post about semantic HTML, or the UX of HTML with <button>

Des fichiers .http normalisent les appels d'APIs