Slashdot Mirror

I think this license is based on a flawed premise.

The only requirement of this license is that the license of any source code covered by this license must not be modified. This license has no requirements about what license you choose for any other code you use alongside the code you receive under this license. Therefore you may use it alongside public domain and BSD licensed code and compile all of the code into a single program, but you may not include any GNU GPL code because the GNU GPL requires that you relicense any code which is compiled into the same program (which it considers to be a derivitive work) under the GNU GPL, which is the only thing that the Antiviral License does not give you permission to do.
The Antiviral License

AFAIK, the BSD licenses, like the GPL licenses (and copyright licenses generally) do require that derived works be bound by their terms. In the case of the 3-clause BSD license, these are: retention of the license in derived sources and binaries (1 clause each) and no use of contributors' names to promote derived works without permission.

Notable conditions of the GPL licenses are: provision of source code (in GPL2 section 3 / GPL3 section 6) and no further restrictions beyond the GPL (in GPL2 section 6 / GPL3 section 10). I expect a license could made be compatible with BSD-like licenses and incompatible with GPL-like ones by disallowing one or both of these conditions on derived works. In particular, the latter one may fit what the author was trying to achieve.

As it is, the requirement "the license of any source code covered by this license must not be modified" sounds to me much like the "no further restrictions" clause of the GPL that I think the author was trying to avoid, while "no requirements about what license you choose for any other code you use alongside" seems to say the opposite. I am not a lawyer, but I suspect this license may either disallow use with any other licenses, or do nothing at all.

The Antiviral License

What, why is it bullshit? It is what BSD license allows you to do. Anyone can stripmine BSD code and not contribute anything back. Take care when thinking of BSD licenses!

Indeed. That's why I created my own license: The Antiviral License

If you don't want to have your code relicensed under different licenses, use a Copyleft license. If you want to have your code relicensed under different licenses, stop complaining when somebody actually does exactly that.

Actually, I'm not sure they want their code relicensed. Indeed, the BSD license doesn't grant you permission to do so. Theoretically the only reason it works is because the GPL only requires that the code be released under the GPL license but it doesn't require that the original license disappear, it simply demands that the original license can only invoke certain restrictions, like the attribution requirements present in many BSD licenses.

I solved the problem for myself by creating my own license which forbids relicensing but otherwise has no requirements whatsoever. BSD projects can use my code simply by keeping my code under my license and their code under whatever license they choose, as there's nothing about copyright law that requires all of the code in a project to be released under only one license. GPL projects, however, cannot use my code, because the GPL requires all code in a project to be GPL code, but the license of my code cannot be changed. It's really quite amusing since my license isn't specifically GPL-incompatible, but rather, it's the GPL's own viral provisions that create the incompatibility. If they ever create a non-viral GPL it'll automatically be compatible with my license, and if there are any other viral licenses I don't know about, they're automatically incompatible with my license.

The GPL doesn't mean that if you include a GPL library, you need to open source your whole project.

Have you actually read the GPL? It actually says as much. The LGPL is slightly more forgiving, in that it's OK to not GPL your whole project as long as it's possible to recompile the library you use and use the modified library with your program. (in other words, you can't statically include)

I'm all too familiar with this shit, due to writing a free but not open source game. There are things I wouldn't mind including, like cracklib to tell people how strong their passwords are, but I can't because that would mean that I'd have a non-statically included library, which takes a game that you can just download and run and turns it into something you can't run if you have the wrong version of the library. (I can't statically include it because that would violate the LGPL.) ...and the really sad thing is that, while researching the license for cracklib, I find they changed it from GPL to LGPL because they thought that doing so would allow anyone to use it, and they wanted it to be used as widely as possible. Unfortunately, like you, they were apparently ignorant of how the GPL actually works.

The GPL absolutely is viral. Take, for example, the GNU's comments on the Microsoft Public License: "This is a free software license; it has a copyleft that is not strong, but incompatible with the GNU GPL. We urge you not to use the Ms-PL for this reason." Why is it incompatible? Because it requires that code released under the license remain under the license. Thus, you can't change the license to GPL, and so it is GPL-incompatible.

Unfortunately, though, a lot of people are like you and don't realize what they're doing when they choose the GPL license. They just like open source and all they know is that the GPL is the open source license, so they choose it. It's disgusting enough that I created my own license, the Antiviral License, since, after running into so much code that I can't use in my closed-source projects, the last thing I want is for the code that I do release to end up being relicensed under the license that has prevented me from using so much other code, and thus, essentially promoting that license. A lot of GPL code starts out as public domain or BSD code and just gets relicensed by someone who likes the GPL. (I found that to be the case when looking for MD5 code. The code in the GPL utilities prominently displays the GPL license, and no mention of where the code came from, even though it's just some public domain code wrapped up in an executable with some command line options. It was particularly amusing since the public domain code in question was largely a copy of the code in the RFC which was labeled "all rights reserved." Anyway, here's the code I wrote, which is AFAIK the only actually free MD5 code in existence.)

The GPL doesn't mean that if you include a GPL library, you need to open source your whole project.

Have you actually read the GPL? It actually says as much. The LGPL is slightly more forgiving, in that it's OK to not GPL your whole project as long as it's possible to recompile the library you use and use the modified library with your program. (in other words, you can't statically include)

I'm all too familiar with this shit, due to writing a free but not open source game. There are things I wouldn't mind including, like cracklib to tell people how strong their passwords are, but I can't because that would mean that I'd have a non-statically included library, which takes a game that you can just download and run and turns it into something you can't run if you have the wrong version of the library. (I can't statically include it because that would violate the LGPL.) ...and the really sad thing is that, while researching the license for cracklib, I find they changed it from GPL to LGPL because they thought that doing so would allow anyone to use it, and they wanted it to be used as widely as possible. Unfortunately, like you, they were apparently ignorant of how the GPL actually works.

The GPL absolutely is viral. Take, for example, the GNU's comments on the Microsoft Public License: "This is a free software license; it has a copyleft that is not strong, but incompatible with the GNU GPL. We urge you not to use the Ms-PL for this reason." Why is it incompatible? Because it requires that code released under the license remain under the license. Thus, you can't change the license to GPL, and so it is GPL-incompatible.

Unfortunately, though, a lot of people are like you and don't realize what they're doing when they choose the GPL license. They just like open source and all they know is that the GPL is the open source license, so they choose it. It's disgusting enough that I created my own license, the Antiviral License, since, after running into so much code that I can't use in my closed-source projects, the last thing I want is for the code that I do release to end up being relicensed under the license that has prevented me from using so much other code, and thus, essentially promoting that license. A lot of GPL code starts out as public domain or BSD code and just gets relicensed by someone who likes the GPL. (I found that to be the case when looking for MD5 code. The code in the GPL utilities prominently displays the GPL license, and no mention of where the code came from, even though it's just some public domain code wrapped up in an executable with some command line options. It was particularly amusing since the public domain code in question was largely a copy of the code in the RFC which was labeled "all rights reserved." Anyway, here's the code I wrote, which is AFAIK the only actually free MD5 code in existence.)

There's also the antiviral license for those of us who almost don't care what people do with our code, the exception being that we don't want our code being used to promote the GNU GPL.

It's probably better to use your card.

A few years ago I ordered some stuff from sciencelab.com which, despite looking like a legitimate online shopping web site, is actually a scam. In the end, getting my money back was fairly easy since all I had to do was go to my bank and file a charge back.

If I had paid via PayPal, I'm not sure the resolution would have been so easy. The credit card companies are actually very consumer-friendly when it comes to things like this, to the point that they're borderline merchant-hostile. ...and for good reason, since they get like 3% of every transaction, the last thing they want is for people to be afraid to use their cards.

You're not kidding. I recently discovered a bug in glibc that causes cos() to return values ridiculously outside the range of -1 to +1 when used along with fesetround() on 64-bit systems. After submitting the bug report (and, indeed, they posted my email address online) someone posts a link to an older bug report, from five years earlier, about a similar issue with exp() and cosh(). The bug report ends with something like "well, I fixed it for exp(), cosh() and sinh(). If any other functions have a similar issue, someone should file a separate bug report."

The bug had been opened five years before it was closed. ...and I'm not sure they even fixed it for cos(), nor do I know if they're going to because I can't find the glibc bug tracker anymore. (how I found it the first time I have no idea) Lesson learned: Don't expect glibc to know how to do math. So I just changed the code so it no longer used fesetround().

Sadly, I was only using it in order to get GCC to stop using glibc and use my FPU directly instead, as glibc's math is slow, but unfortunately the same tricks don't work on 64-bit systems, where glibc seems to always be used. The result is that simply by using the tricks listed in my blog post and recompiling for 32-bit, your math code runs twice as fast as it does when compiled for 64-bit. However, the same tricks cause the math functions to return wildly incorrect results when compiled for 64-bit.

...or, at least, it isn't enough that you'll even notice.

I've been working on a free game for a while. Everything it requires is inside the executable. The download is still just over 1 MB. It's small enough that, when trying to get people to try out the game for me, I have issues with people assuming it must be some sort of trojan simply because of its incredibly small size.

Originally I was distributing it like most software, with an executable accompanied by many other files, but this just created issues of people copying the executable but not the graphics files, or copying things but putting them in the wrong directory (which is quite amazing considering that all anyone had to do was extract the ZIP file and run the executable from where it was extracted to). So I included the files in the executable, which brought it up to 10 MB. Later I made it so that most of the graphics come from the server and are cached locally, so that different servers can have different textures, and so now it's only 1 MB.

Also, until a week ago, it was using a dynamically linked version of GLFW for the Linux version. However, I began hearing reports of people not having GLFW available, so I included the necessary apt-get command on the web page so that people would know how to install it. ...but even then, I heard from several people (which probably means everyone who used the Linux version, given that the game isn't all that popular) that they still couldn't use it because when they used that command on their 64-bit system, it would install the 64-bit version of the library, but my executable is 32-bit.

I suppose I could have installed a 64-bit system somewhere, but honestly, every time I install Linux I have to go through hell figuring out how to make it stop asking for my password every three minutes, as well as changing numerous other idiotic default settings. ...and also about 50% of the time the system ends up being unusable anyway and I have to install something else. Thus I've learned not to install new versions of Linux, even if I'm already aware of two bugs in the two and a half year old kernel that the current version of Linux Mint I'm using refuses to upgrade to anything newer. (vm86 mode is broken, and there's a thread locking issue that stalls all threads in an application until you open another terminal and type "for i in 1 2 3 4; do cat /dev/zero > /dev/null & done; sleep 0.1; killall cat")

So instead I just statically linked GLFW as well. I'm sure it added something to the size of the executable, but at present, 25% of the executable is a single PNG image used for the player avatar. While 1 MB may seems small for executables these days, there was a time when our whole computers ran in a single MB. Code simply doesn't require that much memory. When people complain of some software's memory usage, it isn't using all that memory due to a bloated code base, it's using it to store data (or memory leaks). To put it into perspective, the RGB data of a 1920x1080 display requires 6 MB of memory to store -- the entire executable for my game will fit into that multiple times. Thus, the memory saved by dynamically linking is inconsequential.

There are still things that aren't statically linked, like X11 libraries and OpenGL, but I suspect that statically linking those would cause more problems than would be solved. After all, if someone doesn't have X11 or OpenGL libraries, they probably don't have X11 or OpenGL. (I'd also have to find their various licenses to see if I'm even allowed to statically link -- LGPL won't allow you to statically link closed-source applications, despite its reputation of being nearly public domain, and so it is useless for closed-source software.)

As for the topic of this article, I also realize my game desperately needs an instal

I once made something similar, by attaching my telephone line to my sound card input and decoding the Caller ID information in software.

http://www.ecstaticlyrics.com/electronics/telephone/CallerID/

Rather than play the three tones, however, I simply attached a relay to my parallel port so that the computer could pick up and then hang up the line.

That actually makes them stop calling as well. I guess they're smart enough to realize they're just wasting their time when they get hung up on every time, but not smart enough to realize they're wasting their time when you've ignored the previous hundred messages they've left on your answering machine.

You can also combine it with a phone that you can configure not to ring until it has Caller ID information (by setting different rings for different callers, and thus getting no ring at first since it doesn't have the Caller ID info yet) and you won't even hear the phone ring when the morons call.

I should probably post this anonymously, to avoid all the bad karma... ...but fuck it. Getting bad karma for this would just make me feel good as I'd know I've forced some people to think about the issue.

I agree entirely with what you've said. In fact, I wrote my own open source license, The Antiviral License. The section "Lack of Silly Distinctions" is especially relevant to this discussion.

I'd thought about writing such a license for quite some time, but finally decided to do it after needing a function to calculate MD5 hashes for a Minecraft classic server I was working on. I didn't specifically need a non-GPL function, as I had no intention of distributing the code, but I like to leave my options open. ...but every freely available implementation I could find was GPL.

So I set about writing my own from the reference documentation, which I assumed would be easy since I'd done the same for SHA1 and following the reference documentation was easy. I found that the documentation for MD5 provided example code, but its ambiguous licensing terms rendered it useless. (I forget exactly what, but it's something stupid like mixing statements of "public domain" and "all rights reserved.") The documentation also left a lot to be desired when it comes to endian issues. It explicitly says to use big endian for this and little endian for that, then says nothing at all about a couple of other things, and given the nature of the algorithm it isn't something you can just figure out by seeing where the math goes wrong. If it doesn't give you the right answer, the answer you do get gives you no clue whatsoever about where you went wrong.

So after trying random combinations of endianness for a while, I give up and decide to consult the reference implementation to figure out the correct endianness. However, the code is blatantly unreadable, and after trying to understand it for an hour, I'm no closer to figuring out the answer to my simple question about the endianness of one part of the process.

So I look at the code for the GPL md5sum program. Interestingly, it strongly resembles the reference implementation's code, but claims to be a copy of someone else's implementation which is public domain. So I find that person's code, and he freely admits to copying the code from the reference implementation, claiming that doing so is OK since it's public domain. (...and it might be, but it might not be. Like I said, the licensing terms are ambiguous.)

Indeed, every implementation of the hash algorithm I could find appeared to be a derivative of the code in the documentation. ...and, like I said, it's pretty much all picked up the GPL licensing terms for some fucking reason, turning it into code that I can't use. Eventually I simply had to resort to making random changes until finally the code started spitting out the correct answers. The correct endianness was obvious in retrospect, which probably explains why it wasn't documented.

So, while I was planning to release my code as public domain, as I initially thought that attaching any license to such simple code was dumb, I eventually realized the GPL people are being every bit as dumb every day, and it's time people started doing something about it. So I decided to use the license for anything I release. Insisting that people not use my small little functions when they choose to spread the GPL virus is certainly no worse than insisting that I use the GPL just because I use one small little function in what is otherwise mostly my own work.

The MD5 code is available here if anyone cares. Also some SHA1 code and some FFT code there. IIRC, FFT code is another area where everything is infected with the GPL, which is unfortunate as the algorithm itself, while not anything particularly difficult, seems to lack

I should probably post this anonymously, to avoid all the bad karma... ...but fuck it. Getting bad karma for this would just make me feel good as I'd know I've forced some people to think about the issue.

I agree entirely with what you've said. In fact, I wrote my own open source license, The Antiviral License. The section "Lack of Silly Distinctions" is especially relevant to this discussion.

I'd thought about writing such a license for quite some time, but finally decided to do it after needing a function to calculate MD5 hashes for a Minecraft classic server I was working on. I didn't specifically need a non-GPL function, as I had no intention of distributing the code, but I like to leave my options open. ...but every freely available implementation I could find was GPL.

So I set about writing my own from the reference documentation, which I assumed would be easy since I'd done the same for SHA1 and following the reference documentation was easy. I found that the documentation for MD5 provided example code, but its ambiguous licensing terms rendered it useless. (I forget exactly what, but it's something stupid like mixing statements of "public domain" and "all rights reserved.") The documentation also left a lot to be desired when it comes to endian issues. It explicitly says to use big endian for this and little endian for that, then says nothing at all about a couple of other things, and given the nature of the algorithm it isn't something you can just figure out by seeing where the math goes wrong. If it doesn't give you the right answer, the answer you do get gives you no clue whatsoever about where you went wrong.

So after trying random combinations of endianness for a while, I give up and decide to consult the reference implementation to figure out the correct endianness. However, the code is blatantly unreadable, and after trying to understand it for an hour, I'm no closer to figuring out the answer to my simple question about the endianness of one part of the process.

So I look at the code for the GPL md5sum program. Interestingly, it strongly resembles the reference implementation's code, but claims to be a copy of someone else's implementation which is public domain. So I find that person's code, and he freely admits to copying the code from the reference implementation, claiming that doing so is OK since it's public domain. (...and it might be, but it might not be. Like I said, the licensing terms are ambiguous.)

Indeed, every implementation of the hash algorithm I could find appeared to be a derivative of the code in the documentation. ...and, like I said, it's pretty much all picked up the GPL licensing terms for some fucking reason, turning it into code that I can't use. Eventually I simply had to resort to making random changes until finally the code started spitting out the correct answers. The correct endianness was obvious in retrospect, which probably explains why it wasn't documented.

So, while I was planning to release my code as public domain, as I initially thought that attaching any license to such simple code was dumb, I eventually realized the GPL people are being every bit as dumb every day, and it's time people started doing something about it. So I decided to use the license for anything I release. Insisting that people not use my small little functions when they choose to spread the GPL virus is certainly no worse than insisting that I use the GPL just because I use one small little function in what is otherwise mostly my own work.

The MD5 code is available here if anyone cares. Also some SHA1 code and some FFT code there. IIRC, FFT code is another area where everything is infected with the GPL, which is unfortunate as the algorithm itself, while not anything particularly difficult, seems to lack