I think it's just the GPL family of licenses that tend tend to cause most problems. I appreciate their intent, but the outcome often leaves a lot to be desired.
The GPL exists for the benefit of end users, not developers. It being a chore for developers who want to deny their users the software freedoms is a feature, not a bug.
They have the right to use the code, and they have the right to use improvements that someone else made, and they have the right to get someone to make improvements for them.
They also have the guarantee that the code licensed under the GPL, and all future enhancements to it, will remain free software. The same is not true of the MIT license's weak-copyleft.
As far as I know, all the (L)GPL does is make sure that if A releases some code under it, then B can't release a non-free enhancement without A's permission. A can still do whatever they want, including sell ownership to B.
Neither GPL nor MIT (or anything else) protects you against this.
(EDIT) scenario: I make a browser extension and release v1 under GPL, it becomes popular and I sell it to an adtech company. They can do whatever they want with v2.
By allowing them to benefit from the work of others who do. Directly or indirectly.
I’m not good at car maintenance but I would benefit from an environment where schematics are open and cars are easy to maintain by everyone: there would be more knowledge around it, more garages for me to choose from, etc.
Isn't the legal situation the opposite here? Car manufacturers don't release schematics because they believe in "free as in freedom". In fact any interfaces you as an end-user or an independent garage can use and schematics that are released such as the protocol for the diagnostic port, are open primarily because govermnents made laws saying so.
I'm most familiar with the "right to repair" situation with John Deere, which occasionally pops up on HN. The spirit of someone who releases something under GPL seems the opposite of that?
If you have ill intentions or maybe you're a corporation that wants to use someone else's work for free without contributing anything back, then yes, I can see how GPL licenses "tend to cause problems".
Why? What's your problem with them? They do exactly what they're supposed to do, to ensure that future derivatives of the source code have to be distributed under the same license and distribution respects fundamental freedoms.
I like to think about GPL as a kind of an artistic performance and an elaborate critique of the whole concept of copyright.
Like, "we don't like copyright, but since you insist on enforcing it and we can't do anything against it, we will invent a clever way to use your own rules against you".
That is not really the motivation behind GPL licenses. These licenses have been designed to ensure by legal means that anyone can learn from the source code of software, fix bugs on their own, and modify the software to their needs.
Wtf are these comments? A LGPL licensed project, guaranteed to be free and open source, being LLM-washed to a permissive license, and GPL is the problem here?
They are literally stealing from open source, but it's the original license that is the issue?
That whole clean room argument makes no sense. Project changed governance and was significantly refactored or reimplemented... I think the maintainers deserve to call it their own. Original-pre MIT release can stay LGPL.
I don't think this is a precedent either, plenty of projects changed licenses lol.
I keep kind mixing them up but the GPL licenses keep popping up as occasionally horror stories. Maybe the license is just poorly written for today's standards?
Ok since this is not really answered... Hypothetically, If I'm a maintainer of this project. I decided I hate the implementation, it's naive, horrible performance, weird edge cases. I'm wiser today than 3 years ago.
I rewrite it, my head full of my own, original, new ideas. The results turn out great. There's a few if and while loops that look the same, and some public interfaces stayed the same. But all the guts are brand new, shiny, my own.
You have all rights to the code that you wrote that is not "colored" by previous code. Aka "an original work"
But code that is any kind of derivative of code before it contains a complex mix of other peoples rights. It can be relicensed, but only if all authors large and small agree to the terms.
You have rights, but if it's a derivative, the original author might have rights too. If you made a substantial creative input, the original author can't copy your project without your permission, but neither can you copy theirs.
Hmm are we in a ship of Theseus/speciation area? Each individual step of refactoring would not cross the threshold but would a rewrite? Even if the end result was the same?
Let us also remember that certain architectural changes need to happen over a period of planned refractors. Nobody wants to read a 5000 line shotgun-blast looking diff
So effective, LGPL means you freely give all copyright for your work to the license holder? Even if the license holder has moved on from the project?
What if I decide to make a JS or Rust implementation of this project and use it as inspiration? Does that mean I'm no longer doing a "clean room" implementation and my project is contaminated by LGPL too?
If a copyright holder does not give you permission, you can't legally relicense. Even if they're dead.
If they're dead and their estate doesn't care, you might pirate it without getting sued, but any recipient of the new work would be just as liable as you are, and they'd know that, so I probably wouldn't risk it.
Governance change or refactoring don’t give you a right to relicense someone else’s work. It needs to be a whole new work, which you own the copyright to.
They didn't make them hard by design, I think, it's just the limitations of the current API and prioritisation. Dynamic queries are possible, just not trivial
Oh right, I know what you mean now. I was thinking more along the lines of the QueyBuilder API (and you can write extensions traits to make things more ergonomic). But yeah, some of their APIs work only/best with static strings.
There also sea-query, and sea-orm was already mentioned!
There's lots of things you could do. Imagine you're making a group chat bot (way more difficult than a 1-1 chat) where people can play social games by giving the LLM game rules. You can have an agent that only manages game state using natural language (controlled by the main LLM). You could have an agent dedicated to remembering important conversation, while not paying attention to chit-chatting
Just Google it. There's tons of research on this so I don't know why I need to provide a specific link when this is common knowledge.
But also here is something to think about: your body will produce more D3 than that by being in the sun for just several minutes. So if you consider such a low dose of D3 an overdose then you better steer clear of the sun!
> But also here is something to think about: your body will produce more D3 than that by being in the sun for just several minutes. So if you consider such a low dose of D3 an overdose then you better steer clear of the sun!
This is another superficial statement, that displays shallow-at-best understanding. Staying in the sun and producing via the skin, and intake via food are 2 separate pathways. You cannot just make wild assumptions about one of those pathways from stuff you know about the other pathway.
And actually: Yes, you shouldn't stay in the sun for too long without proper protection. Having the sun shine on your skin is not some inherently healthy thing. It too comes with acceptable dosage and overdose. Symptoms of overdose are commonly known as getting a sunburn.
You can find scientific papers on a lot of search engines, not only Google.
The problem with that is, that you still need to know how to interpret any results and statements within the supposedly scientific papers. If you are not a statistician, you might overlook methodology mistakes. If you are not an expert in the matter of the paper, you might not realize some side condition, that makes some statement or result of the paper irrelevant for your individual situation.
For what its worth, I had the same experience with Tailwind. I regularly see classes that don't have an meaningful outcome.
I don't think the problem is Tailwind or CSS (well, I guess Tailwind is CSS with extra steps but you get the idea) syntax (or any of the CSS preprocessors), but the fact that styling in browsers has accumulated a lot of cruft, and people who haven't "grown up" with it over the years don't fully understand it (I am more competent than most with it and there's still times I screw up).
One thing that's kinda nice about Tailwind is that it made copy-pasting components easier. So people can get something decent without fully understanding what's happening
I mean stuff like adding `display: block` on the parent and `flex: 1` on a child element. Clearly a copy-pasting leftover because someone or whatnot, but then you're debugging a layout issue and you're wondering "but why is this here"
I don't mind the dialogue, but if we're taking about the same author, some of the content gets diminished by the meandering waffling.
I realise it's a stylistic choice but there's been a few posts where I felt tired after reading their articles. And it also feels like one of those YouTube shorts sketches where one person pretends to be multiple people and it starts feeling a bit cheap/meh.
I think it would be fine if it they toned down on the interjections/interruptions
I think one of those pedagogical half-truths useful for onboarding people onto an idea across different languages or getting parts of a point across, and they cover some similar use-cases.
It's a bit like saying JavaScript's prototypes are classes even though they're technically not (even with the introduction of the `class` syntactic sugar), but for casual discussions it's probably fine to just say "JS class".
But to your point: I wouldn't really phrase the way the GP did; it makes it seem like they're on the same level of usefulness as a type class!
I think the barrier to entry with Rust is lower than C++. Like was way lower... And I've been writing C++ for way long than Rust, so I'm probably a bit biased
reply