ERRATA: 0:33 - I mentioned that Zig doesn't have nice stack traces. This isn't true! They're very good, and quite detailed. It also does have a package manager. See @mlugg5499's comment for more information :) (or see the package manager release notes: ziglang.org/download/0.11.0/release-notes.html#Package-Management) 1:18 - []const u8 is a SLICE of const bytes, not an array! Also, strings will COERCE to this type, but as @rexicon2269 correctly pointed out, Zig string literals are technically constant single item pointers to null terminated byte arrays (*const [N:0]u8), however, I left this out of the video as we didn't cover sentinel termination :) 1:30 - @as is not a cast! It's effectively an inline type assertion. It'll only work if the type can be safely (upwardly) cast (thanks again @rexicon2269) 3:02 - The output would be 1, 4, 16, 64, not 4, 16, 64, 256 (thanks @someoneunknown6894!) 4:15 - There are some `const`s missing from types (thanks @unperrier5998!) 4:27 - The first line should be `const x` (thanks @GhislainGt!) 4:43 - Same as 1:18 4:58 - Missing `u8` between `[_]` and `{0}` (thanks @unperrier5998!) 5:39 - Struct fields are assigned with `=` not `:` (thanks @unperrier5998!) 8:18 - The inline loop should print `false` twice at the end (thanks @jcsahnwaldt!)
Nice work. Good middle-ground between Fireship's " in 100 Seconds" and other more in-depth tutorial vids. 7:10 Rust's actual Option type declares `None` before `Some`, affecting the order of comparisons. This means the discriminant (tag) for None is 0, None < Some(0), and this behavior will be optimized out for Option. 9:16 As a newbie, I hadn't seen this syntax before. Looks like the while loop is taking an expression, which should only return true or false as per if/else, but the expression manages to return a value which is captured in the block. It looks more like some sort of Optional value matching, which wasn't explained earlier. I did a little bit of research and it looks like you can run an expression like if (?T) |t| { doSomething(t); } else { doSomethingElse(); } which appears to be special-cased for optional types and error unions. Maybe this errata comment could also be used with a "NOT COVERED:" section to dump a bunch of keywords that may be important to search, starting with the words you said at the end of the video. One thing you haven't mentioned, I think, is tests. Just put those words in there and go. The video is long enough, writing out whole examples in a comment would just be extra work that could go into making a part 2.
At 0:39 the PATH specified is also incorrect. It should be a path to where the binary resides, not a path to the binary itself. In fact, /usr/bin very well should already be in the PATH variable.
This video is like a movie trailer, but for a language, and in a good manner: you watch the video, see how things happen in Zig, and if you think that it's for you, you go deeper. This kind of content is extremely helpful.
@@IsaacHarrisHolt maybe i watched too quickly, but you didn't mention the complete interoperability with inline C and C++. Heck, the zig compiler can also compile these 2 languages !
Wow. This video forced my brain into a higher gear than I'm used to using when watching RUclips. Usually, I'm just vegetating. This required serious focus. But, with sufficient focus, this was well-paced and gave an EXCELLENT overview of Zig. Thanks.
Me too! I usually watch videos on PnP while working because it's not dense at all. This one I had to actually stop and pay full attention, rewinding and stopping to read the code. This is much better.
I'm a complete beginner in Zig, I've been developing for the web - front-end, Javascript with React for about 10 years, I love the productivity of Reat, but I also want to learn a compiled language because I really like embedded electronics for machines... I liked it a lot about Zig... even though I don't know English, your video was the best so far for learning Zig... congratulations
Just got recommended to me, great video! Really enjoyed it and subscribed :D A small note, on 3:02 the loop with the continue expression would print 1, 4, 16, 64 instead of 4, 16, 64, 256 Idk what's your style but I personally like No Boilerplate's errata comment where he mentions small mistakes like this Again though, the video is awesome, thanks for making it! :D
Zig is really my favorite language, as a C developer it really is everything I wish C was and more : - No more Macro cancer. - No more make/cmake/ninja cancer. - No more implicit integer promotion foot guns. - No more namespace conflict. - No more quirks. - No more checking for null everywhere. - No more void* and macros for generic. - Actually useful and usable standard library. - Seamless interop with C. - Lower level control than C with native support for SIMD primitive. - Errors as value. - Stricter type system. - Allocators are first class citizens - Very readable and explicit code, there is next to no hidden control flow everything you read is everything you get.
This is exactly what Zig is trying to solve! It's still not my cup of tea personally - I like slightly higher level languages - but I'm not solving low level problems, so I don't need as much control as Zig provides. That said, I definitely want to experiment more with working on low level systems and such, and I think Zig is definitely a fun way to try and accomplish that.
@@IsaacHarrisHolt That's understandable. If you wish to get the broader perspective on why Zig is so awesome, a quick experiment that I would recommend, would be to re implement something relatively trivial like hex dump. Try to do it in C, try do to it in your favorite language, then try to do it in Zig. This shouldn't take too long, (around 500 loc for a bare bone implementation). If you try hard to write good C code redoing everything in Zig will really give you valuable insights on why Zig is so great.
Ooh thanks! I'll take a look into it. Honestly I've never actually written any C outside of RaspPi/Arduino programming, so it might take me ages to get through it all
Zig big feature is seamless integration with C, not only using libraries in both directions with lon the fly bindings generation but zig even can compile C code or be used as build system (programmed in Zig !).... Zig author(s) should take some prize for it!!! Oh i forgot, Zig can compile itself and c *cross-platform*... you can compile to Windows binary (exe) on mac or linux or vice-versa....🤯
@@IsaacHarrisHoltWell, it’s three things I missed in C, hard to pick one. * optional value as 1st class language citizen (not unwieldy C++ implementation, null pointer or magic value) * being able to add methods to structures (C void pointer way loses type safety and syntax is nuts) * Errors as values, checking for null on top of checking some global error variable is hacky in both C and C++
At 0:33, you mention some missing features. Firstly, Zig does have a package manager - it's a quite recent creation and so somewhat immature, but it does exist, and is being used in the wild (the best example is probably the Mach project). Secondly, I'm not sure what you meant by "reasonable stack traces". I haven't heard of any major issues we currently have with stack traces - in general, stack traces are printed by the panic handler on any crash, and they're detailed & prettified. If you've encountered any specific issue with incomplete/incorrect stack traces, that's a bug, and possibly one we're not aware of, so please report it!
Apologies for that! I couldn't find any information on the Zig package manager (I assume you mean Zon?) on the ziglang.org site, so I assumed it was potentially third-party, like nektro/zigmod. If you could just make sure I've got the right one, and provide some documentation, I'll include a link in the pinned ERRATA comment. I'll do the same re the stack traces. I don't know why, and I can't reproduce them, but I didn't have a great experience when I was researching for this video. Thanks for calling me out, though!
@@IsaacHarrisHolt Sorry it took me so long to get around to this, I've been quite busy. Okay, so! ZON is not the name of the package manager, but rather a file format. It stands for Zig Object Notation - like JSON, we've basically taken Zig's construction syntax and turned it into a file format. ZON is used by the package manager, but it's a general-purpose file format. The package manager itself does not have a name - it's just a system integrated into the compiler. The way it works is that you create a file named `build.zig.zon`, which declares the name of this package, and all of its dependencies and their URLs (the package system is decentralized, unlike e.g. npm). These dependencies can then be referenced from your `build.zig`. The schema for this ZON file is detailed at github.com/ziglang/zig/blob/master/doc/build.zig.zon.md. Unfortunately documentation for the package manager itself is a little lacking at the minute - the best resource is probably the release notes for 0.11.0 (ziglang.org/download/0.11.0/release-notes.html#Package-Management), but keep in mind that might be a little outdated. You can see an example package at github.com/andrewrk/SDL, and an example usage of said package at github.com/andrewrk/sdl-zig-demo. I hope this helps!
This looks a lot like rust in some cases, I also see a lot of rust developers alternating between rust and zig, it looks promising. As for things like panicking on integer overflow, how about dynamic integers? Does it have runtime checks for overflows? That sounds like a poor trade off between performance and safety.
i think the analogy most people make is Rust is "the new C++" and Zig is "the new C". Of course doesn't mean they're going to replace the languages; just that Rust is more implicit like C++ and Zig is more explicit like C. Of course it's not apples to apples, since C++ is (somewhat) extended C, not the same history with Zig and Rust. Interop between the two is a whole other rabbit hole :P
Alternatively, drink 6 pots of coffee, and you'll have to slow down so the universe can think. (Don't drink 6 pots of coffee! Care for your heart! ☕❤💥)
at 1:18 this is not a array of "const u8" :) it's actually a slice of "const u8". the difference being "[]const u8" and "[N]const u8", where N is a comptime known value. "this is a string" is of type "*const [N:0]u8" aka a pointer to a const 0 terminated array of u8. this then coerces into a []const u8 through the explicit type you give "const string: []const u8". same thing at 4:43 minor error, but they are distinctly different things. error 2: at 1:30 the @as is not a cast. it's a inline way of writing `const flt: f80". the actual cast here happens implicitly. the same thing would have worked if you had written "const flt: f80 = 5000.1". of course this can only happen if it's a safe cast such as casting upwards i.e u32 => u64. casting downwards would not work, and be an error, and would require i.e @intCast
I don't feel like Zig syntax is well structured enough, seems like a bunch of syntax sugar that someone just added to make things work. Maybe I'm just used to Rust typesystem.
From the perspective of a rust developers maybe, but if you've been programming in C extensively, you might be able to see that basically all of the "syntactic sugar" is really just very common C idioms (who are very error prone, or unreadable) expressed in a shorter and or safer way. Because the target audience for zig is really just C developers who want to migrate/maintain their old code base with a more modern and safer language, with more control/freedom than what Rust offers (at the expense of memory safety), and without the ugliness of C++. Which makes a lot of sense, I also believe that they've said that the syntax might evolve once everything is ready for the 1.0 as they don't think syntax should be their primary concern.
I disagree with the developers here somewhat. People these days are generally flocking to languages that feel good to write, and syntax is a big part of that. Zig is currently lauded because it's a vast improvement on C, but lots of things are a vast improvement on C, tbh. As soon as a 'Zig with nice syntax' comes along, Zig could be in trouble.
I really like Zig in concept, as a replacement for C it's definitely a stellar option with just straight upgrades everywhere! I've never really worked that low-level though, I don't deal well with the whole "manual memory management" thing, which is why I'll probably stick with Rust instead. What's really sad to me is how awesome the whole comptime and emergent type meta stuff is, and how that whole system is probably fundamentally incompatible with Rust's type system. If the Rust team ever finds a way to integrate all this comptime magic into their code naturally, it's really gonna pop off for me! (and yes I know macros exist, but they only operate on tokens and not actual types and structures. Again because Zig's model of building the types at comptime seems pretty much incompatible with Rust's type checker.)
I like this take! Yeah, comptime is pretty much my favourite feature of Zig. Like you, I prefer Rust's memory management and I find the type system more robust. You can still accomplish most of what comptime offers through generic types, but not everything, sadly. And don't get me started on lifetimes...
A lot of it is down to how low level you can get with it. It's as low level as C, but ultimately safer. Comptime is also very useful once you start getting into advanced stuff with it - much nicer than headers and macros.
Zig is meant to replace C, If you know C well you can clearly see (no pun intended) that Zig was built off the frustrations of C. The problem with C is that it lacks type safety, and carries a lot of terrible decisions, namely, macros, preprocessor, nullability implicit conversion rules, forward declaration etc. You might think that alternatives already exist, like C++ or Rust, the problem with those languages is that they aren't "real" C replacement, Why ? Because they don't follow the same set of principles. Zig on the other hand really focus on simplicity and ease of use, especially if you are a C programmer all of the very "unsafe" things and all of the error prone stuff is replaced with more explicit or safe constructs and idioms. In Zig you can't cast variables as freely as you used to do in C, instead you have to use specific builtins to do so. You don't need to use macro magic or void* to get generics, instead you can use a safe alternative called comptime. You don't need to worry about the build system and portability and linking error, instead you can use Zig to build Zig. You don't have to migrate to a new testing framework, instead you can just rely on the Zig builtin testing framework, You don't need to use more macro magic from another language to generate bindings to interops with your old C you can just compile it with the Zig compiler, You also avoid namespace conflict out of the box, and so much more that I can't really name everything, the point is that I'm a C developer, and Zig literally is everything I wished C was.
zig is awesome, quite difficult to understand the memory model coming from a gc lang, but it is extremely powerful. I love the fact that zig aims to be simple, like c, instead of being complex (but more powerful out of the box) like rust. I also love rust, but at some point it becomes overcomplicated I really liked the video, a lot of info in 10 minutes, loved it!
Yeah, going to a low level lang from a GC Lang is difficult, but eventually you'll wrap your head around it and it'll all just click :) Glad you enjoyed the video!
It looks nice. This is the first time I've looked a new (to me) language and actually wanted to use it. Like I've watched Rust videos & C & python & I've played with C#, but meh idc whatever I'll stick with my PHP. Zig actually looks like a thing i wanna try. But i have 30+ FOSS php projects, so i won't be switching languages any time soon.
**ERRATUM** The return values at 3:01 (loop with continue expr) are wrong, it should be: 1, 4, 16, 64 At 4:15 you're missing a bunch of 'const' to specify the pointer is pointing to constant value (two consts in the pointer definition, just like in C) At 4:24 the code you display works because you forgot to make the variable constant. At 4:58 you're missing the type: [_]{0} requires a type. It should be [_]u8{0} At 5:39 the code doesn't even compile
@@IsaacHarrisHolt I was going along with your examples, playing with them, that's how I noticed them. They're helpful because even though they're slightly wrong at times, the audio commentary tells what matters. On that note I had to reduce the audio speed and pause to actually digest the teaching.
@@unperrier totally fair! I know it's a lot to get through in a short space of time - that's how it's designed - and I definitely expect people to pause and rewatch parts. I'm glad you found it helpful though :)
I *love* it in principle but it's a bit hard to use so far. no function overloading, strings should be easier than C but seem harder instead, and I haven't so far figured out how to have shared libraries, which is pretty important. otherwise I would totally want to use it for small CLI tools.
All totally fair criticisms, I think. For shared libraries, I think there technically is a package manager, but I've not used it. Strings I half agree with - once you've gotten used to using an allocator for them, they're pretty fine
Why do arrays store their length by default? isn't that memory wasted? Also what's a point of 'arbitrary bitwidth' variables? All modern CPUs have a minimum operation width of 8 bits. If you define two variables of type 'u3', it is smart enough to fit both into one byte? Or will it fit each into an individual byte? If it's the latter then what's the point?
To answer your first question, yes, it's extra memory usage at the cost of safety. As for the arbitrary bitwidth ints, I'm not sure. I would Google it, if I were you.
@@IsaacHarrisHolt I've heard that Zig does async differently when compared to other languages. I'd love to know if that is true. And maybe c-interop as well.
I've been a C++ developer for 28 years. I like C++ but Zig looks interesting. How difficult is it to get a Zig development environment working on Windows?
I mean, Zig is a manually memory managed, low level language, so it's gonna be fast. As for the fastest, who knows? It'll vary benchmark by benchmark, but generally the fastest is probably gonna be assembly
I would say Zig is lower level than Rust. Rust allows you to write high-performance code, but other than the borrow checker, it mostly feels like a high level language. Zig gives you a lot more control over your memory, and you can therefore probably write more efficient code in Zig.
@@IsaacHarrisHolt Seems pretty fast and nice. I saw a video of zig being the first in speed in some task. Faster than c and rust. That is amazing ! I hope it replaces c or at least be used as much as c. It feels like a new breath or smthing. I like c / c++ but i would totally love to use zig for a project in my university. The only drawback i see atm is that i feel i cant use it for something solid or long term (since i guess there would be some changes in the languages ). Mostly for some demo projects i guess. I hope it goes well
There are some pretty big production projects happening in Zig right now - you can definitely use it long term! There's nothing saying you'll be forced to update versions.
@@IsaacHarrisHolt what is a footgun?, yes but c is soo simple and straightforward, the datatype before the name is so much more natural than name: type
zig needs a few more years to settle down, every time i come across it i have to find a specific compiler version otherwise full of errors, well that's no fun!
I have mixed feelings about Zig after watching this... I like the errors handling, var VS const, defer keyword and many other things but operators look horrific... I don't want my code to looks like hieroglyphes ** +%= ++ .*
Zig is supposed to be a replacement for C. It's not finished yet, so it doesn't cover quite as wide a surface area, but I can see Zig being used anywhere C might. A good example is Bun, the new JS runtime built as an alternative to Node.
It's how you initialise a new Zig project. It's technically not needed, but it gives a nice structure etc. It's kinda like Cargo init, but more optional
I think there's a "bug" (sorry if it was already mentioned) @ ruclips.net/video/5I4ZkmMS4-0/видео.html: ``` var overflow: u8 = 0; //you example inits with 255 overflow -%1 // overflow == 255 ``` Now, that's the example you intended for, if I'm wrong please shout me.
A lot of the time it can prevent undesired function calls, or situations where the compiler may get confused between attempting to call a function or some.other operation with parens
Whitespace is not a good character in source code (hidden). Imagine that the compiler sees the source code as one continuous line, not like how we view it on screen.
@@IsaacHarrisHolt Ok well ... this is kind of a big ask, but I haven't seen a good overview video for the general software dev audience on the topic of TLA+, the formal specification language that can be used to prove the correctness of programs. Yes, I know, it's a really out there topic, but it has been on my radar for years.
Really not a replacement for C though. The whole advantage of C is that it maps very well to assembly and how memory is represented. Zig seems to have too many abstractions, making it more high level. Anyways, looking forward to learning and implementing it.
Fair take! I think Zig is supposed to give you as much low level control (which I think it does) while being safer than C. Glad you enjoyed the video though!
My biased ass towards C would never make it comparable but it seems promising enough to try. Comparing to other languages, If it makes a good package system then I might ditch Go for backend development and use this instead.
Ooh interesting take! I think I still prefer Go - development speed is much higher - but I can see Zig working if you're doing high throughput computing
Personally I think they solve different problems. Zig gives you more control and will ultimately allow for slightly better performance, but Rust is safer and makes it more difficult to shoot yourself in the foot.
I would say the majority of "modern languages" allow exceptions for errors. And they all have a string type. But with "try" and "catch" in the language it looks an awful lot like exception handling.
I disagree. With exceptions it's difficult to predict where errors are going to come from. Error unions tell you in advance that a function could throw an error via their return type. Take JavaScript for example. `JSON.parse('not JSON')`, will error, but there's no warning in advance. Also, by returning the error rather than throwing it, you know the code won't stop unless you explicitly tell it to stop.
@@IsaacHarrisHolt I think input data is ideally verified with a predicate function. If it is too much to do both (verify and process) there should be an indication that a function returns an invalid input error. I wouldn't do that with an exception in C++/Java etc. since it is a known possibility that the data is malformed and the function should return success/failure. If the Zig code is forcing error handling on a function with a known error possibility that's a good feature since programmers can code like, for example, fopen will never return NULL. I would save exceptions for errors that cannot be anticipated and which don't have a path forward other than program termination and find out what went wrong.
Fair take! This is what languages like Go and Rust do. Errors are values, so you're forced to handle them when they arise, but you can also panic to halt termination
I understand the Java pain. My programming journey started with Minecraft mods and plugins 😅 But I would be careful of dismissing a language for its syntax!
I disagree, to some extent. Having more reserved words typically makes a language LESS verbose, as you only need a single word to achieve something that takes a lot in other languages (e.g. the `go` keyword in Go). I'm curious which language you're comparing to to form this opinion, though
Why bother to learn a new language, where there are no string only arrays defined as [u8], string manipulation function are verbose and clunky, and memory allocators are different paradym. Sure there error handling "try syntax" is good. The complier is your enemy. When we already have Rust why bother with zig ? A simple language with manual memory management and no head files
All your points are very valid! Zig does have some advantages over Rust - it's a bit lower level, and you have more fine grained control over your memory management without having to resort to "unsafe" blocks and so on. Also, comptime is awesome
ERRATA:
0:33 - I mentioned that Zig doesn't have nice stack traces. This isn't true! They're very good, and quite detailed. It also does have a package manager. See @mlugg5499's comment for more information :) (or see the package manager release notes: ziglang.org/download/0.11.0/release-notes.html#Package-Management)
1:18 - []const u8 is a SLICE of const bytes, not an array! Also, strings will COERCE to this type, but as @rexicon2269 correctly pointed out, Zig string literals are technically constant single item pointers to null terminated byte arrays (*const [N:0]u8), however, I left this out of the video as we didn't cover sentinel termination :)
1:30 - @as is not a cast! It's effectively an inline type assertion. It'll only work if the type can be safely (upwardly) cast (thanks again @rexicon2269)
3:02 - The output would be 1, 4, 16, 64, not 4, 16, 64, 256 (thanks @someoneunknown6894!)
4:15 - There are some `const`s missing from types (thanks @unperrier5998!)
4:27 - The first line should be `const x` (thanks @GhislainGt!)
4:43 - Same as 1:18
4:58 - Missing `u8` between `[_]` and `{0}` (thanks @unperrier5998!)
5:39 - Struct fields are assigned with `=` not `:` (thanks @unperrier5998!)
8:18 - The inline loop should print `false` twice at the end (thanks @jcsahnwaldt!)
Nice work. Good middle-ground between Fireship's " in 100 Seconds" and other more in-depth tutorial vids.
7:10 Rust's actual Option type declares `None` before `Some`, affecting the order of comparisons.
This means the discriminant (tag) for None is 0, None < Some(0), and this behavior will be optimized out for Option.
9:16 As a newbie, I hadn't seen this syntax before. Looks like the while loop is taking an expression, which should only return true or false as per if/else, but the expression manages to return a value which is captured in the block. It looks more like some sort of Optional value matching, which wasn't explained earlier.
I did a little bit of research and it looks like you can run an expression like
if (?T) |t| {
doSomething(t);
} else {
doSomethingElse();
}
which appears to be special-cased for optional types and error unions.
Maybe this errata comment could also be used with a "NOT COVERED:" section to dump a bunch of keywords that may be important to search, starting with the words you said at the end of the video. One thing you haven't mentioned, I think, is tests. Just put those words in there and go. The video is long enough, writing out whole examples in a comment would just be extra work that could go into making a part 2.
well this sounds like C with a little more error handling XD
Sounds like a good thing to me 👀
At 0:39 the PATH specified is also incorrect. It should be a path to where the binary resides, not a path to the binary itself. In fact, /usr/bin very well should already be in the PATH variable.
In this case, zig is a directory, as that's what comes from the download :)
As someone who is so used to 2x speed for everything it is unexplainably refreshing to have a video that *_actually_* needs to be slowed
I watch most stuff at 2.7-3x speed, so I understand your plight 😅 it's one of the reasons I like making content like this!
God dam so true
100% agree
@@IsaacHarrisHoltBamboozled 😂😂😂
oh crap i forgot i had this on faster speed
This video is like a movie trailer, but for a language, and in a good manner: you watch the video, see how things happen in Zig, and if you think that it's for you, you go deeper. This kind of content is extremely helpful.
I'm glad you found it useful! Let me know what else you'd like to see
@@IsaacHarrisHolt maybe i watched too quickly, but you didn't mention the complete interoperability with inline C and C++. Heck, the zig compiler can also compile these 2 languages !
Yes, I know, and that's really cool! I was focusing more on the language itself in this video though :)
Wow. This video forced my brain into a higher gear than I'm used to using when watching RUclips. Usually, I'm just vegetating. This required serious focus.
But, with sufficient focus, this was well-paced and gave an EXCELLENT overview of Zig.
Thanks.
Awesome! Glad you found it helpful
Me too! I usually watch videos on PnP while working because it's not dense at all. This one I had to actually stop and pay full attention, rewinding and stopping to read the code. This is much better.
I'm a complete beginner in Zig, I've been developing for the web - front-end, Javascript with React for about 10 years, I love the productivity of Reat, but I also want to learn a compiled language because I really like embedded electronics for machines... I liked it a lot about Zig... even though I don't know English, your video was the best so far for learning Zig... congratulations
Thank you! I'm glad you found it helpful
3:36 most beautiful switch statement ever.
🙃
Just got recommended to me, great video! Really enjoyed it and subscribed :D
A small note, on 3:02 the loop with the continue expression would print 1, 4, 16, 64 instead of 4, 16, 64, 256
Idk what's your style but I personally like No Boilerplate's errata comment where he mentions small mistakes like this
Again though, the video is awesome, thanks for making it! :D
Done! It's something I've done before too. Thanks for pulling me up on it :)
Zig sounds like chrismas for C users
Why do you think I released the video at this time of year 😉
@@IsaacHarrisHolt how long were you waiting for someone to comment this
So long
Merry zig to all C users
All of this looks pretty good, but I think I'll stick with C
Zig is really my favorite language, as a C developer it really is everything I wish C was and more :
- No more Macro cancer.
- No more make/cmake/ninja cancer.
- No more implicit integer promotion foot guns.
- No more namespace conflict.
- No more quirks.
- No more checking for null everywhere.
- No more void* and macros for generic.
- Actually useful and usable standard library.
- Seamless interop with C.
- Lower level control than C with native support for SIMD primitive.
- Errors as value.
- Stricter type system.
- Allocators are first class citizens
- Very readable and explicit code, there is next to no hidden control flow everything you read is everything you get.
This is exactly what Zig is trying to solve! It's still not my cup of tea personally - I like slightly higher level languages - but I'm not solving low level problems, so I don't need as much control as Zig provides.
That said, I definitely want to experiment more with working on low level systems and such, and I think Zig is definitely a fun way to try and accomplish that.
@@IsaacHarrisHolt That's understandable. If you wish to get the broader perspective on why Zig is so awesome, a quick experiment that I would recommend, would be to re implement something relatively trivial like hex dump. Try to do it in C, try do to it in your favorite language, then try to do it in Zig. This shouldn't take too long, (around 500 loc for a bare bone implementation). If you try hard to write good C code redoing everything in Zig will really give you valuable insights on why Zig is so great.
Ooh thanks! I'll take a look into it. Honestly I've never actually written any C outside of RaspPi/Arduino programming, so it might take me ages to get through it all
I agree, zig is the true successor to C. It only needs to be ported to platforms where C is used.
@@lolilollolilol7773 Technically the stage1 compiler is in C, so wherever C is, Zig is not far away if I may say
Zig big feature is seamless integration with C, not only using libraries in both directions with lon the fly bindings generation but zig even can compile C code or be used as build system (programmed in Zig !)....
Zig author(s) should take some prize for it!!!
Oh i forgot, Zig can compile itself and c *cross-platform*... you can compile to Windows binary (exe) on mac or linux or vice-versa....🤯
Yeah, Zig is great! And this is very compelling. I know Vercel used `zig cc` as the build tool for their Go/Rust project
so impressive, how much you manage to pack into 10 minutes
great work - many thanks for sharing your knowledge
subbed
Thanks! I hope you found it helpful :)
Using Zig have been awesome, exactly what I needed after envying Rust/Go features I wished C had!
Cool! What would you say is your favourite Zig feature?
@@IsaacHarrisHoltWell, it’s three things I missed in C, hard to pick one.
* optional value as 1st class language citizen (not unwieldy C++ implementation, null pointer or magic value)
* being able to add methods to structures (C void pointer way loses type safety and syntax is nuts)
* Errors as values, checking for null on top of checking some global error variable is hacky in both C and C++
Very valid reasons! Let me know how you get on with Zig
At 0:33, you mention some missing features. Firstly, Zig does have a package manager - it's a quite recent creation and so somewhat immature, but it does exist, and is being used in the wild (the best example is probably the Mach project). Secondly, I'm not sure what you meant by "reasonable stack traces". I haven't heard of any major issues we currently have with stack traces - in general, stack traces are printed by the panic handler on any crash, and they're detailed & prettified. If you've encountered any specific issue with incomplete/incorrect stack traces, that's a bug, and possibly one we're not aware of, so please report it!
Apologies for that! I couldn't find any information on the Zig package manager (I assume you mean Zon?) on the ziglang.org site, so I assumed it was potentially third-party, like nektro/zigmod. If you could just make sure I've got the right one, and provide some documentation, I'll include a link in the pinned ERRATA comment.
I'll do the same re the stack traces. I don't know why, and I can't reproduce them, but I didn't have a great experience when I was researching for this video. Thanks for calling me out, though!
(I just wrote a detailed reply here and RUclips in its infinite wisdom deleted it when I tried to fix a typo. I'll rewrite it later on :p)
Looking forward to it :)
@@IsaacHarrisHolt Sorry it took me so long to get around to this, I've been quite busy. Okay, so!
ZON is not the name of the package manager, but rather a file format. It stands for Zig Object Notation - like JSON, we've basically taken Zig's construction syntax and turned it into a file format. ZON is used by the package manager, but it's a general-purpose file format.
The package manager itself does not have a name - it's just a system integrated into the compiler. The way it works is that you create a file named `build.zig.zon`, which declares the name of this package, and all of its dependencies and their URLs (the package system is decentralized, unlike e.g. npm). These dependencies can then be referenced from your `build.zig`. The schema for this ZON file is detailed at github.com/ziglang/zig/blob/master/doc/build.zig.zon.md. Unfortunately documentation for the package manager itself is a little lacking at the minute - the best resource is probably the release notes for 0.11.0 (ziglang.org/download/0.11.0/release-notes.html#Package-Management), but keep in mind that might be a little outdated.
You can see an example package at github.com/andrewrk/SDL, and an example usage of said package at github.com/andrewrk/sdl-zig-demo.
I hope this helps!
Very helpful, thank you! I'll add a link to this comment in the errata :)
it's amazing how comptime seems to be actually C++ templates without the garbage syntax !
It's great!
I love C and I think I will love Zig even more. thank you for this video.
You're so welcome! I'm glad you found it useful
This looks a lot like rust in some cases, I also see a lot of rust developers alternating between rust and zig, it looks promising. As for things like panicking on integer overflow, how about dynamic integers? Does it have runtime checks for overflows? That sounds like a poor trade off between performance and safety.
It has runtime checks in Debug and ReleaseSafe mode. For ReleaseSmall and ReleaseFast, integer overflows are UD
Good to know, thanks!
i think the analogy most people make is Rust is "the new C++" and Zig is "the new C". Of course doesn't mean they're going to replace the languages; just that Rust is more implicit like C++ and Zig is more explicit like C. Of course it's not apples to apples, since C++ is (somewhat) extended C, not the same history with Zig and Rust. Interop between the two is a whole other rabbit hole :P
Awesome video. I hope your channel grows! Great work
Thank you!
thank you for the video but I had to slow it down to have some time to think
That's the point! It's meant to be a speedrun of the language. You can always watch it a couple of times 😉
Alternatively, drink 6 pots of coffee, and you'll have to slow down so the universe can think.
(Don't drink 6 pots of coffee! Care for your heart! ☕❤💥)
at 1:18 this is not a array of "const u8" :)
it's actually a slice of "const u8". the difference being "[]const u8" and "[N]const u8", where N is a comptime known value.
"this is a string" is of type "*const [N:0]u8" aka a pointer to a const 0 terminated array of u8. this then coerces into a []const u8 through the explicit type you give "const string: []const u8".
same thing at 4:43
minor error, but they are distinctly different things.
error 2:
at 1:30
the @as is not a cast. it's a inline way of writing `const flt: f80". the actual cast here happens implicitly. the same thing would have worked if you had written "const flt: f80 = 5000.1". of course this can only happen if it's a safe cast such as casting upwards i.e u32 => u64. casting downwards would not work, and be an error, and would require i.e @intCast
Have added to the pinned errata comment! Thanks for calling me out :)
always happy to help :)
just saying:
@as is not a cast! It's effectively an online type assertion.
i think you meant to say "inline type assertion"
I do! Thanks 😅
as someone who programs in c this looks really interesting
Definitely give it a go
Everything I need is in C, Zig, and Go!
Well good job I have overviews of 2/3 of those on the channel 😉
Don't forget about C++, Rust, D, Odin, and HLA!
I don't feel like Zig syntax is well structured enough, seems like a bunch of syntax sugar that someone just added to make things work.
Maybe I'm just used to Rust typesystem.
I do love the Rust typesystem. Zig is still technically pre-1.0 though, and I think there's a lot of room for it to grow and improve
@@IsaacHarrisHolt There is no room to grow and improve syntax i guess
Major versions could introduce breaking changes :)
From the perspective of a rust developers maybe, but if you've been programming in C extensively, you might be able to see that basically all of the "syntactic sugar" is really just very common C idioms (who are very error prone, or unreadable) expressed in a shorter and or safer way. Because the target audience for zig is really just C developers who want to migrate/maintain their old code base with a more modern and safer language, with more control/freedom than what Rust offers (at the expense of memory safety), and without the ugliness of C++. Which makes a lot of sense, I also believe that they've said that the syntax might evolve once everything is ready for the 1.0 as they don't think syntax should be their primary concern.
I disagree with the developers here somewhat. People these days are generally flocking to languages that feel good to write, and syntax is a big part of that. Zig is currently lauded because it's a vast improvement on C, but lots of things are a vast improvement on C, tbh. As soon as a 'Zig with nice syntax' comes along, Zig could be in trouble.
I really like Zig in concept, as a replacement for C it's definitely a stellar option with just straight upgrades everywhere! I've never really worked that low-level though, I don't deal well with the whole "manual memory management" thing, which is why I'll probably stick with Rust instead.
What's really sad to me is how awesome the whole comptime and emergent type meta stuff is, and how that whole system is probably fundamentally incompatible with Rust's type system. If the Rust team ever finds a way to integrate all this comptime magic into their code naturally, it's really gonna pop off for me! (and yes I know macros exist, but they only operate on tokens and not actual types and structures. Again because Zig's model of building the types at comptime seems pretty much incompatible with Rust's type checker.)
I like this take! Yeah, comptime is pretty much my favourite feature of Zig. Like you, I prefer Rust's memory management and I find the type system more robust.
You can still accomplish most of what comptime offers through generic types, but not everything, sadly.
And don't get me started on lifetimes...
Zig feels like a mix, can u tell what the special reason for which zig is in the talks for sometime now??
A lot of it is down to how low level you can get with it. It's as low level as C, but ultimately safer. Comptime is also very useful once you start getting into advanced stuff with it - much nicer than headers and macros.
Zig is meant to replace C, If you know C well you can clearly see (no pun intended) that Zig was built off the frustrations of C. The problem with C is that it lacks type safety, and carries a lot of terrible decisions, namely, macros, preprocessor, nullability implicit conversion rules, forward declaration etc. You might think that alternatives already exist, like C++ or Rust, the problem with those languages is that they aren't "real" C replacement, Why ? Because they don't follow the same set of principles. Zig on the other hand really focus on simplicity and ease of use, especially if you are a C programmer all of the very "unsafe" things and all of the error prone stuff is replaced with more explicit or safe constructs and idioms. In Zig you can't cast variables as freely as you used to do in C, instead you have to use specific builtins to do so. You don't need to use macro magic or void* to get generics, instead you can use a safe alternative called comptime. You don't need to worry about the build system and portability and linking error, instead you can use Zig to build Zig. You don't have to migrate to a new testing framework, instead you can just rely on the Zig builtin testing framework, You don't need to use more macro magic from another language to generate bindings to interops with your old C you can just compile it with the Zig compiler, You also avoid namespace conflict out of the box, and so much more that I can't really name everything, the point is that I'm a C developer, and Zig literally is everything I wished C was.
@@TheMachina42 excellent answer
zig is awesome, quite difficult to understand the memory model coming from a gc lang, but it is extremely powerful. I love the fact that zig aims to be simple, like c, instead of being complex (but more powerful out of the box) like rust. I also love rust, but at some point it becomes overcomplicated
I really liked the video, a lot of info in 10 minutes, loved it!
Yeah, going to a low level lang from a GC Lang is difficult, but eventually you'll wrap your head around it and it'll all just click :)
Glad you enjoyed the video!
Great comment, and heck yeah King Crimson!
It looks nice. This is the first time I've looked a new (to me) language and actually wanted to use it.
Like I've watched Rust videos & C & python & I've played with C#, but meh idc whatever I'll stick with my PHP. Zig actually looks like a thing i wanna try. But i have 30+ FOSS php projects, so i won't be switching languages any time soon.
It's always worth experimenting, even if you don't do anything major with it. Give it a go for the advent of code or whatever :)
**ERRATUM**
The return values at 3:01 (loop with continue expr) are wrong, it should be: 1, 4, 16, 64
At 4:15 you're missing a bunch of 'const' to specify the pointer is pointing to constant value (two consts in the pointer definition, just like in C)
At 4:24 the code you display works because you forgot to make the variable constant.
At 4:58 you're missing the type: [_]{0} requires a type. It should be [_]u8{0}
At 5:39 the code doesn't even compile
Thanks! I think a couple of these are already in the pinned "ERRATA" comment, but I'll add the missing ones
@@IsaacHarrisHolt I was going along with your examples, playing with them, that's how I noticed them. They're helpful because even though they're slightly wrong at times, the audio commentary tells what matters. On that note I had to reduce the audio speed and pause to actually digest the teaching.
@@unperrier totally fair! I know it's a lot to get through in a short space of time - that's how it's designed - and I definitely expect people to pause and rewatch parts. I'm glad you found it helpful though :)
It really seems to be a beautiful language i think ill try learning it i wanna invest time in it but i dont know if it will ever be in demand
There are some really big projects using it! Bun is probably the most famous example at the moment
comptime sounds like *eval* but for compile insted or runtime, neat.
It's great
Really interesting ! Go also has something that works the same as calss delegation named type embedding
Very similar! Struct embedding in Go is great for sure
the day i will write .* to dereference a pointer will happen only in end times
Understandable
"If and loops and switch can be used as expressions" goddamn, I might want to leave easy to write js and try zig for a hot minute.
Honestly having everything as expressions is one of my favourite languages features, be it in Zig, Rust or Gleam!
I *love* it in principle but it's a bit hard to use so far. no function overloading, strings should be easier than C but seem harder instead, and I haven't so far figured out how to have shared libraries, which is pretty important. otherwise I would totally want to use it for small CLI tools.
All totally fair criticisms, I think. For shared libraries, I think there technically is a package manager, but I've not used it. Strings I half agree with - once you've gotten used to using an allocator for them, they're pretty fine
Nice to see more videos in the NoBoilerplate style.
I just hope you found it useful :)
Y'all have some idea of Zig 1.0 ETA? Another question: Why Zig code in Compiler Explorer generate so much assembly lines?
Sadly I have no idea when Zig will hit 1.0. You'd probably be better off asking one of the core team members.
Same goes for the second question :)
would you make one episode on F# and fsx scripts? :) lovely channel
I'll add it to the list!
Zig is pure joy after Rust
I've still not properly used it, but I think I will
would be better to have a slightly longer pauses between the sections.
Thanks for the feedback!
Take a shot every time he says "type", I dare you.
Only if you do it first 👀
how did you make this video? PowerPoint?
Obsidian!
Bro what tool do you use to generate these voice tracks for your videos? 😮
A Blue Yeti, Reaper FM and Adobe Podcast :)
Why do arrays store their length by default? isn't that memory wasted?
Also what's a point of 'arbitrary bitwidth' variables? All modern CPUs have a minimum operation width of 8 bits. If you define two variables of type 'u3', it is smart enough to fit both into one byte? Or will it fit each into an individual byte? If it's the latter then what's the point?
To answer your first question, yes, it's extra memory usage at the cost of safety.
As for the arbitrary bitwidth ints, I'm not sure. I would Google it, if I were you.
Please do a part 2.
Interesting request! What would you like it to cover?
@@IsaacHarrisHolt I've heard that Zig does async differently when compared to other languages. I'd love to know if that is true. And maybe c-interop as well.
It's true! I'd recommend looking at ziglearn.org
AAAAAAAAAAA I read the title as Zig is for impatient devs thinking it is heavy on shortcut syntax... and it also is
There's definitely some strange syntax, but you get used to it quite quickly once you actually start writing Zig, and it's actually quite nice!
No Boilerplate is spreading across languages now
top quality video in your own right though
Thank you!
I've been a C++ developer for 28 years. I like C++ but Zig looks interesting. How difficult is it to get a Zig development environment working on Windows?
Not at all! It's a single binary for the language, and then zigls is available for editors
trying to follow along and add zig to my VScode but I don't know which file is the zig executable 😭
When you download Zig, the compressed file contains the executable and the standard library :)
Great video, thank you.
I'm glad you found it helpful!
AOP reinvented ... nice to see this aproach :)
Ooh interesting take! What makes you say that?
good video , many persons say that zig is the fastest language program, is that true?
I mean, Zig is a manually memory managed, low level language, so it's gonna be fast. As for the fastest, who knows? It'll vary benchmark by benchmark, but generally the fastest is probably gonna be assembly
This feels like C trying to Rust 🤔
Is that such a bad thing? 👀
To me it feels like C trying to Python, which is not bad
Why the rush?
Cause I'm Impatient 😉
you are so underrated
Thank you!
ngl i'm sold. if i'mma compile to binary; this is probably my choice. mostly a scripter personally however
It's a good choice! Zig is pretty good
so well presented, a treat to watch
Thank you!
not a huge fan of the syntax, but holy fuck the overflow operator is peak
I think syntax is a hurdle you can get over pretty quickly. Give it a shot!
Anyone else thought it was a video about the new Zed code editor?
Curious, what made you think that? I wanna know so I can tweak things if needed :)
@@IsaacHarrisHolt I misread the title bro :D Great Video Btw !
I was too impatient. Watched at 1.5.
I'm impressed!
Is it comparable to Rust? And why would anyone use Zig over Rust?
I would say Zig is lower level than Rust. Rust allows you to write high-performance code, but other than the borrow checker, it mostly feels like a high level language.
Zig gives you a lot more control over your memory, and you can therefore probably write more efficient code in Zig.
@@IsaacHarrisHolt So it's basically a new C++?
It's closer to a C alternative than a C++ alternative, I think. It's like C with more constructs to help with safety
Maan zig came out of nowhere
What do you think of it?
@@IsaacHarrisHolt Seems pretty fast and nice. I saw a video of zig being the first in speed in some task. Faster than c and rust. That is amazing ! I hope it replaces c or at least be used as much as c. It feels like a new breath or smthing. I like c / c++ but i would totally love to use zig for a project in my university. The only drawback i see atm is that i feel i cant use it for something solid or long term (since i guess there would be some changes in the languages ). Mostly for some demo projects i guess. I hope it goes well
There are some pretty big production projects happening in Zig right now - you can definitely use it long term! There's nothing saying you'll be forced to update versions.
8:00 I have never seen a macro so simple to understand
It's fantastic
take a shot every time he says type.
Bet
C has really the vest syntax
But so many footguns 👀
@@IsaacHarrisHolt what is a footgun?, yes but c is soo simple and straightforward, the datatype before the name is so much more natural than name: type
Discord link is invalid.
Working for me. What happens when you click it?
Next, you'll do Elixir... right? 😍
Oooh interesting! I hadn't thought of doing Elixir. Maybe I'll start running polls and suggestion stuff on Discord
zig needs a few more years to settle down, every time i come across it i have to find a specific compiler version otherwise full of errors, well that's no fun!
Fair! I'm not experienced enough with Zig to be able to comment on this I'm afraid
Why do you people edit videos like this with zero pauses
So I can stick "in 10 minutes" in the thumbnail 😉
Good. Most tutorials are too slow paced and boring.
I have mixed feelings about Zig after watching this... I like the errors handling, var VS const, defer keyword and many other things but operators look horrific... I don't want my code to looks like hieroglyphes ** +%= ++ .*
Totally valid points! Zig isn't for everyone, but I'd also argue that syntax isn't everything. You'd get used to it after a while.
You lost me at 1:15 "Zig doesn't have a string type". I think I'll just stick with C#...
Totally fair! It does make certain things more difficult
So it's literally modern c
Pretty much! It's a vast improvement
Amazing tutorial
Thank you!
don't understand the comments complaining about pacing, it's literally perfect
good video, keep it up 👍👍
Thank you! I appreciate this
OK, we have C, C++ and Rust, why would one prefer Zig instead? What is Zig's best use-case scenario?
Zig is supposed to be a replacement for C. It's not finished yet, so it doesn't cover quite as wide a surface area, but I can see Zig being used anywhere C might.
A good example is Bun, the new JS runtime built as an alternative to Node.
Sounds like Rust without the weirdness.
Interesting! What do you find weird about Rust?
@@IsaacHarrisHolt A lot of small things. Like not using a ; for return lines. The naming of the crates.
Fair enough! It's not for everyone
@@mrk131324 You call them weirdness, I call them coolness.
Tried it the cache for zig init-exe was to large for simple project. Wait for it for another 2 more years for it to reach 1.0
Interesting! I didn't experiment with init-exe that much for this
What's init-exe?
It's how you initialise a new Zig project. It's technically not needed, but it gives a nice structure etc. It's kinda like Cargo init, but more optional
I think there's a "bug" (sorry if it was already mentioned) @ ruclips.net/video/5I4ZkmMS4-0/видео.html:
```
var overflow: u8 = 0; //you example inits with 255
overflow -%1 // overflow == 255
```
Now, that's the example you intended for, if I'm wrong please shout me.
That example starts at 255, adds 1 (and therefore overflows to 0) then subtracts 1, underflowing from 0 back to 255
This looks unreadable af 😢
Depends what you're used to! And syntax is something you get used to very quickly
Why the modern language as Zig still need semicolons as end of the line?
A lot of the time it can prevent undesired function calls, or situations where the compiler may get confused between attempting to call a function or some.other operation with parens
Removing semicolons is a step backwards, not forwards. Regard.
My RSI disagrees
Whitespace is not a good character in source code (hidden). Imagine that the compiler sees the source code as one continuous line, not like how we view it on screen.
This pointer thing and I don't understand anything
Yeah, pointers take some time to get used to!
Thanks!!
You're welcome! Let me know what you'd like to see next 😉
@@IsaacHarrisHolt Ok well ... this is kind of a big ask, but I haven't seen a good overview video for the general software dev audience on the topic of TLA+, the formal specification language that can be used to prove the correctness of programs. Yes, I know, it's a really out there topic, but it has been on my radar for years.
@@modolief interesting! I'll look into it, but it seems quite far from my usual content, so I can't make any promises 😅
noob question, but why not use C?
Zig provides more safety in things like optionals and error unions, as well as safer patterns for memory allocation :)
10 minute IQ test fr
Did you pass? 😉
Really not a replacement for C though. The whole advantage of C is that it maps very well to assembly and how memory is represented. Zig seems to have too many abstractions, making it more high level.
Anyways, looking forward to learning and implementing it.
Fair take! I think Zig is supposed to give you as much low level control (which I think it does) while being safer than C. Glad you enjoyed the video though!
this is fkn awesome
Thank you!
NIce vide😍😍😍😍
Thank you!
i know zig
-Neo
My biased ass towards C would never make it comparable but it seems promising enough to try.
Comparing to other languages, If it makes a good package system then I might ditch Go for backend development and use this instead.
Ooh interesting take! I think I still prefer Go - development speed is much higher - but I can see Zig working if you're doing high throughput computing
zig vs rust
Personally I think they solve different problems. Zig gives you more control and will ultimately allow for slightly better performance, but Rust is safer and makes it more difficult to shoot yourself in the foot.
I would say the majority of "modern languages" allow exceptions for errors. And they all have a string type. But with "try" and "catch" in the language it looks an awful lot like exception handling.
I disagree. With exceptions it's difficult to predict where errors are going to come from. Error unions tell you in advance that a function could throw an error via their return type.
Take JavaScript for example. `JSON.parse('not JSON')`, will error, but there's no warning in advance.
Also, by returning the error rather than throwing it, you know the code won't stop unless you explicitly tell it to stop.
@@IsaacHarrisHolt I think input data is ideally verified with a predicate function. If it is too much to do both (verify and process) there should be an indication that a function returns an invalid input error. I wouldn't do that with an exception in C++/Java etc. since it is a known possibility that the data is malformed and the function should return success/failure. If the Zig code is forcing error handling on a function with a known error possibility that's a good feature since programmers can code like, for example, fopen will never return NULL.
I would save exceptions for errors that cannot be anticipated and which don't have a path forward other than program termination and find out what went wrong.
Fair take! This is what languages like Go and Rust do. Errors are values, so you're forced to handle them when they arise, but you can also panic to halt termination
Another new language...
Another great new language!
The syntax is ugly af. I'll just use C
Syntax should never be a big reason not to use a language.
Unless that language is Perl.
👍👍!
Thanks! Let me know what you'd like to see next :)
no boilerplate knockoff ⁉⁉
I prefer the word "inspired" 😉
I don't like zig language. Code reading is not easy. İt is so complex
That's fair! You get used to it pretty quickly though, and it's a lot easier to read than C or C++
@IsaacHarrisHolt try this :)
fn writeToArrayListCallback(data: *anyopaque, size: c_uint, nmemb: c_uint, user_data: *anyopaque) callconv(.C) c_uint {
var buffer: *std.ArrayList(u8) = @alignCast(@ptrCast(user_data));
var typed_data: [*]u8 = @ptrCast(data);
buffer.appendSlice(typed_data[0 .. nmemb * size]) catch return 0;
return nmemb * size;
Zig has a lot of cool stuff, but IMHO there's sadly not much point in using it until it gets something equivalent to RAII.
That's a fair take. If you use the larger data structures, and then immediately defer the deinit call, it's not THAT dissimilar to RAII patterns
Very well done, just not a fan of the zig syntax. I honestly prefer the c syntax over zig. Zig reminds me of java and I really hate java.
I understand the Java pain. My programming journey started with Minecraft mods and plugins 😅
But I would be careful of dismissing a language for its syntax!
pointers? no thanks!!!
What's wrong with pointers?
I program in Swift and feel lack of pointers in C-style, especially when implement bindings to C-libraries. In this case, Zig looks better.
You can use handles instead of pointers.
It looks like Java with pub, fn etc. Very verbose, too many words to do something
I disagree, to some extent. Having more reserved words typically makes a language LESS verbose, as you only need a single word to achieve something that takes a lot in other languages (e.g. the `go` keyword in Go).
I'm curious which language you're comparing to to form this opinion, though
Why bother to learn a new language, where there are no string only arrays defined as [u8], string manipulation function are verbose and clunky, and memory allocators are different paradym. Sure there error handling "try syntax" is good. The complier is your enemy. When we already have Rust why bother with zig ? A simple language with manual memory management and no head files
All your points are very valid! Zig does have some advantages over Rust - it's a bit lower level, and you have more fine grained control over your memory management without having to resort to "unsafe" blocks and so on.
Also, comptime is awesome
Python teaches Zig nothing. Async/await approach can't compete with Golang. Huge mistake.
Agreed! Go's concurrency is absolutely next level