Zig (programozási nyelv)

Ez a közzétett változat, ellenőrizve: 2024. szeptember 18.


A Zig egy imperatív, általános célú, statikusan tipizált, fordított rendszerprogramozási nyelv, amelyet Andrew Kelley(wd) tervezett.[2] A C nyelv utódjának szánják, azzal a szándékkal, hogy még kisebb és egyszerűbb legyen a programozás, ugyanakkor több funkciót kínáljon.[3] A Zig szabad és nyílt forráskódú szoftver, amelyet MIT licenc(wd) alatt adnak ki.

Zig

Paradigmaimperatív (procedurális), strukturált, generikus
Jellemző kiterjesztés.zig, .zir, .zigr, .zon
Megjelent2015
TervezőAndrew Kelley
FejlesztőAndrew Kelley
Utolsó kiadás0.13.0 (2024. június 6.)[1]
Típusosságstatikus, következtetett
Hatással volt rá
LicencMIT(wd)
Weboldal

A nyelv egyszerűségét érintő fejlesztések a folyamatkezelésre, a függvényhívásokra, a könyvtárimportra, a változók deklarálására(wd) és a Unicode támogatásra vonatkoznak. A nyelv nem használ makrókat vagy preprocesszor(wd) utasításokat. A modern nyelvekből átvett funkciók közé tartozik a fordítási idejű általános típusok hozzáadása, amelyek lehetővé teszik, hogy a függvények különböző adatokkal dolgozzanak, valamint egy kis számú új fordítói utasítás, amely lehetővé teszi a típusokra vonatkozó információk elérését a tükrözés[4] segítségével.

A Zig egy másik kiegészítése a kódbiztonságot hivatott javítani. A C-hez hasonlóan a Zig nem tartalmaz szemétgyűjtést (garbage collection), és a memóriakezelés manuális. Az ilyen rendszerekben felmerülő potenciális hibák kiküszöbölése érdekében tartalmaz opciós típusokat(wd) és egyszerű szintaxist a használatukhoz. A nyelvbe egy tesztelési keretrendszer is beépítésre került.

A Zig elsődleges célja, hogy jobb megoldást kínáljon a jelenleg C-vel megoldott feladatokra. Ebben a tekintetben elsődleges szempont az olvashatóság; a Zig megpróbálja a meglévő fogalmakat és szintaxist használni, ahol csak lehetséges, elkerülve a hasonló fogalmak eltérő szintaxisának hozzáadását. Továbbá a „robusztusság, optimalizálás és karbantarthatóság” érdekében tervezték, számos olyan funkciót tartalmaz, amelyek javítják a biztonságot, az optimalizálást és a tesztelést. A kis és egyszerű szintaxis fontos része a karbantartásnak, mivel a nyelv célja, hogy a karbantartók anélkül tudják hibakeresni a kódot, hogy meg kellene tanulniuk egy olyan nyelv bonyolultságát, amelyet esetleg nem ismernek.[5] A Zig még ezekkel a változtatásokkal együtt is képes a meglévő C kódba és a meglévő C kóddal szemben fordítani; a C fejléceket („header”) be lehet építeni egy Zig projektbe, azok függvényeit meg lehet hívni, és a Zig kódot a fordító által készített fejlécek beépítésével be lehet linkelni a C projektekbe.[6]

A kód egyszerű és könnyen olvashatóvá tételének általános tervezési filozófiájával összhangban a Zig rendszer egésze számos stilisztikai változást is tartalmaz a C-hez és más C-szerű nyelvekhez képest. A Rust nyelv például rendelkezik operátor-túlterheléssel(wd)[7], ami azt jelenti, hogy az a = b + c típusú utasítás valójában a plus operátor egy típushoz tartozó, túlterhelt változatának függvényhívása lehet. Továbbá, ez a függvény pánikba eshet, ami megelőzheti a következő kódot. A Zig-ben, ha valami meghív egy függvényt, akkor az függvényhívásnak tűnik, ha nem, akkor nem függvénynek. Ha hibát vet fel, az explicit a szintaxisban[6] a hibakezelés hibatípusokon keresztül történik, és catch vagy try segítségével kezelhető.

A Zig céljai ellentétben állnak sok más, ugyanebben az időszakban tervezett nyelvvel, mint például a Go, a Rust, a Carbon(wd) és a Nim(wd). Ezek a nyelvek általában összetettebbek, olyan kiegészítő funkciókkal, mint az operator overloading[7], az értékeknek (tulajdonságoknak) álcázott függvények és sok más, a nagyméretű programok felépítését segíteni hivatott funkció. Ezek a fajta funkciók inkább a C++ megközelítésével közösek, és ezek a nyelvek inkább annak a nyelvnek a vonalait követik.[6] A Zig a típusrendszer konzervatívabb kiterjesztése, amely támogatja a fordítási idejű generikusokat, és a comptime direktívával a „kacsatipizálás(wd)[8] egy formáját alkalmazza.

A memória kezelése

szerkesztés

A C programokban a hibák egyik elsődleges forrása a memóriakezelő rendszer(wd), amelynek alapja a malloc(wd). A malloc egy memóriablokkot különít el a kódban való használatra, és egy hivatkozást ad vissza erre a memóriára mutató formájában (pointer). Nincs olyan rendszer, amely biztosítaná, hogy a memória felszabaduljon, amikor a programnak már nincs rá szüksége, ami ahhoz vezethet, hogy a programok az összes rendelkezésre álló memóriát felhasználják, ami memóriaszivárgást jelent. Gyakoribb a lógó mutató(wd)[9], amely nem megfelelően kiosztott memóriaobjektumra hivatkozik.[10]

Ezekre a problémákra gyakori megoldás a szemétgyűjtő (GC), amely megvizsgálja a programot a korábban betöltött memóriára mutató mutatók után, és eltávolítja azokat a blokkokat, amelyekre már nem mutat semmi. Bár ez nagymértékben csökkenti, vagy akár meg is szünteti a memóriahibákat, a GC rendszerek viszonylag lassúak a kézi (utasítással előírt) memóriakezeléshez képest, és kiszámíthatatlan a teljesítményük, ami alkalmatlanná teszi őket a rendszerprogramozásra(wd). Egy másik megoldás az automatikus referenciaszámlálás (ARC)[11], amely ugyanazt az alapkoncepciót valósítja meg a használaton kívüli memóriablokkok azonosítására, de ezt a mutató létrehozásakor és megsemmisítésekor az adott blokkra mutató mutatók számának rögzítésével teszi, ami azt jelenti, hogy nincs szükség kimerítő mutatókeresésre, hanem minden malloc (allokálás) és release (felszabadítás) művelethez hozzáadódik a referenciaszámláló beállításának többletköltsége.[10]

A Zig célja, hogy a C-hez hasonló vagy annál jobb teljesítményt nyújtson, ezért a GC és az ARC(wd) nem megfelelő megoldások. Ehelyett egy modern, 2022-től kezdődő koncepciót használ, az úgynevezett opciós típusokat.[12] Ahelyett, hogy egy mutató a semmire vagy nil-re mutathatna, egy külön típust használunk az opcionálisan üres adatok jelölésére. Ez hasonló ahhoz, mintha egy struktúrát használnánk egy mutatóval és egy boolean értékkel, amely jelzi, hogy a mutató érvényes-e, de a boolean állapotát a nyelv láthatatlanul kezeli, és nem kell a programozónak explicit módon kezelnie. Így például a mutató deklarálásakor „nem allokált” állapotba kerül, és amikor ez a mutató értéket kap egy malloc-tól, akkor „allokált” állapotba kerül, ha a malloc sikeres volt.[13]

Ennek a modellnek az az előnye, hogy nagyon alacsony vagy nulla overheaddel(wd)[14] jár; a fordítónak kell létrehoznia a kódot, hogy a mutatók manipulálásakor továbbadja az opcionális típust, szemben egy egyszerű mutatóval, de ez lehetővé teszi, hogy közvetlenül kifejezze az esetleges memóriaproblémákat fordítási időben, futásidejű támogatás nélkül. Például egy null értékű mutató létrehozása, majd annak felhasználási kísérlete tökéletesen elfogadható C-ben, ami nullmutató hibához vezet (null pointer assignment). Ezzel szemben egy opcionális típusokat használó nyelv ellenőrizni tudja, hogy minden kódút csak akkor próbálja meg használni a mutatókat, ha azok érvényesek. Ez ugyan nem küszöböli ki az összes lehetséges problémát, de ha futásidőben problémák merülnek fel, a hiba pontosabban lokalizálható és megmagyarázható.[15]

Egy másik változás a memóriakezelésben a Zigben az, hogy a tényleges kiosztás a műveletet leíró struktúrákon (struct) keresztül történik, szemben a libc(wd)[16] memóriakezelő függvényeinek meghívásával. Például, ha C nyelven olyan függvényt akarunk írni, amely egy másik karakterlánc többszörös másolatát tartalmazó karakterláncot készít, a függvény így nézhet ki:

const char* repeat(const char* original, size_t times);

A kódban a függvény megvizsgálná az original méretét, majd a times malloc-méretét, hogy memóriát különítsen el a felépítendő karakterlánc számára. Ez a malloc láthatatlan az azt hívó függvények számára, ha nem sikerül később felszabadítani a memóriát, szivárgás lép fel. A Zig-ben ezt egy olyan függvénnyel lehetne kezelni, mint a következő:

fn repeat(allocator: *std.mem.Allocator, original: []const u8, times: usize) std.mem.Allocator.Error![]const u8;

Ebben a kódban az allocator változónak átadunk egy struktúrát, amely leírja, hogy milyen kódnak kell végrehajtania az allokációt, és a repeat függvény vagy az eredményül kapott karakterláncot adja vissza, vagy az opcionális típus használatával, amint azt a ! jelzi, egy Allocator.Error. Azáltal, hogy az allokátor közvetlenül bemenetként van kifejezve, a memória kiosztása soha nem „rejtőzik” egy másik függvényen belül, hanem mindig az a függvény teszi hozzáférhetővé az API számára, amely végül a memória kiosztását kéri. A Zig szabványos könyvtárán belül nem történik allokálás. Továbbá, mivel a struktúra bármire mutathat, használhatunk alternatív allokátorokat, akár a programban írtakat is. Ez lehetővé teheti például olyan kis objektum-allokátorok használatát, amelyek nem használják az operációs rendszer azon függvényeit, amelyek általában egy teljes memóriaoldalt(wd)[17] allokálnak.[18]

Az opcionális típusok egy olyan nyelvi jellemző példája, amely általános funkcionalitást kínál, miközben egyszerű és általános. Nem feltétlenül a nullmutatós problémák megoldására kell használni őket, hanem minden olyan értéktípusnál hasznosak, ahol a „nincs érték” megfelelő válasz. Tekintsünk egy countTheNumberOfUsers függvényt, amely egy egész számot ad vissza, és egy egész szám változót, theCountedUsers-t, amely az eredményt tartalmazza. Sok nyelvben a theCountedUsers változóba egy bűvös számot helyeznének el, hogy jelezzék, hogy a countTheNumberOfUsers még nem került meghívásra, míg sok implementáció egyszerűen nullára állítja azt. A Zig-ben ez úgy valósítható meg, hogy var theCountedUsers: ?i32 = null, ami a változót egyértelműen „nem hívták meg” értékre állítja.[18]

A Zig egy másik általánosabb funkciója, amely szintén segít a memóriaproblémák kezelésében, a defer fogalma, amely bizonyos kódokat jelöl meg, amelyeket a függvény végén kell végrehajtani, függetlenül attól, hogy mi történik, beleértve az esetleges futásidejű hibákat is. Ha egy adott függvény memóriát foglal, majd a művelet befejeztével el is távolítja azt, akkor hozzáadhatunk egy sort, hogy elhalasszunk egy free-t, hogy biztosítsuk, hogy az felszabaduljon, bármi történjen is.[18]

A Zig memóriakezelés elkerüli a rejtett allokációkat. A kiosztás nem közvetlenül a nyelvben történik. Ehelyett a halomhoz való hozzáférés egy szabványos könyvtárban történik, explicit módon.[19]

Közvetlen interakció a C-vel

szerkesztés

A Zig elősegíti a nyelv használatának evolúciós megközelítését, amely az új Zig kódot a meglévő C kóddal kombinálja. Ennek érdekében arra törekszik, hogy a meglévő C könyvtárakkal való kölcsönhatás a lehető legzökkenőmentesebb legyen. A Zig a saját könyvtárait az @import utasítással importálja, jellemzően ilyen módon:

const std = @import("std");

A fájlon belüli zig-kód mostantól std-n belüli függvényeket hívhat meg, például:

std.debug.print("Hello, world!\n", .{});

A C kóddal való munkához egyszerűen cserélje le az @import-ot @cImport-ra:

const c = @cImport(@cInclude("soundio/soundio.h"));

A Zig kód mostantól úgy hívhatja a soundio könyvtár függvényeit, mintha azok natív Zig kódok lennének. Mivel a Zig új, explicit módon definiált adattípusokat használ, ellentétben a C általánosabb int és float típusaival, az adatok C és Zig típusok közötti mozgatására néhány direktívát használunk, köztük az @intCast és @ptrCast-ot.[18]

Cross compiling

szerkesztés

A Zig a keresztfordítást a nyelv első osztályú felhasználási eseteként kezeli. Ez azt jelenti, hogy bármelyik Zig fordító képes futtatható binárisokat fordítani bármelyik célplatformra, amelyekből több tucat van. Ezek közé nemcsak a széles körben használt modern rendszerek tartoznak, mint az ARM és az x86-64, hanem a PowerPC, SPARC, MIPS, RISC-V és még az IBM z/Architektúrák(wd) (S390(wd)) is. Az eszközlánc bármelyik ilyen célrendszerre képes fordítani további szoftverek telepítése nélkül, minden szükséges támogatás megtalálható az alaprendszerben.[18]

A comptime kulcsszó használatával a programozó kifejezetten elérheti, hogy a Zig a kód egyes részeit a fordítási időben(wd) értékelje ki, nem pedig futásidőben. A kód fordítási időben történő futtatásának lehetősége lehetővé teszi a Zig számára a makrók és a feltételes fordítás(wd) funkcionalitását anélkül, hogy külön előfeldolgozó(wd) nyelvre lenne szükség.[20]

A fordítási idő alatt a típusok első osztályú polgárokká válnak.[21] Ez lehetővé teszi a fordítási idejű kacsatipizálást[8], és a Zig így valósítja meg a generikus típusokat.[22]

Például a Zigben egy generikus láncolt lista típus egy ilyen függvény segítségével valósulhat meg:

fn LinkedList(comptime T: type) type;

Ez a függvény valamilyen T típust vesz fel, és egy egyéni struct-ot ad vissza, amely egy láncolt listát definiál az adott adattípussal.

A név eredete

szerkesztés

A „Zig” nevet állítólag egy olyan eljárás során választották ki, amelyben egy Python-szkript véletlenszerűen kombinálta a „Z” betűvel kezdődő és egy magánhangzóval vagy „Y”-val követett betűket, hogy négybetűs szavakat hozzon létre. A tervezett hosszúság ellenére a szkript által előállított különböző kombinációk közül végül a három betűből álló „Zig” szót választották ki.[23]

Egyéb jellemzők

szerkesztés

A Zig támogatja az általános fordítási időket(wd), a tükrözést(wd)[4] és kiértékelést, a keresztfordítást(wd) és a kézi memóriakezelést(wd).[24] A nyelv egyik fő célja a C nyelv fejlesztése[20][25], miközben többek között Rustból is merít ihletet[6][26]. A Zig számos funkcióval rendelkezik az alacsony szintű programozáshoz, nevezetesen a csomagolt struktúrák (a mezők közötti kitöltés nélküli struktúrák), a tetszőleges szélességű egész számok[27] és a többszörös mutatótípusok.[22]

A Zig nem csak egy új nyelv: tartalmaz egy C/C++ fordítót is, és bármelyik vagy mindkét nyelven használható.

Hátrányok

szerkesztés

