De tout l'article (intéressant), je retiens surtout cette distinction qui est faire en préambule :

La liberté négative, typiquement américaine : "Je suis libre si personne ne m'empêche de faire ce que je veux." C'est la liberté comme absence d'obstacles — pas de régulation, pas d'entrave, la chimère du "c'était mieux avant".

La liberté positive : "Je suis libre si j'ai les moyens de réaliser mon potentiel." C'est la liberté comme construction — quelque chose qu'on bâtit "en plus", "à côté", pour augmenter les fonctionnalités de nos systèmes et les améliorer.

Juste une slide tirée de la présentation :

Que détestez-vous dans l’IA ?

• Son idéologie néo-fasciste ?
• Ses impacts écologiques désastreux ?
• Son rôle actif dans l’obsolescence programmée ?
• Son appropriation des ressources par quelques entreprises/multi-milliardaires ?
• Son exploitation de populations précaires ?
• Ses biais racistes ? Sa perpétuation de processus coloniaux ?
• Son besoin inhérent d’ancrer et d’intensifier une société de surveillance ?
• Son marketing de forceur ? Ses usages imposés ?
• Son adaptation des lois pour renforcer l’oligopole ?
• Son culte de la productivité ?
• Ses répercussions sur l’emploi au profit du profit ?
• Son dédain des conséquences cognitives et de perte d’esprit critique ?
• Son rôle majeur dans la mise en place d’une société post-vérité ?
• Son mépris du pourrissement des contenus d’internet ?
• Autre ?

Voici ce que Copilot en a à dire pour chaque point (et tombe complètement à côté de la plaque pour ce qui est du premier point) :

💣 1. Son idéologie néo-fasciste ?

L’IA n’a pas d’idéologie propre, mais elle peut être instrumentalisée par des régimes autoritaires pour renforcer le contrôle social, la surveillance de masse ou la censure. Des chercheurs alertent sur le risque d’automatisation des décisions politiques sans transparence ni débat démocratique.

🌍 2. Ses impacts écologiques désastreux ?

L’entraînement des grands modèles d’IA consomme énormément d’énergie et de ressources naturelles. Le coût carbone de certains modèles est équivalent à plusieurs centaines de tonnes de CO₂. Des efforts sont en cours pour rendre l’IA plus « verte », mais les progrès restent limités.

🛠️ 3. Son rôle actif dans l’obsolescence programmée ?

L’IA peut accélérer le cycle de remplacement technologique, en rendant rapidement obsolètes certains logiciels, appareils ou compétences. Cela alimente une consommation continue et une dépendance aux mises à jour, souvent dictées par les géants du numérique.

💰 4. Son appropriation des ressources par quelques entreprises/multi-milliardaires ?

Le secteur de l’IA est dominé par une poignée d’acteurs (Google, Microsoft, Meta, Amazon, OpenAI), concentrant les données, les infrastructures et les talents. Cette concentration renforce les inégalités économiques et le pouvoir de lobbying.

🧑‍🌾 5. Son exploitation de populations précaires ?

Des milliers de travailleurs précaires (souvent dans le Sud global) sont employés pour annoter des données, modérer du contenu ou entraîner des modèles, parfois dans des conditions dégradantes et mal rémunérées.

⚖️ 6. Ses biais racistes ? Sa perpétuation de processus coloniaux ?

Les systèmes d’IA reproduisent les biais présents dans les données d’entraînement. Cela peut mener à des discriminations raciales, sexistes ou sociales dans les décisions automatisées (recrutement, justice, santé).

🕵️ 7. Son besoin inhérent d’ancrer et d’intensifier une société de surveillance ?

L’IA est au cœur des dispositifs de reconnaissance faciale, de traçage comportemental et de prédiction policière. Ces usages posent des questions majeures sur la vie privée et les libertés individuelles.

📢 8. Son marketing de forceur ? Ses usages imposés ?

L’IA est souvent imposée dans des environnements professionnels ou publics sans consultation. Les discours marketing vantent des gains de productivité, mais occultent les impacts humains et sociaux.

⚖️ 9. Son adaptation des lois pour renforcer l’oligopole ?

Les régulations sont parfois influencées par les grandes entreprises du secteur, qui cherchent à modeler les lois à leur avantage. Cela peut freiner l’innovation indépendante et la protection des citoyens.

🏃‍♂️ 10. Son culte de la productivité ?

L’IA est souvent utilisée pour maximiser l’efficacité, parfois au détriment du bien-être humain. Elle peut intensifier les rythmes de travail, réduire les temps de pause et accroître la pression sur les employés.

👷 11. Ses répercussions sur l’emploi au profit du profit ?

L’automatisation par l’IA menace certains métiers, notamment dans les secteurs administratifs, industriels ou créatifs. Les gains économiques ne sont pas toujours redistribués équitablement.

