Discussion :

[Bill Fassinou]

Le langage de programmation V sera disponible en open source à partir de juin 2019
et serait rapide, léger et capable de traduire vos projets C/C++

L’équipe de construction du langage V annonce la disponibilité de sa version open source pour le mois de juin 2019. Le langage est présenté comme étant un langage très rapide et qui donne beaucoup plus de pouvoir aux développeurs. V dispose de caractéristiques très intéressantes selon son créateur. Sa syntaxe serait très semblable à celle de Go, le langage de programmation créé par Google et il est également influencé par d’autres langages tels que Oberon, Rust et Swift. Tel que défini par sa documentation, V est un langage de programmation compilé à typage statique conçu pour la construction de logiciels maintenables.

Le langage de programmation a été créé par Alex Medvedniko, un développeur néerlandais qui se dit énormément attaché à la simplicité et à la performance. Selon Alex, tout ce que vous pouvez faire avec les autres langages existants est également faisable avec V. Alex a indiqué avoir créé le langage V pour mener à bien son projet Volt. En parlant de Volt, il fait référence à un client de bureau natif pour Slack, Skype, Matrix, Telegram, Twitch et de nombreux autres services. Inutile donc de disposer d'une douzaine d'applications pour atteindre tous vos contacts sur différentes plateformes. Selon son concepteur, Volt est une application de bureau qui pèse dans les 250 Ko et consomme peu de ressource processeur et RAM.

Elle est également présentée comme pouvant gérer des centaines de milliers de messages sans retard et utilise des API d’interface utilisateur native (Cocoa sur Mac OS, API Win32 sur Windows, GTK+ sur Linux). Bien que simple, cela donne beaucoup de pouvoir aux développeurs, indique Alex. Tout ce que vous pouvez faire dans d'autres langues peut être fait en V. Il dispose de caractéristiques qui pourraient attirer de nombreux développeurs notamment sa rapidité et sa sécurité, sa légèreté et sa capacité à traduire l’entièreté de vos projets C/C++. La totalité du langage V et sa bibliothèque standard sont inférieures à 400 Ko et sa documentation renseigne que V peut compiler 1,5 million de lignes de code par seconde par cœur de processeur. Les principales caractéristiques du langage de programmation V sont présentées comme suit :

• une compilation rapide : V compile 1,5 million de lignes de code par seconde par cœur de processeur ;
• sécurité (pas de globales, immutabilité par défaut, fonctions partiellement pures, etc.) ;
• traduction C/C++ : V peut traduire votre projet C/C++ et vous offrir de la sécurité, de la simplicité et une compilation jusqu'à 200 fois plus rapide ;
• compilateur de 400 Ko avec zéro dépendance : le langage V entier et sa bibliothèque standard font moins de 400 Ko. Vous pouvez construire V en 0,3 seconde ;
• rechargement de code à chaud : obtenez vos modifications instantanément sans recompiler. Étant donné que vous ne perdez pas de temps non plus pour retrouver l'état sur lequel vous travaillez après chaque compilation, vous économiserez de précieuses minutes de votre temps de développement.

La documentation de V renseigne que le langage bénéficie d’une syntaxe simple et donc permet une prise en main plus que facile. « V est un langage très simple. Parcourir sa documentation vous prendra environ une demi-heure et à la fin, vous apprendrez à peu près tout le langage », lit-on. Dans la communauté des développeurs, on estime que la rapidité de V va beaucoup contribuer à son développement. « Les développeurs aiment la rapidité et la simplicité », disent-ils. Néanmoins, continuent-ils, il reste énormément de travail à accomplir sur V pour prétendre atteindre la rapidité du C qu’ils considèrent étant le langage le plus rapide.

D’après d’autres, la création et l'évolution d’un langage de programmation sont une tâche difficile. Il faut également beaucoup de temps pour écrire un ensemble correct de bibliothèques et éliminer la plupart des rides avant de pouvoir les utiliser en production. Sans quoi le langage n’évoluera pas, expliquent-ils. Selon ce qu’ils disent, au fur et à mesure que plus de personnes se lancent dans la programmation, de plus en plus de langues se profilent à l’horizon. Ils estiment que l’idée de V est bien sûr la bienvenue, mais sans un travail acharné et une communauté à l’appui, le langage ne fera pas long feu. « Je me demande quels seront les langages les plus populaires dans 10 ans », s’est interrogé l’un d’entre eux.

