this post was submitted on 13 Mar 2025
568 points (95.4% liked)
linuxmemes
23532 readers
1184 users here now
Hint: :q!
Sister communities:
Community rules (click to expand)
1. Follow the site-wide rules
- Instance-wide TOS: https://legal.lemmy.world/tos/
- Lemmy code of conduct: https://join-lemmy.org/docs/code_of_conduct.html
2. Be civil
- Understand the difference between a joke and an insult.
- Do not harrass or attack users for any reason. This includes using blanket terms, like "every user of thing".
- Don't get baited into back-and-forth insults. We are not animals.
- Leave remarks of "peasantry" to the PCMR community. If you dislike an OS/service/application, attack the thing you dislike, not the individuals who use it. Some people may not have a choice.
- Bigotry will not be tolerated.
3. Post Linux-related content
- Including Unix and BSD.
- Non-Linux content is acceptable as long as it makes a reference to Linux. For example, the poorly made mockery of
sudoin Windows. - No porn. Even if you watch it on a Linux machine.
4. No recent reposts
- Everybody uses Arch btw, can't quit Vim, <loves/tolerates/hates> systemd, and wants to interject for a moment. You can stop now.
5. 🇬🇧 Language/язык/Sprache
- This is primarily an English-speaking community. 🇬🇧🇦🇺🇺🇸
- Comments written in other languages are allowed.
- The substance of a post should be comprehensible for people who only speak English.
- Titles and post bodies written in other languages will be allowed, but only as long as the above rule is observed.
6. (NEW!) Regarding public figures
We all have our opinions, and certain public figures can be divisive. Keep in mind that this is a community for memes and light-hearted fun, not for airing grievances or leveling accusations. - Keep discussions polite and free of disparagement.
- We are never in possession of all of the facts. Defamatory comments will not be tolerated.
- Discussions that get too heated will be locked and offending comments removed.
Please report posts and comments that break these rules!
Important: never execute code or follow advice that you don't understand or can't verify, especially here. The word of the day is credibility. This is a meme community -- even the most helpful comments might just be shitposts that can damage your system. Be aware, be smart, don't remove France.
founded 2 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
I’m OOTL. Are these actual issues people have with the project?
C++ might not be as memory-safe as Rust, but let’s not pretend a Rust code base wouldn’t be riddled with raw pointers.
BSD tells me the team probably wants Ladybird to become not just a standalone browser but also a new competing base for others to build a browser on top of – a Chromium competitor. Even though BSD wouldn’t force downstream projects to contribute back upstream, they probably would, since that’s far less resource-intensive than maintaining a fork. (Source: me, who works on proprietary software, can’t use GPL stuff, but contributes back to my open-source dependencies.)
Don’t have time to factcheck so going to take your word for it. Interesting bit of knowledge! Honestly wouldn’t have thought that. How else are Chrome, Edge, Brave, Arc, Vivaldi and co getting away with building proprietary layers on top of a copyleft dependency?
I’m no legal expert. All I know is that when I’m picking dependencies at work, if it’s copyleft, I leave it on the table. I love the spirit of GPL, but I don’t love the idea of failing an audit by potential investors because of avoidable liabilities.
The three currently-maintained engines which (at their feature intersection) effectively define what "the web" is today are Mozilla's Gecko, Apple's WebKit, and Google's Blink.
The latter two are both descended from KHTML, which came from the Konquerer browser which was first released as part of KDE 2.0 in 2000, and thus both are LGPL licensed.
After having their own proprietary engine for over two decades, Microsoft stopped developing it and switched to Google's fork of Apple's fork of KDE's free software web engine.
Probably Windows will replace its kernel with Linux eventually too, for better or worse :)
They're allowed to because the LGPL (unlike the normal GPL) is a weak copyleft license.
Thanks for teaching me something new!
So Chromium is based on Blink, which is LGPL – a less viral GPL. Hence, it can serve as a dependency in closed-source software.
As to the shared heritage of these well-established projects – I don’t know how else to interpret it other than a testament to the complexity of building a decent browser engine.
Btw, quick shout out to Orion, a rare WebKit browser by the makers of Kagi that’s apparently coming to Linux as well. I’m a monthly supporter. Even though I still mostly use Vivaldi, it’s been coming along really nicely. Proprietary software but idc. I appreciate their unspoken mission statement: pay or be the product. (No-one should be a product, obviously, but that’s capitalism.)
What about safari? Doesn't it still use webkit?
yep. (see my other comment in this thread)
well, its possible to check if a rust equivalent would be riddled with raw pointers: just check the Servo code base.
personally I think its a good thing to have another browser implementation, regardless of specific choices they make about language or license
I'm curious. Why do you believe the last statement to be true?
Anti Commercial-AI license
I don't know if it's riddled with it or not, but what I (think to) know is that one of Rust's goal is to minimize them. No need for raw pointers when handling lists and buffers most of the time.
Did you paste the wrong link?
They have that under all their comments.
If you cant tell from just looking at the relative successes of BSD and linux that copyleft licenses are better than I dont know how to convince you of anything
By that logic proprietary licenses are best for desktop OSs because Windows has the biggest market share?
Windows has lost more market share in the last 20 years than any other operating system
To.... MacOS. Yet another proprietary closed source license
Actually macos was based off of BSD, but there were no basically contributions back to the community, so its whithered away. meanwhile linux is running in every sattelite and scientific insrument, it runs every router and nearly every server that are the internet. Microsoft google and apple all begrudginly make linux better while they make the operating systems they sell worse
Actually to linux, but hey nice try
It's the only operating system with that much market share to lose.
I don't like that "C++ isn't memory safe". It is. Users of that language are usually just not experienced or educated enough and therefore more mistakes happen.
I agree though, that other languages like Rust or Java can make it easier to prevent such mistakes.
In my experience, using smart pointers alone already solves 90% of memory issues I have to deal with. C++ improved a lot in that regard over the decades.
I'm very experienced with C++and I still feel like I'm juggling chainsaws every time I use it. And I've personally run into into things like use after free errors while working in Chromium. It's a massive codebase full of multithreading, callbacks, and nonlocal effects. Managing memory may be easy in a simple codebase but it's a nightmare in Chromium. Tools like AddressSanitizer are a routine part of Chrome development for exactly that reason. And people who think memory management is easy in C++ are precisely the people I expect to introduce a lot of bugs.
I've a very long track record using C++ as well and I can't share the feeling. I don't say it's alyways easy. I'm just saying that it's doable and therefore whether the software is memory safe depends on the expertise of the devs. Modern C++ practises, programming patterns and as well tools from the STL (or even your own implementation) make life a lot easier. If you don't use them, that's not the languages fault. In the end, how you use the language still matters a lot. If you'd like to think less about memory management, go on and use Rust or C# or Java or even Python if performance doesn't matter. That's perfectly fine. This can come with other issues, like more boilerplate in the case of Rust for example, but in the end those languages are tools. Choose the tool which gets your job done.
I don't think this solely depends on the level of experience. People make mistakes, and these kinds of mistakes are very hard to find. And don't tell me you are the perfect coder that makes no mistakes, introduces no bugs.
No. Just stop. If a language depends on the expertise of the developer to be free of memory bugs, then by definition, it is not memory safe because memory safety means such bugs are impossible by design. Quit trying to redefine what memory safety means. A program being free of memory bugs does not in any way imply memory safety.
I agree that experienced users can write code that leaks less than in C, leaving aside the bottomless pit of despair that is undefined behaviour. But the the language isn't memory safe, it doesn't even prevent you from returning a reference to a local or helpnwitg iterator invalidation. you don't have to jump through any hoops to enable making that mistake.
If a language prevents you from doing stuff like that, this always comes at a cost, since it has to do the work for you, almost always. This is additional overhead you can get rid of in C++ and therefore gain a lot of performance. But that again comes with more responsibility on the developer's side and you might need to implement appropriate checks yourself where needed.
Rust prevents the things mentioned above in the compiler; there is no runtime cost for most of Rust's safety measures. There is definitely a build time cost though.
You can unsafe your way around anything, but that's on the dev.
I'm not just talking about performance costs. For example, compared to C++, Rust comes with reduced flexibility and increased complexity in certain cases.
The borrow checker, for example, imposes strict ownership and lifetime rules, which can be difficult to work with, especially in complex data structures or when interfacing with existing systems. Sometimes, you have to significantly refactor your code just to satisfy these constraints, even when you know the code would be safe in practice. This can slow down development, require more boilerplate, and make certain patterns harder to express.
C++ gives developers more freedom but expects them to take responsibility. That tradeoff isn’t just about raw performance; it's also about how much control and convenience the developer has.
You said performance, so I responded to that. You can dislike Rust, that's fine, but a lot of the things you're saying aren't correct. C++ isn't memory safe, the person responding before showed that pretty easily. Rust doesn't perform slower than C++, I responded to that claim. Rust provides tools to be memory safe, but the existence of
unsafeI'd argue makes it also not memory safe, but at least better than C/C++. It also has tons of undefined behavior, just like those two.As for the personal opinion; you don't have to like Rust. I actually have a very different view of the borrow checker and I don't think I've ever "fought" it in a time when I was also doing something inherently safe. Every time I've had an issue with satisfying the borrow checker, which is rare, it's been because I was doing something unsafe or interacting with C code, which Rust would argue is also unsafe. In my experience, it really eases the burden of programming actually and it makes debugging easier. It also makes design easier. As an example, I've been working on a very large C project recently and I ran into a bug where I was getting the wrong data printed out when I checked a value. After looking into it for like 15 minutes, I finally figured out that I had accidentally passed a stack pointer to a function that I wrote expecting a heap pointer. When the function went out of scope the data was garbage, but there was no crash and no compiler error. The borrow checker would have helpfully stopped me in my tracks there and saved that 15 minutes of debugging. The fact that it's hard to implement your own efficient linked list or vector type has never been a problem for me really, especially not in comparison to the gains of not always having to keep ownership and lifetimes of pointers in my own head or in documentation that may go stale. I can't express enough how helpful that is to my programming experience. C puts the burden of pointer lifetimes and ownership entirely on the developer. C++ makes that a bit better with the smart pointers at least, but those have some rules that aren't enforced by the compiler but instead by convention.
Basically I find the phrase "fighting the borrow checker" to be shorthand for "I can't write C or C++ in Rust and I want to". They're not the same language and the constructs are different
That was not the only aspect, but yes, I mentioned that.
I don't dislike Rust. I find it pretty cool. However, I disagree with the blanket statement "C++ isn't memory safe". C++ provides the tools for writing memory-safe code, but it does not enforce it by default. That’s a design choice: favoring flexibility over strict enforcement.
Yes, you can make mistakes that lead to memory issues. But that's not a problem with the language itself; it with how it's used. Stupid example: if you write code, which divides by zero at some point and you don't make sure to check that, this is not the language's fault, but your own.
Of course a language can accomodate for stuff like that and lift some of that burden from the user. Surely there are plenty of use cases and user groups for that. And that's totally okay. Rust was designed with memory safety in mind to prevent common errors that occur to a lot of devs during the usage of C++, which is fair. But that doesn't make C++ less memory safe. It is intentionally open and flexible on purpose. There are various programming patterns and even functionality within the STL that help to prevent memory issues.
So in other words: C++ is a tool, just like Rust. If you don't know how to use the tool, that's not the tool's fault.
You can always implement your own smart pointers. Besides that: which conventions do you mean?
Nah, although it has its persk, I just think that it also imposes a rigid framework that sometimes forces you into cumbersome workarounds. With C++, you retain full control over memory management and can choose the best tool for the job. You're not boxed into a strict ownership model that may force refactoring or add extra layers of abstraction. Instead, you have a mature ecosystem with decades of evolution that lets you balance safety and control based on context. Sure, mistakes can happen, but with proper practices and modern C++ features you can achieve a level of safety that meets most needs without sacrificing the expressiveness and efficiency you might require in complex systems.
This is such a weird take. C++ isn't memory safe. The blanket statement is... true. You say as much in the second sentence.
You have full control in Rust too, at least to the same extent as C++. Rust isn't memory safe either. Rust is just the opposite of C++ in the approach to safety: you opt in to being unsafe with the
unsafeconstruct instead of being unsafe by default. They're just different paradigms. I'd actually argue that you don't have full control in either language unless you opt in to it, modern C++ tries very hard to abstract away memory management. You can write an entire program without a singlenewormalloc, which is pretty great.This is just simply not true and is consistently proven incorrect every time an aspect of C++'s memory unsafety is exploited. I work in security and I still, in 2025, exploit memory corruption. The best developers money can buy still make mistakes with C and C++.
The way you have to interact with smart pointers for example:
Double free, but compiles without warning. It's convention to not use
unique_pointer's constructor, not enforced.Use after free. No compiler error or warning, it's convention to not maintain references to C++ string data, not enforced.
That's all fine, whatever, but these are conventions. We've shot ourselves in the foot a million times and come up with our own guard rails, but the developer needs to know all of them to not make the mistake.
I suppose we need to make definitions clearer. C++ is memory safe in the sense that you can write memory safe code. It doesn't enforce memory safety though. But not doing that is not the language's fault. If someone jumps with a bike from a flying airplane, it's not the bike's fault that they will not land safely. It's the misuse of the bike.
I'd argue those weren't the best developers then. However, I don't want to get ridiculous. I see that there are problems in the common use of C++. Although I can't share that from my experience due to usually proper usage, thorough testing use of additional tools, there is surely a need for aiding C++ devs with writing safe code. I know of the corresponding security concerns as well as probably everyone else in the C++ community.
There are proposals to improve on that. Some of those might already come with C++26. Stroustrup's favourite are Profiles to provide and enforce further guarantees, while others propsed an extension like Safe C++. Whereever the future will take us with C++, I'm confident that this issue will be sufficiently solved one day.
There was a time when C++ wasn't even designed for multi-processor systems, lol. That was redesigned pretty late. Much has changed and it will continue to improve as C++ continues to mature.
Edit: Just saw your convention examples after I've sent my reply. Idk why it wasn't displayed before.
Regarding the double free: It's clear from the documentation that this returns a raw pointer.
Regarding the use after free:
I really don't want to sound arrogant as this is a simple example of course, but that is such an obvious mistake and looks like a topic which is covered in C++ beginner classes. To me, this is almost on the same level as dividing by zero and wondering about resulting bugs.
Yes. Not every language is as user-friendly as python. With more flexibility come more risks but also more rewards if you've mastered it. It depends on what you want to do and how much you're willing to invest. I would at least expect a professional dev to rtfm. Which itself is apparently already a problem. But, in the end of the day we want to use tools, which are effective and easy to use. So sure, point taken. I refer to the section before my edit regarding developments upon improving such aspects in C++.
saying that C++ is memory safe because it's possible to use it in a memory safe manner is like saying jumping out of a plane with the bike is safe, because it's possible to safely land (with a parachute and a lot of training).
you always repeat that C++ is memory safe because its possible, and that "misuse" is "not its fault".
first, you are quite simply redefining what does memory safety mean. you basically say bombs are safe because they can be safely defused with the expertise.
second, do you really need to misuse it to get unsafe code? it does not warn anywhere. not in the instructions, not in the compiler output.
third, its no one's "fault" that c++ is not memory safe. That's not a fault of c++. like its not a fault of factories that you have to wear safery gear when working inside because otherwise you may get injured more severely. this is just a property of C++, not a judgement
oh no, my suspension was correct, you are really thinking that you are the perfect coder who jever makes any mistakes. It does not make sense to argue with you
The definition of "a memory safe programming language" is not in debate at all in the programming community. I have no idea why you're trying to change it.
This is incredibly arrogant, and, tbh, ignorant.
You missed the point of the examples: those aren't necessarily "easy mistakes" to make and of course a UAF is easy to spot in a 4 line program, the point is that there is no language construct in place to protect from these trivial memory safety issues. With respect to the "obviousness" of the
std::stringmistake, if you instead consider an opaque interface that requires aconst char*as an input, you have no idea if it is going to try to reference of that pointer or not past the lifetime of thestd::string. If you can't see past the simplicity of an example to the bigger picture that's not on me.sure, maybe, but performance doesn't matter for deciding if a language is memory-safe or not. And C++ isn't memory-safe by any commonly used interpretation of that word.
You may of course decide that the downsides of memory-safety aren't worth it for your use-case, that is a separate issue
I think it boils down, how we define "memory safe". C++ is perfectly memory safe, if you know what you're doing. A lot of people don't. Which is why Rust was born. that doesn't make C++ a memory-unsafe language. It just demands more responsibility from the user. A design philosophy that comes with a lot more flexibility than Rust can offer.
Which is fine. Both languages have their perks. But saying C++ isn't memory safe, while Rust is, is in my opinion just plainly wrong. Besides, with "unsafe" Rust inherently already the door for memory issues.
Modern C++ practises and dev patterns can handle most memory issues in C++ pretty easily. Consider smart pointers for example, or RAII.
It's not the language's fault if it is used wrong.
https://en.m.wikipedia.org/wiki/Memory_safety
https://www.memorysafety.org/docs/memory-safety/
https://media.defense.gov/2022/Nov/10/2003112742/-1/-1/0/CSI_SOFTWARE_MEMORY_SAFETY.PDF
https://www.cisa.gov/news-events/news/urgent-need-memory-safety-software-products
why do you want to redefine what the term means? why does it hurt to admit that C++ is not memory safe? It's not about your weakness.
Which language would you say is not memory safe then? Is there any serious language out there where you should expect memory issues if you don't make any mistakes?
If the standard is "you know what you're doing and never make mistakes", then all languages are memory safe. All you're doing is arguing against memory safety as a concept by redefining the term in such a way that it becomes meaningless.
Every source I've seen has shown rust and c++ to be very similar in terms of performance.
It's not just about runtime performance, but also about coding flexibility, and for example also reduction of boilerplate.
Ah yes, I love how C++ is has so little boilerplate. Sometimes I can even write several statements in a row without any!
The good news is that the browser comes from Serenity OS which means it probably is lightweight and well written.