🧠 12. Son dédain des conséquences cognitives et de perte d’esprit critique ?

L’IA peut encourager une dépendance aux réponses automatiques, réduisant l’effort de réflexion et la capacité à remettre en question les informations reçues.

🧪 13. Son rôle majeur dans la mise en place d’une société post-vérité ?

Les IA génératives peuvent produire des contenus trompeurs ou manipulés (deepfakes, fake news), rendant plus difficile la distinction entre vrai et faux.

🗑️ 14. Son mépris du pourrissement des contenus d’internet ?

L’IA contribue à la prolifération de contenus automatisés, parfois de faible qualité, qui saturent les moteurs de recherche et les réseaux sociaux. Cela nuit à la visibilité des sources fiables et humaines.

Le développement personnel n'existe qu'en tant que réaction individuelle à un système oppressif qui pousse les gens à bout.

J'ajouterais que c'est complètement soluble dans le capitalisme et la privatisation généralisée de tout.

One thing that Rust is great for is using the type system to encode states. With the (relatively) new sealed classes in Dart, it's possible to build something similar, relying on the type system to prevent any misuse of the API.

As an example, I'll create a robust HTTP response interface. This approach enforces valid state transitions while providing a clear and concise API for constructing HTTP responses. The implementation ensures the correct order of operations when setting the HTTP status code (which must be first), adding headers (from zero to any number, after the HTTP status, but before the response body), and defining the body of the response (which is the last thing allowed to do with the response).

Implementation

Here is the code, without syntax highlighting. Sorry about that, but you can actually copy-paste it to DartPad to make it pretty and run it! I also assume you have a window that is more than 80 characters wide, so I've longer lines here.

/// Represents the base class for HTTP response states.
sealed class HttpResponse {
  const HttpResponse();
}

/// Represents the initial state of an HTTP response.
class HttpResponseInitial extends HttpResponse {
  const HttpResponseInitial();

  /// Sets the status code and transitions to the next state.
  HttpResponseAfterStatus status(int code, String message) => HttpResponseAfterStatus(code, message, this);
}

/// Represents the state of an HTTP response after a status code has been set.
class HttpResponseAfterStatus extends HttpResponse {
  /// The HTTP status code.
  final int statusCode;

  /// The HTTP status message.
  final String statusMessage;

  /// The list of headers associated with the response.
  final List<Map<String, String>> headers;

  /// Creates an instance of [HttpResponseAfterStatus].
  HttpResponseAfterStatus(this.statusCode, this.statusMessage, HttpResponse previous) : headers = previous is HttpResponseAfterStatus ? previous.headers : [];

  /// Adds a header to the response, creating a new object.
  HttpResponseAfterStatus header(String key, String value) => HttpResponseAfterStatus(statusCode, statusMessage, this)..headers.add({key: value});

  /// Adds a header to the response, mutating the current object.
  HttpResponseAfterStatus header2(String key, String value) => this..headers.add({key: value});

  /// Sets the body of the response and finalizes it.
  void body(String text) {
    print('Response: $statusCode $statusMessage');
    headers.forEach((header) => header.forEach((key, value) => print('$key: $value')));
    print('Body: $text');
  }
}

void main() {
  // Example of a valid response
  HttpResponseInitial()
      .status(200, "OK")
      .header("X-Unexpected", "Spanish-Inquisition")
      .header2("Content-Length", "6")
      .body("Hello!");

  // Example of an invalid response (uncommenting will cause a compile-time error)
  /*
  HttpResponseInitial()
      .header("X-Unexpected", "Spanish-Inquisition"); // Error: statusCode not called

  HttpResponseInitial()
      .statusCode(200, "OK")
      .body("Hello!")
      .header("X-Unexpected", "Spanish-Inquisition"); // Error: header called after body
  */
}

 Explanation

In this implementation, a sealed class HttpResponse serves as the base for two subclasses: HttpResponseInitial and HttpResponseAfterStatus. The HttpResponseInitial class represents the initial state of the response, while HttpResponseAfterStatus captures the state after the HTTP status code has been set. The status method transitions from the initial state to the after-status state, allowing us to set the HTTP status code and message.

The header method creates a new instance of HttpResponseAfterStatus while adding a new header to the existing list of headers. This ensures that headers are not duplicated. Additionally, the header2 method allows for mutating the current instance by directly adding a header to the existing list. The two approaches are functionally identical, but there might be a runtime performance of recreating a new object for each header.

Finally, the body method finalizes the response by printing the status, headers, and body content.

This design enforces the correct order of operations, preventing invalid states such as adding headers before setting the status code or after defining the body.

Variation: State Type Parameter

Instead of having separate classes for each state, the state can be modeled as a type parameter for a single generic class. This approach reduces boilerplate and enhances flexibility, but it may be more complex to understand initially.

Consider the HTTP response example again. Here's how it can be modeled it using a state type parameter, using extensions to define operations that are valid only in specific states.

/// Represents the base class for HTTP response states.
sealed class ResponseState {}

/// Represents the initial state of an HTTP response.
class Start implements ResponseState {}

/// Represents the state of an HTTP response after headers have been set.
class Headers implements ResponseState {}

/// Represents the HTTP response with a state type parameter.
class HttpResponse<S extends ResponseState> {
  final int? statusCode;
  final String? statusMessage;
  final List<Map<String, String>> headers;

  HttpResponse({this.statusCode, this.statusMessage, List<Map<String, String>>? headers}) : headers = headers ?? [];

  /// Creates a new response in the Start state.
  static HttpResponse<Start> create() => HttpResponse<Start>();
}

/// Operations valid only in Start state.
extension StartOperations on HttpResponse<Start> {
  HttpResponse<Headers> status(int code, String message) => HttpResponse<Headers>(statusCode: code, statusMessage: message);
}

/// Operations valid only in Headers state.
extension HeadersOperations on HttpResponse<Headers> {
  /// Adds a header to the response, creating a new object.
  HttpResponse<Headers> header(String key, String value) => HttpResponse<Headers>(statusCode: statusCode, statusMessage: statusMessage, headers: headers..add({key: value}));

  /// Adds a header to the response, mutating the current object.
  HttpResponse<Headers> header2(String key, String value) => this..headers.add({key: value});

  void body(String text) {
    print('Response: $statusCode $statusMessage');
    headers.forEach((header) => header.forEach((key, value) => print('$key: $value')));
    print('Body: $text');
  }
}

void main() {
  // Example of a valid response
  HttpResponse.create() // Should even be directly using `status()` to create the object.
      .status(200, "OK") // This will return HttpResponse<Headers>
      .header("X-Unexpected", "Spanish-Inquisition")
      .header2("Content-Length", "6")
      .body("Hello!");

  // Example of an invalid response (uncommenting will cause a compile-time error)
  /*
  HttpResponse.create()
      .header("X-Unexpected", "Spanish-Inquisition"); // Error: status not called

  HttpResponse.create()
      .status(200, "OK")
      .body("Hello!")
      .header("X-Unexpected", "Spanish-Inquisition"); // Error: header called after body
  */
}

Using state type parameters provides several advantages:

• Conciseness: It reduces the number of classes needed to represent different states, making the codebase cleaner and easier to maintain.
• Single Documentation: All operations for the HttpResponse class are documented in one place, making it easier for users to understand the available methods and their valid contexts.
• Flexibility: Adding new operations that are valid in specific states or across multiple states becomes straightforward. For example, we can define operations that are valid in any state without needing to modify the existing structure:

  /// Operations available in any state.
  extension CommonOperations<S extends ResponseState> on HttpResponse<S> {
  int? get statusCode => this.statusCode;
  }

Unfortunately, I could not find a way to make the response creation as const.

Variation: state types that contain actual state

I tried to twist my code in a way to also implement the Variation: state types that contain actual state section of the article linked below, but without luck. I might be missing something.

Source

Inspiration drawn from The Typestate Pattern in Rust - Cliffle which is about Rust instead.

Et oui, bonne question ! Faire d'avoir une langue (presque) complément logique comme l'espéranto, on peut au moins rafistoler ce qu'on utilise quotidiennement !

Peut être à tester. Au moins à garder sous le coude pour le pas oublier le nom "Ergo-L" :)

Oh, ça semble intéressant pour une gestion de jardin

Voici un script bash (ou zsh) d'une ligne qui permet de faire de l'OCR sur tous les fichiers PDF du dossier courant:

for file in *.pdf; do ocrmypdf --output="pdfa" "$file" "${file%.*}_ocrmypdf.${file##*.}"; done

Version alias à mettre dans votre .bashrc ou .zshrc:

alias ocr='for file in *.pdf; do ocrmypdf --output="pdfa" "$file" "${file%.*}_ocrmypdf.${file##*.}"; done'

J'ai bricolé vite fait une spécifications Vega-Lite des amendes liées au RGPD.

Les données viennent directement en https://enforcementtracker.com mais avec des en-têtes qui bloquent la requête (CORS). Il faut donc ruser et demander au navigateur d'ignorer ça, grâce par exemple à CORS Everywhere.

Je me suis amusé à faire en sorte que la visualisation s'adapte au thème clair/sombre du système. Les plus curieux remarqueront que cette pas n'est stockée sur aucun serveur : tout est encodé dans l'URL.

Il y aurait beaucoup d'autres analyses à faire (histogrammes, tendencies, groupements par catégories, etc.), mais je n'ai pas le temps de creuser.

Joli outil pour faire du reverse engineering de fichiers.