Plein de choses :
- ton exemple n'a rien à voir avec un truc réel. Je parlais de typage statique, le genre de truc que l'on trouve dans ocaml, qui ne permet pas ce que tu écris.
- ton exemple n'a jamais été passé dans un prouveur automatique, la démo est manuelle (frama-c ?)
- il faut que l'expressivité soit compréhensible par le commun des mortels, why3 a l'air sympa comme coq, mais il faut être un matheux pour s'en servir. frama-c est un sous ensemble du C, et n'est même pas optimisant !
- c'est très rare d'avoir une spécification aussi simple, un compilo qui optimise, on compare le comportement de sa génération de code sans optimisation, et on colle un fuzzer devant. Imagines le bordel de convertir 500 HLR dans ce genre de langage.
- pour avoir bosser avec un prouveur, l'idéal est de pouvoir écrire un truc dans le même langage et lui demander si la sortie est toujours vrai. Dans le cas contraire, il fournit un contre-exemple. C'est juste énorme. En général, il répond qu'il ne sait pas faire.
Le typage statique est un tel outil. La plupart des systèmes de types n'évitent pas la nécessité de recourir à des tests unitaires, mais ils permettent de capturer certaines erreurs de raisonnement.
Le problème est que tu n'attrapes pas grand chose comme erreur avec un système de typage. La seul architecture que j'ai trouvé pour aider est de transformer un arbre en un autre, sans aucune information redondante ni inutile. Ainsi, un mauvais usage ne compile pas, et on ne traine pas l'entrée à l'intérieur du code. Cela marche bien dans les "filtres unix" mais dans rien d'autre, pour des raisons de performances si les données sont énormes ou pour des raisons pratiques comme l'optimisation d'un AST qui doit donner aussi un AST.
Si on regarde le gadt, la complexité est encore plus grande sans réellement attraper une énorme quantité de bugs supplémentaires. En gros, la complexité devient exponentielle, pour attraper des bugs de façon linéaire.
J'ai discuté avec l'auteur français de smarteffel(?), qui utilise beaucoup les contrats, il disait qu'en codant, il violait régulièrement même des contrats de base présent dans les containers, car la pile d’héritage en bénéficiait (les contrats n’héritent). C'était d'une grande aide pour lui.
Le problème est que le contrat est runtime et nécessite un test pour s’exercer. Il n'est pas possible d'avoir des contrats compile-time ou de vérifier leur cohérence entre eux ?
il est vrai que le langage des modules et foncteurs est assez verbeux.
Attention, la concision est souvent l'ennemi de la clarté. VHDL et ADA sont très verbeux mais très lisible. Je pense que l'abus de symbole est horrible pour la lecture. L'exemple typique sont les regexp Perl qui sont un cauchemar à lire, mais pas à écrire.
Je me demande même si les symboles ne prennent pas "plus de place" dans la tête car il ne se prononce pas, sauf les symboles de base (+).
module type M = sig
type t
val v : t
end
Pour moi, ce truc est bizarre car 2 mots clef se suivent ce qui est très rare ("Module type"), ensuite je lit "M = sig", sig étant un mot clef et ne m'indique pas du tout le début d'une liste qui se fait d'habitude avec des '(' ou des '{' ou des '[' voir des '<'. Ensuite, il y a le ':' qui alourdit la notation, alors que ocaml est ultra light d'habitude (pas de ',', ni de '(').
En go, cela donnerait :
type M module {
type t
var v t
}
(les types sont des valeurs comme les autres et vivent dans le même monde),
C'est génial ça, il existe un autre langage où c'est possible, ou c'est impossible à compiler ?
module type Showable = sig …
Tu te rends compte qu'en go, cette fonctionnalité se fait simplement avec une fonction String() dans un objet ? Elle est reconnu comme présent dans la bonne interface, et le tour est joué.
type Stringer interface {
String() string
} // est définit dans le code du package fmt
Les deux syntaxes sont assez proches : ce sont les mots-clés qui changent. Cela me semble utile, voire conseiller au niveau du principe de moindre surprise,
Non, elles ne sont pas proche justement, ni symétrique.
il serait surprenant que la syntaxe ne le signifie pas par un moyen quelconque : autrement on risquerait de confondre les deux notions.
C'est le but. Coq lui même ne fait pas la différence entre type et valeur, et c'est plus simple.
Je trouve la généricité, les modules très utile. Mais je trouve que leur forme dans ocaml est très complexe et très peu lisible. Cela parait peut être évident pour toi qui est tombé dedans que tu es petit. Mais pour un concept complexe, il faut qu'il ressemble le plus possible à quelques choses de connu (principe UX de moindre surprise). Les modules ressemblent ici vaguement à des objets, avec des définitions de type dedans, mais avec une autre syntaxe.
En fait, je pense qu'il doit être possible de proposer des modules en GO mais avec une syntaxe ultra simplifié pour la compréhension.
Genre :
package toto (type t, int i)
func sort(tab t[i]) {…
import "toto"(int, 1024) -> l'idéal serait d'avoir un seul module instancié pour ce couple de paramètre
Pour l’extension d'un package, j'imagine qu'il doit y avoir déjà l'équivalent d'un "open".
En fait, je pensais au cas d'usage qui reviennent au même. Dans l'esprit, c'est 3 façon d'écrire la même chose, c'est anti-ergonomique, même si c'est formel.
let rp : pt_2D = {x = 1.0; y = 2.0}
let op : obj_pt_2d = object method x = 1.0 method y = 2.0 end
module MP : mod_pt_2D = struct let x = 1.0 let y = 2.0 end
Ils veulent des exemples, et nous on voudrait les types sum. Ils manquent sans doute une bonne explication entre les 2.
L'idéal serait de faire la même chose pour transformer les packages en module, en rajoutant une déclaration "parameter" pour définir des paramètres à remplir à l'import d'un package ou simplement d'ajouter une liste de paramètre à la déclaration de package, puis de fixer un moyen de créer des package "complet" avec ses paramètres. Cela évite un peu la duplication de code, si l'instanciation est faite une seul fois. Si la syntaxe de ces paramètres est exactement symétrique avec des paramètres de fonction, cela devrait rester simple. Il reste la création de signature de package dont je ne vois pas trop à quoi il pourrait ressembler en go. L'idéal serait qu'un package soit à la fois une signature de module et un module, c'est plus simple.
Les modules permettent de pousser la généricité du code à un niveau inaccessible aux enregistrements et aux objets.
J'avais bien compris. Par contre, ce n'est pas du tout évident en lisant tes exemples. Et pourquoi 3 syntaxes différentes pour faire la même chose ou presque ?
"Il a comparé Linux, en 1992 quand Torvalds était encore qu'un étudiant, qu'il ne lui donnerait même pas la moyenne pour ce projet à cause de ce choix architectural dépassé."
Et on peut voir que Linus avait raison. Les tentatives de micronoyau ont tous abandonné, ou on finit avec des très gros noyau pour des raisons de performances (windows NT, le truc d'apple,…). Rien ne va plus vite qu'un appel de fonction.
Si tu veux de la sécurité, il faudrait activer les protections mémoires dans le noyau lui-même( avec une gestion de droit interne). Il le font bien maintenant même pour les DMA.
C'est démontré maintenant? Parce que j'avais retenu que le Go est lent.
En fait, c'est compliqué :
- go est un langage compilé, il n'a pas de warm-up time à la java et n'a pas de load d'une énorme jvm
- go n'a pas de fonction virtuelle, ce qui peut avoir un cout en java dans les piles d'appel de library
- le compilo go sait choisir entre allouer une variable ou la mettre dans la stack de la fonction, la pression sur la mémoire est moins forte (moins de boxing), et le Gc est largement au niveau de celui de java
- le modèle concurrent de Go est limpide et facile, il monte très bien à l'échelle (pas besoin d'être un dieu pour utiliser 20 cpu)
Donc, dans le cas général, d'un programme d'une taille raisonnable, go sera rapide, dans le cas d'un programme optimisé java sera plus rapide grâce au compilateur runtime.
Je n'ai pas eu le choix. Je voulais garder ocaml, mais pour faire un server web, c'est juste pas possible. ocsigen est peut être très bien, mais il faut un bac+12 en théorie des langages pour comprendre l'exemple de 100 lignes, en plus, ce n'est plus vraiment du ocaml.
La simplicité de go me repose l'esprit. Tu retrouves toujours les mêmes pattern de code, tu rentres en 10s dans un nouveau code. Tu ne passes pas ton temps sur une nouvelle particularité du langage. J'aime bien aussi le système d'interface qui rend inutile les class mère, ce qui permet d'avoir plus de réutilisation de code.
Tu ne travailles pas dans l'industrie, je me trompe ? Personne ou presque n'utilise de langage si avancé que ça. Un utilisateur d'ocaml/scala/haskell est vu comme un fou avant-gardiste. Les principaux langages sont toujours javascript, php, C, C++, Java, C#, perl, Go, ruby…
si elles demandaient d'introduire des choses difficiles à formaliser dans le langage.
Non pas seulement. Difficile à comprendre par exemple, le comportement de la généricité avec les sous classe, le comportement de l'héritage multiple en diamant, etc… La gestion des multiples constructeur en C++ qui nécessite de bien comprendre le fonctionnement sous-jacent.
En Ocaml, le code de base ne me pose pas de problème, si tu joues avec les modules et leur définition et un gadt au milieu, je vais beaucoup transpirer.
A l'inverse, l'immutabilité de Ocaml permet d'éviter le concept de pointeur que tout débutant déteste.
Bonne question : Vitesse de compilation, sécurité plus simple qu'en C++, un seul binaire : zéro runtime mammouth, faire un serveur web performant en 3 ligne, simplicité (beaucoup moins de blague que C++, ou de gestion mémoire que Rust), plus performant que Java.
C'est sûr qu'il ne faut pas coder en go comme en java.
1) pour avoir des briques de base sur lesquelles réfléchir
2) parce que la beauté théorique n'est qu'une des multiples dimensions d'un langage (clarté, simplicité, debug, vitesse de compile, performance au runtime, …)
Si on ne spécifiait tout qu'une seule fois, sans jamais aucun recouvrement, on ne pourrait pas détecter automatique d'incohérence.)
Je suis assez d'accord avec toi. Mais tu peux rajouter une dimension : on peut vouloir forcer l'usage d'une library d'une certaine façon (contrat). Ainsi, on évite les bug d'un usage de travers. Il y a duplication, mais dans le temps.
Cela me rappelle une discussion sur un codeur MS qui avait rajouter des checks de cohérence avec des assert() dans une lib. Ses utilisateurs râlaient, mais cela voulait surtout dire que des bug étaient masqués.
D'ailleurs si tu regardes la normes aéronautiques (FACE), il y a une description des variables d'entrée assez mortel avec 4 dimensions (ex: vitesse, vitesse par rapport au sol, en m/s, en fixe 32 bit de 0 à 300). Cela permet de coller des lib qui traitent de vitesse et de faire des conversions automatiques par génération de code statiques si l'unité n'est pas la bonne.
Par contre ça en a beaucoup pour la clarté du programme (sans annotation de type, c'est plus dur de lire le code et de comprendre ce qu'il fait), et la redondance apportée par ces annotations permet à nos outils (les compilateurs) de dire parfois "attention, tu utilises la variable x comme un pointeur, mais tu l'as déclarée comme un entier, n'y a-t-il pas confusion ?", ce qui élimine des bugs.
Il me semble que tu te limites trop. Tu embarques ça dans le terme "outils", mais je ne pense pas qu'un code informatique doit se limiter à du texte dans un éditeur de fichier. Eclipse introduit des sorte de lien hypertexte, l'auto-completion et la vérification d'erreur en ligne, cela aide beaucoup le codeur. Il y a une masse d'information qui pourrait être fournis par l'outil de dev, qui ne nécessite pas une notation du codeur. L'idée est qu'un codeur veut de la concision, quitte à faire trop de raccourci (oublies de vérifier les erreur ou les exceptions), mais un relecteur veut de la clarté (il est plus facile de vérifier l'oublie d'un test d'erreur qu'un catch d'exception). Un codeur veut un texte pour décrire ses objets rapidement, un relecteur veut un diagramme de classe ou de machine d'état ou de block pour tout appréhender rapidement.
Je pense vraiment qu'il faut arrêter de voir la sémantique d'un langage uniquement à travers une suite de caractère. Et la meilleur méthode pour écrire un code, n'est pas forcément la meilleur pour le relire.
ocaml sans l'objet et sans le gadt, et le coté module illisible pour non-initié est un super langage simple, mais avec un lib pauvre.
ELM http://elm-lang.org/ est un nouveau langage qui veut reprendre les bonne pratique des nouvelles lib javascript mais vérifier correctement l'usage (react, DOM virtuel…). Il inclus le type sum. C'est un truc à regarder.
Avec la lib de base de Ocaml tu ne fais pas grand chose. En dehors d'un "filtre unix", tu n'as rien sous la main (tout ce qui prend des fichiers en entré et qui produit une sortie). Tout ce qui est serveur ou interface graphique, est obsolète ou niveau bricolage dans ocaml.
Pour faire un compilateur ocaml est génial, pour du web ou une interface graphique, il faut tout refaire soi-même. c'est d'ailleurs pour ça que j'ai regardé golang.
Et si ocaml stagne, c'est Rust qui risque de lui prendre un peu de sa niche écologique restante.
une question d'approche par la simplicité (au risque d'être simpliste parfois), optique qui n'est pas du tout à la mode et qui manquait visiblement à pas mal de monde ; je pense que des langages avec des systèmes de types plus évolués pourraient essayer de s'en inspirer un peu.
Cela me rappelle ocaml qui est léger graphiquement en virant les "," et les "()" avec des mots clef simple comme "let" et "let in", et puis ils ont rajouté un tas de machin comme ".+", le truc le pire étant camlp4 et les notations à base de "<>" et autre "%". qui ressemble à du "modem line noise".
Un des trucs que j'aimais bien dans Lisaac, c'était sa syntaxe à mot clef. C'est à dire que l'on pouvait écrire des fonctions "à trou" genre func CreateUnObjet (string name) with (string comment). Dans les fonctions à grand nombre de paramètres, c'est plus lisible et moins lourd que les langages utilisant le nom du paramètres (ada, vhdl).
Un des trucs pourris mais finalement génial de ocaml, c'était l'absence d'espace de nom pour les type sum. Je pense que c'est génial, car il n'y a jamais aucune ambiguïté sur le mauvais usage d'un type. En cas d'usage de name space, celui-ci est souvent sous-entendu ce qui peut poser des problèmes pour retrouver le bon.
[^] # Re: Le cerveau n'est pas logique
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 2.
Plein de choses :
- ton exemple n'a rien à voir avec un truc réel. Je parlais de typage statique, le genre de truc que l'on trouve dans ocaml, qui ne permet pas ce que tu écris.
- ton exemple n'a jamais été passé dans un prouveur automatique, la démo est manuelle (frama-c ?)
- il faut que l'expressivité soit compréhensible par le commun des mortels, why3 a l'air sympa comme coq, mais il faut être un matheux pour s'en servir. frama-c est un sous ensemble du C, et n'est même pas optimisant !
- c'est très rare d'avoir une spécification aussi simple, un compilo qui optimise, on compare le comportement de sa génération de code sans optimisation, et on colle un fuzzer devant. Imagines le bordel de convertir 500 HLR dans ce genre de langage.
- pour avoir bosser avec un prouveur, l'idéal est de pouvoir écrire un truc dans le même langage et lui demander si la sortie est toujours vrai. Dans le cas contraire, il fournit un contre-exemple. C'est juste énorme. En général, il répond qu'il ne sait pas faire.
"La première sécurité est la liberté"
[^] # Re: Le cerveau n'est pas logique
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 4.
Il y a un rapport entre why3 et coq ?
"La première sécurité est la liberté"
[^] # Re: Le cerveau n'est pas logique
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 2.
Le problème est que tu n'attrapes pas grand chose comme erreur avec un système de typage. La seul architecture que j'ai trouvé pour aider est de transformer un arbre en un autre, sans aucune information redondante ni inutile. Ainsi, un mauvais usage ne compile pas, et on ne traine pas l'entrée à l'intérieur du code. Cela marche bien dans les "filtres unix" mais dans rien d'autre, pour des raisons de performances si les données sont énormes ou pour des raisons pratiques comme l'optimisation d'un AST qui doit donner aussi un AST.
Si on regarde le gadt, la complexité est encore plus grande sans réellement attraper une énorme quantité de bugs supplémentaires. En gros, la complexité devient exponentielle, pour attraper des bugs de façon linéaire.
J'ai discuté avec l'auteur français de smarteffel(?), qui utilise beaucoup les contrats, il disait qu'en codant, il violait régulièrement même des contrats de base présent dans les containers, car la pile d’héritage en bénéficiait (les contrats n’héritent). C'était d'une grande aide pour lui.
Le problème est que le contrat est runtime et nécessite un test pour s’exercer. Il n'est pas possible d'avoir des contrats compile-time ou de vérifier leur cohérence entre eux ?
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3. Dernière modification le 20 octobre 2017 à 10:18.
Attention, la concision est souvent l'ennemi de la clarté. VHDL et ADA sont très verbeux mais très lisible. Je pense que l'abus de symbole est horrible pour la lecture. L'exemple typique sont les regexp Perl qui sont un cauchemar à lire, mais pas à écrire.
Je me demande même si les symboles ne prennent pas "plus de place" dans la tête car il ne se prononce pas, sauf les symboles de base (+).
Pour moi, ce truc est bizarre car 2 mots clef se suivent ce qui est très rare ("Module type"), ensuite je lit "M = sig", sig étant un mot clef et ne m'indique pas du tout le début d'une liste qui se fait d'habitude avec des '(' ou des '{' ou des '[' voir des '<'. Ensuite, il y a le ':' qui alourdit la notation, alors que ocaml est ultra light d'habitude (pas de ',', ni de '(').
En go, cela donnerait :
type M module {
type t
var v t
}
C'est génial ça, il existe un autre langage où c'est possible, ou c'est impossible à compiler ?
Tu te rends compte qu'en go, cette fonctionnalité se fait simplement avec une fonction String() dans un objet ? Elle est reconnu comme présent dans la bonne interface, et le tour est joué.
type Stringer interface {
String() string
} // est définit dans le code du package fmt
Non, elles ne sont pas proche justement, ni symétrique.
C'est le but. Coq lui même ne fait pas la différence entre type et valeur, et c'est plus simple.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 4.
Le temps de re-rentrer dans du code perdu de vue depuis longtemps est un très bon moyen d'évaluer l'ergonomie d'un langage, je trouve :)
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3.
Pas mal. C'est simple, un type remplacer par génération, et élégant avec le code générique qui compile de base.
D'ailleurs, cela permet de voir la tonne de code généré si on s'amuse avec des modules génériques.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3.
Je trouve la généricité, les modules très utile. Mais je trouve que leur forme dans ocaml est très complexe et très peu lisible. Cela parait peut être évident pour toi qui est tombé dedans que tu es petit. Mais pour un concept complexe, il faut qu'il ressemble le plus possible à quelques choses de connu (principe UX de moindre surprise). Les modules ressemblent ici vaguement à des objets, avec des définitions de type dedans, mais avec une autre syntaxe.
En fait, je pense qu'il doit être possible de proposer des modules en GO mais avec une syntaxe ultra simplifié pour la compréhension.
Genre :
package toto (type t, int i)
func sort(tab t[i]) {…
import "toto"(int, 1024) -> l'idéal serait d'avoir un seul module instancié pour ce couple de paramètre
Pour l’extension d'un package, j'imagine qu'il doit y avoir déjà l'équivalent d'un "open".
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 5.
En fait, je pensais au cas d'usage qui reviennent au même. Dans l'esprit, c'est 3 façon d'écrire la même chose, c'est anti-ergonomique, même si c'est formel.
let rp : pt_2D = {x = 1.0; y = 2.0}
let op : obj_pt_2d = object method x = 1.0 method y = 2.0 end
module MP : mod_pt_2D = struct let x = 1.0 let y = 2.0 end
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 4.
Franchement écrit une proposition propre sur les type sum et poste un lien sur le blog de go 2.0
https://github.com/golang/go/wiki/ExperienceReports
Ils veulent des exemples, et nous on voudrait les types sum. Ils manquent sans doute une bonne explication entre les 2.
L'idéal serait de faire la même chose pour transformer les packages en module, en rajoutant une déclaration "parameter" pour définir des paramètres à remplir à l'import d'un package ou simplement d'ajouter une liste de paramètre à la déclaration de package, puis de fixer un moyen de créer des package "complet" avec ses paramètres. Cela évite un peu la duplication de code, si l'instanciation est faite une seul fois. Si la syntaxe de ces paramètres est exactement symétrique avec des paramètres de fonction, cela devrait rester simple. Il reste la création de signature de package dont je ne vois pas trop à quoi il pourrait ressembler en go. L'idéal serait qu'un package soit à la fois une signature de module et un module, c'est plus simple.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3.
tu devrais lire le lien sur la discussion sur les types sum.
Il demande par exemple comment filtrer "int | interface{}" sachant que interface{} fonctionne pour tout.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 4.
J'avais bien compris. Par contre, ce n'est pas du tout évident en lisant tes exemples. Et pourquoi 3 syntaxes différentes pour faire la même chose ou presque ?
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 2.
Oui mais si tu passes un tel GC sur 32 Go de RAM tu te retrouves avec des pauses de plusieurs secondes. C'est rarement acceptable.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3. Dernière modification le 19 octobre 2017 à 10:24.
Et on peut voir que Linus avait raison. Les tentatives de micronoyau ont tous abandonné, ou on finit avec des très gros noyau pour des raisons de performances (windows NT, le truc d'apple,…). Rien ne va plus vite qu'un appel de fonction.
Si tu veux de la sécurité, il faudrait activer les protections mémoires dans le noyau lui-même( avec une gestion de droit interne). Il le font bien maintenant même pour les DMA.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 2.
En fait, c'est compliqué :
- go est un langage compilé, il n'a pas de warm-up time à la java et n'a pas de load d'une énorme jvm
- go n'a pas de fonction virtuelle, ce qui peut avoir un cout en java dans les piles d'appel de library
- le compilo go sait choisir entre allouer une variable ou la mettre dans la stack de la fonction, la pression sur la mémoire est moins forte (moins de boxing), et le Gc est largement au niveau de celui de java
- le modèle concurrent de Go est limpide et facile, il monte très bien à l'échelle (pas besoin d'être un dieu pour utiliser 20 cpu)
Donc, dans le cas général, d'un programme d'une taille raisonnable, go sera rapide, dans le cas d'un programme optimisé java sera plus rapide grâce au compilateur runtime.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3.
Je n'ai pas eu le choix. Je voulais garder ocaml, mais pour faire un server web, c'est juste pas possible. ocsigen est peut être très bien, mais il faut un bac+12 en théorie des langages pour comprendre l'exemple de 100 lignes, en plus, ce n'est plus vraiment du ocaml.
La simplicité de go me repose l'esprit. Tu retrouves toujours les mêmes pattern de code, tu rentres en 10s dans un nouveau code. Tu ne passes pas ton temps sur une nouvelle particularité du langage. J'aime bien aussi le système d'interface qui rend inutile les class mère, ce qui permet d'avoir plus de réutilisation de code.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 4.
Tu ne travailles pas dans l'industrie, je me trompe ? Personne ou presque n'utilise de langage si avancé que ça. Un utilisateur d'ocaml/scala/haskell est vu comme un fou avant-gardiste. Les principaux langages sont toujours javascript, php, C, C++, Java, C#, perl, Go, ruby…
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 2.
Non pas seulement. Difficile à comprendre par exemple, le comportement de la généricité avec les sous classe, le comportement de l'héritage multiple en diamant, etc… La gestion des multiples constructeur en C++ qui nécessite de bien comprendre le fonctionnement sous-jacent.
En Ocaml, le code de base ne me pose pas de problème, si tu joues avec les modules et leur définition et un gadt au milieu, je vais beaucoup transpirer.
A l'inverse, l'immutabilité de Ocaml permet d'éviter le concept de pointeur que tout débutant déteste.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 2.
Bonne question : Vitesse de compilation, sécurité plus simple qu'en C++, un seul binaire : zéro runtime mammouth, faire un serveur web performant en 3 ligne, simplicité (beaucoup moins de blague que C++, ou de gestion mémoire que Rust), plus performant que Java.
C'est sûr qu'il ne faut pas coder en go comme en java.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 5. Dernière modification le 18 octobre 2017 à 17:17.
1) pour avoir des briques de base sur lesquelles réfléchir
2) parce que la beauté théorique n'est qu'une des multiples dimensions d'un langage (clarté, simplicité, debug, vitesse de compile, performance au runtime, …)
"La première sécurité est la liberté"
[^] # Re: Concernant la clarté
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3.
Je suis assez d'accord avec toi. Mais tu peux rajouter une dimension : on peut vouloir forcer l'usage d'une library d'une certaine façon (contrat). Ainsi, on évite les bug d'un usage de travers. Il y a duplication, mais dans le temps.
Cela me rappelle une discussion sur un codeur MS qui avait rajouter des checks de cohérence avec des assert() dans une lib. Ses utilisateurs râlaient, mais cela voulait surtout dire que des bug étaient masqués.
D'ailleurs si tu regardes la normes aéronautiques (FACE), il y a une description des variables d'entrée assez mortel avec 4 dimensions (ex: vitesse, vitesse par rapport au sol, en m/s, en fixe 32 bit de 0 à 300). Cela permet de coller des lib qui traitent de vitesse et de faire des conversions automatiques par génération de code statiques si l'unité n'est pas la bonne.
"La première sécurité est la liberté"
[^] # Re: Concernant la clarté
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 5.
Il me semble que tu te limites trop. Tu embarques ça dans le terme "outils", mais je ne pense pas qu'un code informatique doit se limiter à du texte dans un éditeur de fichier. Eclipse introduit des sorte de lien hypertexte, l'auto-completion et la vérification d'erreur en ligne, cela aide beaucoup le codeur. Il y a une masse d'information qui pourrait être fournis par l'outil de dev, qui ne nécessite pas une notation du codeur. L'idée est qu'un codeur veut de la concision, quitte à faire trop de raccourci (oublies de vérifier les erreur ou les exceptions), mais un relecteur veut de la clarté (il est plus facile de vérifier l'oublie d'un test d'erreur qu'un catch d'exception). Un codeur veut un texte pour décrire ses objets rapidement, un relecteur veut un diagramme de classe ou de machine d'état ou de block pour tout appréhender rapidement.
Cette vidéo est absolument à voir : https://www.youtube.com/watch?v=PUv66718DII C'est un rêve de dev d'avoir une boucle de rétroaction aussi rapide.
Je pense vraiment qu'il faut arrêter de voir la sémantique d'un langage uniquement à travers une suite de caractère. Et la meilleur méthode pour écrire un code, n'est pas forcément la meilleur pour le relire.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3.
Je suis du même point de vue.
ocaml sans l'objet et sans le gadt, et le coté module illisible pour non-initié est un super langage simple, mais avec un lib pauvre.
ELM http://elm-lang.org/ est un nouveau langage qui veut reprendre les bonne pratique des nouvelles lib javascript mais vérifier correctement l'usage (react, DOM virtuel…). Il inclus le type sum. C'est un truc à regarder.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 4.
Je pense que Renaut veut dire que la propreté formelle d'un langage ne le rend pas forcément clair et concis. C'est mieux, mais on peut vivre sans.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 3.
Avec la lib de base de Ocaml tu ne fais pas grand chose. En dehors d'un "filtre unix", tu n'as rien sous la main (tout ce qui prend des fichiers en entré et qui produit une sortie). Tout ce qui est serveur ou interface graphique, est obsolète ou niveau bricolage dans ocaml.
Pour faire un compilateur ocaml est génial, pour du web ou une interface graphique, il faut tout refaire soi-même. c'est d'ailleurs pour ça que j'ai regardé golang.
Et si ocaml stagne, c'est Rust qui risque de lui prendre un peu de sa niche écologique restante.
"La première sécurité est la liberté"
[^] # Re: go 2.0
Posté par Nicolas Boulay (site web personnel) . En réponse au journal Pourquoi la recherche en langages de programmation ?. Évalué à 4.
Cela me rappelle ocaml qui est léger graphiquement en virant les "," et les "()" avec des mots clef simple comme "let" et "let in", et puis ils ont rajouté un tas de machin comme ".+", le truc le pire étant camlp4 et les notations à base de "<>" et autre "%". qui ressemble à du "modem line noise".
Un des trucs que j'aimais bien dans Lisaac, c'était sa syntaxe à mot clef. C'est à dire que l'on pouvait écrire des fonctions "à trou" genre func CreateUnObjet (string name) with (string comment). Dans les fonctions à grand nombre de paramètres, c'est plus lisible et moins lourd que les langages utilisant le nom du paramètres (ada, vhdl).
Un des trucs pourris mais finalement génial de ocaml, c'était l'absence d'espace de nom pour les type sum. Je pense que c'est génial, car il n'y a jamais aucune ambiguïté sur le mauvais usage d'un type. En cas d'usage de name space, celui-ci est souvent sous-entendu ce qui peut poser des problèmes pour retrouver le bon.
"La première sécurité est la liberté"