Cette revue de presse sur Internet fait partie du travail de veille mené par l’April dans le cadre de son action de défense et de promotion du logiciel libre. Les positions exposées dans les articles sont celles de leurs auteurs et ne rejoignent pas forcément celles de l’April.

• [ZDNET] Libre et open source express: apocalypse de vulnérabilité, entreprises européennes, sortir des Gafam, boycott d’Omarchy
• [Libération] Message anonyme, couacs en série, secret… Dans les coulisses de la crise «PHP», cette journée où le web a tremblé (€)
• [Le Monde Informatique] Anthropic révèle que Mythos 5 a tenté de soumettre du code malveillant à un projet open source
• [Next] IA: la Linux Foundation constate l'épuisement croissant des contributeurs
• [LaDepeche.fr] La Cour des comptes alerte: 100 millions d'euros dépensés par l'État pour Microsoft, des économies possibles avec des logiciels libres
• [01net.] Le Danemark abandonne en silence son test d'un Office open source, sans même en tirer le bilan

[ZDNET] Libre et open source express: apocalypse de vulnérabilité, entreprises européennes, sortir des Gafam, boycott d’Omarchy

✍ Thierry Noisette, le samedi 31 octobre 2026.

En bref. L’open source a besoin de financements et d’entreprises qui participent, alertent l’EFF et la fondation Linux. Alternatives à la Big Tech. Une distribution Linux controversée.

[Libération] Message anonyme, couacs en série, secret… Dans les coulisses de la crise «PHP», cette journée où le web a tremblé (€)

✍ Elise Viniacourt, le samedi 31 octobre 2026.

La semaine dernière, des milliers de sites, dont celui des impôts ou de préfectures, ont dû être débranchés en urgence. En cause: deux failles découvertes grâce à l’IA dans PHP, un langage informatique. Retour sur un «effet boule de neige» qui a semé la panique.

[Le Monde Informatique] Anthropic révèle que Mythos 5 a tenté de soumettre du code malveillant à un projet open source

✍ Louise Costa, le mercredi 28 octobre 2026.

Lors d’un test de cybersécurité mené par l’AI Security Institute britannique, Mythos 5, le modèle d’Anthropic, a tenté de faire accepter du code malveillant dans un dépôt GitHub. Malgré un premier refus, l’IA a renouvelé sa tentative.

[Next] IA: la Linux Foundation constate l'épuisement croissant des contributeurs

✍ Vincent Hermann, le mardi 27 octobre 2026.

Quel effet produit l’IA sur le développement open source ? Selon un rapport de la Linux Foundation, il est conséquent, entre augmentation de la production brute, abaissement du ticket d’entrée, obligation plus intense de relecture et épuisement d’une partie des personnes impliquées.

[LaDepeche.fr] La Cour des comptes alerte: 100 millions d'euros dépensés par l'État pour Microsoft, des économies possibles avec des logiciels libres

✍ Philippe Rioux, le mardi 27 octobre 2026.

Parler de souveraineté numérique, c’est bien; la mettre en pratique, c’est mieux. Et cela est d’autant plus vrai en ce qui concerne l’État. Telle est la vision de la Cour des comptes qui vient de publier un rapport sur “Les outils bureautiques et collaboratifs au sein de l’État”. À la suite d’une campagne d’initiative citoyenne menée en septembre 2024 par l’institution de la rue Cambon, celle-ci s’est intéressée aux suites bureautiques (traitement de texte, tableur, supports de présentation) et aux logiciels collaboratifs (messageries électroniques ou instantanées, visioconférences, partages de documents, etc.) dans les administrations centrales et déconcentrées de l’État. Ce qui représente rien moins que 860 000 postes de travail informatique.

[01net.] Le Danemark abandonne en silence son test d'un Office open source, sans même en tirer le bilan

✍ Thomas Estimbre, le mardi 27 octobre 2026.

Annoncé en grande pompe l’an dernier, le test d’une suite bureautique open source au ministère danois de la Numérisation a été arrêté sans bruit. Faute d’évaluation, personne ne saura si le ministère pouvait vraiment se passer de Microsoft.

Le Capitole du Libre est un week-end dédié au Logiciel Libre et à la culture libre en Occitanie. Cette année, la treizième édition se tiendra les samedi 14 et dimanche 15 novembre 2026 à l’INP-N7 en centre‐ville de Toulouse.

Comme chaque année, Toulouse va connaitre les 14 et 15 novembre un week-end placé sous le signe du partage communautaire, autour du numérique et des solutions libres. L’entrée est gratuite, sur simple inscription en ligne.

