2024 is the year of "X is the year of ..." articles

"coffee machines are written in C". But to write C code, one needs coffee. How does that work?

Zig's C interoperability is such a killer feature. Love it.

"I don't know what CLIT is... never found one"

7:25 this is why I chose zig after escaping the Ivory Tower, simply due to the fact of how much stuff is already written in C, so being able to trivially use any C-library from zig without having to rely on some janky, possibly outdated bindings is invaluable… xlib, xcb, libgl, raylib.. the list goes on.

Also just a note on how zig errors work, Zig's `try errorResult` is the same as `errorResult catch |err| { return err; }`. All it does is say "if this is an error, return it so that the parent function can handle it"

Zig's C Interoperability is interesting to mix it with older C code.

bro is able to turn 9 min into 48, content beast

andrew kelly said they're changing the syntax after 0.12. can't wait to see what type of optimizations they can get with a different syntax. pretty exciting language, just has a lot more work to be done on it.

Zig competes with rust in the same way c competes with c++. They have different philosophies

Zig is an awesome language. All of its bad PR is from people comparing it to Rust. Apples and oranges everyone!

Summary cons/pros - return in Zig is always ending with semicolon. In Rust it is an expression if it doesn't have semicolon. So it is harder to grasp what is going on in Rust. - performant Rust is 100% harder to understand than performant C++ - In Rust you don't know if something is on heap or on stack. You have to learn it. In Zig you know it. - In Rust you feel like you program in high-level language. But you actually program in low-level language. And that mentally is a bit of a foot gun. - Zig is like almost Rust but nicer. - comptime in Zig is like macros in Rust but you don't have to have doctorate to use it. And you write comptime in Zig. And macros in Rust are like a different language. Level one is syntax. Level two is async and lifetimes. And procedural macros are very hard and like level 3. And you have to dye your hair blue when you reach level 3. - When you start learning Rust, it is hard. It gets easy and then it gets significantly harder when you jump into async and stuff. When you use some web framework all that complexity is hidden from you. You don't even know what thread you're running on. But the moment you try to write those things, it's excessively difficult and generics can get really, really, really hard. Working with trait objects and generics is non-trivial. And people think it's trivial. And then you go to fourth level. The difficulty of Rust is a lifelong learning process and it is kind of a big issue. It gets exponentially harder. It is deceivingly easy at the beginning and then it very quickly ramps up. - Using mutex, locking/unlocking it is cumbersome. - In Rust memory will be freed and you don't know when. In Zig you know when memory is freed. Also code github.com/rofrol/zzd Regarding try: 'try' is on the left to discourage chaining on purpose. you can wrap parentheses to get around it, but having to 'try' usually means a resource was collected that you might want to defer. postfix error handling would leak easier. Technically try is syntax sugar over catch |err| return err; discord.com/channels/605571803288698900/1238567770157875200

I had the same opinion about “what should I learn next?” questions. But then I spent 4 months learning Rust for game dev. It isn't very good for that. Looking back, if I asked and read more opinions, I would spent that time on something more useful, like making my peace with Cpp.

Your interview content is always so good. More please.

4:56 “Learning something is better than trying to figure out the best thing to learn ever.” Never have I related to something so hard.

Zig is my #1 favorite language. I tried to like Rust, i truly did, but once I tried Zig, I fell in love with how easy it was to just "do stuff"

3:01 LISP has less syntax than GoLang because LISP is just words and values composed in a bunch of parentheses

Understanding control flow better, having explicit allocators, and having comptime make zig the ideal language for game dev imho.

Yo prime, nice to see you on more zig. Regarding the try syntax: postfix operators are not a big thing in zig in order to promote explicit intermediate values. Zig is a hardcore imperative language, so chaining is intentionally kept to a min.

Finally Prime coming around to Zig. I believe its going to replace C for sure. They have alot to do at the moment, though.

As someone who really likes Go I have to admit I like Zig. I’ve been looking into it and there are a couple of things that Go could actually adopt from Zig.

As far as replacing very low level systems programming and embedded stuff zig seems ideal. The Zig cc compiler is great for cross copliling C programs. Very handy. It's big flaw is that much like C it's not very modular. Making large higher level projects in it is tough. I've written high level projects in C++ and while it's very doable I would never describe it as pleasant compared what you can do with Rust. Given that Zig and Go exist I actually think that Rust is more the odd one out. It kind of lives between the two. That said in practice I think Go has problems. Most of them small, but cargo tooling is heavenly compared to working with Go, Go does whack things with JSON, writing error aware Go code hurts my eyes, etc. But for a simple CLI or basic microservice Go is great. It's runtime is pretty fantastic.