A Zig-nek számos hátránya van. Ha a memória nincs megfelelően felszabadítva, az a rejtett vezérlés hiánya miatt memóriaszivárgáshoz vezethet. A Zig tanulási görbéje meredek lehet, különösen azok számára, akik nem ismerik az alacsony szintű programozási koncepciókat. Bár a zig közössége egyre növekszik, 2024-től ez továbbra is új nyelv marad, ahol az érettség, az ökoszisztéma és a szerszámok terén még javítani kell. A más nyelvekkel való interoperabilitás kihívásokat jelenthet, mivel gyakran több erőfeszítést igényel az adatsorolás és a kommunikáció kezelése. Végül, a tanulási források elérhetősége korlátozott az összetett felhasználási esetekben, bár ez fokozatosan javul, ahogy az érdeklődés és az elfogadottság nő.[28]

A 0.10-es verzió óta az (új alapértelmezett) Zig fordító a Zig programozási nyelven íródott, azaz egy önfordító(wd) fordító[29], és ez egy fontos újdonsága ennek a kiadásnak. A régebbi, C++ nyelven írt, régebbi bootstrapping(wd)[30] fordító továbbra is választható, de a 0.11-es verzióban már nem lesz. Az új Zig fordítóval történő fordítás során sokkal kevesebb memóriát használ és egy kicsit gyorsabban fordít. A régebbi, most már örökölt, C++ alapú fordító 3,5x több memóriát használ.

A Zig alapértelmezett optimalizálási háttere továbbra is az LLVM[31], az LLVM pedig C++ nyelven íródott. A Zig fordító az LLVM-mel 169 MiB, míg LLVM nélkül 4,4 MiB. Az új Zig-lang alapú fordítóval általában gyorsabb futtatható kódot fordítanak, az LLVM kódgenerálása jobb, és sok hibát kijavít, de a régebbi legacy fordítóhoz is vannak fejlesztések a 0.10-es verzióban. A saját fejlesztésű linker szorosan kapcsolódik a saját fejlesztésű fordítóhoz. Az új verzió emellett kísérleti (tier-3) támogatást ad az AMD GPU-knak (van még egy kisebb támogatás az Nvidia GPU-knak és a PlayStation 4 és 5 számára is).

A régebbi bootstrapping ("stage1") fordító Zig és C++ nyelven íródott, LLVM 13-at használ háttérként[32][33], amely számos natív célt támogat.[34] A fordító ingyenes és nyílt forráskódú szoftver(wd), amelyet MIT Licenc alatt adtak ki.[35] A Zig fordító lehetővé teszi a C és C++ fordítását a Clang-hez(wd) hasonlóan a zig cc és zig c++ parancsokkal[36], számos fejlécet biztosítva, beleértve a C standard könyvtárat (libc) és a C++ Standard Library(wd) (libcxx) számos különböző platformra. A Zig cc és c++ alparancsai keresztfordítóként működnek.[37][38]

Ráadásul az operációs rendszerek (főleg az asztaliak) hivatalosan támogatottak (és dokumentáltak), (minimális) alkalmazások készülhetnek és készültek is Androidra (Android NDK-val(wd)), és iOS-re is lehet programozni.

A 0.11.0 verzió előtt a Zig nem rendelkezett csomagkezelővel, de a 0.11.0-ban megjelent egy kísérleti verzió, amelyet a 0.12.0 verzióban tovább bővítettek. Nincs hivatalos csomagtár(wd); ehelyett a csomag egyszerűen egy URL, amely egy tömörített fájlra(wd) mutat, amely kitömörítve tartalmaz egy szabványos build.zig fájlt (amelyet a Zig fordító konvenció szerint a forráskód lefordításához használ) és ideális esetben egy build.zig.zon fájlt, amely a csomag nevének és verziójának meghatározására szolgál.

A Zig fejlesztését a Zig Software Foundation (ZSF), egy nonprofit társaság finanszírozza, amelynek Andrew Kelley az elnöke, amely adományokat fogad el és több teljes munkaidős alkalmazottat alkalmaz.[39][40][41]

Hello World

szerkesztés
const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {s}!\n", .{"world"});
}

Generic linked list

szerkesztés
const std = @import("std");
const stdout = std.io.getStdOut().writer();

fn LinkedList(comptime T: type) type {
    return struct {
        const Self = @This();
        pub const Node = struct {
            next: ?*Node = null,
            data: T,
        };

        first: ?*Node = null,

        pub fn prepend(
            list: *Self,
            new_node: *Node,
        ) void {
            new_node.next = list.first;
            list.first = new_node;
        }
        pub fn format(
            list: Self,
            comptime fmt: []const u8,
            options: std.fmt.FormatOptions,
            out_stream: anytype,
        ) !void {
            try out_stream.writeAll("( ");
            var it = list.first;
            while (it) |node| : (it = node.next) {
                try std.fmt.formatType(
                    node.data,
                    fmt,
                    options,
                    out_stream,
                    1,
                );
                try out_stream.writeAll(" ");
            }
            try out_stream.writeAll(")");
        }
    };
}

pub fn main() !void {
    const ListU32 = LinkedList(u32);
    var list = ListU32{};
    var node1 = ListU32.Node{ .data = 1 };
    var node2 = ListU32.Node{ .data = 2 };
    var node3 = ListU32.Node{ .data = 3 };
    list.prepend(&node1);
    list.prepend(&node2);
    list.prepend(&node3);
    try stdout.print("{}\n", .{list});
    try stdout.print("{b}\n", .{list});
}
output
( 3 2 1 ) 
( 11 10 1 )

String ismétlés allokátorral

szerkesztés
const std = @import("std");

fn repeat(
    allocator: *std.mem.Allocator,
    original: []const u8,
    times: usize,
) std.mem.Allocator.Error![]const u8 {
    var buffer = try allocator.alloc(
        u8,
        original.len * times,
    );

    for (0..times) |i| {
        std.mem.copyForwards(
            u8,
            buffer[(original.len * i)..],
            original,
        );
    }

    return buffer;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    var arena = std.heap.ArenaAllocator.init(
        std.heap.page_allocator,
    );
    defer arena.deinit();

    var allocator = arena.allocator();

    const original = "Hello ";
    const repeated = try repeat(
        &allocator,
        original,
        3,
    );

    // Prints "Hello Hello Hello "
    try stdout.print("{s}\n", .{repeated});
}

output:

Hello Hello Hello

Kapcsolódó szócikkek

szerkesztés

C (programozási nyelv)

  1. Release 0.13.0
  2. Taking the warts off C, with Andrew Kelley, creator of the Zig programming language (angol nyelven). Sourcegraph , 2021. október 19. (Hozzáférés: 2024. április 18.)
  3. Zig has all the elegant simplicity of C, minus all the ways to shoot yourself in the foot (amerikai angol nyelven). JAXenter , 2017. október 31. [2017. november 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. február 11.)
  4. a b Az informatikában a reflektív programozás vagy reflexió egy folyamat azon képessége, hogy saját struktúráját és viselkedését megvizsgálja, "magába nézzen", és módosítsa.
  5. Elizabeth, Jane: Tired of C? New programming language Zig aims to be more pragmatic and readable. jaxenter , 2017. október 19. [2020. október 1-i dátummal az eredetiből archiválva]. (Hozzáférés: 2020. április 22.)
  6. a b c d Yegulalp, Serdar: New challenger joins Rust to topple C language (angol nyelven). InfoWorld , 2016. augusztus 29. (Hozzáférés: 2020. február 11.)
  7. a b A számítógépes programozásban az operator overloading, amelyet néha operátor ad hoc polimorfizmusnak is neveznek, a polimorfizmus egy speciális esete, ahol a különböző operátorok argumentumaiktól függően különböző implementációkkal rendelkeznek.
  8. a b A számítógépes programozásban a kacsatipizálás a kacsateszt(wd) alkalmazása – „Ha úgy totyog, mint egy kacsa, és úgy hápog, mint egy kacsa, akkor biztosan kacsa.” – annak meghatározására, hogy egy objektum felhasználható-e egy adott célra, tehát a megfelelő adattípus feltételezése.
  9. A számítógépes programozásban a lógó mutatók (dangling pointer és wild pointer) olyan mutatók, amelyek nem a megfelelő típusú, érvényes objektumra mutatnak.
  10. a b ARC vs. GC. Elements
  11. Az Automatic Reference Counting (ARC) a Clang(wd) fordító memóriakezelési funkciója, amely automatikus referenciaszámlálást(wd) biztosít az Objective-C és a Swift programozási nyelvek számára.
  12. A programozási nyelvekben (különösen a funkcionális programozási nyelvekben) és a típuselméletben(wd) az opciós típus(wd) (option type vagy maybe type) egy olyan polimorf típus(wd), amely egy opcionális érték kapszulázását jelenti.
  13. Guide To Java 8 Optional, 2022. november 28.
  14. Az informatikában az overhead a többlet vagy közvetett számítási idő, memória, sávszélesség vagy más erőforrások bármilyen kombinációja, amelyek egy adott feladat(wd) végrehajtásához szükségesek.
  15. Rust: Memory Management
  16. A C standard library vagy libc a C programozási nyelv szabványos könyvtára(wd), az ISO C szabványban meghatározottak szerint.
  17. A memory page a memória fix hosszúságú összefüggő (nem szegmentált) blokkja.
  18. a b c d e Allocators, 2023. szeptember 11.
  19. Tyson, Matthew. „Meet Zig: The modern alternative to C”, 2023. március 9. 
  20. a b  The Road to Zig 1.0 - Andrew Kelley. ChariotSolutions.
  21. Egy adott programozási nyelvben az első osztályú polgár (first-class citizen) egy olyan entitás, amely támogatja az összes olyan műveletet, amely más entitások számára általánosan elérhető. Ezek a műveletek tipikusan magukban foglalják az argumentumként való átadást, a függvényből való visszaadást és a változóhoz rendelést.
  22. a b Documentation. Ziglang.org . (Hozzáférés: 2020. április 24.)
  23. andrewrk: origin of the zig programming language name. by @andrewrk, 2024. március 13. (Hozzáférés: 2024. március 13.)
  24. The Zig Programming Language. Ziglang.org . (Hozzáférés: 2020. február 11.)
  25. The Zig Programming Language. Ziglang.org . (Hozzáférés: 2020. február 11.)
  26. Company, Sudo Null: Sudo Null - IT News for you (angol nyelven). SudoNull . (Hozzáférés: 2020. február 11.)
  27. Tim Anderson 24 Apr 2020 at 09:50: Keen to go _ExtInt? LLVM Clang compiler adds support for custom width integers (angol nyelven). www.theregister.co.uk . (Hozzáférés: 2020. április 24.)
  28. Chigozie, Oduah: Comparing Rust vs. Zig: Performance, Safety, and More. LogRocket Blog , 2024. június 4. (Hozzáférés: 2024. július 16.)
  29. Amint a nyelv eléggé kiforrott, a fordítóprogram fejlesztése átválthat a fordító saját nyelvére, lehetővé téve a fordító számára, hogy saját magát építse fel (self-hosting).
  30. Egy önfordító fordító előállításának technikája, ahol fordító kezdeti alapváltozata (a bootstrap fordító) egy másik nyelven jön létre (ez lehet pl. assembly nyelv).
  31. New LLVM version 15, Zig legacy uses version 13
  32. A Reply to _The Road to Zig 1.0_ (brit angol nyelven). www.gingerbill.org , 2019. május 13. (Hozzáférés: 2020. február 11.)
  33. ziglang/zig. GitHub . Zig Programming Language, 2020. február 11. (Hozzáférés: 2020. február 11.)
  34. The Zig Programming Language. Ziglang.org . (Hozzáférés: 2020. február 11.)
  35. ziglang/zig (angol nyelven). GitHub . (Hozzáférés: 2020. február 11.)
  36. 0.6.0 Release Notes. Ziglang.org . (Hozzáférés: 2020. április 19.)
  37. 'zig cc': a Powerful Drop-In Replacement for GCC/Clang - Andrew Kelley. andrewkelley.me . (Hozzáférés: 2021. május 28.)
  38. Zig Makes Go Cross Compilation Just Work (angol nyelven). DEV Community , 2021. január 24. (Hozzáférés: 2021. május 28.)
  39. Jakub Konka on Twitter (angol nyelven). Twitter . [2022. április 10-i dátummal az eredetiből archiválva]. (Hozzáférés: 2021. május 28.)
  40. Announcing the Zig Software Foundation. Ziglang.org . (Hozzáférés: 2021. május 28.)
  41. Sponsor ZSF. Ziglang.org . (Hozzáférés: 2021. május 28.)

További információk

szerkesztés