IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langages de programmation Discussion :

Zig est un langage de programmation polyvalent qui permettrait de maintenir des logiciels robustes


Sujet :

Langages de programmation

  1. #1
    Chroniqueur Actualités
    Avatar de Bruno
    Homme Profil pro
    Rédacteur technique
    Inscrit en
    mai 2019
    Messages
    1 016
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Rédacteur technique
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : mai 2019
    Messages : 1 016
    Points : 20 664
    Points
    20 664
    Par défaut Zig est un langage de programmation polyvalent qui permettrait de maintenir des logiciels robustes
    Zig est un langage de programmation polyvalent et serait une chaîne d'outils permettant de maintenir des logiciels robustes,
    optimaux et réutilisables

    Zig est un langage de programmation relativement jeune pour la programmation de bas niveau. Peut-être pas aussi bas niveau que l'assembleur, mais certainement aussi bas niveau que C ou C++. Il permet de se concentrer sur le débogage de l’application plutôt que sur ses connaissances en langage de programmation. « Je suis habituellement très sceptique à l'égard des nouveaux langages, alors j'ai naturellement voulu essayer Zig. Mais après avoir joué et construit quelques petits projets avec, je dois dire que j'ai vraiment apprécié de coder en Zig », déclare Serge Zaitsev, programmeur informatique, au sujet de Zig.

    La Zig Software Foundation est une société à but non lucratif fondée en 2020 par Andrew Kelley, le créateur de Zig, dans le but de soutenir le développement du langage. Actuellement, la ZSF est en mesure d'offrir du travail rémunéré à des tarifs compétitifs à un petit nombre de contributeurs principaux. Nous espérons être en mesure d'étendre cette offre à un plus grand nombre de contributeurs principaux à l'avenir.

    Nom : ZigB.jpg
Affichages : 27041
Taille : 7,7 Ko

    Zig est un langage de programmation open source conçu par Andrew Kelley pour garantir les performances telles que la robustesse et la maintenabilité. Andrew a annoncé dans une courte introduction au langage Zig qu’il l’a créé dans le but de concurrencer voire remplacer à l’avenir le redoutable langage C dans le cadre de la programmation système. Ainsi, il dit avoir bâti Zig sur quatre principaux aspects afin qu’il soit un langage de programmation pragmatique, optimal, un coffre-fort en matière de sécurité et un langage le plus lisible possible.

    « Je ne suis pas si ambitieux et mon objectif est de créer un nouveau langage de programmation qui sera plus pragmatique que le C. C'est comme essayer d'être plus diabolique que le diable lui-même », a écrit Andrew en introduction à la présentation du langage Zig. Lorsqu’il parle de langage plus pragmatique, il fait allusion au fait « que tout ce qui compte à la fin, c’est de savoir si le langage vous a aidé à faire ce que vous tentiez de faire et d’une manière plus simple que les autres langages ».

    La Zig Software Foundation présente le langage Zig comme un langage simple qui permet de se concentrer sur le débogage de votre application plutôt que sur celui de vos connaissances en langage de programmation.

    • Pas de flux de contrôle caché ;
    • Pas d'allocations de mémoire cachées ;
    • Pas de préprocesseur, pas de macros.

    Avec sa nouvelle approche de la métaprogrammation basée sur l'exécution du code à la compilation et l'évaluation passive, il est possible d’appeler n'importe quelle fonction au moment de la compilation, de manipuler les types comme des valeurs sans surcharge d'exécution.

    Il est également possible d’utiliser Zig en tant que compilateur C/C++ à dépendance zéro et à intégration immédiate, qui prend en charge la compilation croisée dès la sortie, d’exploiter zig build pour créer un environnement de développement cohérent sur toutes les plateformes.

    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
    23
    24
    25
    26
    27
    28
    const std = @import("std");
    const json = std.json;
    const payload =
        \\{
        \\    "vals": {
        \\        "testing": 1,
        \\        "production": 42
        \\    },
        \\    "uptime": 9999
        \\}
    ;
    const Config = struct {
        vals: struct { testing: u8, production: u8 },
        uptime: u64,
    };
    const config = x: {
        var stream = json.TokenStream.init(payload);
        const res = json.parse(Config, &stream, .{});
        // Assert no error can occur since we are
        // parsing this JSON at comptime!
        break :x res catch unreachable;
    };
    pub fn main() !void {
        if (config.vals.production > 50) {
            @compileError("only up to 50 supported");
        }
        std.log.info("up={d}", .{config.uptime});
    }

    Zig ressemblerait beaucoup au bon côté du C, lorsque le langage est simple et petit, que les programmes qui en résultent restent minuscules et rapides, et que le codage ressemble à du « codage » et non à de « l'ingénierie » ou de « l'architecture ». Zig reste plaisant. Selon Serge Zaitsev, l'une des raisons pour lesquelles Zig est plaisant, c'est que le langage lui-même est petit. On peut explorer la syntaxe complète et les constructions de base du langage en moins d'une heure. Par exemple, voici une tentative d'introduire Zig avec quelques lignes 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
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    // Single-line comments start with "//", documentation comments start with "///"
    
    const x: i32 = 42; // immutable int32 value that can not be changed
    var y: u32 = 5;    // mutable unsigned int32 variable
    var z = y; // type can be omitted if it can be inferred from the value
    
    // There is no "int" type, all integers have fixed width.
    // Same about floats, there are f16, f32, f64 and f128.
    // For indices, "intptr_t" or "size_t" types use "isize" or "usize".
    
    // All function parameters are immutable as if they are passed-by-value.
    fn add_two_ints(a: i32, b: i32) i32 {
    	if (a == 0) { // if statement looks like C
    		return b;
    	}
    	return a+b;
    }
    
    // Arrays have fixed length, here numbers.len == 5
    const numbers = [_]i32{ 0, 1, 3, 5, 7 };
    // String literals are arrays of []u8
    const hello = "hello";
    // Arrays can be initialised with repeating values using ** operator
    const ten_zero_bytes = [_]u8{0} ** 10;
    // Arrays may contain a sentinel value at the end, here array.len == 4 and array[4] == 0.
    const array = [_:0]u8 {1, 2, 3, 4};
    // Slices are pointers to array data with associated length. The difference between
    // arrays and slices is that array's length is known at compile time, while slice
    // length is only known at runtime. Like arrays, slices also perform bounds checking.
    const full_slice = numbers[0..]; // points at &numbers[0] and has length of 5
    const short_slice = numbers[1..3]; // points at &numbers[1] and has length of 2
    
    fn count_nonzero(a: []const i32) i32 {
    	var count: i32 = 0;
    	for (items) |value| { // "for" works only on arrays and slices, use "while" for generic loops.
    		if (value == 0) {
    			continue;
    		}
    		count += 1; // there is no increment operator, but there are shortcuts for +=, *=, >>= etc.
    	}
    }
    
    pub fn main() void { // main() is a special entry point to your program
    	var eight = add_two_ints(3, 5);
    	var nonzeros = count_nonzero(full_slice);

    Zig est en concurrence avec C au lieu d'en dépendre

    La bibliothèque standard Zig s'intègre à libc, mais n'en dépend pas. Voici Hello World :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    const std = @import("std");
    
    pub fn main() void {
        std.debug.print("Hello, world!\n", .{});
    }

    $ zig build-exe hello.zig
    $ ./hello
    Hello, world!


    Lorsqu'il est compilé avec -O ReleaseSmall, sans les symboles de débogage, en mode single-threaded, il produit un exécutable statique de 9,8 KiB pour la cible x86_64-linux :

    $ zig build-exe hello.zig -O ReleaseSmall --strip --single-threaded
    $ wc -c hello
    9944 hello
    $ ldd hello
    not a dynamic executable


    Une version Windows est encore plus petite, avec 4096 octets :

    $ zig build-exe hello.zig -O ReleaseSmall --strip --single-threaded -target x86_64-windows
    $ wc -c hello.exe
    4096 hello.exe
    $ file hello.exe
    hello.exe: PE32+ executable (console) x86-64, for MS Windows


    Déclarations de premier niveau indépendantes de l'ordre
    Les déclarations de haut niveau telles que les variables globales sont indépendantes de l'ordre et analysées nonchalamment. Les valeurs d'initialisation des variables globales sont évaluées au moment de la compilation.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    var y: i32 = add(10, x);
    const x: i32 = add(12, 34);
    
    test "global variables" {
        assert(x == 46);
        assert(y == 56);
    }
    
    fn add(a: i32, b: i32) i32 {
        return a + b;
    }
    
    const std = @import("std");
    const assert = std.debug.assert;

    $ zig test global_variables.zig
    1/1 test.global variables... OK
    All 1 tests passed.


    Le compilateur est écrit en Zig et C++, utilisant LLVM 11 comme back-end, prenant en charge plusieurs de ses cibles natives. Le compilateur est un logiciel libre et open source, distribué sous la licence MIT. Le compilateur Zig fournit la possibilité de compiler du C et du C++, similaire à Clang en utilisant respectivement la commande zig cc et zig c++. Le langage de programmation Nim prend en charge l'utilisation de zig cc comme compilateur C.

    WebAssembly

    « Avec la version 0.9.0, nous avons franchi quelques étapes importantes. Le linker autonome pour wasm a été réécrit, avec les connaissances acquises lors de la construction d'un linker autonome pour wasm », indique la Zig Software Fondation. En effet, le linker est maintenant capable de construire une disposition de la mémoire avec une pile virtuelle, ainsi que d'effectuer des relocations. Ce sont là quelques-unes des fonctionnalités nécessaires à l'implémentation de zig test.

    À ce jour, le backend wasm auto-hébergé est maintenant capable de passer 13 % de tous les tests comportementaux. Avec tous ces changements, la contribution au backend wasm est beaucoup plus facile. L'éditeur de liens est maintenant suffisamment performant pour que seule une connaissance de wasm soit nécessaire pour contribuer au backend.

    RISC-V

    Correction des caractéristiques CPU de l'assemblage RISC-V. Auparavant, Zig ne communiquait pas correctement les caractéristiques du CPU pour RISC-V à l'assembleur Clang, car Clang a une manière différente de transmettre les caractéristiques du CPU pour le code C et pour le code assembleur. Ce commit fait passer à Zig un tag RISC-V -march afin de communiquer les caractéristiques du CPU à Clang lors de la compilation des fichiers d'assemblage.

    Source : ZigLang

    Que pensez-vous du langage Zig ?

    Selon vous, quelle plus value ce langage pourra apporter ?

    Voir aussi :

    Wren, un petit langage de script concurrent rapide basé sur des classes est en cours de conception, il souhaite faire de l'ombre aux autres langages de script par sa concision et ses performances

    D2 : un nouveau langage déclaratif pour convertir du texte en diagrammes, il prend en charge les extraits de code et la syntaxe Markdown

    OK ?, le langage de programmation moderne, dynamiquement typé, élimine la complexité inutile des langages de programmation actuels
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

  2. #2
    Membre chevronné
    Homme Profil pro
    Ingénieur avant-vente
    Inscrit en
    septembre 2020
    Messages
    423
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur avant-vente

    Informations forums :
    Inscription : septembre 2020
    Messages : 423
    Points : 1 852
    Points
    1 852
    Par défaut
    Le C est la pierre de rosette des langages de programmation puisqu'ils sont nombreux à prendre en charge ses types de base, facilitant l'interopérabilité. Autant dire qu'il va être difficile à remplacer.

    Le compilateur Zig prend en charge Webassembly, c'est une bonne chose. Par contre, je pense que Rust est mieux placé sur ce segment vu qu'il semble susciter plus d'enthousiasme chez les programmeurs.

  3. #3
    Modérateur
    Avatar de gangsoleil
    Homme Profil pro
    Manager / Cyber Sécurité
    Inscrit en
    mai 2004
    Messages
    10 101
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations professionnelles :
    Activité : Manager / Cyber Sécurité

    Informations forums :
    Inscription : mai 2004
    Messages : 10 101
    Points : 27 845
    Points
    27 845
    Par défaut
    Hello,

    Je ne vois pas l'intérêt... Quelles sont les améliorations par rapport au C ?

    J'ai un peu regardé le code proposé ici, et je ne vois pas d'améliorations notables. Le fait qu'il n'y ait pas d'allocation dynamiques ne me semble pas être un gain, et je ne vois pas en quoi les tableaux en Zig seraient meilleurs qu'en C.

    Faire un nouveau langage parce qu'il y a un besoin, je peux comprendre.
    Faire un nouveau langage pour la beauté du geste, je peux comprendre.
    Mais là...
    "La route est longue, mais le chemin est libre" -- https://framasoft.org/
    Les règles du forum

  4. #4
    Membre éclairé
    Homme Profil pro
    Développeur C++
    Inscrit en
    octobre 2008
    Messages
    240
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur C++

    Informations forums :
    Inscription : octobre 2008
    Messages : 240
    Points : 720
    Points
    720
    Par défaut
    Citation Envoyé par gangsoleil Voir le message
    Hello,

    Je ne vois pas l'intérêt... Quelles sont les améliorations par rapport au C ?
    Je suis un féru du C (et je code tout en C) donc je sais plutôt bien de quoi je parle pour répondre.

    Le C n'est malheureusement pas parfait. Comme on dit souvent pour rigoler “undefined behavior is the name of the game”, alors oui ça permet aux implémentations de faire les choix qui leur sont propres afin d'avoir les meilleures perfs possible mais surtout la plus grande flexibilité. Si je décide de fabriquer mon propre processeur, mon propre OS alors j'ai le droit dans mon cas de dire que faire un overflow de deux entiers signés sera autorisé; or dans la norme c'est bien UB.

    Il y a des problèmes existentiels partout dans le C et même les développeurs les plus avertis se font toujours avoir un jour ou l'autre.

    Si je devais développer mon propre langage, il serait aussi proche du C mais il corrigerait tellement de problèmes qui à mon sens causent aussi parfois sa perte*:

    • Moins d'undefined behavior
    • Meilleur système que les entêtes
    • Build system intégré (combien de fois les packagers de distributions ragent quand un programme utilise un build system maison autre que CMake, meson et autres)
    • RAII ou à minima un système de defer, une fonction qui doit allouer et désallouer en fonction des échecs de fonctions est fastidieuse à écrire (combien ont déjà oublié un pthread_mutex_unlock avec de multiples return ?)
    • Gestion des chaines de caractères fastidieuse
    • Le mot clé const… n'en parlons pas


    Zig corrige déjà pas mal de ces points justement.

  5. #5
    Membre éprouvé

    Homme Profil pro
    Retraite
    Inscrit en
    octobre 2005
    Messages
    442
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 70
    Localisation : France, Aude (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Retraite
    Secteur : Industrie

    Informations forums :
    Inscription : octobre 2005
    Messages : 442
    Points : 1 139
    Points
    1 139
    Billets dans le blog
    1
    Par défaut
    Le mieux est de rentrer dans le sujet, j'ai du temps étant à la retraite.

    Mais dès le premier abord, on sent que le c/C++ et Rust ont marqué l'orientation.

    Je reviendrai plus tard après un vrai projet. (outils, ide, documentation, forum...)

    Par contre, après avoir fouillé, ce langage est riche et très puissant.

Discussions similaires

  1. Réponses: 0
    Dernier message: 14/04/2020, 14h16
  2. Réponses: 4
    Dernier message: 14/05/2018, 21h25
  3. langages de programmation necessaires pour une application web
    Par nesrine 51092 dans le forum Débuter
    Réponses: 3
    Dernier message: 30/05/2014, 21h25
  4. L'utilisation d'un langage de programmation approprié permettrait une réduction considérable des dépenses
    Par Stéphane le calme dans le forum Débats sur le développement - Le Best Of
    Réponses: 52
    Dernier message: 22/10/2013, 14h35
  5. Réponses: 51
    Dernier message: 17/10/2013, 20h52

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo