Zig est un langage de programmation polyvalent et serait une chane d’outils permant de maintenir des logiciels robustes, optimaux et rutilisables

The Zig Software Foundation is une socit but non lucratif merges in 2020 by Andrew Kelley, le crateur de Zig, dans le but de soutenir le dveloppement du langage. Actuellement, the ZSF est en mesure d’offrir du travail rmunr des tarifs comptitifs un petit nombre de contriburs principaux. Nous esprons tre en mesure d’tendre cette offers a plus grand nombre de contributeurs principaux avenir.

Zig is an open source programming language with Andrew Kelley to guarantee the performances telles that the robustness and the maintenability. Andrew a annonc dans a courte introduction au langage Zig quil la cr dans le but de concurrencer voire remplacer lavenir le redoutable langage C dans le cadre de la programmation systme. Ainsi, il dit avoir bti Zig sur quatre principaux aspects afin quil soit un langage de programmation pragmatique, optimal, un coffre-fort en matire de scurit et un langage le plus lisible possible.

Je ne suis pas si ambitieux et mon objectif est de crer un nouveau langage de programmation qui sera plus pragmatique que le C. C’est comme essayer d’tre plus diabolique que le diable lui-mme, a crit Andrew en introduction la prsentation du langage Zig. Lorsquil parle de langage plus pragmatique, il fait allusion au fait que tout ce qui compte la fin, cest de savoir si le langage vous a aid faire ce que vous tentiez de faire et dune manire plus simple que les autres langages.

The Zig Software Foundation presents the Zig langage as a simple langage here allowing you to concentrate on the dbogage of your application plutt que sur celui de your connaissances en langage de programming.

• Pas de flux de contrle cach;
• Pas d’allocations de mmoire caches;
• Pas de prprocesseur, pas de macros.

Avec sa nouvelle approche de la mtaprogrammation base sur l’excution du code la compilation et l’valuation passive, il est possible dappeler n’importe those fonction au moment de la compilation, de manipuler les types comme des valeurs sans surcharge d’excution.

Il est galement possible dutiliser Zig en tant que compilateur C / C ++ dpendance zro et intgration immdiate, here take en charge the compilation croise ds la sortie, dexploiter zig build pour crer un environnement de dveloppement cohrent sur toutes les plateformes.

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 ct du C, lorsque le langage est simple et petit, que les programs qui en rsultent restent minuscules et rapides, et que le codage ressemble du codage et non de l'ingnierie 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-mme est petit. On peut explorer la syntaxe complte et les constructions de base du langage en moins d'une heure. For example, voici une attempts to introduce Zig avec quelques lignes de code:

// 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 dpendre

The standard bibliothque Zig s'intgre libc, mais n'en dpend pas. Voici Hello World:

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 dbogage, en mode single-threaded, il produit un excutable 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

Dclarations de premier niveau indpendantes de l'ordre
Les dclarations de haut niveau telles that les variables globales sont indpendantes de l'ordre et analyzes nonchalamment. Les valeurs initialisation des variables globales sont values ​​au moment de la compilation.

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 as back-end, prenant en charge plusieurs de ses cibles natives. The compilers are free and open source, distributed under the MIT license. The compilers Zig provide the possibility of compiler du C et du C ++, similaire Clang en utilisant respectivement the command zig cc et zig C ++. Le langage de programmation Nim take en charge the utilization de zig cc comme compilateur C.

WebAssembly

With version 0.9.0, nous avons franchi quelques tapes importantes. The autonomous linkers pour wasm at rcrit, avec les connaissances acquises lors de la construction d'un autonomous linker pour wasm, indique la Zig Software Fondation. Indeed, the linker is maintenance capable of constructing a disposition de la mmoire avec une pile virtuelle, ainsi que d'effectuer des relocations. Ce sont l quelques-unes des fonctionnalits ncessaires the implementation of the zig test.

ce jour, le backend wasm auto-hberg est maintenant capable de passer 13% de tous les tests comportementaux. Avec tous ces changements, the contribution au backend wasm est beaucoup plus easy. L'diteur de liens est maintenant suffisamment performant pour que seule une connaissance de wasm soit ncessaire pour contribuer au backend.

RISC-V

Correction des caractristiques CPU de l'assemblage RISC-V. Auparavant, Zig ne communiquait pas correctement les caractristiques du CPU pour RISC-V assembleur Clang, car Clang a une manire diffrente de transmitting the caractristiques 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 caractristiques du CPU Clang lors de la compilation des fichiers d'assemblage.

Source: ZigLang

Que pensez-vous du langage Zig?

Selon vous, those 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 dclaratif pour convertir du texte en diagrammes, il take en charge les extraits de code et la syntaxe Markdown

OK?, Le langage de programmation moderne, dynamiquement typ, limine la complexit useless des langages de programmation actuels