La version open source du langage sera publiée au mois de juin 2019, mais vous pourrez avoir un accès anticipé dès le mois de mai si vous rejoignez la communauté en tant que membre premium pour un minimum de 5 dollars. En attendant, vous pouvez accéder à la documentation ainsi qu’à la FAQ dédiée à ce dernier pour en savoir davantage sur V et sa syntaxe.

Source : Billet de blog

Et vous ?

Que pensez-vous de ce nouveau langage de programmation ?
Serait-il vraiment capable de rivaliser avec Go, C++ et autres comme l'indique son développeur ?

Voir aussi

Python est sacré langage de programmation de l'année 2018 par l'index TIOBE, deviendra-t-il le langage le plus utilisé des programmeurs ?

Le logiciel de programmation graphique Scratch passe à la version 3.0 et intègre des extensions

Éducation : Python bientôt langage officiel de programmation en France ? Un projet dans le cadre de la réforme du Bac et du lycée

[Matthieu Vergne]

Ne pas confondre simplicité et simplisme. La simplicité de Go implique notamment l'absence de génériques ou équivalent, ce qui impose pas mal de code redondant qu'on n'a pas dans les langages en ayant, comme Java. Si ce langage est encore plus simple, c'est qu'il doit en faire encore moins. En poussant jusqu'au bout la simplicité, au final en on viendrait à faire une simple machine de Turing, qui peut tout faire aussi. Le prix à payer en est cependant que, pour faire des choses évoluées, il faut beaucoup plus de code. Que le langage soit simple et qu'il permette de tout faire veut généralement dire que c'est au développeur de faire l'effort que le langage ne fait pas.

J'avoue ne pas avoir lu plus que ce que dit l'article, mais si c'est pour me retrouver avec un langage qui me donne plus de travaille à faire, ça n'a aucun intérêt. Pas question de retourner à l'assembleur. Très certainement que, comme Go s'oriente sur des applications hautement concurrentes, ce langage s'oriente vers un usage spécifique, justifiant ainsi les choix de simplifications effectués. Je prendrais donc cette affirmation de "pouvoir tout faire" avec des grosses pincettes : si c'est techniquement possible, je ne doute pas que certaines applications se feront mieux avec un autre langage que V.

[Cassoulatine]

Très intéressant. Merci pour l'info.

[Pyramidev]

Je viens de lire la documentation actuelle du langage V.
De ce que je connais du langage Go, V se rapproche du langage Go surtout sur ces deux critères : la simplicité et le sous-typage structurel.

Pour illustrer le sous-typage structurel du langage V, je vais prendre un extrait de la documentation de V et écrire le code équivalent en Go, en Rust et en C++.

Voici un extrait de la documentation du langage V :

Interfaces

Code V :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct Dog {}
struct Cat {}

fn (d Dog) speak() string { return 'woof' }
fn (c Cat) speak() string { return 'meow' }

interface Speaker {
	speak() string
}

fn perform(s Speaker) { println(s.speak()) } 

fn main() {
	dog := Dog{}
	cat := Cat{}
	perform(dog) // ==> "woof" 
	perform(cat) // ==> "meow" 
}

A type implements an interface by implementing its methods. There is no explicit declaration of intent, no "implements" keyword.

V interfaces are very efficient. There's no dynamic dispatch.

Dog et Cat sont automatiquement des sous-types de l'interface Speaker, car ils ont chacun une méthode speak compatible avec celle déclarée dans l'interface Speaker.

Sur ce point-là, c'est comme le langage Go (à part le fait que le dispatch se fait à la compilation et pas au runtime). Voici un code équivalent en Go que l'on peut exécuter en ligne dans la page The Go Playground :

Code Go :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main
 
import (
	"fmt"
)
 
type Dog struct {}
type Cat struct {}
 
func (d *Dog) speak() string {
	return "woof"
}
 
func (c *Cat) speak() string {
	return "meow"
}
 
type Speaker interface {
	speak() string
}
 
func perform(s Speaker) {
	fmt.Printf("%s\n", s.speak())
}
 
func main() {
	var dog Speaker
	var cat Speaker
	dog = &Dog{}
	cat = &Cat{}
	perform(dog)
	perform(cat)
}

En Rust, par contre, il faut écrire explicitement que Dog et Cat sont des sous-types du trait Speaker. Voici un code équivalent en Rust que l'on peut exécuter en ligne dans la page Rust Playground :

Code Rust :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
struct Dog {}
struct Cat {}
 
trait Speaker {
	fn speak(&self) -> &'static str;
}
 