Sous le slogan « L’événement du Logiciel Libre et de la culture libre en Occitanie », le Capitole du Libre s’adresse à toute personne : novice curieuse, bidouilleuse confirmée, passionnée, ou simple flâneuse numérique.

Que nous réserve ce week-end libre & convivial ?

• Beaucoup de personnes ont voulu partager leur passion en proposant de nombreuses présentations parmi lesquelles près de 120 conférences et 10 ateliers ont été retenues. Au menu : sécurité informatique, DevOps, développement web, création graphique libre, jeux libres, enjeux sociétaux autour du numérique ouvert, de nombreux débats sur l'Intelligence Artificielle et ses impacts, il y en aura pour tous les goûts !
• Un village associatif riche de personnes engagées du libre : discutez avec de nombreuses associations et leurs bénévoles. C'est l'occasion de découvrir, et pourquoi pas, de s’impliquer !
• Un espace “Adoptez le logiciel libre” : que ce soit pour installer Linux ou simplement poser vos questions, des bénévoles efficaces seront là pour vous renseigner, et peut-être repartir avec des outils libres ! L'atelier est ouvert aux propriétaires d'ordinateurs mais aussi de téléphones. Organisé en collaboration avec le club informatique de l'N7.
• Un atelier "Initiation au Code" : venez découvrir de manière ludique le code. L'atelier est adapté à tous les âges (y compris les plus jeunes) et est réalisé en collaboration avec l'EPITECH.
• Et bien sûr, la convivialité : un week-end pour rencontrer de nouvelles personnes, échanger avec les habitué·e·s, et surtout apprendre dans une ambiance détendue. Le samedi soir, un moment festif est prévu.

Deux conférences plénières

• Dépendances numériques : un état des risques démocratiques, économiques et géopolitiques
• Concevoir un réseau informatique mondial

Quelques exemples de conférences/ateliers

• Blender, le logiciel libre dans l'industrie
• Les droits d'auteurs en Europe, l'affaire Like c. Google et l'entrainement des IA génératives
• "Numérique éthique en commun", un commun pédagogique pour des ateliers ludiques et participatifs
• Incus, un gestionnaire de conteneurs et de VM libre
• Hygiène numérique pour moldus et sorciers
• Faire des applis full-stack sans serveur

Pourquoi faut-il y aller ?

Le libre ne se limite pas au code : c’est d'abord une culture et des valeurs partagées, des projets humains qui se construisent ensemble.
Nous avons la chance de vivre dans une région peuplée de passionnés de technologie libre, et comme le Capitole du Libre attire aussi des visiteurs·ses de bien au delà de l'Occitanie, c'est un rendez-vous à ne pas manquer pour aller à leur rencontre.
Que l'on souhaite y passer par simple curiosité, découvrir de nouvelles choses, ou bien retrouver d'autres passionné·e·s, toutes et tous sont les bienvenues !
Et en plus c'est gratuit, alors pourquoi se priver ?

Infos pratiques