Hey dudes! Glad to see Zig being explored and curiosity growing day-by-day. I've got a couple of playlists for learning Zig. Zig Master covers the latest version: kzfaq.info/sun/PLtB7CL7EG7pDKdSBA_AlNYrEsISOHBOQL&si=rylNoBpDV14kfjIh ; and Zig in Depth covers version 0.11: kzfaq.info/sun/PLtB7CL7EG7pCw7Xy1SQC53Gl8pI7aDg9t&si=-py8hirleVyyKpHj . For Spanish-speakers there's also Zig Master en Español: kzfaq.info/sun/PLtB7CL7EG7pC960XOA5vymEyTfQ3M_QhL&si=vcTfQf5TEwwwRURk

Are we going to get the reaction to the I'm Leaving Rust GameDev article as a vod?

I think zig has the best philosophy for it to be adopted. The fact that it essentially can be used as an all-in-one replacement for cmake and clang/gcc and integrates well with C code is fantastic. Rust was created to be it's own entity, which is the biggest turnoff for people learning it imo

@41:59 Matheoux7 posted "zig reverted async"! That is so important. Zig was about to go down the C++ route of including all the latest 'cool' gimmicks, but in the process introducing all sorts of footguns (footgun mentioned). Thank god they reverted it. Well done Zig team. The devil is in the details though.

The only way you can make driving 100% safe, is just to not drive.

29:08 comptime is so powerful that i made a joke program where I read a json file (file stored on disk) at compile time and converted it into a struct and used that struct as a regular struct in the code.

The zzd example is missing `defer file.close()`, no? I'm fine with explicit allocations if combined with RAII.

C is chaotic neutral, chaotic evil is C++.

I just like Zig's compiler. I can write my code, in C or Zig, and compile it for all of my supported platforms with a single command. Right now, I'm working on a library similar to GLFW or SDL, and being able to use C to talk to libraries like Xlib in a more reasonable fashion while using Zig to do the "hard" stuff, all using a single build file is just so nice.

My favorite way to do error handling in Rust is by returning a `Result`. When an error occurs, you simply eprintln!() it and return Err(()). So if all of your functions do this, it's very easy to use the `?` operator and not worry about converting between error types. Of course, this might not be the most versatile approach, but for application code it's fine 99% of the time (Library code is different)

For me the most confusing thing with Zig is its allowance of . to dereference a pointer and access a struct’s members. In C++ it’s super clear that I’m dealing with a pointer when I use ->. While that may make it easier to write it makes it a lot harder to read; am I operating on a copy of the data or the original data?

Rust's value proposition is still unmatched. Would comptime be amazing to have? It would. Would switching allocators be amazing to have? It also would. That does not detract from the fact that people make incredible things with it and prototype fast with it when they need.

18:02 A similar mechanism to defer exist in Dlang: scope(exit) 29:28 Compile time function execution (CFTE) like this could be done with Dlang already ages ago.

It depend on the user and which area targeting. For this it is portable and small. But depend on the size as it need cross platform tool compiler to handle those stuff. To able to export to different platform is easy and hard. vs those toolchain has big file depend which toolchain is it and packages. zig is about 300mb last checked for exe size is 150mb. While other is +400mb. It depend on application and packages. It all one package or crazy different config builds.

Anybody else here who remembers segment registers and non flat address spaces as on the 8086?

15:54 Why is Result an "evil" statement. Frantically asking since most of my error handling is done this way lol.

Odin is more like C than Zig is even though it's also quite Pascal-like. Zig has the momentum from Bun. I like both, and Rust. Go doesn't bring back the joy of coding C that Zig, Odin, Rust, and Swift do.

LLL/Ed was one my childhood best friends (12-16), we wrote game maker language code/built 2006-2010 style websites (that I often had to "fix" because I had 1 or 2 years more experience than him). We'd stay up all night programming and studying and drinking energy drinks (vault gang/mr coffee gang). We woke up so many days at his parents house at 2-4pm because we stayed up til they made us coffee and breakfast when they woke up, my parents would always let me stay over because they knew I was working on stuff/learning, super funny hahaha. It's crazy to see him on your channel! Long live the joveproject and long live mario fan games.