impl Speaker for Dog {
	fn speak(&self) -> &'static str {
		"woof"
	}
}
 
impl Speaker for Cat {
	fn speak(&self) -> &'static str {
		"meow"
	}
}
 
fn perform(s: &Speaker) { println!("{}", s.speak()); }
 
fn main() {
	let dog = Dog{};
	let cat = Cat{};
	perform(&dog); // ==> "woof" 
	perform(&cat); // ==> "meow" 
}

En C++, si on fait de la programmation par templates, on n'a pas besoin de déclarer une interface Speaker. Voici un code équivalent en C++ que l'on peut exécuter en ligne dans la page Coliru :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <string_view>
 
struct Dog {
	std::string_view speak() const { return "woof"; }
};
 
struct Cat {
	std::string_view speak() const { return "meow"; }
};
 
template<class Speaker>
void perform(Speaker const& s) { std::cout << s.speak() << '\n'; } 
 
int main() {
	const auto dog = Dog{};
	const auto cat = Cat{};
	perform(dog); // ==> "woof"
	perform(cat); // ==> "meow"
	return 0;
}

Dans ce code C++, c'est lorsque le compilateur compile perform(dog) qu'il instancie la fonction perform<Dog>. Et c'est quand il instancie perform<Dog> qu'il vérifie si l'écriture s.speak() est bien valide pour le type Dog. Comme il n'y a pas besoin de déclarer explicitement une interface, on peut voir ça comme une sorte de duck typing à la compilation, ce qui a ses avantages et ses inconvénients.

Sur le site du langage V, dans la page qui compare V avec d'autres langages, on peut voir la comparaison suivante avec le langage Go :

V is very similar to Go, and these are the things it improves upon:
- No global state
- Only one declaration style (a := 0)
- No null
- No undefined values
- No err != nil checks (replaced by option types)
- Immutability by default
- Much stricter vfmt
- No runtime
- Much smaller binaries
- Zero cost C interop
- No GC
- Fearless concurrency (no data race guarantee at compilation)
- Generics
- Cheaper interfaces without dynamic dispatch
- Centralised package manager

À première vue, le langage V me semble mieux conçu que le langage Go.

Cependant, puisque le langage V veut être simple (comme le langage Go), la contrepartie est que l'on n'a pas beaucoup de fonctionnalités. Par exemple, dans le site, je n'ai rien vu pour faire de la métaprogrammation. (En Rust, on peut définir des macros.)

@Matthieu Vergne : selon la doc, le langage V a bien les generics. Tu peux jeter un coup d'œil. La doc est encore toute petite.

[codec_abc]

quand on voit la liste de features que le langages propose on peut se demander si l'auteur nous vend pas du rêve. Faire mieux que Go Rust et C++ par une seule personne qui ne semble pas avoir de background en design de langage ça me semble (un tantinet) surréaliste. Sans compter que l'auteur n'a pas encore finalisé pleins de parties, notamment la partie multithreading qui est censé être "data race free" a la compilation tout en étant plus facile à utiliser que Go et Rust.

Je vais enfoncer le clou mais ça me gêne pas mal que certaines news soient juste du copier-coller issues de Reddit ou HacknerNews sans approfondir ce qu'il y a dessous. Autant, quand une information viens d'une entreprise connu on peut se dire que le contenu ne sera pas complètement pipeauté même si une prise de recul est toujours la bienvenue. Mais là on a un particulier qui nous avance quelque chose que l'on peut pas tester et qui est censé être bien meilleur que la concurrence en terme de langage. Et pourtant l'article ne prend pas vraiment de recul alors que ça sent un peu l'arnaque.

[oooopppp]

Salut, je viens du monde du web mais j'adore la programmation.
De fait j’aimerais beaucoup apprendre un langage de bas niveau mais lequel ...
j'ai examiné C, R, (H?), V ... mais c'est compliqué de faire un choix ...

Je regrette presque le Basic que j'ai pratiqué à un très jeune âge et qui m'a permis de faire
des petits jeux de rôle .. etc assez facilement.

J'aimerais beaucoup faire le lien avec le web si c'est possible, je crois qu'en C, on peux faire ce qu'on veut.

mais il y a aussi des nouveaux outils pour créer des web-app qu'il faut que j’appréhende aussi,
d'après eux, un peut de javascript et hop, voilà une app. compatible avec tous les appareils ... ( ça me fait penser à l'interface de W10 ..)

