David Delassus a écrit 749 commentaires

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

En mathématiques, tu verras très souvant le genre de phrase :

Soit x blablabla

Ou en anglais :

Let x blablabla

Dans mes premiers brouillons, tout se définissait en utilisant le mot clé let (fonctions, classes, etc…). Ce qui a donné le nom Letlang.

J'ai fini par écarter cette dernière idée par soucis de lisibilité.

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

Tu veux un système symbolique ou numérique ?

Je ne me suis pas encore penché sur la question. J'avais gratté un peu la surface des solveurs SAT mais sans plus. Pour le coup, je compte contacter des gens plus compétents à l'INRIA pour m'aider sur cet aspect.

tu risques de te retrouver à devoir gérer des problèmes d’arrondis sur les flottants, d’intervalle et caetera …

J'avais imaginé utiliser libgmp pour représenter les nombres et esquiver les problèmes d'arrondi. A voir comment ça s'intègre avec le solveur d'équation.

J'espère pouvoir utiliser un solveur existant (et pourquoi pas plusieurs backend qu'on peut choisir à la compilation ?) et ne pas devoir en implémenter un de 0.

il y a des solveurs pour ça, https://choco-solver.org/docs/ qui fait les variables discrètes et aussi les flottants apparemment, ou http://www.ibex-lib.org/ pour les domaines flottants.

Je vais lire ça avec attention, merci! :)

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

Le système de contraintes (que je trouve vraiment cool) demander d'implémenter un solveur d'équation, c'est pas très lourd quand on dépasse les exemples simples ?

Exact, le solveur d'équation va être la fonctionnalité la plus difficile à implémenter, et je n'ai aucune idée des performances que cela donnera.

J'ai même songé à faire un bête appel à Wolfram Alpha pour le coup. Je vais sûrement essayer de les contacter à un moment.

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

je suis tout de même très impressionné par le volume de fonctionnalités.

Avant d'être impressionné, attend que je l'implémente :)

L'avantage que je vois immédiatement sur des langages comme Haskell, c'est l'expressivité de letlang

Cette expressivité tu la retrouves beaucoup en mathématiques, qui à l'avantage de pouvoir utiliser plus de symboles qu'il n'existe sur un clavier et de ne pas être limité à une seule ligne de texte pour écrire une expression.

Je m'étais d'ailleurs acheté "Principia Mathematica" et 2-3 autres livres, pour au final me rendre compte que cette expressivité vient du manque de règles dans l'écriture des mathématiques.

Merci pour ton retour en tout cas.

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

Bonne année aussi à toi ! :)

Tu décris ça comme un "side project", je suis plutôt impressionné.

Rien d'impressionnant pour l'instant, au niveau du code j'ai l'AST, et j'ai commencé à écrire le validateur sémantique. Même pas encore de parseur à l'heure actuelle (je compte faire ça avec la librairie pest).

Le plus abouti dans le projet, c'est le design de la syntaxe et des fonctionnalités.

À défaut d'avoir les compétences pour collaborer

J'avoue également manquer de compétences sur l'implémentation de certains aspects du langage, c'est l'occasion d'apprendre :)

succès qui dépendra probablement de la disponibilité d'une collection de modules standard

Pour moi, ce sera un succès le jour ou j'arrive à compiler un programme écrit en Letlang ^{^}

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

En quoi est-ce différent du système de haskell, dont les classes de type permet de résoudre élégamment se problème ?

C'est également similaire au système de type de TypeScript ou toute forme de pattern matching structurelle que l'on trouve en Erlang/Elixir, et qui commence à apparaître en Python avec match.

Ici c'est pour dire que l'information de type ne se situe pas au niveau de la variable. Il n'y aura pas de mot clé typeof par exemple.

Pour le système de contrainte, tu as vu juste :

let x-3 = 0 // => x = 3, c'est la seule solution

x:=2   // Erreur
x:=3   // Valide mais inutile, on sait déjà que x = 3

Quand on ajoute une contrainte, est-elle testé à la compilation ?

Comme je l'ai dit dans le disclaimer, très peu de code pour l'instant. Le but ultime est d'en faire un langage compilé vers LLVM IR, pour l'instant c'est un interpréteur.

Je compte faire le plus de vérifications possibles à la compilation, mais l'exemple suivant devra être testé à l'exécution :

let x: int
let x > 0
x := readline() |> parse_int()  # pipeline operator comme en Elixir

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

"Propagande politisée" n'en fait pas non plus parti.

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

Developpez.com est une très bonne source d'information technique : https://developpez.com/

DataTau, un équivalent de HackerNews pour les amoureux des data-sciences : https://datatau.net/

Medium, malgré son paywall, il y a de superbes articles par moment : https://medium.com

Après, je suis beaucoup sur youtube avec des chaînes comme :