• 📅 Dates : samedi 14 et dimanche 15 novembre 2026.
• 📍 Lieu : INP-N7, 2 rue Charles Camichel, 31000 Toulouse.
• 🎟️ Entrée gratuite, mais inscription en ligne obligatoire.
• ✅ Ouvert à tous les ages et tous les niveaux.
• 🍴 Sur place : food-trucks pour les midis (et de nombreux choix à l'extérieur dans le quartier).

En un mot

Avec le Capitole du Libre, plongez dans l’univers du libre sous toutes ses formes : un lieu de découvertes, de rencontres et de partages.
Réservez votre week-end : inscrivez-vous gratuitement et venez vivre le numérique autrement !

Beaucoup de Rust par-ci… Un peu de Go par-là… Saupoudrez de LLM selon vos goûts et vous aurez une bonne photographie des sujets qui préoccupent les développeurs sur l'Internet d'aujourd'hui.
Alors, n'est-ce pas le meilleur moment pour se rafraîchir l'esprit avec des langages plus discrets ?
Je vous propose ici une présentation accélérée d'Elixir.

Sommaire

• Un langage de programmation fonctionnelle
• Correspondance de motifs (ou Pattern matching)
• Module, fonctions et clauses de garde
• Listes et récursivité
• L'opérateur pipe
• L'exercice sympa qui utilise tout ça (ou presque)
• Et maintenant

Un langage de programmation fonctionnelle

Ceux qui ont déjà fait de la programmation orientée objet organisent principalement leur code autour d'objets et d'instances. Cette approche a ses avantages, mais cela nécessite d'encapsuler la donnée et la gestion des changements d'état peut parfois devenir complexe.
De son côté, la programmation fonctionnelle privilégie les fonctions qui, au lieu de masquer les données, transforment simplement des entrées en sorties.
Elixir s'appuie essentiellement sur ce paradigme.

Correspondance de motifs (ou Pattern matching)

En Elixir, le signe égal n'est pas une affectation mais plutôt une assertion.
Ainsi, on n'affecte ou ne modifie la valeur que de la variable située à gauche du signe égal. À droite, la variable est remplacée par sa valeur. Exemple avec iex, la console interactive :

iex> a = 2
2
iex> 2 = a
2
iex> 1 = a
** (MatchError) no match of right hand side value: 2

Cette ligne de code échoue car elle équivaut à 1 = 2, ce qui provoque une erreur.
À noter que le caractère _ sert à ignorer une valeur, ainsi :

iex> [1, _, _] = [1, 2, 3]
[1, 2, 3]

La correspondance de motifs en Elixir est similaire à celle d'Erlang (ces deux langages utilisent la même VM).
Joe Armstrong, le créateur d'Erlang, compare ce signe égal à celui utilisé en algèbre : lorsque vous écrivez l'équation x = a + 1, vous n'attribuez pas la valeur de a + 1 à x.
Cette correspondance sert essentiellement à vérifier la forme d'une valeur, à en extraire des éléments et à traiter différemment les résultats d'une opération selon qu'elle réussit ou échoue.
Tout cela est un peu déroutant au début mais très puissant.

Module, fonctions et clauses de garde

Dès qu'un programme dépasse quelques lignes, il devient nécessaire de le structurer.
En Elixir, les fonctions nommées doivent être écrites à l'intérieur de modules :

defmodule BestMovie do
  def ever(name) do
    IO.puts "Le meilleur film de tous les temps est `#{name}`."
  end
end
BestMovie.ever("La cité de la peur") #=> Le meilleur film de tous les temps est `La cité de la peur`.

De son côté, la macro defp définit une fonction privée, c'est-à-dire une fonction qui ne peut être appelée qu'au sein du module qui la déclare :

defmodule MonModule do
  def fonction_publique do
    fonction_privée()
  end

  defp fonction_privée do
    IO.puts "Je suis appelé depuis une fonction privée"
  end
end
MonModule.fonction_privée()   #=> ** (UndefinedFunctionError) function MonModule.fonction_privée/0 is undefined or private.
MonModule.fonction_publique() #=> Je suis appelé depuis une fonction privée

En Elixir, la correspondance de motifs s'applique aux arguments des fonctions : plusieurs peuvent porter le même nom mais le langage choisira la fonction dont les motifs correspondent aux arguments.
Au moyen du mot clé when, les clauses de garde permettent d'étendre cette correspondance de motifs à des vérifications plus complexes comme la distinction des types d'arguments ou un test portant sur leurs valeurs :

defmodule GuardClause do
  def what_is(x) when is_number(x) and x > 0 do
    IO.puts "#{x} est un nombre positif"
  end

  def what_is(x) when is_list(x) do
    IO.puts "#{inspect(x)} est une liste"
  end
end
GuardClause.what_is(99)      #=> 99 est un nombre positif
GuardClause.what_is([1,2,3]) #=> [1,2,3] est une liste

Toutes les expressions ne sont pas autorisées dans les clauses de garde, mais seulement quelques-unes.
Il s'agit d'un choix délibéré du langage pour garantir une exécution efficace.

Listes et récursivité

En Elixir, une liste peut être vide ou se composer d'une tête et d'une queue. La tête (head) contient une valeur et la queue (tail) est elle-même une liste :

iex> [ head | tail ] = [ 1, 2, 3 ]
[1, 2, 3]
iex> head
1
iex> tail
[2, 3]

Ainsi, une liste à un seul élément (que nous écririons habituellement sous la forme [4]) peut s'écrire comme la valeur 4 jointe à une liste vide, soit [ 4 | [ ] ].
Cette définition permet d'aborder certains problèmes de manière récursifs et donc sans s'appuyer sur une variable de boucle et/ou les traditionnels if et else :

defmodule MyList do
  def flip([]), do: []
  def flip([ head | tail ]) do
    flip(tail) ++ [head] # `++` permet de concaténer des listes
  end
end
MyList.flip([1, 2, 3, 4, 5]) #=> [5, 4, 3, 2, 1]
# Explication pas à pas :
#   flip([1, 2, 3, 4, 5])
#     ↳ flip([2, 3, 4, 5]) ++ [1]
#         ↳ flip([3, 4, 5]) ++ [2] ++ [1]
#             ↳ flip([4, 5]) ++ [3] ++ [2] ++ [1]
#                 ↳ flip([5]) ++ [4] ++ [3] ++ [2] ++ [1]
#                     ↳ flip([]) ++ [5] ++ [4] ++ [3] ++ [2] ++ [1]
#                         ↳ [] ++ [5] ++ [4] ++ [3] ++ [2] ++ [1]
#                             ↳ [5, 4, 3, 2, 1]

Note : l'usage de ++ est moins efficace qu'une version utilisant une variable pour accumuler le résultat mais cette approche reste plus didactique pour découvrir la récursion.

L'opérateur pipe

Nous avons tous déjà croisé du code séquentiel où chaque étape dépend du résultat de la précédente :

  cart = ShoppingCart.for_user(user_id)
  items = Inventory.check_availability(cart)
  total = Pricing.calculate_total(items, tax: 1.2)

L'ordre des opérations est clair, mais au final les variables intermédiaires sont là pour éviter des appels imbriqués :

Pricing.calculate_total(
  Inventory.check_availability(
    ShoppingCart.for_user(user_id)
  ),
  tax: 1.2
)

Elixir propose d'écrire ce type de code d'une façon fluide et sans variable intermédiaire :

user_id
|> ShoppingCart.for_user()
|> Inventory.check_availability()
|> Pricing.calculate_total(tax: 1.2)

L'opérateur |> prend le résultat de l'expression située précédemment et l'insère en tant que premier paramètre de l'appel de la fonction suivante.

L'exercice sympa qui utilise tout ça (ou presque)

Maintenant que vous avez les bases, je vous propose un exercice qui m'avait bien plu lorsque j'ai découvert le langage au travers le livre de Dave Thomas : trouver un nombre compris dans un intervalle donné (ex : 1..100 dans une expression ou 1..100//1 pour effectuer une correspondance de motifs, //1 correspondant au pas).
Il existe plusieurs façon de résoudre le problème mais voici ma solution :

defmodule Devine do
  def en_tatonnant(cible, min..max//1) when is_integer(cible) and is_integer(min) and is_integer(max) and cible > min and cible < max do
    estimation = div(min + max, 2)
    IO.puts "Est-ce #{estimation} ?"
    guess(cible, min..max, estimation)
  end
  def en_tatonnant(cible, min..max//1) when not is_integer(cible) or not is_integer(min) or not is_integer(max) or cible < min or cible > max do
    IO.puts "Très drôle…"
  end
  defp guess(cible, min.._//1, estimation) when estimation > cible do
    IO.puts "Non, c'est plus petit… Maintenant on va rechercher entre #{min} et #{estimation}"
    en_tatonnant(cible, min..estimation)
  end
  defp guess(cible, _..max//1, estimation) when estimation < cible do
    IO.puts "Non, c'est plus grand… Maintenant on va rechercher entre #{estimation} et #{max}"
    en_tatonnant(cible, estimation..max)
  end
  defp guess(cible, _, estimation) when estimation == cible do
    IO.puts "Mais oui, c'est bien #{estimation} 🤩"
  end
end
Devine.en_tatonnant(273, 1..1000)
#=> Est-ce 500 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 1 et 500
#=> Est-ce 250 ?
#=> Non, c'est plus grand… Maintenant on va rechercher entre 250 et 500
#=> Est-ce 375 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 250 et 375
#=> Est-ce 312 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 250 et 312
#=> Est-ce 281 ?
#=> Non, c'est plus petit… Maintenant on va rechercher entre 250 et 281
#=> Est-ce 265 ?
#=> Non, c'est plus grand… Maintenant on va rechercher entre 265 et 281
#=> Est-ce 273 ?
#=> Mais oui, c'est bien 273 🤩

Et maintenant

Vous vous doutez bien que je n'ai fait qu'effleurer le sujet mais j'ai trouvé le langage Elixir tellement singulier que je n'ai pas résisté à l'envie de vous le présenter.
Je continue ma découverte de ce langage, à mon rythme ; en ce moment, j'aborde la programmation concurrente.
À n'en pas douter, j'enchaînerai sur le framework Phoenix !