Bon du coup j’avoue je nage carrément sur le choix d'un langage de bas niveau,
pouvez-vous m'en dire un peut plus, que créez-vous et avec quel langage ?
Et y a t'il des débouchés en restant freelance ?
ça pourrais m'être utile ... (bon du coup je suis un peut hors sujet ...)

Cordialement !

[Matthieu Vergne]

@Matthieu Vergne : selon la doc, le langage V a bien les generics. Tu peux jeter un coup d'œil. La doc est encore toute petite.

Ne l'ayant pas lu, je n'ai pas spéculé sur ce que V contient. Je parlais de Go, vu qu'il s'appuie dessus, et ce n'était qu'un exemple pour illustrer le problème potentiel que j'y voyais. Mais merci pour l'analyse.

[Matthieu Vergne]

Salut, je viens du monde du web mais j'adore la programmation.
De fait j’aimerais beaucoup apprendre un langage de bas niveau mais lequel ...

Ta question n'ayant aucun rapport avec l'article, merci de créer un sujet dédié.

[Pyramidev]

Faire mieux que Go Rust et C++ par une seule personne qui ne semble pas avoir de background en design de langage ça me semble (un tantinet) surréaliste.

Ça dépend ce que l'on appelle faire mieux que C++ et Rust. V a l'ambition d'être un langage simple et rapide à compiler. Mais sa simplicité se traduit par l'absence de certaines fonctionnalités (ex : les macros).

Sur le site, voici la comparaison actuelle entre V et Rust :

Rust has a very different philosophy.

It is a complex language with a growing set of features and a steep learning curve. No doubt, once you learn and understand the language, it becomes a very powerful tool for developing safe, fast, and stable software. But the complexity is still there.

V's goal is to allow building maintainable and predictable software. That's why the language is so simple and maybe even boring for some. The good thing is, you can jump into any part of the project and understand what's going on, feel like it was you who wrote it, because the language is simple and there's only one way of doing things.

Rust's compilation speed is slow, on par with C++. V compiles 1.5 million lines of code per cpu per second.

Concernant le background en conception de langage, je pense que c'est beaucoup moins difficile de concevoir un langage correctement à notre époque que dans le siècle passé, parce que l'on peut analyser les problèmes engendrés par la conception des langages déjà existants. C'est plus compliqué d'innover, car beaucoup de bonnes idées ont déjà été trouvées. Mais c'est moins compliqué d'éviter de répéter les erreurs passées.

Prenons l'exemple de l'erreur à un milliard de dollars (billion-dollar mistake) de Tony Hoare dans laquelle toutes les références sont nullables. Au 20e siècle, pour les concepteurs de langages statiquement typés, ce n'était pas évident qu'il s'agissait d'une erreur de conception qui affaiblissait le typage. Par contre, aujourd'hui, la conception de beaucoup de langages statiquement typés part du principe qu'il faut distinguer les références nullables des références jamais nulles. On le voit avec les types optionnels en Swift, les types nullables en C#, std::option::Option en Rust, Maybe en Haskell, typing.Optional en Python 3 (si on utilise le typage statique), l'option de compilation --strictNullChecks en TypeScript, etc. Par contre, dans beaucoup de vieux langages et dans le langage Go, les références sont toutes nullables.

Aujourd'hui, pour concevoir un langage, je pense qu'il est plus important de bien connaître l'existant que d'avoir conçu un langage au 20e siècle. Par exemple, parmi les 3 auteurs du langage Go, Ken Thompson a conçu le langage B. Et pourtant, quand j'ai regardé la conception du langage Go, avec certains défauts comme les références toutes nullables, la muabilité par défaut et l'absence des generics, je n'avais pas l'impression que les concepteurs du Go avaient un background solide en conception de langage.

Concernant C++, il a été pensé dès le départ pour être rétrocompatible avec le langage C (à quelques exceptions près) et les nouvelles versions du C++ ont eu tendance à rester rétrocompatibles avec les anciennes (à quelques exceptions près). Si on conçoit un nouveau langage sans cette contrainte de rétrocompatibilité, ce n'est pas si difficile de concevoir un langage meilleur que C++. Par contre, redévelopper tout l'écosystème serait très très long. Remarque : V ne pourra pas être meilleur que C++ sur tous les points, car il veut rester simple, mais il pourra échapper à certains défauts du C++ qui resteront à cause de la rétrocompatibilité.

Sans compter que l'auteur n'a pas encore finalisé pleins de parties, notamment la partie multithreading qui est censé être "data race free" a la compilation tout en étant plus facile à utiliser que Go et Rust.

