David Delassus a écrit 762 commentaires

Prend l'exemple de la SDL.

Tu serais obligé de créer des unique_ptr<SDL_Window> et unique_ptr<SDL_Renderer> avec les deleters appropriés. Tu devras aussi encapsuler dans une classe l'appel à SDL_Init avec son destructeur qui appelle SDL_Quit. Tout plein de code qui complexifie une fonction pourtant toute bête.

Je t'avouerai en plus ne pas connaître suffisamment la spec pour te garantir dans quel ordre les destructeurs seront appelés. Ici, au moins, c'est explicite.

RAII c'est un design pattern parmi d'autres. Si tu utilises une lib C en C++ (SDL, lua, …), c'est parfois plus simple et plus clair d'avoir un simple defer.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Et voilà, après 5 relectures, je laisse ensemble de fonction au lieu de ensemble de fonctions.

Quand est-ce que je le vois ? Juste après avoir cliqué sur "Poster".

Si les modos passent par là…

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Ah si je pouvais être payé pour écrire ce qui me passe par la tête sur LinuxFR, j'écrirais peut être plus souvent que 2-3 articles tout les 4-5 ans.

C'est pas que je manque de sujet, c'est plutôt que si j'écrivais vraiment tout ce qui me passe par la tête, mon karma ne survivrait pas longtemps. Du coup je vous partage que ce qui selon moi vous intéressera.

Coup de bol, ce mois-ci, pour la première fois de mes 10+ années de moulage, je suis dans les meilleures notes, et 2 fois en plus ! Ça fait plaisir, j'ai gagné des points internets :D

Vivement le jour ou mon score de base de mes commentaires est de 2 ou 3 pour pouvoir m'accaparer plus de visibilité par défaut un peu partout sur le site…

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

https://fr.wikipedia.org/wiki/Club_des_27

Le club des 27, appelé aussi Forever 27 Club, 27 Club ou le Club 27, est le surnom donné à un ensemble d'artistes célèbres du rock et du blues qui ont comme point commun d'être morts à l'âge de 27 ans.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Le kernel : 6.6 Mo
Le initrd : ~40 Mo

Et les bins de busybox ~20Mo. J'aurais pu télécharger uniquement le binaire busybox et faire des hard links (cc ln) pour économiser de l'espace.

Mais oui j'ai pris celui de Debian tel quel, pour pas me prendre la tête, il y a beaucoup d'optimisations possibles.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Que tout le monde comprend, c'est pas évident, faudrait faire un sondage.

Comme je l'ai dit dans un autre commentaire. La majeure partie de la littérature informatique et technique est en anglais.

Il est donc très très peu probable qu'un individu ne rencontre jamais les termes anglais. Il est de même très probable que ce même individu ne rencontre jamais les termes français. D'ailleurs pour être honnête, la plupart de ces termes, je ne les vois QUE sur LinuxFR.

Au delà de ça, en fonction du contexte, tout le monde a probablement une limite d'acceptabilité de l'artificialisation du langage, dont la jargonnalisation procède.

Kamoulox!

Par exemple je trouve disgratieux et potentiellement pas clair l'idée d'uploader sa ssh-key pour checkouter son repo.

Merci de prendre cet exemple.

• "to download" -> télécharger
• "to upload" -> télécharger

Et non ! Téléverser est un néologisme, il n'existe pas dans le dictionnaire de l'académie française.

Du coup, la vraie traduction de "upload an ssh-key to checkout a repository", c'est "télécharger une clé SSH pour récupérer un dépôt".

On est d'accord que c'est sujet à confusion ?

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

j'ajouterai que les francisations qui n'existent (quasiment) pas dans le language courant sont vraiment reloues …

Exemple, toutes les déviations de "logiciel" :

• cadriciel, systématiquement je dois googler pour me rendre compte qu'on parle de "framework"
• progiciel pour logiciel propriétaire
• maliciel, pour malware
• gratuiciel, pour freeware
• cacaciel, pour la blague

Après, il y a les faux amis qui sont mal traduit :

• library -> c'est bibliothèque, pas librairie, merci