I'm curious why his allocator is the page allocator. Won't each allocation will give an entire page of memory regardless of how small the allocation is?

14:40 I sort of think there's more common space on this between you and Uncle Bob than you admit; IIRC his advice in his talks is boils down to "babysitting" the try/catch in to a function of its own, and then return a "normal" value. (I'm not sure, though, I need to re-watch your interview with him.)

And yeah ghost allocations is the reason that when I worked in medical systems we weren’t allowed to use libc. We wrote all we needed ourselves, as to be damn sure that if libc changed or the platform changed the code was still tested and working. Last thing you want with an insulin pump (and that was the junior/medior development because insulin is forgiving) is that you had a OOM and in an embedded device you don’t see that, and it will not deliver that insulin when needed.

But doesn't go essentially have try/catch with panic/recover and rust with panic/catch_unwind? try/catch can have it's usefulness. It can be much easier to escape multiple levels of functions with a simple try/catch then multiple levels of returns and if/match statements. But if you don't like try/catch then you can just think of throw as panic and just don't catch it. Nothing is stopping anyone in any that has functions from returning an error rather than using try/catch.

I was thinking about the Linux kernel including Rust. I think that since Zig isn't 1.0, it won't be considered, yet. Zig may be closer to what we would want in the kernel, since it doesn't have hidden control flow. I could be wrong here, and I'm to busy to put in the time to figure out if I am. The main problem is thread safety, but when you're in the kernel, the Rust compiler doesn't have information about everything, so the thread safety is only for what's made in Rust. I'd like to do some Actor Oriented code in Zig to see how safe that pattern could make things without needing a borrow checker, which seems to be what blocks many people from using Rust.

The answer to "Should I learn Rust or ...?" is yes.

18:10 ok, that's amazing

46:25 read the tests next to the function implementation :)

The fact that I can install zig as a clang replacement in my windows for some libraries/apps is just mindblowing

most of skill issues in rust can be wrapped in unsafe.

Pointers to stack allocated objects caught me so much when I started with zig

Did @ThePrimeTime managed to do the C course for DSA?

8 seconds in, he says "we're like 2 minutes in" lol

C is awesome, super simple, and with the newer safety stuff like shadow stacks, _s methods, etc, it's getting safer and safer to use.

"I don't know what it means to attach a payload to an error". Alright man

Saw a comment about C++ modules. Get cmake nightly and clang 19 (may have to build from source tho, or ask your linux distro community) Both `import std` and custom modules work Have fun!

I agree! Rust gets very hard and unfriendly in embedded systems. And when I did Zig (I have a couple of videos) it all is so simple in comparison. It’s a bit verbose here and there although Rust is that too, but you don’t need to do lifetimes; which is a terrible syntax imo, looks like a hindsight implementation. I choose Zig for any project I’d normally would use C now.

31:42 I LOVE this feature!! It's like having a garbage collector without the garbage collector

I think defer is a bad design...this code demonstrates one of the reasons, where is the close for the file? The defer was missed. There are many other issues with defer like scoping, slow, etc. EDIT: Just spotted fBuf clean-up was missing

people tend to search for a more optimal path when they want to do less work which ithink many programmers now adays because alot of people go into programming for money (happens in all careers that balloon up)

I just end up writing actor systems over and over again in async. Someday I’ll figure out macros and make that into a proper crate.

8:02 Agreed, but that's also because computer science has based its curriculum off of C (and C-like languages) for half a century. It's like saying a piano naturally represents music theory, where in reality the standard 12-tone scale is largely built around the piano. Not to say C or the piano are bad or holding back either field, just that their ability to feel natural isn't unique to them nor an accident.

But... what about Nim? Where we can place it compared to Zig?

Hmm seems like a lot like Odin but with more syntax quirks on top and the nice comptime which it currently doesn’t have.

“Quick discussion” lol

I just love how Prime and LowLevel are becoming friends. They're just my favourite KZfaqrs

for those who don't know, you create an error in rust by "tagging" a stype that implements Debug and Display as std::err::Error. it's a zero function trait

my fav. youtube cam boys

@2:08 - I couldn't agree more. Hope there's some consideration for it as it becomes more mature.

26:30 "You should learn," and the round of applause. Great, Primeagean! Very good. Now tell that to an employer who prefers 100+ years of experience in every effing damn framework for ONE language (otherwise, if your interests are broad -- you're considered mediocre at everything, at best, from the get go) as deep as possible for the "new grad" position for 16/hr

the problem of go is actually not GC for most perforamce use cases but its green threads. the problem is the slowest ffi in the world. i dont know how its not but a go callback called from c could have up to 1ms call overhead due to the green thread stuff go is doing. writing a game engine under those condition where you simply need to talk a lot to the OS is just unfeasable regardless of any other features of the language

it all feels like java from a syntax perspective. What am i missing?

Zig is good for complied extensions for other languages FFI and C APIs

If we go right, we take the left type 🤔

zig is pretty much the modern C but when I tried it there were a few annoyances specially there is pretty much no support in the language for any sort of interface/trait(or either I have massive skill issues) to share functionality which could lead to repetitive code but the language is elegant though and I am excited for 1.0 release and hoping they polish the tooling specially the LSP because it takes up a lot of resource and kinda buggy.

I was Ok with Zig but read the issue (zig fmt) of tabs and 2 space indentation and almost felt like the proprietary Rust

I've get yt recommendation: Vlang: "The language of 2023". Year Old Prime video. But zig at least is working

I will finish Rust but I admit I really liked Zig since I learned about it. If I will stick to Rust it will depend on how I enjoy writing it.

Zig's `comptime` reminds me of Perl/Raku's BEGIN.

rust is like trying to be cpp alternative, creating cpp... i like zigs idea. clean and simple.

You asked about async in Zig. Worth noting that async has been removed from Zig for a couple of major releases now. They deemed their first implementation flawed and scraped it 🤨

Is there anything that Zig adds that couldn't just be added to Rust? Like the build logic/comptime feels like it should be able to expanded on further in Rust's proc macro system. I say this because Go's greenthreads were so popular they just got adopted everywhere.

Writing and reading zig code is so freaking simple!

proc_marco is extreme hard , but once it over, it become the best templating tool to reduce the most of dev time

Any time people talk about "programming languages" the guy from Office Space pops up in my head asking: "What would you say you do here?"

What if you port your Go code to Odin? It will be a lot fun.

As a mathematician I gotta confess... Golang's " :=" syntax is just awesome, I loooove it 😎

zig is a great centrist systems language, its almost exactly what a C continuation should be imo.

Wise words from ThePrimeagen: "If you can just keep on having something you can do again, that's better than the thing you'll do once." Or equivocally: smoke weed everyday.

A lot of takes also apply to Nim

Prime slowly becoming the Zig version of his Elixir dev meme

No matter whether I talk to a Zig, Rust, C or Go developer they all seem to share one thing in common: They either dislike or straight up hate C++. 🤨

I was interested into trying zig for embedded, but their repo about it seems to be abandon from a few years... while Rust embedded team made miracles to give safe and generic interface to pretty much any LLVM supported chip

Pretty simple really - different programmers think in different ways. Languages are a tool to express a thought process about how to build a thing. Zig is not for everyone, but it’s great for programmers that mostly think in terms of assembly and system calls when they are coding a solution. (Just like C programmers do) There aren’t many programming languages left that target this direct mode of thinking.. so it’s nice that Zig exists in this space. The stdlib is a bit of an evolving mess, but that’s fine, as it’s more a collection of suggestions at this stage rather than a hard reliance. Doesn’t get in the way at least, and isn’t needed for a lot of jobs. If you are in this camp, then unused vars (for example) is a bug, and deserves to be a compiler error. Likewise - formatting code is not a concern, and syntax quirks are what they are.

Imo zig is more of a c replacement, rust is more of a C++ replacement and Go would be a Java/C# replacement. And what i mean by "replacement" is more of the areas you would currently use those other languages (c, c++, c#/java), you can quite easily replace it was more modern alternatives. You could probably do higher level stuff like game programming in zig similar to being able to do it with C but would imagine it would be easier with rust since the language would make it a bit easier (syntax sugar and language feature making standard clean up and such easier).

Ron Burgendy "sqeeeeeeeeeel-X"

C++ LIIIIIIIFE.

420k subs

"use after freeze" 😛

Prefix and suffix