Sur ce point, je serais curieux de connaître les restrictions précises que le langage V imposera pour garantir l'absence d'accès concurrent. Sur le site, j'ai vu ce bout de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
fn main() {
    resp := http.get(STORIES_URL)? 
    ids := json.decode([]int, resp.body)? 
    mut cursor := 0
    for _ in 0..8 {
        go fn() {
            for {
                lock { 
                    if cursor >= ids.len {
                        break
                    }
                    id := ids[cursor]
                    cursor++
                }
                resp := http.get('$ITEM_URL_BASE/$id.json')? 
                story := json.decode(Story, resp.body)?
                println(story.title)
            }
        }()
    }
    runtime.wait() 
}

Je présume qu'il y aura une erreur de compilation si on écrit cursor++ en dehors du bloc lock. En effet, en programmation concurrente, il faut synchroniser les accès aux variables muables accessibles par plusieurs threads. Mais je me demande comment le langage va gérer ce genre de chose quand il faudra décomposer le code en sous-fonctions.

[Pyramidev]

À part ça, dans le site du langage V, je lis que le nom initial du langage était le même que celui de l'application Volt qui est écrite dans ce langage. Ensuite, il a renommé le langage en V avec le motif suivant :

Initially the language had the same name as the product it was created for: Volt. The extension was ".v", I didn't want to mess up git history, so I decided to name it V

Je suis surpris par ce motif, car j'en vois un autre : il existe déjà un autre langage qui s'appelle Volt. Le langage Volt est un langage avec ramasse-miette qui s'inspire du langage D.

Il y a tellement de langages que personne ne connaît... Je me demande si le langage V est destiné à finir oublié lui aussi.

[Cassoulatine]

Il y a tellement de langages que personne ne connaît... Je me demande si le langage V est destiné à finir oublié lui aussi.

Oui c'est probable. Y a t il un aspect qui va permettre à ce langage de trouver sa communauté ? Possible (simplicité, faible taille, larges cas d'utilisation) mais pas sûr.
Surtout qu'il reste pas mal de points non finis. L'application Volt qui est sa vitrine ne marche pas sur mon windows, elle a des dépendances DLL qu'elle ne devrait pas avoir, et il n'y a pas de build linux. Son annonce me semble un peu prématurée.

[Jamatronic]

Code Lisp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
(defclass cat)
 
(defclass dog)
 
(defgeneric speak)
 
(defmethod speak (dog D)
    "ouaf")
 
(defmethod speak (cat C)
    "miaou")
 
(let (sultan (make_instance dog))
   (speak sultan))

[Cassoulatine]

Autant, quand une information viens d'une entreprise connu on peut se dire que le contenu ne sera pas complètement pipeauté même si une prise de recul est toujours la bienvenue. Mais là on a un particulier qui nous avance quelque chose que l'on peut pas tester et qui est censé être bien meilleur que la concurrence en terme de langage. Et pourtant l'article ne prend pas vraiment de recul alors que ça sent un peu l'arnaque.

Corporatisme quand tu nous tiens. Faut arréter de croire que l'individu n'est rien et la corporation (groupe) tout. En fait les corporations comme Google marchent énormément en achetant des projets et talents externes. L'innovation radicale aura toujours lieu en dehors des corporations.

A propos de "censé être bien meilleur" :
1) il est écrit après les autres langages, donc a appris de ces derniers,
2) il a d'autres objectifs, et ne répond pas aux mêmes contraintes,
3) il n'est pas fini.

Quand à que ce soit une arnaque, rien ne permet de l'affirmer, et on a qu'à attendre Juin.

[Pyramidev]

@Jamatronic : s'il s'agit de Common Lisp, alors ton code ne s'exécute pas. Par exemple, en Common Lisp, c'est make-instance, pas make_instance. Il y a aussi quelques problèmes de syntaxe.

Pour reprendre l'exemple que j'avais traduit en Go, en Rust et en C++, voici la traduction en Common Lisp :

Code Lisp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
(defclass Dog () ())
(defclass Cat () ())
 
(defmethod speak ((dog Dog)) "woof")
(defmethod speak ((cat Cat)) "meow")
 
(defun perform (s) (format t "~a~%" (speak s)))
 
