Youtube comments of (@pierreollivier1).
-
322
-
Zig is definitely an amazing language, but there is so much you should have mentioned, maybe in another video, because as a C developer, Zig is really everything I wish C was.
1 - It's simple and easy to use.
2 - I'ts the most refactorable language (meaning you don't have to jump in 30 files fixing headers and function prototypes.
3 - Comptime is capturing 90% of the power of C++ templates/Macros, while still being very readable and type safe.
4 - The build system is insanely good, I replaced make/cmake with Zig, and with Zig itself it's really amazing.
5 - Zig found the right balance of freedom, meaning you can do exactly what you are doing in C (aka crazy casting and weird stuff unlike Rust) but at the same time the language design makes it very inconvenient and verbose to do so. Which makes it actually easier to just to the right thing and not take any shortcuts. So for once the Type system is actually one that doesn't deceive you because of how loose it is like C or how tight it is like Rust.
6 - Allocators are first class citizen. Even the Std is build around that which is amazing. I really don't get how a manual memory managed language like C didn't come with some form of interface for allocators.
7 - The interops with C is the most natural, intuitive, and straightforward that I've ever seen. You literally just add an @cImport("header.h"); and a exe.addCsourceFile("") in your build.zig and you are good to go.
8 - Zig also has integrated unit testing, which makes it so easier and cheaper to test code. In C I would literally spend 30 minutes writing some code and one hour testing it properly. In Zig you write a function write 2/3 tests forget about it and just do a quick zig build test and you are good to go. Which is also why it's so easy to refactor Zig btw.
9 - No hidden memory allocation, no hidden control flow, everything you read is everything you get, you don't have to guess whether this functions aborts, returns -1 or 0, or whether it sets ernno.
10 - The error handling and all the builting safety features makes it so much easier to write fast and correct code.
I could go on an on but TLDR if you are a C developer you should definitely try Zig as I'm sure it's going to be the real C replacement. In System level programming.
262
-
89
-
56
-
44
-
33
-
26
-
25
-
25
-
the best technique I know to learn things fast is to talk a lot about it, and role play you being a teacher in that domain, for example when i used to read a lot about economics, and listen to a lot of podcast i would roleplay in my head being interviewed or giving a lecture on that subject. And there's a lot of benefit to it :
1- The first one is that it improve your conscious understanding of the subject, when you learn about something it's almost like you have learned nothing and everything, and when roleplaying lecturing about a subject when speaking you'll have that unconscious understanding that will give you the intuition to correct yourself, or to explain yourself better and instead of crystalizing the surface level understanding you'll really get the deep understanding of the subject.
2- Second is that it will tremendously improve your ability to communicate with other, because when you teach (even when you are just pretending) you'll find ways to illustrate your ideas in such a way that it would be understandable for 12yo, and that's true understanding, if you can explain something complex to a 12yo and he get it.
3- Finally it will improve your ability to think and more often than not you'll end up connecting dots between different knowledge and you'll come up with your own ideas, that come only from you, this will give you very nuanced and interesting opinions, and most people will really appreciate and value such ability to think.
24
-
23
-
21
-
The oil industry is a very cyclical industry, because oil is so capital intensive to (find, extract, transport, refines, distribute etc) it rely almost entirely on investment, but companies can only invest when they have both the ressources and the need to do so. The problem is that our society relies on oil to function properly. So since oil has been discovered and has taken such an important role the same cycle is happening every 10/20y. The industry is doing fine, there’s even some surplus of capacity, so since there’s more oil than there’s demand the price slowly decreases as the profits and in the end the investment does. So they stop spending money or finding new sources and creating new oil rig and stuff, so a few years forward the demand is superior to the offer, so the price skyrocket, and oil companies start making huge profits allowing them to both invest to find new sources, and reopen less profitable sources, driving the price down etc etc. So unfortunately we will always suffer through the same issues.
19
-
This is why I will never be a web dev, The web stack is absolutely broken imo, you can't be expected to be good at it when everything is changing everyday, I like C because if you learned C 10 years ago, it's almost the same language, the way you are coding is still very idiomatic, and you can read code from other people and immediately get it. There is also the benefit of being able to immediately spot inefficient or incorrect code, like I know this might seems crazy for web people but I can actually just look at some code, and immediately know if it's correct, performant, and idiomatic. That doesn't mean that change is not good, like I'm currently learning Zig, and getting more familiar with Ocaml, so there is a fine line between changing things all the time, and never learning anything new. But in the web world it seems like everyday there you are just becoming more and more useless if you don't invest time in learning the new how thing without even being sure that you are going to use it, I really feel bad for web people it must really be a pain to work in the web.
17
-
16
-
16
-
@jorge42343 The difference is that It's less verbose than Rust, and the compiler won't fight you for it, but at the same time if the compiler see something that it knows to be wrong it won't let you shoot you in the foot like C would. To give you a better representation, Rust is like that overly protective mother that will not let you do anything because it's "unsafe", While C is the father who doesn't see anything wrong with letting you base jump at the age of 8 from a bridge and expect you to just be ok. Zig is the reasonable aunt, that will warn you but still be ok if what you want to do is reasonable. Also when I say that Zig is more verbose when you do some unsafe thing, It doesn't mean that it's painful or unbearable, you just have to use explicit builtins which are obviously more verbose than no builtins at all, but at the same time they improve the code readability and in the language design the intent of the Zig creator was to make the "easy" path also the correct one, so while you can still take shortcuts, those shortcuts are more verbose, and they gently push you to a more "correct" approach.
15
-
14
-
14
-
12
-
12
-
11
-
10
-
10
-
10
-
@dmdjt Be careful, with all that logic, the "Skill issues" folks are going to come here and say that C++ is perfect and easy and that the sole reason why you want another language is because of "Skill issues". When in reality C++ is the absolute worst programming language in existence (in terms of design). It's so bad, that it's a text book example for pl designer of what not to do.
I think the reason so many people are fighting tooth and nails to defend C++ is because of all those years they have invested in learning things that are not transferable to other language. Programming is already hard, but on top of that when you master C++ there is not much you can transfer to another language. Because debugging C++ is 20% debugging your logic, 80% debugging your language knowledge. That's unlike any other language out there.
This is an undeniable proof of poor design, if C++ was correctly designed you would spend most of your time debugging logical errors, but no instead you have to remember that this overload, does this but this one is slightly different, oh and this is not a function but actually a macro, and this template will produce this type, but not if it's a reference, or a universal reference, and the forwarding doesn't work if you do that, which means this template 20 function down the road, uses this overload instead of this one, but now because of the casting rules you get this instead of that, how but this lambda is actually doing that instead of this. It's just an incredible mess, where you are constantly triggering UB if you are not careful, where Error handling is really hard to achieve, and where all the "Zero Cost" abstractions actually have a big cost, outside of the iterator, all those smart-pointers aren't cheap in the slightest. And they also have their own quirks and logic that you have to remember and this creates just an exponential amount of cognitive load, but people will still say "skill issue" but I'm sorry if your language requires 20y of experience, before it becomes easily usable, it's a language problem not a skill problem.
10
-
10
-
10
-
10
-
10
-
9
-
8
-
The thing that i disagree, is that we should take into account technological progress into account, because it’s a very tricky subject, for example if you bought a 500£ computer today, to do some spreed sheets, some google, and some emails, and 2 years later you buy a computer that’s 1000£ but it’s twice as powerful as the other one, if you haven’t changed the way you use your computer this is inflation, but in my country they’ll say that since it’s twice as powerful therefore even tho it’s twice the price, it has actually not inflated.
Same can be say for a dishwasher, maybe the new one clean dishes 10% better, but does it have an impact on your life ?
8
-
8
-
@surgeon9039 No they are not, In fact they are some of the most well connected in certain parts of the world, sure they can't rival with the Americans, but in the middle east, even the CIA relied on the DGSE for a lot of operations, same thing for Africa. You never hear about them, which is a sign they are doing their jobs well. They also have very singular capabilities, for example unlike many who relies on SF for cover operations. The DGSE has it's own in house Special Forces, that only belong to them and them only, the training is very rigorous, more than 3 year, and they only recruit from the most elite special forces group in France. They are also very strong in the economic intelligence business. Obviously any agency out there French included is less capable than the US/Russian/Chinese, but they are far from soggy.
8
-
8
-
7
-
7
-
7
-
7
-
7
-
why does it matter ? like I'm also learning C, and I can guarantee that my code is riddled with horrendous pattern, terrible naming/style,, and even more UB. But that's part of the process of learning, like sure you can learn it from a book or at school, but the best way to learn is to actually shoot yourself in the foot, When I started I wanted to do well so for me everything was about creating abstractions, and using the correct pattern for the job, and it's only by realising how terrible my code was to read and use that I've come to the conclusion that "Clean code" is terrible both for productivity, and one's sanity. In C I used to rely on pointers and casting, until I realised that casting should be done more intentionally at time because it can lead to strange promotion behaviours. My point being that sure all of that can be learn through college or books, but the best way to learn that is to actually do it yourself.
7
-
7
-
7
-
As much as I love C, as it's my favorite language, it's just a very annoying language, most of the time, I'm not debugging a problem in my logic, but I'm debugging C, oh yes the variable in that struct is a int, and this one is a uint32_t, so in that edge case in the loop it will overflow and the language will do absolutely nothing to warn me, unless I decide to make it pathetically slow, by using 30 different sanitizer. Or yes let me cast this ptr into this one and don't warn about alignement. And yes don't tell me that this variable initialization depends on a branch deep in the stack call. Or yes let the library that I've just imported silently undef this particular function that I use a bunch, to replace it with a macro hidden somewhere deep in the most intuitive .h file. Or yes please let the current system my code is being built on redefined a previously defined type_t into a slightly different type, which will cause a bunch of silent bugs that are hard to find and reproduce. Like C is just so frustrating and fragile.
I'm probably not skilled enough, but when I see languages like Zig, and see it fix probably 99% of the footgun that I'm used to encountering in C that just makes me more angry about why C doesn't give me more warnings, despite having a ridiculous amount of flags, but the good new is you can use Zig type system to write better C so that's ok. Still I wish C dies as soon as possible and gets replaced by really anything at this point.
7
-
6
-
6
-
6
-
6
-
6
-
6
-
I think Electron should be used by companies or people who don't have the means or the need for true native app. The problem is that Electron allows too many Lazy developer to make shitty software. VScode is just embarrassing, we have Tflops of power, recent CPU's have SSE extension with a minimum of 128bit width, mine has AVX512, I can do as much as 64 * 8 bits of processing per clock cycle, for each core, we have Mbs of cache, most computers have between 16 and 128gb of Ram nowadays. We have GPU's that are more powerful than most Super computers 15y ago. Yet somehow VScode can't do 120fps, it can't updates it's UI in real time, it can't do syntax highlighting well, it doesn't let me move my cursor fast enough. WTF ??? And that's entirely on the lazy companies and the lazy developers that just simply aren't good enough to make decent software. This is why I will never use an IDE, it's not that I don't think that they are useful or that I think that TUI's are better, but it's simply that the current IDE's are just trash, they just are terrible.
5
-
5
-
5
-
5
-
5
-
5
-
5
-
5
-
5
-
5
-
5
-
@sleepnaught I'm not as experienced as the people commenting above, but I can safely say that there will still be jobs within the next 10 years, even if AI progress are amazing, it still takes time to transition. Just like when tractors were invented, it wasn't a sudden transition, little by little, small farms were buy out and merged together, jobs were replaced by machine but it took time. Even tho i expect it to go faster, that transition will still take time. lastly you wont magically become useless, the skills you are acquiring will still be valuable, and usable within another industry if needed
5
-
@LeviShawando Dude you are trying so hard to defend C, this is actually text book example of average C/Cpp dev sunken cost bias. I've worked 8/12 h a day in C for the past year, and while C is an amazingly cool language, the more time you spend writing C the more you realise it's evident flows, thinking that there is an ounce of argument in favour of C is ridiculous when Zig exists, the goal of a programmer is ultimately to write code, who cares that you've built your application in C, Zig, Rust, Javascript for that matter, the end goal of any code is to be good at what it's trying to do, and sorry to break it to you but in the light of what modern programming languages offer to the developer in terms of ease of use, simplicity, effectiveness, correctness, readability, usability. Zig even in it's early pre-production stage is light years away from the average C/cpp experience.
To be semi-decent at C I had to watch probably a hundred conferences and videos about C detailing all of it's intricacies, I've read 6 books on C and advance C, I've read countless repo of big C codebase to get a feel of how good software is written in C, I've made my own version of almost all of the C std functions, I've written a C lexer/parser from scratch, a posix compliant C shell, a hand written simd library for some functions of the std, and despite all of that practice (probably around 100k lines rn) I still bang my head on the absolutely terrible ergonomic of the language, this is insufferable to waste so much time fighting the language, between all of the implicit conversion rules that you have to know and carry around when doing basically anything, the keyword semantic changing in regard to the scope, the 80 different type_t that are all typedef of 400 int's variant, the fact that you constantly have to check for NULL which isn't even a thing just a stupid macro for (void*)0, the dogshit std library, the lack of namespace, the shadowing of identifiers, the macro which are just stupid to debug, the terrible linker, and errors that just go un notice unless you use static analysis tools, the 800 compiler flags, the absolutely horrendous build system and overall tooling clunkiness, the lack of portability (despite being the "most portable language" the lack of modern tooling and standards make that "portability" very very very relative, you can only hope there is no #undef, or #define, conflicting with any of you header file or you are screwed.) The fact that enums are just integers, the lack of type safety, the lack of generic, the lack of basically everything.
C is awesome to make you a better programmer not because of the fact that it's a low level system programming language, no but because to achieve any meaningful success in writing anything in C you have to go get such a wide array of knowledge and understanding of the whole bloody ecosystem and environment of the system you are working in. It's great for learning but that's it.
On the other hand in less than a week I was writting Zig code, using the Zig build system, and thoroughly testing my code because unlike C in Zig they understand that to improve code quality and developer ergonomic, the language most natural way of doing thing has to also be the most correct one, it has to be the path of least resistance otherwise it's not going to be widely use. In zig I write a function and I immediately write a bunch of test because to test any code I just have to do : test "name of the test" { code running a comptime}. I don't have to create separate C files, and fight the build system to integrate nicely with my suit of test, and if mid developement I change my mind on the type of my functions / parameters, I don't have to modify and maintain 50 files just to have some working test, no I just use comptime and type inference to do that for me. There is no more hidden control flow, and implicit garbage conversion rules to remember. Easy 10x on the type safety, Easy 10x in reduce cognitive load, the tooling is already better in some areas than C will ever be, If the code compiles and run I already know it's 99% correct. This is just my opinion after a year of experience, I can't even begin to imagine how badly any C devs want Zig to become a reality.
Like if you think C is fun than go try zig, there is no going back C really does pale in comparaison, and again the language is not even finished or production ready and yet it's already 10 times better than C on all fronts. Unless you are doing embedded stuff, or kernel development where zig is not supported yet, honestly there is no excuse to keep using C.
edit : I'm comparing C to zig because I happen to write zig, but Those arguments are probably true, for Rust, nim and many other languages that are basically not C or Cpp.
5
-
@LeviShawando In terms of standards, I refer to a language's power, expressiveness, underlying philosophy, tooling, ecosystem, and semantics. C is an old language, it's natural to expect its eventual replacement. Regardless of its current extensive use or foundational role in programming. If there is a tool capable of performing the same tasks with greater ease, safety, and power eventually It will replaced the previous tool that's just the way things are. While I mentioned Zig specifically, the same arguments hold true for Rust or any of the system level programming language, and in the next couple of decades, similar claims might arise about Zig, Rust, or any other language. C's evolution is limited, lacking the potential to attain the safety or expressiveness found in languages like Zig, Rust, Jai, Odin, or other modern system-level programming languages because this would completely brake backward compatibility.
5
-
I went through the same process but decided to switch to Helix, it's written in rust, it's blazingly fast, super responsive, it's very minimalistic, lean, and effective you get the bare minimum of usefulness and no bloat. Out of the box you get full modal support like vim / nvim ( but based on kakoune motion ( which I personally prefer tho if you are switching from vim and want only vim bindings there's already a repo with pre-made config for that ) The configuration of the editor is so much better than neovim, there's no Lua file just a config.toml file which is very well documented and easy to use. You get the ability to split windows, a file gutter, fuzzy finder, lsp, themes ( you can add your own too it's very simple compare to vim, just create a theme directory in your .config/helix/themes and put the file ) it support transparency, debugging, through DAP, buffer, clipboard support, different registers for copy pasting, It's imo a superior neovim, I really liked neovim, but it's so unintuitive to configure, the documentation is inconsistent at best, and I'm probably not that good at lua. I get that you can configure it the way you want, but helix just work, it has everything I want, and it consistently work, with just a brew install helix, I get my nice editor, I symlink my config and hop I'm ready to work in no time.
5
-
Exactly what I was going to say (although not for game engine) But zig is perfect in that sense, that it is an extremely type safe language, there is no implicit casting (like in C/cpp unless for larger non overflowing conversion), if you want to cast you have to use builtins from the compiler, there is a check on out of bound, sentinel values, all arguments are constant by default. There is all the syntactic sugar and features you expect modern language to have, (optional, enum with proper value space, union type, defer etc.) Without all of the inconvenience of Macros, templates, and all that garbage which I'm convinced exist only to make people want to change job. Yet in zig you can do everything as you would in C or Cpp in safer way without the overhead of the Borrow checker. Such an amazing language.
5
-
4
-
4
-
@Iordygon Il faut vraiment chercher la ressemblance, ils sont fondamentalement libéraux et libertaires, avec seulement des idées de protectionnisme, idées qui, il n'y a pas si longtemps, étaient défendues par le Parti communiste. De même, les premiers à rejeter l'immigration de masse étaient les communistes, car ils savaient exactement à qui cela profitait. Franchement, le RN est un parti médiocre, mais l'idée de voter pour eux, c'est juste pour faire bouger les choses. Je ne comprends pas que tant de gens aient peur que si l'on vote pour eux demain, on devienne comme l'Allemagne en 36. Non, avant d'être des prétendus "fachos", les membres du RN sont surtout des politiciens. Tu peux le croire, qu'après 40 ans à se dédiaboliser, la première chose qu'ils vont faire, c'est essayer de conserver leurs places. Personnellement, je préfère voter pour eux car au moins, je leur fais plus confiance que les autres pour défendre nos intérêts économiques. Le fait que tant de gens aient voté pour Macron, qui est de loin le plus gros traître que la France ait connu depuis Giscard, montre qu'il y a une inculture politique profonde. Dans n'importe quel pays, quand quelqu'un déçoit et trahit autant que Macron, il n'est pas réélu.
4
-
4
-
4
-
4
-
4
-
4
-
4
-
4
-
I think this isn't an expression of a lack of education, most people listening to Lex's podcast, have at least some background that allows them to judge. The truth is that people aren't interested in communism. Mainly because we've seen what communism means (and I know right know you are probably thinking that everything called communism so far hasn't been "real" communism), and although theoretically communism is definitely superior on some aspects, it will never be for the simple reason that it doesn't take into account Human nature, the truth is most people don't want to have the same as their neighbors, they don't necessarily want to be dependent on others/state/whoever is giving them their share of the production. Humans are vile creature, they want power, they want to dominate, they want to be better than others. Unfortunately that's fundamentally incompatible with Communism, every attempt will result in the same problematics, overtime as more and more people will be dispossessed arbitrarily by those who have nothing until nobody has anything, than peoples in charge of said dispossession will start to do more and more to keep their power even if that means killing every of their "brothers". Communist are wasting their time on things that aren't possible instead of contributing for things that could actually happens and be beneficial.
Now I'm not saying capitalism is perfect because it's not but at least this system acknowledge the fundamental of the human nature, and channels it to the profit of the group. Human selfishness ? no problem in capitalism you are free to do whatever you want with your money, but to get money you either need to work for someone higher up in the hierarchy (aka cooperation), or to create your own business but even then you'd still have to find costumers willing to cooperate with you to buy your product. Human needs for Power and dominance ? well in capitalism outside of the problematic nepotism (which would exist in communism) the only way to achieve power and dominance is still by cooperating with others, you have to be talented, and approved by your peers to become powerful therefore it is still a matter of cooperation.
Anyway TL;DR capitalism is imperfect but works ok because at least it takes into account the truth about human nature, whereas communism will always fail because it fails to recognize human nature.
4
-
3
-
Hard disagree, I think practical experience will always be more impressive to recruiters no matter what field you are in. The reason it's so prevalent in SWE is that we can get experience with only a computer, and because most of the knowledge you need is widely available and not necessarily unattainable. If you wanted to be a self taught doctor or self taught material or civil engineer the reason you would fail as little to do with your lack of a degree and more to do with the fact that you weren't able to get experience at all in that field so you are effectively worthless. This will never be the case in SWE. Everyone can teach themselves how to code, contribute to FOSS or build a good FOSS project and convince a recruiter that they are worth the bet. Sure someone with a degree might be more reassuring, but honestly most people that come straight from university aren't good at code, they may have implemented a lot of basics and you might get them up to speed in a reasonable amount of time. But people who taught themselves how to code and actually have hands on experience with complex problem or projects are much more interesting for recruiters. At least that has been my experience as a self taught, most recruiters were very upfront with the fact that they really appreciated the fact that I was already "operational" in the sense that despite being classified as a "junior" my portfolio was more inline with a mid-level engineer. Because while learning SWE I built tons of things that very few people from a university did. I have a working compiler, I built multiple games, and even built my own engine, I have implemented tons of data structures, did a lot of multithreading, and SIMD code. Built a few other projects like HTTP servers and CLI utilities, and I'm currently writing an x86_64 kernel. I've yet to find a company that I truly want to work for but so far they all made a proposition to hire me despite having no previous professional experience, just solid technical skills, and good people skills. Which everyone is able to learn just like I did by googling and taking online courses. So yeah I don't think the field is going to shift toward hiring only people with a CS degree.
3
-
3
-
3
-
As a Zig longtime user, I've never used it on Windows, but I have to agree with you, on everything except for the memory efficiency, while Rust can like any compiled languages be used to write very memory efficient code, there is often a high skill barrier in front of it, the lack of a stabilized allocator_api certainly doesn't help Rust. From my experience being mainly a C developer, I would say that Zig is a great middle ground for high performance software. Rust can be but sometimes the added time of development and the additional complexity required to prove to the compiler that everything is safe, aren't worth the safety benefits, a lot of software doesn't need to be airtight safe, those who do should obviously try Rust first, but Zig is a good middle ground, as @maledil1 said technically both C and Zig offer the same level of "safety" but from experience I've built a strong opinion that the main reason why C is so problematic is because it lacks a lot of the ergonomics of modern languages, and the tooling certainly doesn't help there too. Zig just like Rust is trying to improve on that by taking a slightly different approach. Rust enforces correctness with a combination of a strong type system, strong static analysis tools, and an airtight semantic that's meant to prevent developers from being able to compile erroneous code. Zig does I would say 50% of that, and the rest requires the developer to be extra explicit which I find to be a great middle ground, because a lot of "unsafe" pattern in Zig are very verbose on purpose to make, it clear to the reader that this code may need more attention. This makes fixing bug so much easier than in C because it's really easy to see block containing tons of cast, and memory access, and it focuses the attention. On top of that they offer a wide array of great tools to help you catch bugs early, the testing framework, the debug allocators that help to catch use after free, double free, the optional semantic, and 99% of C UB are replaced by Zig panics, with stack trace. Technically in C you can enable all of what I've mentioned too, but the point is that this is not a default, and C still relies on UB unless asked otherwise. Plus even with everything enabled the tooling is still inferior and the debug ability is really not good.
But I think you are wise to keep on using Rust, it's should definitely be used over C, but as a friendly suggestions you might want to wait a few years and revisit Zig once it's a bit more stable :)
3
-
3
-
3
-
3
-
@shivenbhatt7475 makes more sense phrased this way, and true to some extend it might be misleading to say that UB is overblown, but I don't think he is wrong, in the sense, that a lot of people have this conception of C being unsafe all the time when in reality there's only a few areas of C that lead to undefined behaviour, namely the lack of type safety, when casting, the fact that there is no bound checking, macro magic, "object" lifetime, integer promotion, the lack of overflow/underflow protection etc. That's still a lot and you are right to point that despite being simple C is dauntingly hard to reason when it comes to debugging because of all of those UB, but the belief that C is all UB is a misconception in my opinion and it is really overblown.
3
-
@ІО-13ГлібШин Well there are many things that are broken in C for a multitude of good reasons, it's hard to blame them considering when the language was made. But many things are really annoying. The most broken things has to be header inclusion, this can lead to absolute nightmares because things will still compile, due to C relax rules about shadowing/definition. But once you flash it, it just doesn't work and you have to figure it out. On top of that you don't get a lot of visibility on the platform you are working on, on what types look like, because of the poor reflection, in Zig it's trivial to print a type info at comptime, even for weird targets, cross-compilation is a pain, linking is a pain, I mean it's not unusable per say, but you constantly have to keep in mind all of that C doesn't do for you that it should do. It might be counter intuitive but I'd rather have Zig or Rust compiler yell at me for missing something or doing something stupid, rather than C assuming I'm the god of programming and I cannot make any mistakes. There is also a ton of rules to keep in mind with implicit promotion rules, and also how they play with the thousands different typedef. It's also a language where everything is hidden in the compiler. One thing that's really nice in Zig is that I can just goto definition and I can inspect the source code of the std. I don't need to look what version of muslc or glibc I'm linking against, and then go look into their github. Figuring out which 200 #ifndef/#define is enabling which macro/function to understand how is the implementation for my thing. If you had the poor build system, and the poor ecosystem. C is really cool but I think it's time we try to get some better tools, because whether it's Zig or Rust, or any modern option, It honestly can't be worse than C.
3
-
3
-
3
-
totally agree, the one thing I really don't like with a low of the newer, language, is that they try so hard, to have you write the least amount of code possible, and for certain domains it's fine, but if you take a language like rust/python/cpp, they have so much of those abstractions that in my opinion if there isn't some strict guidelines the codebase can become very innaccessible to maintain. Whereas C is by nature such a simple language, that the few abstractions needed for a project kind of standout naturally and are really easier to understand, generally speaking my favourite feature in C is that for every problem you encounter, the only solution the language is forcing you into is to write more C code. In other language, you have to use niche container class, external libraries etc it can become hard to follow.
3
-
@MrZnarffy Agree by no means, was I trying to imply that C++ is good, hell no. For Rust I'm on the same fence as you. On one hand from my limited experience with rust (probably 20/30k loc). I think it's a great language to rewrite stuff, because when the problem space is solved you can really encode the correctness in Rust, and the compiler will protect you from making a lot of wrong assumptions in the future when working with the code. But despite all of it's features and facilities, I think that the kernel layer isn't well suited for Rust, it's not even about the extensive use of "unsafe" because even in "unsafe" block the compiler still offers better safety features than a C compiler. No the real problem with languages like Rust or C++, is that those language are harder to write kernel code, because the truth is that in a Kernel you need to squeeze every bit of memory, every cache line matter, every cache-miss is a loss. Unfortunately I find it extremely difficult in both Rust and C++ to manage the memory layout to fit the performance requirements of what's possible, grant it I wouldn't call myself a Rust expert, and obviously it's feasible, but the cost/benefit is IMO way to high right now. In languages like C/Zig/ASM, it's really really easy to actually "manage memory" you can exactly layout your memory for it to fit in cache, to be as tight as possible, and not waste ton of space, the current problem is that to achieve that result in C you have to walk on a very fine line were you can easily invoke UB by managing your memory with such precision. This is why I think a language like Zig (or any other language that has a modernized C semantic) is a better fit. Because the real problem with C is that the wobbly semantic and the poor ecosystem makes testing/debugging way harder than it should be. In Zig you have a lot of facilities in the STD and in the semantic that help you catch those bugs early. I think if C devs were given a language that has a very similar semantic but with better tooling, better defaults, better debugging/testing utilities they would easily write safer code, which again makes me really doubt that we will ever see a broader adoption of Rust in the lower layer of the Linux kernel.
3
-
3
-
@_Karlsson I'm curious now, like I can understand that one might not like Zig's syntax depending on your taste and background, I come from C so for me it's very familiar, and intuitive. Now for the ceremony part I've done some Java so I'm very much aware of the "ceremony fatigue" same with C++, I hate C++ for that reason, I'm tired of spending 5 minutes writing the same thing for each class definition. But in zig I really don't have that feeling, like it's not more verbose than C, it's actually less in a lot of ways, and C is well known to be simple. The stuff that's added is usually small and readable. For example in C when you have a complex struct with lots of dynamic memory allocation for the
initialization, you have to eitheir have a :
this->field3 = (field*) malloc(1 * sizeof(field));
if (this->field3 == NULL)
{
....free(this->field1)
....free(this->field2)
....free(this)
}
and the thing gets longer and longer. or you have to use GOTO: label. in zig just :
errdefer allocator.free(this);
and this is just a silly example but point being there's actually a lot of conveniences . Zig has done a fantastic job of making correct but hard thing in C trivial in Zig but easy and error prone stuff from C harder in Zig (like type casting for example, const vs var, unused variable or wrong type, exhaustive switch etc)
So I would really appreciate if you could provide any example such that I could see if there is something that I'm missing, because I'm not sure where zig is more verbose ?
3
-
@maharta8458 No, I don't look down on Front-End dev, it's just as hard if not harder at time because of product managers and what not, it's just that AI is already able to generate complex website, based on simple sketch. From this observation, it seems logical to make the assumption that the front-end will probably be the first to be replaced, simply because smaller organization, that want a homemade website may not need to contract, or hire those types of engineer, if the IT guy with low knowledge can make the front-end using those AI. Whereas if you work on more abstract and low level issue, it might take a bit more time for the AI to take your job and even then since it's lower level, you still probably need a few engineer to make sure it's not buggy.
3
-
3
-
3
-
One of the issue that Jonathan blow and Casey moratori, have talked about a lot and I really agree with is that modern languages tend to do the same mistake. Instead of nailing the fundamentals of the languages, meaning (performance, readability, expressiveness, tooling, compiler control / good error messages, flexibility) languages people try to be the Jack of all trade, but end up being the master of none, I know this go against what a lot of people seem to think, but to me languages like C and Go, Zig and potentially JAI or Odin, should be the end goal, languages that are simples, that follows sort of sensible syntax conventions, have good toolings, languages that are readable and expressive, languages that don't rely on unmaintainable obfuscated syntax and abstraction to make it look like your doing some real work when all you do really is niching and fighting the languages quirk. Like in languages like C if you want a behaviour or something you just need to write more C, same with Go but modern languages are doing the weirdest things, to try to cater to all audiences, instead of focusing on the fundamentals. I don't belive nim will go anywhere.
3
-
for you maybe not but mojo, has a very promising future, mainly because they are making the compiler smarter which in turns make the languages easier to optimise for AI research and other devs, (but mainly AI) which often rely on custom or very specialised hardware, like GPU, TPU etc, and previously one had to go figure what was the size of the registers on the cpu(s), refactor the code to take advantage of the line size of the cache, reformat to improve the branching prediction of the pre-fetcher, go and optimise the assembly to take advantage of the AVX512, or refactor to take advantage of the SSE2, to use the SIMD by reducing the long chain dependency of the code. I could go on but basically the guy behind MOJO, is the compiler god, he's the guy behind LLVM which is still today's standard for modern compiler backend, he's the guy behind swift, which is a really cool languages, better than C# for mobile dev. The guys is really good, and now he's working on making a superset of Python somewhat similar like C++ and C, so everything you've learned and used so far in python, will work fine with mojo, it will just go BRRRRRR and be faster
2
-
2
-
2
-
2
-
2
-
2
-
It’s such a shame really, the European Union is so positive, yet managed by the most incompetent and fanatics (arrogant?) people on earth. Every economist said that having only one currency, in a non optimal monetary zone was stupid, yet they did it anyway, everyone said hey be careful with the value of Euro it’s a slightly devalued DM which combined with the Hartz Reform will make Germany too competitive for the southern economy to sustain their pricy social security system. Everyone told them hey stop introducing competition where it doesn’t make sense, yet they went above and beyond to make everything plain stupid (yeah i love paying my electricity 10x what it’s worth even tho i have nuclear electricity). Loads of people told them hey stop saving the system by letting both government and companies go in debt you are actively interrupting creative destruction your just gonna make it worse. Well basically everything the European Union is doing is either dumb, counterproductive or hardly effective. So i won’t be the one crying when it ultimately disappear, i just hope that we will create a real union based on improved trading capital movement, and all that jazz, just not the political power, or the shared currency.
2
-
Great insights! Regarding Zig, I agree with you wholeheartedly. While it's true that at the moment Zig is still evolving, once it solidifies into a stable language, there will be every reason to embrace it fully. Zig truly embodies the spirit of being a "better C." It's not just about its impressive features, but also its underlying philosophy, which aligns closely with what C aimed to be originally.
C was designed to provide a higher level of abstraction over assembly language, making it more manageable and easier to understand, while still retaining a close relationship with the underlying hardware. However, over time, C has accumulated its fair share of shortcomings, from poor portability and a cumbersome build system to a lack of type safety and a quirky preprocessor. Despite these flaws, C remains deeply entrenched in many codebases, and expecting it to suddenly evolve into a better language isn't realistic.
This is where Zig shines as a compelling alternative. Its simplicity is evident in its explicitness, self-contained nature, and lack of ambiguity. Everything in Zig is clear and straightforward, making it easier to reason about code and catch errors early on. The language offers superior generics, a streamlined build system, and improved error handling, all of which contribute to a more pleasant and productive development experience.
Moreover, Zig prioritizes ergonomics, enabling developers to write safe and performant code without the fear of undefined behavior. From custom memory allocators to SIMD support and runtime checks for undefined behavior, Zig empowers developers to write code that is both efficient and reliable. And perhaps most importantly, transitioning from C to Zig feels natural, thanks to its familiar syntax and structure.
Finally while Zig may still be on its journey to maturity, its potential as a successor to C is undeniable. With its emphasis on simplicity, safety, and performance, Zig presents a compelling option for developers looking to modernize their codebases without sacrificing familiarity or efficiency. If Zig continues on its current trajectory, it's most certainly going to become the go-to choice for C developers in the years to come.
2
-
2
-
2
-
@open_ckt I don't think you realize how expansive chip design is, even for crappy chips, you still have to have a access to a fab to print and test your design, and although when you scale things can be quite cheap, the process of testing chips, is extremely hard, takes some of the most insanely good engineers out there, and it's abysmally expansive for very little return because you can just buy a license for a design and be good to go. depends on the application of course, but for 99% of companies out there it's cheaper, to outsource both chips design and production, to specialist.
2
-
True but if you look more closely, Mojo isn't a random guy's garage project, behind it is Chris Lattner, the guy who created LLVM, which is now the backend for a lot of modern compilers, He created swift, which is still a very popular and appreciated language. He's bringing very nice features to Python making it way more powerful, the aim is to make it easier to write code, rely less on C libraries, and have a better use of the specialised hardware. So even if you are not into AI, you'll most likely benefit from using Mojo instead of python
2
-
2
-
2
-
2
-
@Kuraitou have they tho ? I hear this all the time that people have been trying to replace C for decades but failed like it was impossible ? All those
languages who ""tried"" to replace C where failing from the start. For example Jave could never be a C replacement yet in the early days it was advertised as such, On the other hand nowadays we have in my opinion real contenders, Zig for examples actually feels like a C replacement, as a C developer, Zig makes me feel at home, it's imperative, there is no inheritance, it's lower level than C. Everything feels better in Zig than in C, the type system feels better, the std is light years more useful, the semantic feels more cohesive, the error handling is better, testing code as never been easier, building it too, allocators as first class citizen is awesome, I could go on but all those things considered makes me feel like Zig could be an actual replacement to C, same with Rust, It feels a lot like Cpp, I hate Cpp, but Rust makes it more fun, it's still way too convoluted for my taste but It's a fantastic C++ replacement. So I think the argument of many have tried and they all failed isn't relevant anymore, because now that programming as a whole as evolved people have grown tired of C, myself included, it's a great language but the developer experience is really terrible and outdated, I see that everyday around me the programmers I work with all hate C in one way or another, and none of them use C in their spare time to build toy project, they all use Rust, Zig, Odin, Nim, OCaml and whatnot. I think the question is not about whether any of these languages will replace C, it's more of a when ? because it's pretty obvious that nobody in the industry wants a decade more of C, let alone another 50 years of it.
2
-
@GingerGames Totally agree, with you, this is why I don't really understand the reflex to immediately dismiss any languages that try to replace or at least replace some usage of C. To me the more option we have the better, realistically, any sound developer would prefer to use something more modern, and consistent over C, Now whether that language is Rust, Zig, Odin, Nim, or maybe one day Jai, depends on your preferences, your domain, etc. The point being I'm confident people won't continue to use C as a "defacto". It will obviously still be used, but not by choice. Which is in my opinion the real moment where a language truly dies, is when you choose it only because you have to and not because it offers you something that help you solve your problems.
2
-
@NoBoilerplate For better or for worse C is kind of all we have with Assembly, a stable ABI is a step in the right direction, but fundamentally we simply don't need what Rust offers. For what we do its more cumbersome, for example Rust solves memory safety, ok great in embedded you only have two scenarios, first one is no memory allocation at all, second, is taking a chunk of memory and using it as an allocator. The hard part in embedded is not to write the code, it's to work within the constraints of the system, it's reading and understanding the hardware, what it can or cannot do. What makes C great is that it's really just a more readable assembly. C is a terrible language in many regards, but it's like assembly you can just do whatever you want and it will work if you are correct. C is basically just a a language that you can define with header files, if you put in your stdint.h that a int is 12bits it's 12bits. It's that simple, There isn't a lot of values for us. Same thing with parallelism, Rust solves that, but most of the time you just have a single core, and the "parallelism" is simply interrupt based. Or if you work on a more powerful chip you use RTOS, where you organize threads in a very different way than what most are used to.
Now there are some areas where maybe one day Rust might be kind of good, like automotive and aerospace, but even that is like years away, because while this kind of code would benefit from Rust features, you still need proving software, and a ton of testing infrastructure to make it viable, and compliant.
2
-
2
-
I took the course too, and those are two ends of the stick, languages like Rust or Zig or obviously higher level than C, but that doesn't mean they loose the property of C. You can take an iterator in Zig, over an array of number, and a for loop in c over an array of int, and the assembly looks the same, but the iterator will stop when you are at the end of the slice, you don't have to keep or pass the length around like in C.
So you gain some ergonomics for free, because you don't have to pay it by sacrificing cycles. There is also a whole range of solutions that you might not even try because it's too complex, that you might feel like trying because the language offers it. For example I wanted to implement an autocomplete engine for a small project of mine, I would have never used a thread pool if it wasn't for the fact that std.Thread.pool exist in Zig. Even tho I know how to do multi threading in C, I just don't want to deal with that in C at all.
2
-
2
-
What's even more frustrating with our voting system is that it's so bad that it's the reason why the mandates are so short, because of the voting system essentially forcing division and alienation, mandates cannot be too long or a good portion of the population feels miserable. I believe that someone getting elected should at least get 10y as the head of the country he/she is leading. The truth is nobody can make meaningful changes in 4/5y, you barely start to see the effect of someone's decision after the 10y mark, which should be indefinitely renewable btw, as there is no reason to pass on a good leader even if it means the guy/gal stay for 30y as the president. Candidates shouldn't have a "program", they should have a vision and convince people that vision needs to be followed, this would lead to a way better political scene. Part of the reason politic is so bad this days is that you have to promise the world to people just to be noticed, you need to be sketchy, and appeal to the masses, lie and manipulate, you have to play a horrific game of demagogy and "move" and lie and deception, its just so bad. Whereas when you have 10y to do something, than you can relax and actually take the time to put your vision into action. Long term planning is essential for anyone to be successful. The most successful companies and countries don't plan for the next 5y, instead they have plan for the next 10, 25, 50y ahead of them because that's the kind of scale where a vision is essential.
2
-
2
-
@xBiggs for sure I'm not denying this, and that's one of the reason why I'm learning Zig too, because I'm interested in low level programming, but I do understand that C has limitations, Undefined behaviour, shouldn't be a thing the compiler should very much enforce it, but still not everything in C is UB, has I've said most of C's UB comes from a small place (implicit/explicit casting/lack of bound check/error check, name space, pointer arithmetic, macro expansion etc) This is unfortunately a big part of the language, so you really need to be aware that those areas are dangerous. Still I think too many people think that C is that old language, that is fundamentally unsafe.
2
-
@ІО-13ГлібШин The std is also very inconsistent, some function use errno, some returns -1 for errors, some returns -2, some returns 0, some returns 1, some returns NULL, some ask you to pass an out parameter, some needs to use a macro, I mean there is just an incredible amount of experience required to just be able to write C quickly, I'm Ok, I know the C standard really well, and the std, too so I don't have as much trouble with it anymore, but in Zig it's simple, you get an Error, or a null value or a bool, it's dead simple to just write correct code. You can make your api really consistent, and that's really really neat, when the project becomes large.
2
-
2
-
@seanborland4531 There is no emerging of anything, because there is nothing to emerge, you are using the wrong words here, they don't display any ability to reason, simply because they cannot reason. According to the definition of reasoning "Reason is the capacity of applying logic consciously by drawing conclusions from new or existing information, with the aim of seeking the truth." The most important part here are "consciously" and "seeking". Consciously imply that there is a consciousness to be found, and seeking, imply that there is a goal to achieve. Like I've said LLM are nothing but a fancy Trie, they are just statistic that infer a sequence of token. There is no consciousness, no thinking or understanding involved in the process, The human brain has 2.5 petabyte of memory, and estimated 1 exaflop of computing power, and receive gigabytes of sensory input every milliseconds. Chat GPT took month to train to billions worth of A100, it was trained on gigabytes of text, more than any human will ever be able to read in a lifetime. Achieving even a figment of our abilities is light years away from current AI technology, period.
2
-
I love how C++ constantly fails to realize that it doesn't have to be every other language in existence to still be relevant. Stop trying to add more features, remove them, remove them all go back to C, and start adding back the good things, start making a half decent tool-chain that doesn't require a 2 phd to understand, start shipping with sane defaults, an official build system, an official package manager, some better debugging and sanitizer or fuzzer tooling, try to actually improve the language and stop trying to make it even worse every time. This is why language designed by committee sucks so hard. No vision, no personality no idea of where they want to go with the language, just random people stitching up random features, until it's as ugly, unreadable and hard as humanely possible, god forbid C++ would ship with one godforsaken simple feature, or straightforward way of doing things. Not it's way better to be as complex as possible.
2
-
2
-
@testtest-qm7cj That's true, but the real problem with C is simply that it's type system is non-existent, that compilers defaults are terrible, and although UB existed and was used for a reason, There is no reason why modern languages should not actually defined those UB. On top of that the tooling around C is bad, making it even harder to actually make safe code.
This is why Rust is so awesome, it provides a strong type system, a powerful suit of static analysis tools through the borrow checker / lifetime annotation system. The defaults in Rust are sane defaults. But the things I've just mentioned are not something unique to Rust, what they are at their core is good tools.
Which is why I think Zig is actually a very safe language too, it's not as safe as Rust that's for sure. But it doesn't need a borrow checker and static lifetime annotations to get there. What Zig needs to reach Rust level of safety is simply to provide the tools to ensure that the code is correct and safe.
Because the true measure of a language safety potential is not just that it can be safe. C code can be made as safe as Rust, same goes with C++ or Assembly, the reason they are not considered safe, is simply because there is very few tools inside or outside those languages to ensure correctness and safety, and their defaults assumptions are also terrible. Which means that realistically to make safe and correct code in those languages you have to invest a ton more time into proper infrastructure, testing, etc. Which is tedious and means you can't ship as fast, so most companies simply skipped this part.
But Zig already provides a lot of tools to ensure safety and correctness, and more importantly those tools are very easy to use and they fit perfectly with the language, if you add that Zig is very strongly typed, and comes with the sanest defaults, has very simple syntax/semantic, provides unit testing, fuzzy testing, has allocators which provides protections against, double free, use after free, protection against any UB because Zig doesn't accept any UB. You end up with a mix where it's actually quite hard to make unsafe code out of the box. It's not perfect and it will improve in the future.
But the point is simply that Yes with Rust you are 99% guaranteed that the code you wrote is valid and safe. And with Zig it might be only 80%, but because of every tools provided and how easy they are to use, ironing out the last 20% is actually quite easy. So in practice you can expect safer code than C despite the fact that both languages are relatively similar. Because again safety is not a feature of a language itself, it's a feature of the tools the language comes with to ensure safety (compiler, fuzzer, unit testing, memory sanitizers, sane defaults, not allowing UB to be used by the compiler, bound checking, protection against use after free, double free, use of uninitialized memory, use of null pointer etc.)
2
-
2
-
2
-
I think memory safety is a bit overblown, yes rust has strong guarantees about memory safety thanks to the borrow checker, but as long as a language can provide you with some extensive facilities to ensure safety and correctness than I'd consider that language to be viable. For example Zig doesn't have a concept of borrowing, but in debug mode using the GeneralPurposeAllocator, you can detect memory leaks. use after free, you need to handle nullability and errors explicitly, you have some runtime safety for out of bound indexing, uninitialized memory read etc. You get to execute your code at compile time, to test it and configure it. This to me sounds like a reasonable tradeoff between safety and ease of use. But of course there are other languages, that will propose the same kind of facilities, I just think that Rust is not the only language that can offer strong guarantees in terms of safety.
I also don't think that Rust is a great language for system level programming, like I'd like to use it for writing a driver, or a deamon or something like that, maybe a server or some system utilities. But for the Linux kernel I don't think it's a great choice. But I love Rust for CLI tools I think that there is quite frankly nothing that is as good as Rust for that.
Regarding C and C++ I think that no matter what they try they won't be able to compete with those new languages because fundamentally the problems regarding safety in C/C++ is rigged inside the type system / semantic of the languages. So despite loving C I have to admit that yes it shouldn't be use for newer project with long term support in mind
2
-
2
-
2
-
Greatest take ever, Zig should have been the one to go into the Linux kernel (i mean not now because it's not stable) but man this is such the perfect language for kernel development, Like Rust is great don't get me wrong, and I think for pieces of code that must be 100% safe, it can be good, but for everything else, It's Zig or C. I'm quite sure that once it matures it will actually just replace most of C code out there, because it has such a great ergonomic and it is such a great language to do everything like you would in C, but better, faster, safer, and without sacrificing the maintainability. Like honestly recently I wanted to go look for implementation details for libc, and I swear it's actually physically painful and emotionally bruising to look a libc code. Even with goto definition of the lsp, you just jump around in 40 different files of private macro definiton of function embedded macro in 50 #ifndef, #elif, #define, using weird type_t crap, it's terse, ugly, horrendous, and I think that it should be removed from this planet. On the other hand I basically learned Zig by reading the code of the compiler, because of how readable, expressive and easy it is to parse with the eyes.
2
-
Windows is definitely the worst OS, no questions asked, the only reason why we are still talking about it it's because it takes time before people stop putting up with shit, they really have to eat a bunch of it before eventually realising that they could avoid eating shit every day. The only reason it still exist, is because tons of people are used to it, and practically all software is made for windows as it has the largest costumer base.
But honestly even the most unstable linux distro will be probably more stable than the latest windows. I mean at this point literally any OS is better than windows. The menus are bad, The boot up time is bad, the windows update is absolutely terrible, the ads everywhere on a 140$ paid software is honestly just hilarious, the constant mayhem of windows losing your dll's all the time is really the cherry on the cake. The new updates that changes all of your settings back, reinstall microsoft services you've explicitly uninstall is just ridiculous, I could go on but it's objectively the worst OS out there, and i'm using it daily as part of my job so it's not like I'm a fanboy of another brand or anything, apart from gaming or very specific software this is just a terrible experience.
2
-
I'm not familiar with the system of peer reviewed articles, but I want to put an hypothesis, because I can think of a possible explanation, from another industry that I'm more familiar with, In 2008 The banking system collapsed because of the subprime, there was a lot of reasons why we end up in that situation but one of them was that the companies that were supposed to be independent, and who's jobs were to properly rate, and evaluate the subprime financial products, (CDS, CDO, etc) were actually not doing their jobs properly because if they were to not rate the products according to the clients needs, then the clients would simply knock on the concurrent's door. Therefore I wonder if this is a similar situation, where in order to maintain their grandiose/reputation, those journals are becoming less and less careful about what they allow and publish, in order to be "the one" publishing ground breaking work.
2
-
2
-
2
-
2
-
2
-
@JwokeLionheart Avec quel argent exactement ? 3000 milliards de dettes, ça te parle ? On ne peut même pas subvenir à nos propres besoins, et tu t’attends à ce que l’État vienne en aide aux migrants illégaux en plus de ça ? C’est ridicule, ça relève de l’obsession à ce niveau-là, il faudrait consulter. IL N’Y A PAS D’ARGENT DANS LES CAISSES.
Le jour où notre dette sera raisonnable, que notre armée, notre justice, et notre police seront en bon état, que les hôpitaux et les écoles seront au top, et que les salaires et retraites atteindront des niveaux décents, pas de problème, je serai prêt à accueillir toutes les personnes en détresse que tu veux. Mais tant que ce n’est pas le cas, prétendre que les personnes qu’on "accueille" seront réellement prises en charge est illusoire. Elles seront simplement laissées à Porte de la Chapelle, où elles finiront par tomber dans le crack ou la criminalité.
2
-
2
-
2
-
2
-
2
-
That's a feature not a bug imo, firstly all the syntax of the language can and will probably evolve, I remember Andrew saying that once the language is "stable" they will try to improve the syntax to make it more cohesive. But second one of the reason why you have to write a bit more code in Zig is because one of their moto is "no hidden control flow", the reason for this is that it makes the code more readable but it also offers a new capability which is that even people who never programmed in Zig can fairly easily read and understand what some zig code is doing I have one example of that I was working on a linter for C to autofix my style and I had a bug in the AST and a friend of mine who never coded in Zig was able to sit down with me and help me figured where the bug came from despite never seing any Zig prior to that, I don't think I would be able to do the same in C++, Rust or Haskell for that matter. The same thing can't be said about C++ templates, or Rust Macro, yet Zig comptime just read like normal code to anybody.
One good exercise that I can advice you to try for yourself to understand how the explicitness of the language makes it trivial to read it, is to go into llvm compiler c++ codebase, pick a random part and try to understand what it does, then try going into a similar part of the Zig compiler codebase and understand what it does. The difference is the answer why it's a bit more verbose and less syntactically convenient.
On top of that I don't think syntax should be a primary concern, the lifetime of any code is that you spend less than 10% of your time typing code, 90% reading it. Even for projects in teams at companies, your code will maybe take a few weeks or month to be written, but it will lives for years, so in the grand scheme of things I don't think that syntax is such a big deal especially if the trade off of weird syntax, enhances readability and maintainability at scale.
Also you've mentioned C++ and Rust which in my opinion have both one of the ugliest and convoluted syntax that I know, in comparison zig feels simpler, but I guess it's familiarity.
2
-
2
-
@maharta8458 On top of that it would make sense that those type of jobs will be the first that the AI will try to replace, if you can control the front-end market, you can get a share of the ad revenue, get massive amount of data to refine your AI even more and create AI products that use the data collected, to create plug and play plugins to enhance your user experience, and then they'll probably go after the micro-services again, then the back-end etc. But if your work is in embedded software, AI, research, algorithm, etc. your less likely to get replace quickly just because those tends to be more "complex" and also because there is less money to make for the AI service provider through data collection.
2
-
2
-
2
-
2
-
2
-
2
-
2
-
2
-
2
-
1
-
@igorglushatov1948 Not really its a problem I've solved countless time over the year because my favourite project is to make a C11 compiler. It's 10k line, and when I learn a new language that's what I try. So even though the problem is the same, the sheer scale and difference in semantic/syntax makes it not really similar in any way. I mean sure there maybe some marginal speed increase in Zig due to the fact that I had more experience, But it was still a whole lot harder to just get it to work, and mind you I was really giving my best shot at writing Rust code that's idiomatic and leverages all the cool stuff, like pattern matching, enums, using a few crate here and there. It was just really harder than it should be. The compiler was helpful and the tooling was god tier. But it didn't felt really fun to code. Zig felt natural really quickly, it was actually really boring and that made it fun, everything is so predictable you don't get surprises often using Zig, it's fast, and you are in control but the language still gives you help to make good code. It's very relaxing tbh
1
-
When compared to Zig, despite C being more “forgiving” I don’t find myself writing better code in C despite having spent the last 2 years doing 10h of C, and doing everything from scratch, like I’ve made a 3d rendering engine, in C did all my data structures myself, and on the CPU alone I was able to get a cool 200fps, took me 2 weeks to get it right, when I decided to reimplement it in Zig, it took one day to get it right, and the naive implementation was reaching 230fps, and yes I was using all the good flags for C, but the point being that even considering the fact that it’s always easier to rewrite something once you done it, I just don’t feel like C is a good language, and you don’t have that much control, in Zig it’s so easy to do SIMD, to use compiler intrinsic and communicate precise intent to the compiler. In C this sucks hard. And in C you also have to check for null pointer if you want your program to be correct so like 10% of my C code is literally:
If (!ptr)
return NULL;
So I don’t think there’s a big difference.
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
Because Zig is a better language than C, which is to be expected I mean C was created in the 70s by one guy on a pdp7 It's not fair to expect it to be a modern language. C is flawed on all level, the design is flawed UB shouldn't be a thing. Preprocessor is an error. Unhygienic macro are a terrible idea. General lack of type safety. Lack of implementation convention. Implicit conversion rules, Unusable standard library. Terrible tooling capabilities. Lack of guidelines and so on and so forth are all reasons why Zig is a better C, there is even more reasons but I can't be exhaustive.
But generally speaking Zig is just a better C, and going forward it would be a better idea to start new project in Zig rather than in C, because you get all the convenience of a modern language like Zig (improved syntax/semantic/better compiler/more safety and correctness features/better default/better build system etc) without loosing the performance or the interoperability with C. Of course there are other languages like Rust, Nim, Jai, Odin, or whatever you prefer, but they all bring to the table some level of improvement that makes it really better to write and develop application than C.
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
Il est temps que l'etat reduisse ses depenses, en revanche je ne comprends pas du tout l'idee de reduire les depenses pour l'apprentissage, c'est l'une des voies de profesionnalisation les plus rentables, 6000 euro par ans, c'est 2x moins que le cout moyen d'une annee universitaire, pour des meilleures garanties d'employabilites, il faudrait plutot penser a couper les budgets dans le financements des 50% de Master et Doctorat complement inutile et improductifs, Conserver les sciences les vraies. De meme pour les investissements dans la recherche c'est ridicule, si il y a bien un poste de depense dans lequel il ne faut jamais couper c'est celui la sinon, faut pas s'etonner d'etre dependant de technos etrangerers, et de ne pas avoir des gains de productivites long terme, Puis si ont pouvait arreter avec les privatisation totalement insense, comme celle de l'electricite qui rajoute des couts totalement parrasitaire. Pour les impots meme choses, faut arreter d'etoufer les entreprises avec les impots, fin y'a un moment quand ont a chomage structurelle il faut se demander pourquoi, et faire les changements necessaire.
1
-
@Gigasharik5 Not exactly, they are implementing their own backend, currently the intent is to dramatically improve compilation speed in debug mode with very few optimization, and it's also why they wrote their own linker to not depend on lld, all of that is to offer faster debug build and also implement incremental compilation, remove the dependency on LLVM which is a big deal for many people, improve the modularity by making LLVM just an optional dependency, and in the long run they want to offer a new platform for white paper folks to implement their research in order to benefit from top of the line research and optimization. The problem with LLVM is that despite the fact that it can be used theoretically by any language, you still have to lower your language to an IR that was and still is designed to be optimal for C/C++ semantic, which is a problem because languages like Zig or Rust offers way more detailed and tailored semantic that has to be dumbed down or lower in a way that resemble C/C++. LLVM has also some blindspot that for example lead to the removal of async in Zig, it's also causes many bug reports in the zig project that stem from LLVM which takes time off the maintainers who need to investigate to rule out that it's not a problem from their compiler.
1
-
1
-
I think the concept is great, but they are marketing this product very poorly, I'm positive that an AI trained on a per channel basis could be amazing, but not in making content, I think it would be great that within a video you could have access to that AI for other things, for example I could see myself, watching a Linus Tech Tips video, and querying the AI, about some other videos that are similar or related, or maybe I don't fully understand something and AI can summarize something within a segment, or at the end it could summarize the entire video into a few bullet points if it's an educational content or a tech conf, I'm throwing ideas here, but the point is not to replace Human, it's to enhance the User experience, which AI can certainly do, so their tech is really cool, but they are trying to put it in the wrong place.
1
-
1
-
1
-
1
-
I think there's a fine line to find, but when you start programming, I believe it's ok to spend hours trying new software, it took me at least 1 month to be as productive in Neovim as I was in eclipse, than it took me 2/3 days learning about yabai for windows management, and 2/3 days for tmux, probably 2 days for lldb, a few more days for nnn, stow, fzf, etc, but in then end it's worth it, I can program so well so fast, and iterate so quickly.
1
-
1
-
I think part of the problem is that macbooks are already so good, that we are reaching the end of meaningful advancements, like sure everything can always be better, but currently I'm rocking a mpb 13 m2, and I really can't see myself changing for years, to come because the underlying hardware is already so good, and it's not even a top tier model, but the screen, the battery life, the power, I mean I just don't see how an upgrade is going to help me because In my current workflow, everything is taking less than a few seconds in the absolute worst case scenario, (i'm a SWE) so currently I'm working on a project of mine which is about 50k lines of code, and the compilation process takes less than 4s if I do everything from scratch, and sure I guess the newer max model could do it in 2s but that's not really a life changing upgrade, my previous computer would take about 40s to compile a similarly sized project do 10x more time, so the upgrade was really impactful, but I guess they've trapped themselves into making laptops that are too good
1
-
I've tested NixOS for about 6 months, and it's definitely not for everyone, I recently switched back to Ubuntu 24.04. Because If you don't get deep inside the ecosystem and understanding how everything works, and how to get around with it, it can be quite frustrating, I've really enjoyed how stable and easy it was to actually install packages, but installing dev tools / library is sometimes a pain because most things you want to build from source do expect dynamic libraries and what not, and for example I spent something like 2 weeks trying to install readline for a project and just couldn't find any way that was working reliably, without missing features or missmatch in version despite trying experimental channel and the official discourse forum nothing solved my problem, so I really like NixOS and if you often break your system it's definitely a huge benefit, but to me as someone who's bread and butter is C/CPP/Zig/Rust/ASM it's really hard to develop on NixOS unless you go trough the trouble of deeply learning how it works and imo it ain't worth the once every year few hours it takes to reinstall cleanly your system
1
-
@neniugrava I think going forward Zig makes a lot more sense than Rust for low level programming. The main reason in my opinion is that I don't think that the Rust Borrow checker, and all the mechanics of lifetime are necessary for 95% of the problems it tries to solve. On one hand I get it with Rust at least there is next to no doubt, when it compiles it means 99% of the time it does what you wanted it to do, and it's safe. But from my experience, most of the problems and bugs in C/C++ code base don't come from memory management, in fact I would argue that the problem of memory management is really just a symptoms of the general lack of type safety in both languages. C++ has improved a lot, but it also carries so much bloat and unnecessary complexity. Zig is IMHO in the perfect middle, it's very strongly typed compared to C/C++ and unlike Rust Zig allow you to do all of the error prone / hacky stuff very easily in comparaison, but to do so in Zig means you'll need to be very verbose and that friction was made to both make explicit to you and others that what you are doing is not normal. If you combine this with the fact that Macro and templates are replaced with Comptime and compiler builtins, This makes writing complex code trivial and much more importantly maintaining that code is a breeze, idk if anyone has ever tried to build complex templates in C++ but it's very painful especially the debugging is hell.
1
-
When writing you own code at the beginning, don’t try anything fancy just copy paste the tutorial, type what the instructor or the book is doing, and just try to modify a few micro-elements, like oh let me rename that variable, let me change the value, let me try to do it again in a different order, just start small, and the more you follow the tutorial that way, the more you’ll find yourself modifying more and more until eventually you’ll have enough confidence in your knowledge to write very small programs on your own, and at that point you just have to grind exercise over and over again. The language doesn’t matter, pick what you want, at first you just want to understand the logic behind programming the syntax is the easy part, think of it like writing skills, if your a decent author in English the barrier of entry to become a great writer in French is a lot lower than knowing both languages but not being able to tell compelling stories. Same with programming.
1
-
1
-
@arnerademacker I see your point but I'm using a lot of servers too, and it doesn't bother me, I know how to use VIM, but I prefer to daily drive Helix, as it's a more polished and pleasant experience, VIM is nice it gets the job done, but it's missing a ton of features, and overall installing anything feels like a chores whereas helix has almost everything you need out of the box to get a solid developer experience, they even added multi lsp-support recently, all configurable through a simple languages.toml file, which is a breeze compared to every plugin having it's own lua api that you have to learn to configure things properly. But I get it VIM is always there, it's reliable, works great, and works everywhere.
1
-
1
-
1
-
le niveau scolaire est affligeant, mais le problème ne se trouve pas principalement, dans le manque de personnel, de moyen ou des salaires à la baisses, la réalité est toutes autres, le fait est que quand cela fait 30 ans que on fait tout pour avoir un taux de 100% d'obtention au BAC bah on se retrouve vite à niveler par le bas, sauf que aujourd'hui ceux qu'on a laissé passer il y a 30 ans ils sont profs maintenant, le fait est que pour retrouvé du niveau il suffirait d'arrêter d'essayer de tout apprendre, avec 30 classes et matières différentes et se focaliser sur l'essentiel, arrêter de niveler par le bas et réorienter ceux qui sont vraiment à la traîne vers d'autres fillières plus épanouissantes et adaptées. Alors oui on passera de 100% d'obtention à 60% mais au moins le BAC retrouvera de la valeur, et on pourra se focaliser sur le développement de ceux qui en ont le niveaux, car faisant partie d'un milieu modeste, et ayant toujours été dans le public, bien souvent les professeurs me demandait de rester en retrait et de ne pas donner toutes les réponses, car "on devait s'adapter à tout les rythmes" grosso merdo tais toi ! faut répeter 20 fois pour les idiots turbulents du fond de la classe, y'a qu'en prepa ou j'ai enfin pue m'épanouir et normalement ça devrait pas être le cas
1
-
1
-
@isodoubIet Rust is better than C++, maybe not in the syntax or in the idioms, but just from the knowledge I have of the compiler (I wrote compilers a lot). Rust and any modern language for that matter, are starting with a clean slate and have way better compilers, and you may think that this is just not that important as at the end of the day Cpp is a really performant language ? well the problem is that having the compiler being really responsive (like real time level of responsiveness) is becoming more and more crucial, for the tooling around the language, tools like linter, static analyser, formatter, lsp want to access the AST and use those informations to help the developer to be more productive, unfortunately C++ because it has inherited a lot of the ugliness of C (i love C but you know it was made on machine that had less word of memory than there is letters in my comment, so it's understandably bad). Cpp has a worst compiler, worst reflection and informations from the compiler, it's not as fast as the competitors (zig for example as a really good compiler, as well as jai or odin). So in the long run despite any attempt from the ISO board, Cpp is inevitably going to die to be replaced by better languages. Because cpp can only evolve so much. I love Cpp this is still my go to language for almost all of my personal projects, but it's just facts that it wont stand a chance against the incoming languages.
1
-
Honestly I get it, I really like MacOS too, I think it's one of the best OS after Linux, Windows is a pile of trash. MacOS has the best window manager too, Yabai is incredible, and even on the linux side I never found something that mimics the power of Yabai that doesn't require tons of configuration. But this days I'm on a vanilla ubuntu, no WM, just Ghostty, Helix, and firefox, is what I use and it's not bad at all, sure I can't teleport and move stuff as quickly as when I was using my Mac but this is because I can't find a WM that doesn't suck to configure, or adds instability, the thing I liked the most about Yabai is that you essentially just get the vanilla MacOS desktop, but with keyboard centric control. I3 just remove your desktop you just have nothing to interact with, and I've tested other WM but they also don't let me have the regular ubuntu desktop and just move windows around like yabai, this is definitely skill issue tho, I can probably take hours to figure it out, but I can't be bothered at this point.
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
I will never go back to an IDE I think, I've started with them, tried vim, than nvim, then Helix, and now I don't even think It's possible for me go to back to an IDE first I don't understand what they offer that I can't get in the terminal ? With Helix and Iterm there is everything, I need, file picker, quick navigation with fzf, and nnn, debugging with lldb, lazygit, omz, lsp, all of the unix utils, like grep, sed, wc, awk, etc etc. I move at the speed of light all of this with maybe 400mb of ram usage with everything from the terminals, to the editor open with lsp running. On the Other hand when I tried CLion I was actually just embarrassed for the developers who made it, like what a shame, I don't even understand how anyone would release that piece of steaming hot garbage and think it's any good. For reference I have a top of the line computer, and despite having what's basically a supercomputer, CLion can't actually run it seems, Takes about 20 solid seconds to open, when it finally decides to display something it fails at the most basic task that you can expect from an IDE which is syntax highlighting. Everything is sluggish, menus, and the interface is bloated everywhere, The debugger is great tho, at least in terms of functionalities. All of that while taking 2.7g of RAM like WTF ??? I really don't understand how others are working on code with IDE.
1
-
1
-
1
-
1
-
Agree, In my opinion a piece of code can be qualified as "readable" if someone with any programming background can read it and understand it intuitively. This is why I love programming languages like C or Zig. They are both very easy to read and harder to write. This is also the reason I dislike C++ and complex Rust (because simple Rust reads really well). Both languages offer very complex syntax and encode way more information into the semantic, and while it might benefit the "experts" the truth is that it cannot be qualified as "readable" in the broader definition. If you look at the same code in the 4 languages mentionnned.
Zig code :
pub fn foo(allocator : std.mem.Allocator, n : usize) AllocatorError![]u8 {
const mystring : []u8 = try allocator.alloc(u8, n);
return (mystring);
}
C code :
char *foo(size_t n) {
char *mystring = (char*) malloc(sizeof(char) * n);
return (mystring);
}
C++ code :
std::string* foo(size_t n) {
std::string* mystring = new std::string(n, '\0');
return mystring;
}
Rust code :
fn foo(n: usize) -> String {
let mystring = String::with_capacity(n);
mystring
}
You can clearly see that the C and the Zig code are more explicit, in the eyes of everyone, the Rust example is really nice when you already know rust, but if I were to come from basically any other languages the lack of a return is very frustrating, also if I'm not familiar with String than I can't say if this code returns a dangling stack pointer ? in C++ if you don't know how the std::string works or what std:: is than it's quite confusing and again from just reading the code it's hard to know where the memory is coming from, The C code is a bit better, because the there is an alloc which takes the size of a char and mutiply it by N returning a char something, but still hard to know where the memory is coming from unless you know malloc, the Zig code on the other hand is IMO really explicit, because you can answer all the questions that you might have. Where is the memory coming from ? the Allocator. What is the function returning ? it returns an AllocatorError something something or an Array of u8. the allocator try to alloc n elements of the type u8 and returns it. Yes there is some subjectivity in readability but I think some objectivity can be found when you try to define "readability" as the proportion of code that one can clearly understand without being familiar with the language semantic.
1
-
@maleldil1 From my own experience, I vastly prefer Zig over C. I've been doing C for years, and it's just not a good language. Zig offers better ergonomics, and tooling, to help us be productive. There are a range of errors that are hard to make in Zig when you have a C background. Zig is ofc still a young language. But it's by far the most promising than any of the new languages I've tested, except for maybe ODIN which is really good but doesn't really align with what I believe a programming language should do. Zig is also far more predictable when it comes to the assembly output. It's easily readable, and cheaply testable. The std is filled with a ton of different DTS for quick prototyping and experimentation. Some solid testing and debugging tools, builtin sanitizer, etc. I love Rust too and I think it's a fantastic language, but I think it's a matter of philosophy. I prefer to have high level of control over my code. I think Rust is amazing at rewriting stuff, but Zig is definitely the one I would choose to replace C.
1
-
1
-
1
-
@phene-449 How's Zig a swiss army knife ? If anything Rust is the kitchen sink programming language here, not Zig, while I agree that Zig will never reach the mass adoption of Rust, it will clearly be as big as C. I work in embedded and I've been rewriting some C++ to Zig for the last 6 month at a major defense company, colleagues have a blast with the language too, productivity and morals are good, build time are cut in half, number of issues and bugs were cut significantly. We sure aren't google, but what I can tell you is that of all the developers that I work with, many of whom (myself included) used to be hardcore C/C++ developers, none of them have suggested we use Rust to rewrite anything, Zig brings some incredible value to our world.
1
-
1
-
1
-
1
-
1
-
@CamaradaArdi There is already TigerBeetle written in Zig which is not a banking system but a transaction data base, no matter how young a language is if your team of engineers is convinced it's a good choice than there is not much to say. Yes Zig is young, and it will absolutely break and change as time goes. But I heavily doubt that the fundamentals of the language are going to chance drastically. Zig is most certainly going to be the future C replacement, for doing what you would have done in C. And Rust is going to replace or at least take some of the stuff that's made in C++, to be made in Rust.
Rust is great but in application where speed is important, I think you are better off using Zig, because the assembly is much more predictable, and all of the language design revolves around giving all the facilities for programmers to manage memory and achieve 80% of the safety that Rust offers. In Rust you can indirectly manage memory, or you can manage it with a good granularity, but it's not exactly it's strong selling point and this level of manual memory management, while absolutely feasible falls into the probably bad idea.
Rust is a language that offers an amazing performance/abstraction/safety ratio, but just because it's amazing doesn't mean that it can do it all. And in my humble opinion if you want the finest granularity without hand writing assembly than Zig is definitely the language that offers the best ratio of control/predictability/safety.
1
-
1
-
@bentleysayer5812 No and I agree, one shouldn't just assume everything is well implemented, but at least from my own experience, all the time that I'm not wasting on C correctness proofing, is all more time that I can invest in actually making significant performance improvement.
I know I'm not the best C programmer, but I believe that C is too simple, and it has some negative impact on the semantic and therefore the tooling too.
Even with all the -fsantizer, the -W etc. C just can't understand that it shouldn't allow you to compile certain things, and worst than just accepting all your errors, C will straight up optimize those errors on the assumption that those errors can't occur which they clearly can. So from my experience, the slightest mistake in C can really put your productivity and motivation on jeopardy.
More modern language, like Zig or Rust, offer a way better ergonomic and so all the time that you don't waste in C on finding the error that the Zig compiler or the Rust compiler would have catch, can be invested into actually improving the performance if necessary.
1
-
1
-
Ce qui est surprenant avec Mr Slama, c'est que à 28:50 il est terrifié par Twitter, et selon moi ce n'est pas un rien, cela en dit long, là où nous les français de la campagne, des petites, moyennes villes ont sait tous (soit à cause d'une expérience perso, d'un proche à qui c'est arriver, ou à cause des incessants faits divers ) qu'il y à certains coins, et certains quartiers dans lesquelles ont ne peut pas passer sans perdre son téléphone ou se faire lyncher, lui a peur de 0 et de 1 sur un écran de téléphone, c'est tout le problème enfaite ses personnes qui votent pas dans le bon sens elles le font car le réel, les y poussent par par gaîté de cœur.
Qui plus est, je dénote une indignation à géométrie variable qui me fait doucement rire, je veux dire ce monsieur, défend la loi comme outil fondamental de défense des droits publiques, et d'épanouissement de l'indidivualité, néanmoins aucune indignation vis à vis du fait que aucune peine n'est appliqués dans ce pays, aucune indignation que les OQTF ne soit pas appliqués, aucunes indignation lorsque la loi ne va pas dans son sens enfaite. Je veux dire la plupart des personnes votant MLP ou zemmour veulent juste une chose, QU'ON APPLIQUE LA LOI. Je suppose également que il ne s'offusquerais pas du référendum de 2005 et ce qui a suivis. Alors moi je veux bien qu'on s'érige en défenseur de la démocratie mais à ce moment là c'est partout pareil, si demain 90% des français votent l'ouverture des frontières totales, moi j'opèrent juste mon choix individuel de partir mais je trouve ça totalement normal et légitime, et de la même manière j'attends de mes opposant idéologiques, que lorsque 70% des Français dans tous les sondages d'opinions se disent contre l'immigration qu'il y est au moins un début de remise en question, surtout quand je le répète, aucune loi n'est appliqué dans ce pays, j'ai des connaissances de collège dont on ne citera pas les origines qui ont été condamné plus de fois qu'ils n'ont de bougie et qui n'ont jamais vue de prison de leurs vie.
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
I love helix, the key binding are very powerful, and Helix in it self, cut through the hustle of having to install 50 things like neovim, you get the basic out of the box, it's simple to change, keybindings, create languages specific, or project specific, formatting, etc. It's only lacking a better debugger integration to be truly amazing.
1
-
1
-
1
-
@jackblack1801 It's not about what I want to hear, but let's set the record straight about the future of programming. Despite the buzz surrounding developments in AI, particularly language models like LLMs, the notion that they will replace software engineers is absurd. Understanding the capabilities and limitations of AI, particularly LLMs, is essential to dispel any misconceptions.
LLMs, in essence, operate as sophisticated Trie, inferring the most likely sequence of tokens given a prompt. While we could delve into the technical nuances and complexities involved, it's crucial to recognize that this falls far short of replicating human capabilities, especially in professional contexts.
Will AI enhance code writing efficiency and quality? Undoubtedly. Will it alleviate the mundane tasks of testing, deployment, bug analysis, and security? Absolutely. However, the idea of AI supplanting human expertise is far-fetched. While a cursory knowledge of JavaScript and a simple app might have sufficed in a previous job market bubble, genuine software engineering expertise remains indispensable.
Those who dedicate themselves to mastering software engineering, continuously learning, gaining experience, and developing domain knowledge, along with effective communication skills, are poised for long-term success. Adapting to utilize AI tools to augment our skills is essential for staying relevant in the evolving landscape.
However, the belief that AI will imminently match the complexity and versatility of even entry-level web developers is misguided. While incremental progress is typical in many fields, AI operates on a different paradigm, with advancements often driven by hardware capabilities rather than fundamental breakthroughs.
The consensus among most experts, not driven by commercial interests, is that LLMs pose minimal threat to skilled professionals. While acknowledging the need to adapt, it's crucial to recognize that AI is not a substitute for human expertise, at least not in the foreseeable future.
The only reason we are having those conversation is that :
1 - People have a general lack of understanding of how those "AI" work at their core.
2 - We as human are very bad at discerning something from the illusion of something. Which LLM are all about (they are emulating human speech and capabilities but can't produce anything on their own, because they lack the fundamental ability to understand what they do or say).
3 - We let ourself be scared by our environnement changing and we tend to overreact and imagine the worst outcome possible. I was among the first to tell my father that in a few years he would be replaced by self driving vehicle, but since then I've been learning about AI, following the progress in the field, and my best friend who works at Hugging Face, has been really helpful to understand the future prospects of the field). Now I'm confident that we are safe for decades to come. Unless there is an absurd amount of breakthrough into hardware/techniques and energy.
1
-
@jackblack1801 It's not about what I want to hear, but let's set the record straight about the future of programming. Despite the buzz surrounding developments in AI, particularly language models like LLMs, the notion that they will replace software engineers is absurd. Understanding the capabilities and limitations of AI, particularly LLMs, is essential to dispel any misconceptions.
LLMs, in essence are just fancy Trie data structure, inferring the most likely sequence of tokens given a prompt. While we could delve into the technical nuances and complexities involved, it's crucial to recognize that this falls far short of replicating human capabilities, especially in professional contexts.
Will AI enhance code writing efficiency and quality? Undoubtedly. Will it alleviate the mundane tasks of testing, deployment, bug analysis, and security? Absolutely. However, the idea of AI supplanting human expertise is far-fetched. While a cursory knowledge of JavaScript and a simple app might have sufficed in a previous job market bubble, genuine software engineering expertise remains indispensable.
Those who dedicate themselves to mastering software engineering, continuously learning, gaining experience, and developing domain knowledge, along with effective communication skills, are poised for long-term success. Adapting to utilize AI tools to augment our skills is essential for staying relevant in the evolving landscape.
However, the belief that AI will imminently match the complexity and versatility of even entry-level web developers is misguided. While incremental progress is typical in many fields, AI operates on a different paradigm, with advancements often driven by hardware capabilities rather than fundamental breakthroughs.
The consensus among most experts, not driven by commercial interests, is that LLMs pose minimal threat to skilled professionals. While acknowledging the need to adapt, it's crucial to recognize that AI is not a substitute for human expertise, at least not in the foreseeable future.
1
-
@concernedcitizen6572 This is ridiculous, I don't think that in 1-3 years anyone in the field will be replaced by AI, LLM are very good at imitating us, but that's it they are just an imitation, software is all about creating, understanding, planing, the writing part is actually the easiest part. LLM can help with that but even that still requires you to understand what it does, because at least in my field, they don't do very well, they create ton of CVE, leak memory all around, they overwork the CPU by doing stupid things, they can barely understand and be of any use once, you start optimizing the code, they are just not that good, and this is my experience on toy project, I can't even imagine that they will be of any use aside from, testing, and automating the boring tasks.
1
-
@jackblack1801 I think you are legit trolling, idk in what world you live in but it's been a year of chat gpt and we have yet to see anyone let alone any programming job being, actually replaced by an AI system, I'm stating this confidently that 80% to 90% of jobs are very very safe, and those who are not will only unlock new jobs, in the field.
But you are delusional if you think AI can replace any professional developer, in a professional setting maintaining and developing a product.
Like I've said in my field top of the line specialized LLM (that I've trained myself) running locally on a huge set of data (documentation, codebase, international language specification, and tons of high quality programming books and website) is not able to provide anything except immediate technical debt, same goes for chat GPT, or for copilot.
If they can replace your job, that means there is probably a ton of things that you should be able to automate yourself, to increase your productivity and as such your market value.
1
-
@seanborland4531 But that's the thing, it doesn't show any emergent properties, because there is nothing there to emerge, this is why everyone needs to take some time to learn about how those LLM works, I'll restate it here, They are nothing but a fancy Trie data structure, they can infer what is it that you want them to say but they cannot reason.
Yes there is nothing in the Human minds that an AI cannot beat, even today some AI are able to easily beat us in most of the task we are good at. But our real value comes exactly from that, we are very polyvalent and adaptable. GPT took months to train on billions of dollars worth of GPU, gigabytes of text, more than any human will ever be able to read in a lifetime. If you need to wait month before you are up to date this means you are already behind. Just because Devin can self prompt doesn't mean it will be able to learn in the long term, I think you wildly underestimate the "SPECS" of the human brain. A normal human brain is suspected to have a capacity of around 2.5 petabytes, and to have a capacity of about a exaflop of "processing power" all of this for a 20w tdp, you call me the day a GPU comes with that
1
-
1
-
@concernedcitizen6572 That's assuming AI will reduce the need for labor, which at least historically is very much incorrect, progress has always led to more jobs. Before the clock alarm some people job was to wake up very early and go with a stick around town, hitting on people's window to wake them up. Some people's job was to turn on the public light before electricity was invented. Before the invention of the printing press, thousands of books were handwritten.
Every time there has been progress, it always led to more job, and more demand, it's the same with software, AI, will only improve our ability to get stuff done. Imagine what you would have been able to deliver with 5 more engineers ? Imagine how much more features the client would have ask if you could get stuff done for half the amount of time or money ? For example C was a big improvement over assembly, developers could finally be more productive, was it the end of assembly ? no it's still a very popular platform to this day. But the same way we don't handwrite books nowadays we don't need to write assembly everywhere to get stuff done. Ai will have the same impact, in a few years I can see writing unit test being a thing of the past, AI will be able to generate complete test coverage for each functions, and help us move faster in the process. Ai might be able to generate and improve our CI/CD pipelines, correct them, and make sure deployment is smooth. But will it be able to make a commit with a 6 month plan, on how to improve the code base, and steer it in one direction, because you and your team thinks it will lead to an improvement in reliability and velocity ? Hell no, it struggles to this day to even just complete a fairly simple Linked List insert_at() implementation, without completely omitting edge cases. And everyone seems to think that in 2/3 years we are out of jobs ? That's just silly and baffling to hear.
1
-
I think for the language part, if you are trying to learn a new language, at the very least try to learn one from another paradigm, so if you use an imperative language, try to learn a functional one, or an OOP. Don't focus just on the features, and syntactic sugar, but really the philosophy or paradigm shift that the language has to offer. Learn Rust, for example, for it's memory safety patterns, Learn OCaml for the functional programming patterns. C or Zig for a low level system programming language. Java / C# / C++ for an object oriented language, Try to learn languages like Awk, Bash, those can be very useful too. For example I'm a C developer, But I've touched on Python, and now I use very consistent pythonic names for my functions, I've also learned Zig, so now I'm using a lot of custom allocators, I've learned some OCaml, so now I'm using high order functions in C to enhance the customization of my code. Those are examples, but if you really want to learn some other languages, try to go toward languages, that can broaden your view on how to do things.
1
-
1
-
1
-
1
-
Being part of the Gen Z myself i understand why so many are depressed, unless you learn about some stoïcism there's no way you feel happy with our current situation given the environment we've grown up in, unless you are from a privileged background.
Mainly because most of us have grown up in an environment where we've been told that our world is doomed, that humanity will disappear or at the very least face huge catastrophe. On top of that we are statistically the poorest generation since the 19th century. Plus because of the population aging in some countries we have to sacrifice our future to pay for the boomers, because they are the demographic that make the election and that politicans really work for them more than for us despite being the litteral future of humanity. I'm not even gonna mention that now you can't speak freely, you can't date or meet people like we used to do, everything has to be online, you have to be as fake as possible, on Insta, Tinder, etc or people won't be interested in you. So yeah it suck, especially the economic part, because we can't solve that one, since GDP growth is based on the energy intake growth of the whole system (the world) we can't even expect economic prosperity in the future because we are globaly in an energy contraction that can't be solved indefenitly by debt. So unless someone figures a way to increase our energy intake massively we will be in a permanent recession which mean we'll get even poorer and more in debt than we are. Now i don't belive that we are doomed i've out grow that philosophy becayse even if it's true it doesn't make me happy and i have to take accountability and make the best i can with what i have but ofc a lot of gen z are gonna be depressed if they can't outgrow that.
1
-
1
-
1
-
1
-
1
-
KushLemon Also just for context, I work in the defense industry in Europe and my job is literally to rewrite some of our C/C++ code to Zig right now. And I have some real world experience, I'm also proficient in Rust, and I was free to choose which stack I wanted, I rewrote the networking stack to Rust because it has to be safe, but the rest of it I wrote it in Zig, because it's hard real time performance. The code is well tested, I've made a dedicated simulator which is able to simulate thousands of years worth of CPU, and I use the fuzzing tester provided by Zig too, which is able to also provide thousands of random inputs concurrently, which in turns allow you to generate, test coverage. The "safety" is actually doable in a very reasonable amount of time, and I know it because I've done it.
1
-
@toby9999 True but the point is C++ doesn't help you at all, I'm a C++ developer so you can say skill issue if you want, my point still stand, making fast and correct C++ all the while keeping a maintainable and extendable code base is hard. Sure it's hard in any language, but C++ doesn't help you at all, It's error prone, super slow to compile, terrible tooling, defaults, I rewrote part of our stack from one project to Zig, took me no time, the code base size has reduced, trivial to build, cross-platform, trivial to test and ensure it works correctly, can it be done in C++ sure, did it make sense to make it in C++ ? no. It's not rocket science, management asked me to try to rewrite it, I did it, it passes with flying colors, offers more out of the box, and it's easier to work with, mind you I was pretty much the only one who knew Zig at the time, and everyone around me are C/C++ embedded developers, they are not your average JS kiddo, yet they all find it better and easier to work with.
1
-
A lot of reaons why apple products are so popular, is that they are a symbol status, they are what most people need, they are quite cheap for the quality. ( I say cheap because unlike android, windows and whatnot) you actually receive update for years, and can resell it for a good price. They also last very long, In my familly most of them have Ipad that have been aroung for 3/7 years, and in my opinion this is the reason why apple is dominating, it's not really the software or the hardware specifically but the fact that they are really cheap to buy second hand, are supported for often more than 5/6 years, which in turn mean people have such a long time to get into the ecosystem that by the time they have to change there's not really a reason to do so. Finally unlike apple manufacturers have limited ability to depart from the OS and change it to their taste or optimize it for their hardware.
1
-
1
-
@mmstick The problem with C is not one of memory safety, that's a consequence not a cause. Zig tries to fix the cause, which ends up resolving 90% of the consequences at 10% of the cost of something like Rust. Like the linux kernel is 17M loc of pure C, it's crafted by the most talented devs in the world, and honestly with such a wobbly and error prone language is actually incredible how safe and well made the kernel is. So if anyone (because I don't really care if Zig ends up wining) can offer a language that has similar semantic but modernized C semantic, sane defaults, actually helpful compiler and really well made and useful tooling for debugging and crafting high quality code, than It's not even a question of if it will win against Rust, it just will. Yes Rust does make writing safe and correct code somewhat easy, but nothing comes free, and I'm not sure the community of the linux kernel as a whole is willing to pay the price that comes with Rust. But full disclosure I have zero ball in this game I really don't care which languages ends up landing in the kernel, and I would be happy if it's Rust, I just think it's a hard sell.
1
-
1
-
@warpspeedscp I mean surely it's probably not that bad, but I just don't understand the workflow, because I'm constantly switching tabs, moving from file to file, greping left and right, It did actually bothered me a lot that the syntax highlighting wasn't instant despite running a very good computer, on top of that a very simple project in C (about 10k lines) took like about 10/20 second to fully load, this to me was insane, everything is instantaneous in the terminal, and with support for lsp, you basically have the same kind of functionalities that an IDE can provide without all the bloat. But in the end it probably is just personal taste
1
-
1
-
1
-
@Descent098 Exactly, Like if you just want a quick and easy desktop app cross-platform and the app isn't really complex and it's not even that important if it's really snappy and reactive, or you have a small team or a small budget, than yes Electron is really fine by me. But if you are a billion dollar company like Microsoft, that you are literally a company that sells, Freaking proprietary kernel code (aka Windows), but you are telling me that they went with Electron for VScode ? Like It's embarrassing like most of their products, but 2006 Visual Studio, booted in a fraction of a seconds. Everything was snappy and fast, mind you it was freaking 2006 hardware. But now 19 years later we basically have super computers at home. Microsoft is literally one of the biggest company one the planet, recruiting top notch talents across the world, And you are telling me that those guys can't even be bothered to make a native cross-platform editor ? Like VScode is the app I have in mind, it's just so slow, there is no excuse for that, I'm not even asking for much, but not having my UI update in real-time when I change code, is just straight up disrespectful for all of the engineers at AMD and Intel and there is no amount of money that will make me use that piece of trash, when I need to help someone, if they only have vs code, I'll open note, or text edit, or vi, just to make sure I don't ever touch that embarrassment. In absolutely zero parallel universe should a vanilla text editor, doing absolutely jack shit, take 1gb to 1.5gb of memory doing nothing, and if for some reasons it actually need all that memory it better be a thousand times more responsive that it currently is. To me VScode is probably the absolute worst app for Electron.
1
-
1
-
@Descent098 No for sure VScode has it's merit, I'm not saying it's not doing usable to solve problem, and despite my tone this is not an attempt at burning a church to say that mine is better. I really don't care what people use, I know what I want and care about, but I also understand that people are different and some might not be bothered by the things that I noticed when trying VScode. But for some context I use an editor called Helix. It's very much like Neovim, except its' written in Rust, and is basically a Neovim with all the plugins you would want, but written in native language. So it's like 15/20 mb peak RSS, and everything is just as it should be, on our modern computers, meaning instantaneous. ? you want to fuzzy find from your root directory ? instant. You want to quit and open 50 files, quit and reopen them all ? instant. Want to have multiple lsp ? instant. Fuzz your millions of LOC codebase ? instant. And again not saying that to say it's better, not everybody cares about it, but it's why when I see something like VScode, it's just out of this world, like I just can't fathom what is happening to that poor silicon when you decide to open VScode.
1
-
1
-
@FengLengshun The reason Windows is failing so much is because windows is a pile of hot retrocompatibility garbage, they made a lot of improvement with windows 11 and who knows one day windows might be decent, but if they want to succeed on arm, they would need to properly redesign their code base, use more modern language, like rust or zig, or very recent c++ to avoir concern with memory safety, and security issues. Even then their API or often very bad compared to what you can get on other platforms (apart from gaming where it's decent).
Also the emulation part is a non issue, for engineers of their caliber it would be easy to design an emulation layer, if apple managed to do it so can microsoft, on top of that there isn't as much incompatibility, most languages used by system programmer nowadays can be easily implemented on the backend by compiler people. For example I'm working on a c compiler in c, and i work on both a macbook pro m2, and a ryzen 7 7735hs, both machine can compile fine. no modification needed, of course more complex and professional applications might rely on os specific library, or they are build using really non portable code, but they just need to provide good api, and ideally tools and documentation to help software maker to pivot onto arm.
1
-
1
-
1
-
1
-
1
-
1
-
@SystemAlchemist Yes I know, I don't even think it was on the Radar when Rust was proposed to it into the kernel, so within that realm, it was sensible to take Rust over anything at the moment. Rust is just such not a Kernel language tho, that's the thing, so I just hope they don't let it grow too much. As for Zig I'm curious about what you think is sloppy within the language ? It's surely a young and immature language, but as a C developer, I can tell you that this is only improvement over what I'm using currently, and If I could I would gladly avoid the annoyance and mental load that come with a language like C. I mean I get, an actually usable STD, memory allocator are first class citizen, so the STD can be used on freestanding target. The build system is also in Zig, and can build and cross compile C, there's already a package manager (although very primitive at the moment). You can use all C libraries, so you already have one of the most extensive ecosystem at your disposal, embedded unit test framework, so tests are inexpensive, and can live with the code they are meant to test. It's extremely readable, you have more control than C, but also more safety features, and more debugging tools. It's honestly an amazing C. But I'd be glad to hear what you think Zig is lacking, because obviously it's far from perfect, and it's still very quirky.
1
-
@mgord9518 Yes that's for me one of my favorite features of the language, is just how much readable it is, at doing what you would do in C. One example that I love is logging. I'm a sucker for logging things to a file as a mean to debug, in C it's cumbersome, and you can't really use printf unless you also use fflush and all that jazz, you have to change the %_ to do anything, or you have to write your own implementation of printf, and even that is tricky and annoying, in Zig, you just implement a format functions, and you can call that type format function it's very easy and, with comptime you can automate that process, and basically recursively check the type of the field at comptime, to see whether it has a member called idk print, or if it's a simple type just use {any} with it it's really amazing..
1
-
1
-
1
-
Because C++ sucks, it's not ergonomic, it's not fun, it's very bloated and hard to read. Zig achieves 90% of the power of C++ while remaining very readable, understandable, and that's why it's worth talking about. I love C++, but this language, is just not a good language compared to what exist today, it's hard to collaborate with people, it's hard to use some else's code because you have to audit it all to make sure it works like you want it to work. It's hard to debug with templates, the error messages aren't good, the compiler is quite slow, but the real problem is the amount of features available in the language, and how you can basically do everything with everything. I know people don't like to hear about it, but at the end of the day a programming language is just a tool, not a church to go on a crusade for, everyone with an ounce of objectivity can see that C++ is just not a good language this days, when things like Rust, Zig, Odin, Jai, exist.
1
-
1
-
1
-
that's why I use Helix, you get a good modal editor, that feels modern, work wonderfully, is extremely efficient and snappy, you can configure stuff using a simple .toml file, and the best part is that it simply just work. It's by far the best experience I had, I've started using VIM, than I moved to NVIM, tried a few distros, made my own config multiple times, learned a fair bit of lua too, but ultimately it felt like I was spending more time tinkering and messing my whole config, that doing actual code, Helix came in clutch, and just blew me away, it really feels like a well made ultra polished, nvim distro, without the clutter, and the buggyness that this would imply
1
-
@oresteduvillage Je pense pas que la gauche soit fondamentalement supérieur à la droite ou vice-versa, il faut simplement comprendre ce que signifie ses étiquettes, la gauche est par essence un mouvement qui se veut de "rupture" pour apporter un "progrès", là ou la droite est généralement un mouvement dit "conservateur" au sens ou il veut conserver les valeurs de la société, ses principes, structures et fondement. Or je pense que chacun d'entre nous ici à fait ses années lycée et si c'est le cas en philosophie nous avons tous dû disserter sur la notion de progrès, et à la fin n'importe quel petit philosophe en herbe arrive à la même conclusion ou le progrès en un sens est positif, mais il ne l'est pas par essence. Et c'est tous le problème des mouvements de gauche à mon sens, c'est qu'il vont quasi systématiquement vers un progrès aveugle sans s'interroger sur les conséquences de ce "progrès". Je vais prendre des exemples concret pour clarifier mon propos. La gauche actuel est pour l'immigration, elle considère que les immigrées si ils sont légitime exercent un droit (celui d'émigrer) qu'à ce titre ont devrait les accueillir dans de bonne conditions, et ceux sans considérations pour leurs cultures d'origine, leurs religion, ou leurs couleurs de peau comme si ses caractéristiques n'avait au final pas d'importance et qu'on fond c'était un devoir moral d'aider son prochain. Sauf que si on veut s'en tenir aux factuels il à été démontré par des études, que plus une société est "multiculturel" moins il y a de capital social (confiance entre les individus, coopération, productivité horaire, etc.) en résulte dans cette étude pour les groupes multiculturel une productivité inférieur aux groupes homogènes, une confiance et une coopération également inférieur. Là ou je veux en venir c'est que nous avons ici un exemple d'une volonté de progrès et de rupture voulu par les mouvements de gauche qui s'arrête seulement à la qualité morale de cette idée sans s'interroger sur les conséquences réel de cette décision. Là ou je veux en venir c'est que pour résumer brièvement tout ce travail de recherche que j'ai lu, plus une société est multiculturel, plus il y a de haine, de racisme, de violence etc. Et d'ailleurs le réel leurs donne raison si on compare rapidement la France une société avec un modèle historiquement assimilationiste et les États-Unis une société très communautaire. On s'aperçoit que le niveau de violence en France est bien moindre que là bas (bien évidement c'est une réalité multicausale et d'autres facteurs l'explique j'en présente un pour ne pas être exhaustif). Donc si on essayait d'être pragmatique, si on voulait réellement luter contre la haine raciale. il faudrait voter pour un parti qui souhaite au minimun réduire l'immigration, et qui propose de restaurer le modèle assimilationiste qui à permis d'intégrer génération d'immigrés polonais, allemand, autrichien, juif, italien etc. qui aujourd'hui sont indistinguable des français de souche car ils en font eux même parti par la voie de l'intégration.
Ensuite je pense que tu fais une erreur quand tu dis que s'intégrer c'est se soumettre et oublier sa diversité, s'intégrer ce n'est pas se soumettre c'est exprimer la volonté active de s'intégrer de faire partie de l'ensemble nationale pour partager avec les autres, tu prétends qu'il n'existe pas de socle commun mais je pense sincèrement que tu te trompes il existe une culture et une identité française elle est réel, et c'est difficle à décrire car c'est un ensemble complexe de pleins de code et d'habitus qui créer cette ensemble qui permet de distinguer un Français d'un non-Français. Que ce soit la bise, le vocabulaire, les repas de famille le dimanche, le syndicalisme, la littérature, le cinéma, le vin le fromage et j'en passe toutes ses petites choses misent bout à bout font de toi un français et sans renier le caractère unique de ta personne elle te permettent d'un point de vue sociologique d'être plus sociable avec les autres et donc de contribuer à une société généralement plus apaisés car si tous les individus qui la compose partage cette ensemble de code ils communiquent et coopèrent d'une manière plus efficiente. Et lorsque cela est vraie il y a moins de tensions basés sur la race, la religion ou autres et ça c'est un fait.
Or qui défend ses valeurs, cette culture ? et qui cherche à la déconstruire ? si tu arrives à répondre à ces deux questions tu sauras probablement déterminer qui va créer des problèmes et qui va tenter de les résoudre.
1
-
1
-
1
-
1
-
1
-
1
-
@JwokeLionheart Bah je suis desole, j'ai fais des etudes d'economie, et bien que ce ne soit pas ma profession, je sais exactement comment fonctionne la dette, maintenant je me doute bien que vous ne considerer pas qu'il y est de probleme, moi je fais parties de ceux qui au contraire trouve sa problematique. Tout ce que je dis c'est que l'enfer est pave de bonne intentions, c'est bien de vouloir aider, mais il faut aller plus loin que ca et reflechir pragmatiquement, combien meme je penserais comme vous (que l'on a heriter d'une responsabiliter envers ses peuples du fait de notre passe coloniale) comment aide t-on ses gens, dans une France en stagnation economique depuis des annees, avec zero perspective de croissance, du fait de la desindustrialisation, de l'energie trop chere, et de la main d'oeuvre trop chere ? La realiter, c'est que on ne peut pas aider ses gens la, puisque on ne peut deja pas s'aider nous meme. J'ai enumerer les problemes auquel on fait face (education nationale, sante, armee, justice, police, acces aux service public, etc...) Je ne vois vraiment pas comment inviter encore plus de gens a venir va les aiders, ils vont se retrouver sans travail, ils seront sans formation adequates, notre systeme de solidarites ne peut pas supporter du volume, et tout sa fait le jeux des patrons, plus de competition pour les recrutements egales, salaires plus bas, et moins de leviers de negociations pour les salaries.
Franchement je suis pas contre l'aide, je suis juste contre l'aide a domicile, aidons les chez eux, si une entreprise francaise veut delocaliser, faisons en sorte qu'elle delocalise la bas, si ils manquent d'access aux soins, construisons des hopitaux la bas, pareils pour les ecoles, et autres, aidons les chez eux, faisons en sorte qu'ils puissent rester chez eux pour developer leurs economies et infine ameliorer leurs conditions de vie.
Oui aux droit d'asile, et a l'acceuil d'urgence, mais n'invitons pas la planete entiereres chez nous, aidons les a s'aider eux meme. Car ceux qui viennent chez nous ce ne sont pas les femmes/enfants/veillards non ce sont les hommes en age de travailler, jeunes adultes precisement la tranche demographique qui permettrait si elle restait chez elle de developer l'economie locale.
Bref j'en ai juste marre des gens qui veulent acceuillir pour acceuillir sans penser d'abord la question de l'acceuil et des consequences de ce dernier.
1
-
1
-
1
-
I'm actually in the process of writing a unix kernel in Zig, for my master degree validation. As a mainly C dev, I can confidently say, that Zig is indeed a very nice language for Kernel development, I can quickly experiment with some dirty C code, put that in my build.zig, and once I'm happy with how it work, I can port and solidify that implementation in Zig, writing some unit tests along the way, and using Zig type systems and assertions/compile error to ensure correctness. I feel like people have a binary view about safety, every language can be used to write safe code, what hinders that ability is not really the semantic of the language, but the general lack of tools and infrastructure to maintain and enhance that safety. Zig provides a lot of that infrastructure and as such while not perfect (because I'm not god) I can confidently say that I can out of the box write safer code in Zig than I can in C despite having probably a good half million lines of C worth of experience, and maybe a 10th of that in Zig. I didn't change the way I wrote my code tho, but the infrastructure and tools provided by the language itself were what made my code safer. So it's not like if you were to write a kernel in anything that isn't Rust, that suddenly your Kernel would be trash and unsafe. It's all about the infrastructure.
1
-
@ That's true, I don't think its for everyone either. But I find that it's really a great tool already, when you want to do something that you would have done in C. It gives you way more practical control than C. The way I see it Zig is simply a continuation of C philosophy. While Rust is more C++ with good defaults, better compiler/tooling, better type system, etc.
I love Rust I did all of AOC 24 with it, and the code is always pretty good out of the box. But optimizing Rust, is like optimizing C++, there is no shortcut, all you need is deep knowledge of how things are implemented, how they translate at a high level in assembly, and I personally can't be bothered.
This is where Zig shines, by being extremely simple, explicit with nothing hidden (but also not much abstractions out of the box) optimizing is extremely easy, because the reasoning is much less based on knowing each language constructs, and library/traits/templates etc. and much more intuitively thinking about hardware, memory layout, instructions throughput etc.
1
-
1
-
1
-
1
-
Very valid criticism, I'm an iphone user, and personally I go with Iphone because it does what I need it to do reliably, I have the most basic use of my phone, I just use for music, map, call/sms, and the occasional google, or youtube short. I had an android before, and although it was a good phone, I really didn't need all the features from it. To me it felt like more clutter, but I can totally see how a power user would be able to yield much more benefits from android than an Iphone. Also when you buy into the whole ecosystem everything just work wonderfully, the shared clipboard between an iphone and a mac is awesome.
1
-
I've been part of the development process since early on, and I think a lot of the discussion around this project misses the core point. Let's break it down.
Some people say, "Why should I care if my terminal is fast? I don't notice the difference." But here's the thing, why settle for slow software at all? If a terminal doesn't offer a feature you care about, like WezTerm's Lua scripting, that's fair, or if you are missing something that's essential to your workflow, by all means don't use Ghostty. But if you're indifferent beyond that, why not prioritize speed? I'm not saying everyone should use Ghostty, but I do believe anyone who spends significant time in a terminal should at least try a faster one. The difference becomes apparent when you're handling verbose output, such as package installations or extensive logs. Terminals can lag, especially if you're using nerd fonts, special glyphs, or working with non-English languages. Speed matters.
I used kitty extensively before switching to Ghostty. As someone who practically lives in the terminal, performance hiccups are glaring. In iTerm2, for example, text rendering artifacts or paste lag can be painfully noticeable. It's not just a minor inconvenience, when pasting a large block of text takes seconds or more, it disrupts workflow and feels archaic. That friction compounds over time.
Ghostty's goal isn't just to be another terminal emulator. Its ambition is to serve as a cross-platform, drop-in replacement for existing terminals. Admittedly, the current Windows experience isn't ideal, and on Linux, GTK as the sole native option may put some people off. But let's keep in mind this is version 1.0. The project has been developed behind closed doors, but over the next few years, expect more features, backend flexibility, and expanded customization. The combination of the Zig build system and Ghostty's modular architecture makes adding new platform support straightforward.
One of Ghostty's most exciting aspects isn't Ghostty itself, but libghostty the terminal emulation library that powers it. Ghostty is essentially a frontend for libghostty, which is shaping up to be one of the most comprehensive cross-platform terminal emulation libraries available. Right now, Ghostty is the primary showcase, but I envision other projects with embedded terminal components adopting libghostty. Many existing terminals embed home-grown, brittle terminal emulation layers. Replacing those with libghostty could drastically improve performance and feature parity across different environments.
Ambition is what sets Ghostty apart. Some features might seem niche today, like the terminal inspector. But consider this: if you ever develop internal TUI tools, having the ability to deeply introspect your terminal could become invaluable. Debugging TUI apps is notoriously cumbersome, and tools like this could make a real difference when printf debugging isn't enough.
In the end, Ghostty isn't just about speed, being written in Zig, or ticking off feature checkboxes. It's about elevating the terminal experience. The project's mission, to create an open-source, high-performance, feature-rich terminal is worth paying attention to. It pushes the boundaries of what terminal emulators can do and encourages innovation in a space that often feels stagnant. If nothing else, that ambition deserves recognition.
1
-
1
-
1
-
@InfiniteQuest86 In my own experience, it's quite the opposite, digging on your own on things you have chosen will always result in a better learning experience, whereas from everything I saw through school, high school, and college, people learn the stuff, they do the stuff and immediately forget about it. Whereas, I could rewrite my compiler from scratch tomorrow, because there was nobody to teach me how to do it, I had to take note, watch videos, read, tons of code on github, to even begin to understand what I was doing. This is active learning, and I don't see any world where sitting in a classroom listening to someone talking, would make you somehow more engaged and better, I think the best value comes from the interactions with teachers, and other students but that's about it.
1
-
@InfiniteQuest86 let's just say it's not for everyone. My best friend for example, he's the type of guy who really thrive in a school environment, I know for sure that I couldn't do it, not that I couldn't to what he does, just not the way he does it, In one year I taugth myself to code in C, and I've made my own C compiler written in C, I'm now learning Zig, I also started a cursus in the school 42. And In one year I probably have as much knowledge of code and computer science than 2/3y in college, the reason has nothing to do with how relatively smart I might be, just that working from home, living at my parent house, I was able to work everyday 10h a day for a full year, that's about 3500h of experience, On top of that this is consistent high quality deep focus time, whereas in College you waste a lot of time and energy going from place to place, and your brain is getting distracted all the time by everything around you, so even tho some people thrive in College and that's good, we must also acknowledge the fact that for some it's much more efficient to learn on your own
1
-
@_Karlsson I get your point, but still can't really understand it, in my experience C end up more verbose when you try to make idiomatic and correct code. Because of dynamic memory allocation failure you always need to check if the pointer is valid and if not you need to either signal an error and do some cleanup or do the cleanup directly which in both cases is quite verbose. Probably 10 % of my code is just if (this == NULL) cleanup; and the lack of optional value makes it even more cumbersome to handle error correctly because as soon as one of your function does some memory allocation, it can fail and as such you need to check that where it's called we check and include some cleanup code, which ends up polluting everything. Also the fact that you don't have generics means you either have to write custom code for each data types, or use void* which is slower and ugly, or use header and casting which is dangerous, or use macro which is cumbersome, error prone and not easy to debug. Zig is not perfect of course, there's quite a few area where it's inconsistent at best and straight up weird in the worst case. But I really don't understand the "verbosity" complaint, like if you write even a small program like idk reimplenting cat, The same code in Zig is easier to follow, and quite a lot shorter, because it's easier to handle options, and arguments, it's easier to handle errors, and memory management is pretty much automatic with defer. The same code in C is ok I'm not saying it's bad but if you look at it there's a lot of verbosity involved in checking every pointers, and cleanup code everywhere, premature returns etc.
1
-
@_Karlsson Totally get it, Plenty of other languages are more mature and more cohesive than Zig, I really like OCaml, or Go, and even assembly especially ARM assembly is really nice. At the end of the day they are just tools, but even tho I still love C, I can't wait for something to replace it whether it's going to be Zig, nim, Carbon, or Rust, only time will tell. Wish you the best and happy new year.
1
-
@earx23
This is how you would do it in C for toy projects, it's so easy and so good.
const std = @import("std");
const my_c_source_files = [_][] const u8 {
"src/main.c",
"src/helper.c",
"src/error.c",
"src/server.c",
};
const my_c_flags = [_][] const u8 {
"-Wall",
"-Wextra",
"-Werror",
"-fsanitize=memory",
"-fsanitize=integer",
"-fstrict-overflow",
};
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "my_app",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
.link_libc = true, // you can statically link libc
});
// this works like a for each
for (my_c_source_files) |file_path| {
exe.addCSourceFile(.{
.file = .{
.path = file_path, // you add your path
}
, .flags = my_c_flags, // your flags
});
}
Plus on top of that with the zig build system and the ability to interract and talk to C you can use Zig's integrated testing framework to call and test your C code easily. It's so cool. and managing dependencies is not an issue anymore you can just use build.zig.zon to describe where to fetch your dependencies
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
so pissed at all the idiots in the comment, saying that there's nothing wrong with that girl exposing herself, that it's ok, that it's not her fault if this is what is getting attention, that she is indeed pretty smart because she has a biology major, that this is simp's fault for watching, or that twitch was never meant to be family friendly. Because you are all a bunch of stupid morrons, nobody forced that girl to stream, nobody forced her to put herself in a situation where she has to live nacked in front of a camera. SHE choose to do that, she is the only person responsible, if she was so smart she would do something more meaningful and respectable than being a hoe on the internet. You might think that this is harmless that we should tolerate that kind of behaviour but you couldn’t be further from the truth. By doing that, she contributes to normalise nudity, she probably contributes to a lot of girls having poor self esteem, thinking that all they might hope to achieve is being a hoe, and even tho that might feel like something foreign from your life by not shaming that kind of content, tomorrow it's gonna be your sister, or your daughter on only fan or twitch or on the hub, just because none of y'all have the fucking ball to stand your ground and tell the truth, she is for the street, she put herself out there and she is a disgrace for womankind.
1
-
1
-
1
-
1
-
1
-
1
-
@covo1covocovo386 Je suis ancien militaire, j'etais dans la Legion Etrangere, non seulement je connais exactement la maniere dont ont fonctionne, mais durant mon contrat de 5 ans j'ai ete amis/en contact avec plusieurs membres de divers branches de l'armee Russe, d'ancien membre certes, mais des gens connaissant de le sujet de pres. Le fait est que tous ont rapporter la meme chose, corruption, manque de moyen, personnels peu competent, mal former, pas motiver, mal payer. Tout ca c'etait quelques annes avant le debut de la guerre en Ukraine, j'ai dans ce meme temps participer a plusieurs exercices de combat de l'Otan, et de l'armee francaise. Meme la France toute seule leurs roulerais dessus, et je dis ca seulement en considerant les forces au sol, je ne prends meme pas en compte notre superioriter aerienne evidentes, nos forces speciales bien mieux entrainer/equiper. Ce que je dis la est vrais pour la plus part des pays contributeurs net de l'UE. L'Allemagne, l'Angletterre, l'Italie, l'Espagne (un peu moins), et meme d'autres pays comme la Pologne.
Donc non desoler pas besoins de fantasmer une invasion qui n'arrivera pas parce que Poutine n'a en aucun cas les moyens de nous envahir, donc il ne le fera pas un point c'est tout.
1
-
1
-
@Salinz just buy another brand, I don't understand what the government has to do with that, especially the EU which is not even a democracy , all that crap isn't even happening because citizens were complaining, this is the result of just politics, and lobbying, because they are just a bunch of sold rats, the EU has absolutely no care at all, most of the politicians can't even send a fucking email without 5 assistants, if you think they have even a remote conception of what is side loading, you are dead wrong, this has no purpose at all, if you don't like apple device, just buy android or windows devices.
1
-
1
-
1
-
1
-
1
-
1
-
@UwU-f2a You should have used the
var gpa = std.heap.GeneralPurposeAllocator(.{
.safety = true,
.never_unmap = true,
.retain_metadata = true,
});
This protects you against use after free, double free, and leaks in general. Again it's pre 1.0v so yes there is some rough edges, but If you enjoy the freedom and low mental overhead of languages like C, Zig is really neat. Yes the error messages are not good, and you have to learn the language and it's idiom to not write very verybose code, but once you understand how to use it it's very powerful, and it's easy to write correct and readable code. If you don't want to manage memory you can also just use an arena allocator or write your own GC nothing prevent you from doing that. Rust doesn't have an allocator interface that's stable and good enough to use. And truly complex code in Rust is orders of magnitude harder than complex code in Zig, once you have async trait with lifetime it's an absolute shitshow. Plus despite it's very good ecosystem everyone uses async in libraries so you always have some coloring issues witch is annoying. Overall I'd rather manage my memory through allocators, than with a static analyzer that adds ton of complexity to the frontend.
1
-
The simplest way I think, is to use a composite type, with typedef, you create a struct, that contains a void* data, a size_t size, and an enum for the type, that is declared with the type width, I use this a lot you just typedef it into a nice array_t, or t_array and boom you have a simple and easy to use array. you can even go a step further, and use generic functions that are only facade to fonctions pointers switch statements to redirect your array to the correct type specific functions, based on the value of your enum. ( and in some cases if the compiler is able to see that your functions are only there to redirect your array to another functions, the compiler might replace your switch statement by a look up table reducing a bit the overhead).
1
-
1
-
I'm currently in a programming school, called 42, for those who know, the way you learn, is by building a series of projects compliant to a given specification, the school is open 24/7 you can come when you want, and the only required in person part is when other students have to correct your work, or when you have to correct someone else's code. In that context in my experience, working from home is really really important, when I need to get stuff done, because I can focus on my work, there is nobody to distract me or to sidetrack me. But when it's a group project and you have to tightly collaborate with people, in person is the clear winner, It's so much more fluid, and enjoyable, than having to send messages on someone's discord and wait for them to respond to you, you get less opportunity to be clear, and you loose that fine granularity, and clarity that in person conversation can provide, which leads to a significant decrease in productivity, confusion, and overall frustration. I just want to mention that we are all very "junior" so I don't know if some of those observations of mine vanishes as you work or collaborate with more senior individuals. But if I had to take a guess, I would say that as long as the task is fairly well defined in scope, specification and that the task you are assigned doesn't depend on domain specific knowledge or business logic, I think remote work gives you the ability to explore more efficiently, otherwise I would assume that in person would be probably the best, when the task or the scope and knowledge required is less well defined.
1
-
1
-
@jorgec55 I'm not describing my POV of human nature, there is actually a field of science that is exclusively focusing on understanding human nature, called psychology , and we shape our societies always on the same principles from the time we were large tribes to this day we still behave the same, we all have the same aspiration, and the name we put on our institutions, the language we use, or the flag we defend might have changed throughout the centuries, but we've stayed the exact same, and for the longest time we actually evolved in an environment very similar to communism, yet they were always hierarchy, with some successful individual and some less successful, and that has nothing to do with the means of production or who they belong to. Just human nature some people are ambitious and hard working, other don't find as much interest in working this much and are happy to have more free time and less responsibility to focus on other aspects of their life. Communism will never happen because like I said it romanticize human nature by thinking that communism is actually what everyone want, but that has never been true and never will be. Simply because we aren't programmed to have those inspiration, and actually this is true for every single living creature in the universe it's not even exclusive to humans, that's just how life got where it is in the first place.
1
-
1
-
@plum_colored_dahlia yeah exactly when I say that humans are greedy and selfish it's not a critique, it's absolutely normal to better yourself, and primary care for yourself and those who happen to be close to you, I'm not saying that humans are bad by nature, but that the expression of said nature in a communist context just can't work.
When I say that some humans want's more money, power and success it's not that they want more to simply have more, they want more usually to provide for their family, friends, or to support the cause they cherish.
Either way even if you don't consider all the bad apples among people, who actually want to take advantage of others, by lying, and stealing for their own profit you would still end up in a system where people would treat their "own" differently which is actually the true issue of capitalism as well.
People don't have issue with the principle of the accumulation of wealth in itself or whatever because that can be tackle within capitalism it self with redistribution policy through taxes.
No what people (and rightfully) despise the most is that the rules don't apply to everyone in the same way, small to medium companies pay full taxes while giants like Amazon, Apple etc are paying pocket money.
poor and middle class individuals pay everything full price while really rich people have their money where it can't be taxed.
average people are going to jail for meaningless offense while real gangster can easily donate for the campaign of a judge, a senator, or whatever and get away with real crimes.
Unfortunately this issue is not related to capitalism it self rather than our human nature. Which is why changing economic paradigm will never happen or work.
1
-
@brandongregori995 Yes, and no I've tried, many distros, like NvChad, LunarVim, AstroVim, SpaceVim. They are all very good implementation, and yes you are right, with them you get a lot out of the box, and you get the opportunity to customise it further. The thing is, they all require a bunch of dependencies, that may break in the future, with an update, it happened a few times and it's quite frustrating. I don't expect it to be perfect, because at the end of the day I know the maintainers are doing it for free, but Helix so fas has always been simple and reliable, and to me it's what I'm looking for, I don't need much for what I code, so I don't mind having less features, as long as the one integrated are well made, and coherent. Because with nvim, plugins, a lot of the times you get some conflict, and things that stop working, and it's quite annoying to go dig in to fix, at least it's my experience, some people might have another experience and it's totally fine.
1
-
1
-
1
-
1
-
1
-
1
-
1
-
1
-
@kuhluhOG Completely agree, I understand why Rust encodes lifetimes in the type system because those annotations are needed for the lifetime analysis, but at the same time. Lifetime are not a set in stone thing, this is why I find that languages like Zig is in this case imo superior because lifetime is managed by your allocator. So I can have let's say a linked list, and Idk maybe I can allocate my node with a fast static allocator on the stack because I know those nodes need to live only for that function, maybe I want those nodes to live for a frame time, so I might use an arena, or maybe I just need to allocates a few nodes here and there in which case a heap allocator is ok, but now I want to debug something so I can swap that with a debug allocator and a logging allocator to track my allocations. The point being that I think Rust would benefit from an actual allocator interface, that could offer to the compiler some lifetime guarantees, because structs should have generic lifetime in 99% of the cases and should be managed by the developer locally, I think this would help reduce the syntax clutter and also make the code more explicit and self documented
1