You must log in or # to comment.
Hey it could be worse. It could be the completely and utterly worthless MIT license.
The only difference is that BSD defends a bit more the owner rights. Either of them defends the software or its users.
Well how is MIT more worse than BSD? Both allows prorpietary right?
Should’ve written it in python, smh
This is such a non-issue
BSD is freer than GPL. Fight me.
BSD is freer for programmers (or frequently their corporate overlords), but not for people using the software.
That’s false. Derivative software that doesn’t use the BSD licence has no bearing on the BSD-licenced software itself. For example, Sony using FreeBSD for the PS3 operating system has zero impact on the freedom of a FreeBSD user. The GPL, on the other hand, directly infringes on the user’s freedom to fork and redistribute the software.
The GPL, on the other hand, directly infringes on the user’s freedom to fork and redistribute the software.
that’s plain bullshit. under GPL, you are free to fork it and redistribute it
You’re not unless you keep the licence.
The only “freedom” the GPL infringes on is the ability to take the freedom the code originally had away from an end-user.
That’s also false. The GPL doesn’t only restrict non-free licences, it restricts any licence change on the derivative work. If I fork a GPL project and want to redistribute my changes with a free licence such as MIT, the GPL will prevent it to protect itself. It’s an authoritarian licence that doesn’t respect your freedom.
I fail to see how the share-alike nature of the GPL is “authoritarian” and “doesn’t respect your freedom”.
It is built to guarantee the freedom of the user. It’s imperfect, as it has to work within the constraints of the copyright system, but it’s a hell of a lot better than licenses like MIT for propagating freedom to end users.
Here’s a real world example:
If I want to root my android device with KernelSU or build a custom ROM, I need to recompile the heavily customised kernel built by the vendor for my specific device. Because Linux (the kernel of android) is under the GPL, the manufacturer is compelled to give the user the same freedoms that were given to them, which means I can download the source code and do this.
If Android were based on, say, the FreeBSD kernel instead, this would be impossible. There would be very few, if any, android custom ROMs, because the vendor could, and would, withhold the modifications they made to the kernel.
You’re again assuming that the GPL only restricts non-free licences. This is not the case. If I add a feature to a piece of GPL software, I can’t use BSD on my new code even though the new code isn’t derivative work. Hell, if I write a completely independent piece of software that links to GPL software, my new software has to be GPL even though not a single line of GPL code was used. All of this also applies to free licences like BSD. The GPL doesn’t protect freedom, it protects itself.
You’re assuming that the GPL protecting freedom and protecting itself are mutually exclusive. They aren’t. Again, the GPL is written to ensure the code remains free forever.
Also, I’ve already pointed out the flawed nature of licenses like MIT and BSD, and if the GPL could be relicensed to them, it would provide a very easy way for proprietary developers to strip the freedom from the GPLed code when passing a derivative on to their users.
It is unfortunate that it cannot be relicensed to other copyleft licenses, as that would not pose such a problem, but without an explicit list of licenses it can be relicensed to I’m not sure that’s even legally possible under copyright.
Redistribution only becomes an issue if you try changing the license or selling it. GPL primarily protects against businesses profiting off of it. There are use cases for both licenses.
I won’t fight you because I agree. But a lot of people think it’s more free to have freedoms end when it comes to proprietary forks and such.
To me, that’s just one less freedom.
Copyleft protects the freedom of the user, regardless of who is the developer, I think that is way more important if what we want is to make software for humanity rather than pragmatic business choices.
It is a point of what you regard as real freedom, do you wish to eventually lock in your users or let who might fork/take over your project do that?It is one less freedom.
Yeah but GitHub defaults to GPL, so checkmate nerd 😎
The GitHub owned by Microsoft? That GitHub?
I don’t understand why everyone wants to jump ship to a whole new browser, when the governance of a browser is the real issue to solve regardless of which browser is supported. A good stewardship model has to be established by people of integrity, technical skill, and funding. From there forking making a hard fork of Firefox is way cheaper and easier than trying to invest in one that’s not even finished.
Having more than two browser engines out there would be nice for standardization reasons.
There are more than two browser engines. But it’s important to emphasize supporting Firefox’s engine because we’re already at threat of there being only one dominant engine.
Because they want to. What other reason would one need?
Okay, you do you. But it still doesn’t make sense to try to rally everyone else behind a whole new unfinished browser, when an otherwise very good one just needs new leadership.
i do not control mozilla leadership or their mishandling my data. the most influence i can exert as an individual is by not being a willing participant to their mischief. i’ll be happy to come back if the leadership changes and i get some guarantees.
Absolutely untrue. Firefox is entirely open-source. Forks of it already exist. The only thing that’s needed is for people who are willing and capable, to create a more dedicated stewardship model and the rest of us to get behind the hard fork they release. This is exactly the kind of thing software freedom is meant to allow us to do.
It is a debatable point which would be easier:
1 - get Ladybird to the point it is competitive
2 - establish a viable and popular alternative dev and governance infrastructure capable of stewarding and evolving Firefox
The fact that people want to try option one is far from crazy.
with mandatory male pronouns for users in the documentation.
(and no politics allowed!)
This whole situation was a concern for me too, but with Ladybird being spun off into its own not for profit, these kind of things are much less likely to occur again going forward. The project is a lot more focused now.
can I get some context for this, what is the reference to? I stopped caring about new browsers and now just use Firefox 🤷♀️
it’s about the ladybird browser. i edited my comment to add details.
mastoqueers
That was a good laugh! thanks for the explanation ❤️
That’s not controlled by Google…
It is also important to note that the license is still foss and GPL compatible. In the future they could made it GPL.
Every contributor needs to have signed a CLA in order for the license to be changed
Is it that difficult to implement a CopyLeft licence ? Well we do have Servo (A modular browser engine) in development & SeaMonkey is a thing too (Which is an entire internet-application suite)
It is not difficult. Not everybody agrees that it a desirable thing to do.
Not only C++ but also Swift, which just feels strange
Why build a new browser in C++ when safer and more modern languages are available?
Ladybird started as a component of the SerenityOS hobby project, which only allows C++. The choice of language was not so much a technical decision, but more one of personal convenience. Andreas was most comfortable with C++ when creating SerenityOS, and now we have almost half a million lines of modern C++ to maintain.
However, now that Ladybird has forked and become its own independent project, all constraints previously imposed by SerenityOS are no longer in effect.
We have evaluated a number of alternatives, and will begin incremental adoption of Swift as a successor language, once Swift version 6 is released.
c++ is adding memory safety features… it’s still modern and frequently updated
It’s not the C++ that I find strange hah
Swift is a pretty fully fledged systems language at this point … however, it’s far from tried and tested for use cases like this and cross platform support is still garbage, so still a pretty questionable choice.
that is actually really goofy, didn’t know about that
Everyone knows links2 is the best browser.
#links2gang
You misspelled curl. The keys are right next to each other so it’s understandable.
Comic review closed: please don’t advertise identity politics
Yess more pmv2q…x…?
Ladybird is run by a bigot. I wouldn’t touch it with a barge pole.
Can you elaborate ?
Is he the one constantly spewing hateful shit in the Issues on GitHub whenever people ask him to not use only “he” and “him” in the docs?
That dev definitely doesn’t seem like the best human around, but this is all around terrible to me. Calling the project “dehumanizing” and “vile” because of this is ridiculous. Are people really willing to have their browsing tracked and sold rather than using a browser that has an assumed gender in the documentation? Not saying that they shouldn’t use gender neutral language, but as the original issue said, it’s a minor nitpick, let’s be honest. It’s also something that’s representative of one dev as a person, not of the project as a browser. Additionally, it could be something as simple as the dev coming from a gendered language, where the word “user” itself is masculine, and doesn’t see it the same way as English speakers asking for neutral language.
Yeah that was the thing that alerted me.
Dammit, again? What did this developer do…
I’ve only tangentially picked up things about this but this is an example for it
(For some context, if you didn’t already know this, Ladybird originated from a SerenityOS component and the first reply is from the lead dev)
What are we reacting to here? The single comment from the actual dev saying that the project wanted to avoid politics? Or the actual hateful comment from some bystander?
Ladybird has split from SerenityOS and from that community. Hopefully the bystander has been left behind.
As for the actual project founder, if all he has ever said is that one statement, I am impressed with his level of restraint given how some have vilified him for it.
Oh… That’s… Disappointing. Firefox it is, then, for now.
It’s weird… It makes “business” sense, too. If you want people to use your stuff and you can choose to appeal to more people, why wouldn’t you? I think we’ve reached the stage of normalcy now where using “they” and “them” are not in itself something that would necessarily scare away right-wing users (given you want to keep appealing to that attractive market, too.)
Well, in that case, I hope it gets forked into a super gay version in the future lol
At least there’s other projects too…
This is the way 🌈
_They_dybird
mastoqueerz
Wow 😳
I cannot see who made that comment. Pretty sure it is not the dev who is getting crucified. I am not sure it is even anybody that contributed to SerenityOS or Ladybird.
I certainly do not see anybody from the project endorsing that language.
I mean, I read the comment on Lemmy. Should I now go around saying not to use Lemmy and using that quote as evidence for why?
was that nukeop? that Guy is a known asshole. He was also quoted Saying licenses don’t matter and threw a huge fucking hissy fit when someone forked his project and gave it a copyleft license because of making such a stupid statement. Unfortunately the website archiving the drama is down, and I could only find an archive if the first iteration of it (it had at least 2 more paragraphs after this) https://archive.is/UT9Xe
Let’s see how ladybird writes docs in the future. Will they assume the user is a man and shut down any corrections for being political?
As far as i know, the pronouns were fixed
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.)
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
What about safari? Doesn’t it still use webkit?
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 :)
How else are Chrome, Edge, Brave, Arc, Vivaldi and co getting away with building proprietary layers on top of a copyleft dependency?
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.)
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.
I’m not. But in my experience, using memory safe programming patterns, classes and possibly additional testing and analasys tools do the job quite well.
But yeah. I changed my mind about this memory-safety-property. The lack of enforcement really does make C++ inherently memory unsafe.
whether the software is memory safe depends on the expertise of the devs
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.
Yes. I stopped now. I was hinted towards the usual definition of memory safe languages at another point in this discussion.
Although it is perfectly possible to write memory safe code in C++, I agree that the lack of enforcement makes it inherently unsafe.
The good news is that the browser comes from Serenity OS which means it probably is lightweight and well written.
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.
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.
You’re right. Thanks for the links. Although I still think that C++ provides the tools to enable memory-safe programming, I guess the lack of enforcement makes it inherently memory-unsafe.
Point taken, I’ll stop saying that.
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?
No. I changed my mind just very recently throughout this discussion.
I agree now that the lack of enforcement of memory safe techniques in C++ makes it inherently memory-unsafe.
That doesn’t change the fact though that it’s possible to write memory safe code, if you know what you’re doing, use the right patterns, classes etc…
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!
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.
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.
You can always implement your own smart pointers. Besides that: which conventions do you mean?
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”.
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.
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
-
using the Linux / BSD situation as a benchmark ignores a lot of history. I would argue that the BSD lawsuit was the deciding factor.
-
the Linux project is not representative of a typical GPL code base. It rejected GPL3 and features a rather significant exception clause that deviates from GPL2.
Clang vs GCC is probably a better metric for the role of the license in viability and popularity. Or maybe Postgres vs MySQL.
Why has nothing GPL replaced Xorg or Mesa or now Wayland?
Why hasn’t the MIT or Apache license held Rust back from being so popular? Why would Ubuntu be moving away from GNU Coreutils (GPL) to uutils (MIT)? How did Pipewire (MiT) replace PulseAiudio (LGPL)? How did Docker or Kubernetes win (both Apache)? Actually, what non-Red Hat GPL software has dominated a category in the past 10 years?
If the GPL is the obvious reason for the popularity of Linux, why would RedoxOS choose MIT?
This is not an anti-GPL rant.
My point is that choosing the GPL (or not) does not correlate as obviously with project success as you make it sound. It is an opinion that would require a lot more evidence.
-
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
It’s the only operating system with that much market share to lose.
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
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
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.
I’m curious. Why do you believe the last statement to be true?
Did you paste the wrong link?
They have that under all their comments.
What is the problem with a BSD-license? I’m not familiar with the different open source licensing models and their problems.
It’s not really an issue for the end user. But it’s basically made for companies to take advantage of free hobbyist developers without needing to give anything back in return.
So if you’re the kind of person who runs to foss software to get away from corporate tech bull, having a license that benefits companies more than users just kinda feels scummy.
Remember the Minix operating system that runs on your processors ? It’s a proprietary spyware now because of BSD licencing
It’s not a viral copyleft license, so you’re free to use the source code without giving anything back.
This has pros and cons over something like GPL, but people like to circlejerk GPL and pretend it’s always the best option 100% of the time.
For situations where you have to sign an NDA and are unable to release source code (eg; console game dev), MIT and BSD licensed projects are a godsend.MIT/BSD also makes the most sense for small/minimal projects where GPL is likely overkill. A 100 line script does not need to be GPL’ed. A small static website does not need to be GPL’ed.
Apple, Sony, N*****do, Netflix all use BSD but they don’t contribute any code to the BSD project itself, because of the BSD allow other people/company to close source their code when using with BSD
Sony actually does contribute. https://christitus.com/sony-playstation-and-freebsd/
TBH, considering those corporations, most of that would be DRM stuff, and they can’t let that leak in any format. Others are drivers.
Basically, it allows you to steal all the code and use it in your closed-source programs, giving a green light for corporations to use open-source code without giving anything back.
GPL doesn’t allow that, forcing you to open-source anything that was produced using other GPL-licensed code. That’s, for example, why so much of Linux software is open-source - it commonly relies on various dependencies that are GPL-licensed, so there is no other legal option other than sharing the code as well.
It’s not “stealing”. It’s explicitly allowed. Using IP according to its licence is the opposite of stealing.
Ok, then call it “plagiarising”.
That is definitionally not plagiarising. It follows IP law, which is the opposite of plagiarism.
There’s more than a legal definition of plagiarism.
Plagiarism is when you sell the work of others as your own without attribution. There are bucketloads of examples of legal plagiarism.
I’m pretty sure that everything H. Bomberguy discussed in his plagiarism video was legal, for example.
No, actually, plagiarism is a legalistic term. If IP law did not exist, neither would plagiarism.
And if you give someone permission to use your IP, and they go ahead and use that permission, it is not plagiarism neither legally nor by any colloquial understanding of the term. That is what happens when someone uses BSD or MIT code in their proprietary software. It is explicitly allowed, by design, by intention.
without attribution
BSD/MIT also don’t allow you to not attribute the author of the BSD/MIT code, so that doesn’t even make sense. You are perhaps thinking of code released public domain, in which case, again, the author specifically chose that over BSD/MIT, and the main practical difference is not needing to give attribution, so that must be what the original author wanted.
I think your legalistic view of the world is quite limiting.
It’s not illegal to rephrase what someone wrote in a book and pass it off as your own work. You can’t “wown” a cultural analysis. It’s still plagiarism.
BSD license is the only thing that annoys me. Chrome not by google.
