"If however for legal reasons a licence is required, the license of your choice will be granted."
Very well, I want an exclusive license, meaning I'm the only person who can use this software. Also perpetual, of course, so the license never expires. And don't forget to indemnify me. But don't bother indemnifying yourself, so I can sue you if the software doesn't do everything I ever dreamed. And...
(I'm being sarcastic here. My point is that you can't get away with not licensing your free software, or saying the equivalent of "I don't care." It's not like there's a dearth of free licenses to choose from.)
If you really don't care about the license, just use MIT. It has the best combination of simplicity, compatibility with every other license, and it's already known and used in just about every collection of any sizeable amount of free or proprietary software.
Trying to go even further by using a weird, probably not legally enforceable declaration like this one, or other oddball things like public domain dedications, the Unlicense, the WTFPL, or CC0 is just likely to lead to more confusion, more problems with legal ambiguities in different jurisdictions, simply more time spent reading and evaluating the licenses to make sure there's nothing hidden or that it does have legal meaning in your jurisdiction, etc.
Yes, there are a few prominent examples of public domain dedication that are widely used, like SQLite. They make it work out by actually having all contributors sign an affidavit, and additionally charging a fee for people who really do want or need a license rather than the public domain dedication. Thus, being public domain is actually more work and more friction for the project than if everyone just licensed their contributions under a permissive license like MIT.
Plus, of course, 'public domain' is a very fuzzy concept and in some countries either doesn't exist or else exists in a very different form to the US. It's a legal minefield both the the producer and the consumer; way, way better to ignore it completely and use an OSI license.
(Apropos of nothing, I generally prefer the BSD-2 clause license to the MIT one because I think it's clearer and easier to understand, but they're fundamentally equivalent.)
I don't know about the specific intentions of the author, but I also refuse to put an explicit license on my code, because I firmly believe that code cannot be owned, sold or licensed anymore than the Pythagorean theorem can.
In that sense, I consider the refusal to put a bunch of legalese nonsense on/near my code a form of protest against the current copyright laws.
I'm here to write code and I don't want to put a license on my work just to appease some lawyers, as it lends credibility to a system that I reject on principle.
Doing it this way only presents a problem for people and companies who subscribe to the view that copyright is indeed a real thing.
> So, you accept potential legal hassle for you and the users of your software in order to "protest against the current copyright laws"?
Yes.
> Exactly. So why not just add a brief MIT license [1] to your code, painlessly clarifying your legal stance?
Because that does not clarify my legal stance at all. My legal stance is that code does/can/should not have a license and that no license is necessary to use any code. I feel like adding a license (even a permissive one) undermines this very idea.
The only people who insist on a license are exactly the people that this form of protest is meant to oppose.
>> My legal stance is that code does/can/should not have a license and that no license is necessary to use any code.
Is this an aspirational stance?
Because at the moment that's not what the law says (in any country I know of) and simple licenses like the MIT are probably the easiest way to legally say that you're allowing any use the recipient likes.
Actually something with strong copyleft semantics might actually be more appropriate than MIT in this case (if we're already willing to legitimize the copyright system by having a license, which is necessary).
If the argument is that everyone should be free to use whatever code however they want, then MIT lets delivers on the "however", but not the "whatever". GPL slightly limits the "however", but delivers on some of the "whatever" due to its viral nature.
While it could invite legal hassle for him and his users, if he thinks it's a fundamentally immoral thing then I can't fault him for not partaking and supporting the system by using a license, which does legitimize a system what he doesn't support.
I understand that there are practical problems with this approach, but I disagree with your conclusion: Adding a free license would express my principles within a framework that I fundamentally disagree with.
Your comparison with the freeman on the land / sovereign citizen line of thinking made me reflect on my own views on the subject, as these people are obviously nutjobs. However, I view my approach as a valid act of civil disobedience with no ill effects for anyone involved.
I don't see why it should be possible to own code.
I think the ownership of physical items is an intuitive concept that comes naturally from the scarcity of such items.
Code, algorithms or ideas on the other hand are not scarce and I think that the legal framework that makes it possible to own such immaterial things is immoral.
It seems like a reasonable approach to me; it shifts the burden of choosing the license to those who care about licensing. For example, if you work for a company with uptight lawyers you can just request Apache 2.0 and everybody's happy, rather than getting into arguments about public domain or WTFPL or some other stupid thing.
But does the author actually send messages granting those licenses, or is the user supposed to "will them into existence"? Because in the first case, the author just bought himself a whole lot of stupid work, and in the second, I don't see how anyone can be sure that will hold up in court.
No, the simplest thing to do would have been to use an actual non-restrictive OSI-approved license such as the standard MIT or Apache 2. CC0 is not OSI approved and is broken by design as it's a public domain dedication.
Well, the very simplest thing is just what he did. "Here guys, look at my code."
By doing so, he doesn't give up any (exclusive) rights he has as an author. It's not the best from a user's perspective, but it's the simplest and most conservative from an author's perspective (short of not releasing the code at all).
> [CC0] is broken by design as it's a public domain dedication.
Could you please expand on this a little bit ? CC0 is not only public domain dedication, it has terms for "when public domain dedication isn't possible, here's a list of things that are possible"
And using an existing widely known license has benefits, as in what is unlicense? This is the first time I hear from this, but I'm pretty used to deal with MIT licensed software.
It's very unfortunate that many geeks refuse to learn how licensing work (just like many users refuse to understand software).
Some licenses, like GPL/AGPL/LGPL, has been written by teams of lawyers to ensure protection for developers and users against lawsuits and patents.
Other licenses has been written by people with no legal background.
I understand why it is a problem for some, but I guess it can be somewhat principled stance. I mean, refusing to accept all this lawyerish hassle, unnatural language any official documents must be written in and so on. Because, obviously, people who just make things and do not participate in any kind of legal struggle do not care about all this stuff.
So I can understand why some people do act like that.
> My point is that you can't get away with not licensing your free software
djb did, before he released everything (or practically everything?) into the public domain. Look for my other comment thread to see the practical results of that.
Huh? djb had some sort of requirements, otherwise maintainers wouldn't have had the big tiff they did about his directory ideas (arguably better, but not in isolation). They couldn't package qmail up to use their distro-specific ways. Public domain fixed this, of course.
An earlier release had a note that the library could theoretically be ported to an architecture supporting LL/SC instead (load-linked/store-conditional), but this note seems to have been removed in later versions:
"Currently, liblfds has been ported only to platforms which provide a contigious double-word compare-and-swap (x86, x64 and ARM). It is entirely possible to port to a platform which instead provides load-link/conditional-store where non-load-linked loads can be performed inside the LL/SC pair (this is how ABA is solved using single word LL/SC) but this has not yet been done and it is not reasonable to ask a third party to undertake such a port until I've done it and documented it." --http://liblfds.org/documentation/mediawiki/index.php?title=r...
I could not readily find an answer to the question of how safe memory reclamation is handled. When elements are removed they are placed on a freelist, but there's no indication that the freelist is protected from prematurely deleting things at all. Perhaps the library is using DCAS somehow to ensure that deleted nodes are never dereferenced.
While reading the rather hilarious blog of his, I stumbled upon this possible explanation why that sentence is gone:
I'm going to ditch LL/SC implementations, in part because they're just too unreliable and in part because they prevent the library from being able to simply offer the caller a choice - "garbage collection or not?" which in turn removes a TON of stuff which otherwise has to be explained to the end user.
> "Note that the Alpha, IA64, MIPS, PowerPC and SPARC architectures do not provide contigious double-word compare-and-swap and as such, liblfds cannot be ported to those architectures."
Yet the front page claims that MIPS, PowerPC and SPARC are supported since version 7.0.0. How does that add up?
Hej. I am the author. I understand there are a range of simple and well understood licenses, such as the MIT license, which can be used. However, this implies the I agree with and abide by the notion of licensing as it exists today. This is not quite the case. I think property rights are correct, but I think freedom (all contracts must be voluntary and well-informed, except in self-defence) is correct, and so the situation as it stands, where other people decide the law regarding licensing and we have no choice but to adhere to it, this is unethical.
Be clear here - it is not so much the purpose of licensing which I disagree with (for it fairly closely implements property rights, which I profoundly agree with) but rather the method of implementation - there is a single set of law, decided by others, and we have to obey that law. This violates my idea of freedom.
So with regard to the licensing text on the library, I am attempting to meet the legal needs of users by giving them a carte blanche; they can know their (reasonable, sane) licensing needs will be met, and this I hope simply removes the issue as far as they are concerned, while honouring my ethical views.
It's sort of like not to check the values of parameters passed to a function, expecting than only reasonable, sane values will be provided, and no one will try to exploit the function.
This may be a fine assumption for a private function. But for a public interface, be it a function or a license, you have to program defensively.
If it's distributed without a license, it's illegal to redistribute the software, or to distribute modified copies. You can only distribute patch kits which can be applied to the original codebase, which everyone must acquire from the original developers.
> Once you've legally downloaded a program, you can compile it. You can run it. You can modify it. You can distribute your patches for other people to use.
> You are free to use this software in any way, for any purpose.
This is a license. It can't possibly be anything else. It's a simple, permissive license, but it's a license. Them claiming it isn't a license is nonsense.
> Is public domain a license, or is it no license?
Public domain means nobody owns the copyright to that work. Anyone can use it for any purpose whatsoever, because there's nobody to tell them they can't.
So, no, it's not a license. It's putting something in a category where a license wouldn't even make sense.
A public domain dedication is a statement intended to create that legal status, but may in legal effect be actually a form of gratuitous license and/or promise not to sue.
Just nitpicking here, but it's not illegal [1]. It's just not allowed. (At least where I live, YMMV...)
If I just drop a disc with some code on your desk without saying a word, it is not a crime for you to do something with it. Meaning the police won't begin investigating, the DA won't press charges against you.
You still have no OK from the author - "all rights reserved" so to speak. He can always come and sue you for infringement.
So saying "there is no license" leaves all the options open for the author, putting all the risk on the user of the code. Which is pretty nice for the author, I guess. If I didn't care about adoption of my programs beyond anonymous hobbyists, I'd probably do something similar. "Look at my code. I can't sue you if you use it secretly at home, but other than that I'l make no guarantees."
This guy goes a step further and says, if you want to use his code outside of your basement, and his word that he won't sue you is not good enough, then he'll say "OK, I grant you usage under <reasonable license>". Which I also like, because it makes explicit that a license is a kind of contract between two parties, not just a label that belongs to some code (as we frequently treat it simplifying).
----
[1] I realize this depends on your definition of illegal: Either A) everthing that is not forbidden is legal, or B) everything that is not explicitly allowed is illegal. Also, wheter you count just penal law or also civil law.
To answer various questions people have asked and to make one or two notes of my own;
1. The current version of the library contains a profound design flaw - it allocates memory. This is not viable in any way. The next release (which is very close to completion, but has been deferred for the last month due to a crisis project at work) does not. Regarding ConcurrencyKit, it is an excellent project, and I know Samy (I was involved in him getting his last job); he is an excellent programmer. He said to me about four years ago I needed to make a new release :-)
2. Regarding ABA and memory reclaimation. There is a comment noting that it is hard to find this information in the docs. I apologise. It is indeed not particularly explained. The docs were written with a view to a non-lock-free informed user wishing to use the API, so technical information regarding the internal implementation is lacking. In the current release ABA is resolved by the use of DCAS (limiting the library to ARM and Intel), and there is no memory reclaimation. In the next release, memory reclaimation has been implemented (removing the limit of ARM and Intel). I also implemented on ARM LL/SC versions of the algorithms, but these have been removed, because it's too hard to know which platforms they will or will not work on. ARM is still supported of course, but by using LL/SC to emulate CAS.
3. The blog, ah, yes. It's where I let off steam in the heat of frustration, which is off course not always pleasent - however, it's nice to vent. I am thinking of getting rid of it though, because it's not very professional.
4. The reason for a new github repo on each release, and the naming strategy, is to permit the concurrent use of multiple releases of the library. By allowing a new release to be used in parallel with old releases, existing code does not have to be modified. This minimizes work and risk. For minor releases and bug releases, where APIs do not change, a global search and replace will permit a full change to the new version.
5. Regarding frames. The site uses a number of third-party applications, such as a forum and a blog. These all emit HTML which assumes they are generating the whole page - they have a <HTML> tag in their output. Their output then has to exist in a frame. If I capture it and send it to a DIV, the DIV renders incorrectly.
Finally, please note the forum (which is fairly new) needs to be upgraded to reduce spam attacks (I've been too busy to do so). Currently I see hundreds of attempts each day, by robots, to generate accounts and so it is impractical to continually scan the lists of requests to find any real requests. The forum does now offer a captch for this, and as soon as I get time (one or two weeks) I will upgrade to this.
> The reason for a new github repo on each release, and the naming strategy, is to permit the concurrent use of multiple releases of the library. By allowing a new release to be used in parallel with old releases, existing code does not have to be modified. This minimizes work and risk. For minor releases and bug releases, where APIs do not change, a global search and replace will permit a full change to the new version.
You can just have multiple branches in a single github repo. :) That is what most people do.
I wanted to ask you if tags on a mian dev branch, wouldn't be enough, but I guess the reason for branches is the ability to port back some changes etc.?
The design of memory access behaviour is absolutely paramount in high performance software. Such software has a great deal of time and effort invested in the design to minimize memory accesses and, where they must occur, to make them cache friendly - for example, ensuring the buffer used for something being read from is allocated next to the buffer being used to write to, so they will both be covered by a single TLB lookup. This requires complete control over memory allocation. A library which not only makes its own allocations but even more staggeringly at run-time, is beyond the pale - absolutely unusable.
The next release performs no memory allocation; all allocation is performed by the user and passed into the function calls as pointers to those allocations.
Users can still of course perform run-time allocations if they wish, but now they can also fully pre-allocate, in ways which are memory access friendly given the work being performed by their software.
Hey, I just wanted to say -- I think your blog is great! Entertaining and a lot of it rings true. If you get rid of it, move it to some other place at least!
Funny thing I sort of judge projects now by being on github and looking at issues and PRs to see quality and health of the project -- I really would like to get a sense of the number of bugs and the issues people are running into while using it.
Thus an independently hosted project like this is thus hard to for me to objectively judge.
There isn't one, at least publicly. The author exports everything from SVN for each release, even though I pointed him towards git-svn for github two years ago.
What's painful is that the liblfds API is completely renamed for each release, even minor ones -- all functions prefixed by the version number [1]. According to the author, the intention is to facilitate concurrent use of different liblfds versions. That might be forgivable for major releases, but not minor ones, IMHO.
Overall, liblfds worked well (at least the queue, which was the only part I used) until version 6.0 was back-ported with the API rename and totally broke my code. After a couple emails with the author about this, I stopped using the library because I found the release strategy disagreeable enough to be a dead-end.
[1] There are ways to sanely achieve this effect with macro expansion of function names, and still maintain a consistent API with #define aliasing... the author didn't seem interested in supporting this.
Very well, I want an exclusive license, meaning I'm the only person who can use this software. Also perpetual, of course, so the license never expires. And don't forget to indemnify me. But don't bother indemnifying yourself, so I can sue you if the software doesn't do everything I ever dreamed. And...
(I'm being sarcastic here. My point is that you can't get away with not licensing your free software, or saying the equivalent of "I don't care." It's not like there's a dearth of free licenses to choose from.)