Je suis pour la francisation des termes, mais ça doit aussi refléter la réalité …

La réalité c'est que 99% de la littérature informatique et technique est en anglais. Et que la nomenclature qui en dérive, est anglaise. Pour un débutant dans le domaine, c'est difficile de devoir apprendre des termes que de toute façon personne n'utilise.

Je dis plus souvent kernel que noyau, je dis booter et pas démarrer, je continuerai de dire framework, library, software et bullshit au lieu de cadriciel, bibliothèque, logiciel et merde de taureau.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

La manie de vouloir absolument traduire les termes anglais que tout le monde comprend… moi je la comprend pas.

Release of Groovy 4.0

Ça se traduirait par :

Sortie de Groovy 4.0

Bien que Google Translate traduit "to release" en "libérer" (dans le sens libérer de prison). C'est pas le cas ici. Pour le coup "libération de [SOFTWARE]" ça signifie qu'il était propriétaire et qu'il est sorti sous licence libre. On est bien loin de la réalité ici.

Sur une note plus positive, ravi que le langage derrière les Jenkinsfile continue d'évoluer. Merci pour cette mise en bouche.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

bref, j'ai écrit un init qui se configure en Lua

Je suis un DevOps, le "Infrastructure as Code" c'est mon quotidien :D

Si tu te méfies pas, tu vas te retrouver avec une distrib perso :)

Là, on en est encore loin quand même :

• pas de gestion des users, il y a que root pour l'instant
• pas de gestionnaire de paquet
• pas une chaîne de compilation indépendante d'un système hôte (faire gaffe donc au chemin des .so, ou alors tout compiler en statique, ou alors tout plein de lien symboliques)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Mon RootFS utilise actuellement environ 70Mo.

Ce que tu décris est parfaitement possible, c'est le principe même des unikernel.

Il faut cependant noter que le processus init a un rôle particulier :

• il doit toujours tourner, si il s'arrête, kernel panic
• il doit écouter le signal SIGCHLD de tout ses enfants, et le traiter correctement, sinon les processus zombies de sont pas supprimé de la liste des processus
• il doit gérer les signaux ACPI pour éteindre la machine, rebooter, etc…

C'est la raison pour laquelle j'ai choisi BusyBox au lieu de développer le mien.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Yes, pas besoin de le préciser, mais je l'ai mis de manière explicite pour faire découvrir l'option du noyau, au cas ou tu veux t'écarter du FHS.