• blackpenredpen (math) : https://www.youtube.com/c/blackpenredpen
• Cracking the Cryptic (puzzles) : https://www.youtube.com/c/CrackingTheCryptic
• Blitzstream (échecs) : https://www.youtube.com/c/VideosEchecs je vous recommande les analyses des parties du championnat du monde qui est en cours, Magnus contre Nepomniachtchi
• MindYourDecisions (math) : https://www.youtube.com/user/MindYourDecisions
• 3blue1brown (math) : https://www.youtube.com/c/3blue1brown
• MinutePhysics (physique) : https://www.youtube.com/user/minutephysics
• PBS Space Time (physique) : https://www.youtube.com/c/pbsspacetime
• PBS Infinite Series (math) : https://www.youtube.com/c/pbsinfiniteseries
• Primer (math, simulation, analyse) : https://www.youtube.com/c/PrimerLearning
• Reducible (algo) : https://www.youtube.com/c/Reducible
• Sebastian Lague (gamedev) : https://www.youtube.com/c/SebastianLague
• Stuff Made Here (robotique) : https://www.youtube.com/c/StuffMadeHere

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

Oui parce que la solution au spam c'est :

tu peux moinser les commentaires et journaux qui ne te satisfont pas pour quelques raisons que ce soit
tu peux étiqueter les journaux inutiles de manière à bien indiquer ta désapprobation

De demander aux utilisateurs de le faire ;

tu peux ne pas afficher les journaux en page d'accueil

De ne pas consulter une grande partie du site ;

le système actuel est bien fait

De suivre la politique de l'autruche, ignorer le problème, et laisser le contenu général du site perdre en qualité.

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

La tradition des journaux inutiles répondant aux journaux inutiles est ancienne :-)

Ce qui provoque un flot de "spam" sur la page d'accueil du site. Pas très attrayant…

Certaines traditions devraient tout simplement disparaître, ou alors on rajoute une section "toilette" sur le site et on tire la chasse de temps à autres.

Tu veux nous parler de https://datapio.co/ pour changer?

Quand le moment sera venu et que ce sera plus à l'état de PoC :p

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

Cool, LinuxFR devient vraiment une collection d'article inutile produit par des gens en manque d'attention.

Vous vous êtes cru sur Twitter les gars ?

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

Haha ok.

Le typage faible, c'est lorsque le compilateur/interpréteur n'est pas strict sur la vérification de type avant exécution du code.

La majorité des langages avec typage dynamique ont donc par définition un typage faible.

Je prend par exemple Python:

3 < "something"
int.__lt__(3, "something")

Et oui, on check pas le type on vérifie juste si la méthode est défini --> typage faible.

En Erlang/Elixir on peut comparer aussi différents types:

1 < :atom
1 == 1.0

C'est donc du typage faible.

Pareil dans les autres langages que j'ai cité.

Bordel, je pourrais rajouter le langage C/C++ dans le typage faible pour la bonne et simple raison que je peux aller chercher un pointeur sur la zone mémoire et convertir ça dans n'importe quel autre type.

Tu ne répond donc pas à la question, en quoi le typage faible est il un problème ?

Je vais même aller plus loin, l'appellation "typage fort" et "typage faible" n'a aucun sens, et est complètement inutile.

Tu ne répond d'ailleurs à aucune des autres critiques. Donc oui on va arrêter là car tu n'es clairement la que pour le troll.

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

Des micro-package c'est normal mais 1 ligne sérieusement….

Ce genre de chose c'est en aucun cas la faute du langage. Je peux t'écrire des libs de 1 ligne en Python, en Go, en Rust, en C++, etc…

Tu n'as qu'a pas les utiliser, personne t'y obliges.

Par contre si je pouvais avoir une lib pour implémenter String.capitalize avec les edge cases du type emoji, kanji et autres alphabets exotiques, etc… Je l'ajouterai sans regrets car j'ai pas envie de les gérer moi même.

J'espère qu'il y a les packages isEven, isOdd, isTrue et isFalse faudrait quand même pas devoir les implémenter moi même.

Cette partie, c'est du troll rien de plus…

Pas de stdlib

https://nodejs.org/docs/latest-v16.x/api/index.html

bourrés d'incohérences

Des exemples à la place d'un avis subjectif sorti de nul part ?

typage faible

Python, Erlang/Elixir, Lua, PHP, Perl, Ruby, … En quoi c'est un problème ?

C'est drôle tu défends JavaScript en nous parlant de Typescript.

Donc après avoir cité la norme EcmaScript, toutes les évolutions du language Javascript qui ont eu lieu et qui sont en cours, j'ai le malheur de mentionner Typescript une seule fois et c'est tout ce que tu retiens ?

C'est de la mauvaise foie pure et dure.

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