(let ((dog (make-instance 'Dog))
      (cat (make-instance 'Cat)))
  (perform dog)
  (perform cat))

Le code ci-dessus s'exécute sur le compilateur en ligne suivant : http://www.compileonline.com/execute_lisp_online.php

Explication pour les développeurs qui ne connaissent pas Common Lisp : defmethod permet de faire de la surcharge de nom de fonction. Le dispatch se fait au runtime en fonction des types de tous les arguments.

[epsilon68]

encore un autre langage...
je suis déjà java, kotlin, C++, javascript, typescript, objective C++, swift et python...
sans compter les frameworks, Qt, cocoa, javafx, react native et j'en passe

ca vaut vraiment le coup de faire un autre langage?

il y a de quoi saturer honnetement

[KsassPeuk]

Pour l'instant, il n'y a rien qui permette de parler effectivement du langage.

• c'est annoncé safe, avec quelle justification ?
• c'est annoncé plus rapide, on ne peut pas exécuter de benchs,
• on n'a accès à rien du langage, mais "on peut payer pour avoir un accès en avance" (tiens, tiens ...)

Le plus fort : le langage n'a pas de GC, n'a pas de système de types explicite à la Rust pour la gestion des ressources, MAIS la gestion des ressources est automatique et sans runtime. Bizarrement, je suis extrêmement dubitatif.

[Pyramidev]

c'est annoncé plus rapide, on ne peut pas exécuter de benchs

C'est annoncé comme plus rapide à compiler que C++ et Rust.
À l'exécution, c'est annoncé comme aussi rapide que C :

Performance
• As fast as C
• Minimal amount of allocations
• Built-in serialization without reflection

Cependant, pour les performances à l'exécution, c'est probablement de la publicité mensongère car, dans la doc, dans le code :

Code V :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct Point {
	x int
	y int
}

fn main() {
	p := Point{10, 20}
	println(p.x) // Struct fields are accessed using a dot
	p2 := Point{ // Fields can also be set using this syntax
		x: 20
		y: 30
	}
	// & prefix returns a pointer to the struct value.
	// It's allocated on the heap and automatically cleaned up
	// by V at the end of the function, since it doesn't escape.
	pointer := &Point{10,10}
	println(pointer.x, pointer.y) // Pointers have the same syntax for accessing fields
}

on peut lire It's allocated on the heap. Heu, quoi ? Pourquoi le point de coordonnées (10, 10) est-il alloué dans le tas au lieu d'être alloué dans la pile alors qu'on n'en n'a plus besoin après l'appel de la fonction ?

Le plus fort : le langage n'a pas de GC, n'a pas de système de types explicite à la Rust pour la gestion des ressources, MAIS la gestion des ressources est automatique et sans runtime. Bizarrement, je suis extrêmement dubitatif.

On ne sait pas s'il n'a pas d'annotations spécifiques pour gérer la durée de vie des variables. Pour l'instant, le peu que la doc dit, c'est :

Is there garbage collection?
No. V's memory management is similar to Rust but much easier to use. More information about it will be posted in the near future.

Zig's goals are similar. The things V improves upon:
[...]
- Automatic memory management

[Cassoulatine]

À l'exécution, c'est annoncé comme aussi rapide que C

Parce qu'il permet de compiler son langage en C, puis de compiler en full optimisé avec GCC.

A terme il veut intégrer les optimisations donc son compilo, mais ce n'est pas le cas actuellement.

on peut lire It's allocated on the heap. Heu, quoi ? Pourquoi le point de coordonnées (10, 10) est-il alloué dans le tas au lieu d'être alloué dans la pile alors qu'on n'en n'a plus besoin après l'appel de la fonction ?

Manifestement la syntax &Truc dans son langage ça fait "new Truc" des langages habituels. Et il le fait juste à des fins de démonstration je suppose.

[Invité]

C'est annoncé comme plus rapide à compiler que C++ et Rust.
À l'exécution, c'est annoncé comme aussi rapide que C :

Cependant, pour les performances à l'exécution, c'est probablement de la publicité mensongère
...

C'est bien là le problème : à part une grosse liste d'annonces invérifiables, on a pas grand chose de concret. Les commentaires sur reddit et hacker news sont intéressants...
https://news.ycombinator.com/item?id=19403271
https://www.reddit.com/r/rust/commen...red_by/eilwzzt

[ParseCoder]

J'ai pas vraiment compris en quoi il était absolument nécessaire de créer un énième langage. Désolé mais je vais continuer avec C++ et peut-être me mettre plus sérieusement à Rust qui lui a amené quelque chose de nouveau. C'est quoi la nouveauté avec V? Je vois pas.