Je me suis amusé à faire un /apps/busybox/bin/* par exemple.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Je suis vraiment curieux de savoir quel type de technologie il y a là dessous :p

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Ben déjà parce que npm ne compile pas vraiment et que c'est compliqué de savoir ce que l'on garde ou pas, contrairement à un langage compilé qui sait tout ce qui est référencé.

Oui, c'est bien ce que je voulais souligner :

• langage interprété : beaucoup de dépendances == problématique
• langage compilé : beaucoup de dépendances == osef

cela vient aussi en doublon du gestionnaire de paquets de ta distrib.

Sauf que sous Linux, tu n'as pas 2 distributions qui fournissent les mêmes versions de la lib dont tu dépend. Ce qui rend la tâche difficile pour celui qui veut distribuer son logiciel. Plusieurs choix s'offrent à lui :

• supporter toutes les distros et chacune des versions de la lib via du code spécifique, des tests de régressions, etc…
• supporter une seule version de la lib et donc ne supporter potentiellement que peu de distro Linux
• se reposer sur des environnements type flatpak ou docker qui standardise entre plusieurs distro les libs incluses

Je te laisse deviner quel choix est le plus souvent fait.

Heureusement qu'on n'a pas attendu Rust pour faire de la compilation statique…

Vas-y, montre mois les binaires fait en C/C++ qui compilent statiquement boost, Gtk, Qt, et autres giga-lib, alors qu'ils n'utilisent que 3 fonctions de ces dernières.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Sauf que contrairement à npm, ça compile que les symboles nécessaire et ce de manière statique.

Le fait que tu n'as que peu de dépendances en C/C++ c'est dû au fait que tu n'as pas de réel gestionnaire de paquet pour ces écosystèmes. Au final, soit tu réinvente la roue, soit tu dépend d'une immense librairie type boost. Moue, j'ai jamais été convaincu.

En Rust, on a pris le meilleur de NPM (la réutilisation du code) sans les défauts (pas de node_modules de 8Go, versions fixées à mettre à jour explicitement donc pas de chaos dûe aux mises à jour auto de colors/faker/leftpad).

A la fin, on est bien content d'avoir un binaire unique qui n'inclus que ce qui est réellement utilisé. C'est plus facile à distribuer qu'un programme C/C++ qui dépend de dll/.so qui sont jamais distribués dans les bonnes versions par les distros.

C'est facile de cracher sur npm, c'est moins facile de regarder comment ça marche dans la réalité.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Rust est moins populaire que l'assembleur. Celle là me fait toujours sourire.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

https://www.youtube.com/watch?v=-4iFWhzU230 :)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Je comprends l'intérêt de "let x = y2 - 3*y + 2", mais pas de "let x2 -5*x + 3 = 6*y".

La deuxième forme n'est qu'une conséquence du fait que = est une opération. La plupart des langages appellent cette opération ==, du coup je comprend la confusion.

Au niveau de l'AST, j'ai :

pub struct LetStatement {
  expression: Box<Expression>
}

pub enum Expression {
  Add { lhs: Box<Expression>, rhs: Box<Expression> }, // +
  Sub { lhs: Box<Expression>, rhs: Box<Expression> }, // -
  // ...
  Eq { lhs: Box<Expression>, rhs: Box<Expression> },  // =
  // ...
}

Autoriser la première forme, c'est autoriser la seconde. Sachant que pour la seconde, si je connais la valeur de x et de y, il est logique de pouvoir faire ce test.

Ce qu'il faut comprendre, c'est que let ajoute des contraintes (qui doivent être compatibles avec les contraintes existantes) :

let (x, y): (int, int)
let x**2 - 5 * x + 3 = 6 * y  # tout seul ne sert pas a grand chose

x := get_int_from_stdin()
# si le user tape "0" alors :
# l'equation devient 3 = 6 * y
# il n'y a pas de solutions dans int
# ==> runtime error!

Ce qui pourrait aussi être utilisé comme il suit :

data := csv_data
  |> filter(record =>
    record.x ** 2 - 5 * record.x + 3 = 6 * record.y
  )
# data ne contient que les lignes qui valident l'équation

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Dans la théorie ZFC, qui est une théorie de fondation des mathématiques, au même titre que la théorie des catégories, on ne manipule que des objets que l'on pourrait qualifier d'ensemble.

La seule opération de base est appartient à (ou in). L'opération = est alors défini comme il suit :

• Soit A et B deux objets, A = B si et seulement si :
• Pour tout X appartenant à A, X appartient à B
• Pour tout Y appartenant à B, Y appartient à A

On peut définir les opérations union et intersection de la même manière.

On définit ensuite l'ensemble vide avec le théorème suivant :

• Soit 0 un objet tel que :
• Pour tout X, X n'appartient pas à 0

NB: En utilisant la définition de = et de 0, on arrive à prouver que l'ensemble vide est unique.

L'ensemble vide, je l'ai appelé 0 c'est pas pour rien. On peut définir quelques autres ensembles :

• 1 = 0 U { 0 } = { 0 } = { {} }
• 2 = 1 U { 1 } = { 0, 1 }
• 3 = 2 U { 2 } = { 0, 1, 2 }

A partir de cette construction, on peut créer la formule suivante : S(n) = n U { n }, ou S(n) est le "successeur de n".

NB : On peut définir l'opération A < B tel que A appartient à B.

Tout ça pour dire que = est très différent de in. En effet si on accepte A = B comme synonyme de B in A :

• on brise la définition même de l'opération = en théorie ZFC
• on insinue que A = B => B < A ce qui est contraire au sens commun

Enfin, on a défini let x: int, c'est bizarre de le considérer comme étant un ensemble d'int. D'un point de vue typage, ça passe pas non plus.

---

Fun facts:

• N = { 0, 1, 2, 3, ... } est un objet de la même forme que 0, 1, 2 etc…
• w = N U { N } est le successeur de N, et on a la définition des nombres ordinaux

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

> Ça serait dommage, mais c'est une éventualité que je n'exclu pas.
Je ne suis pas sûr de comprendre.

Ce que je voulais dire, c'est que si il s'avère qu'implémenter cette fonctionnalité est impossible ou apporte plus de problèmes que de solutions, je n'exclu pas de la retirer.

Mais au final, je me demande quand même, à part l'exploit, à quoi ça peut servir.

Cette idée est partie du concept de undefined, pour permettre de travailler avec les propriétés d'une variable sans forcément connaître sa valeur (ce qui se fait beaucoup en math).

Si tu prend l'exemple suivant :

let s: string
let l = std.strlen(s)
let l < some_buffer_maxsize

s := "foo"
let 3 = l

s := "hello"
let 4 = l

s := "too big for buffer"  # une erreur

Pas besoin d'écrire plusieurs fois std.strlen, on connait déjà la définition de l. En ajoutant une contrainte à la valeur de l, on contraint aussi les valeurs possibles de s.-

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Sans être méga lourd, je sais pas.

J'avoue qu'à part des solveurs SAT/SMT pour résoudre des Sudokus ou autre problèmes du genre, j'y connais pas grand chose.

J'ai réuni un ensemble de papier de recherche sur le sujet que je dois encore lire pour vraiment me faire une idée des possibilités et limitations.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Mais ça fait quoi si mon if est comme ça :

let x: int

if (x = 3)
   # plein de trucs à faire

Je fais plein de trucs, ou pas ?

Hahaha. Selon ma spec actuelle, oui tu fais plein de trucs.

Peut être rajouter un mot clé solvable <equation> pour éviter de perdre les développeurs non matheux ?

Ainsi:

let x: int

if (x = 3) ## error

if solvable (x = 3) ## true

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Félicitations pour ce travail !

Merci :)

Pour information, à combien estimes-tu le temps passé jusqu'ici sur la spécification du langage ?

Les premiers brouillons datent d'il y a 1 an et demi. En temps cumulé, je dirais bien 6 à 8 mois du coup.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Ça me semble aussi limite impossible dans l'absolu

Ça serait dommage, mais c'est une éventualité que je n'exclu pas.

Ce que je n'ai pas trop compris, c'est ce qui était censé être du ressort du compilateur.

Pour le coup, c'est comme les constexpr en C++ : si le compilateur peut le faire, alors il le fait. Sinon, c'est au runtime.

si ça se fait à l'exécution, ça va avoir une conséquence sur les perfs

Oui, mais je suis justement curieux de voir l'ampleur de cet impact.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

La sémantique est bien différente dans chacun de ces langages. Mais à l'usage, ça se ressemble.

Entre Python :

match val:
  SomeClass(a, b):
    # ...

  SomeOtherClass(c):
    # ...

Et Elixir :

case val do
  (:some_val, a, b) -> # ...
  (:some_other_val, c) -> # ...
end

Ou TypeScript :

type SomeTaggedUnion =
  | { t: 'SomeClass', a: osef, b: osef }
  | { t: 'SomeOtherClass', c: osef }

const f = (val: SomeTaggedUnion) => {
  switch (val.t) {
    case 'SomeClass': # ...
    case 'SomeOtherClass': # ...
  }
}

La réflexion du développeur est la même bien que l'implémentation du langage et le sens du code soit différent.

En Letlang on aurait donc :

class some_class(ab: (osef, osef))
class some_other_class(c: osef)

res := match val {
  some_class((a, b)) => # ...
  some_other_class(c) => # ...
}

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Indirectement,

Elixir compile en Erlang qui est inspiré de Prolog.

Je voulais vraiment intégrer de la programmation logique (cf prédicat des classes et ensembles et let).

En pattern matching par exemple, on utilise la notion d'unification (l'article parle justement de Prolog).

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg