Symphonious

You may remember a few days ago I argued against a comment regarding my GPL vs The World entry.

It’s just been pointed out to me that the “MJR” fellow is actually quite well known.

I had no idea….

Every so often, FARK comes up with something truly wierd. This is one of those times. A fish that reportedly wedges itself in your urethra. What really got me though, was a short, largely hidden quote towards the end:

There are no confirmed reports of deaths or penectomies–several cases of the latter are thought to have run afoul of piranha.

Because if there’s one thing worse than a Candirú up your urethra, it’s a piranha biting it off entirely.

In the comments to my last entry, MJR comments:

Interesting opinion, but harmed by some bugs in the basic ideas. For example, “open source” and “commercial” are not opposites, unless you have some particularly strange definition that you use.

At least for the GPL this is completely false. The GPL does not give you permission to sell the GPL’d software. The GPL does state:

You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.

This quite clearly doesn’t say: you may sell GPL software. Thus, GPL’d software is most definitely not commercial software even though it may come on a commercial CD. Section 4 then says:

4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

Making it really quite clear that selling the software itself is not allowed, just the physical act of transferring the copy. Besides this, the common usage of the terms open source software and commercial software are most definitely mutually exclusive and thus the intended meaning of the terms should have been clear to anyone who was actually making an attempt to follow the argument rather than just blindly disagreeing. MJR then goes on to say:

Anyway, I think the reason that ASL-1 fans have problems with GPL is because it prevents addition of further conditions and most ASL-1 fans seem to like adding their own “Your announcement must praise ME!” condition to the permission grant. Their position is a lot weaker than FreeBSD fans.

Personally, I fail to see a great moral difference between the ASF license requiring you to include a one line statement that you’ve used someone else’s work and the GPL’s requirement that you include the full text of the GPL. Kind of puts things in perspective when you consider it that way.

And finally:

Personally, I’m more concerned that people will misapply ASL-2.0 by claiming that something like “Ode to my goldfish” in the NOTICE file is an attribution notice. The patent termination stuff does seem close to the borderline, though.

I’m not quite sure how that’s a misapplication of the license. If the original author wants credit to go to his goldfish, what’s wrong with that? The requirements for the license are still clear and unambiguous - you have to include “Ode to my goldfish” in your about box (or similar location). You can put an explanation above it to say that the statement was required as part of using a particular piece of software and so on.

The patent termination stuff is something that could be argued over, but personally I take a very strong stance against software patents and particularly the abuse of the patent system, so I’m all for it. If I were to ignore practical issues, the license I’d use would require anyone who used by software to relinquish any software patents they hold. Reality however dictates a more conservative approach as it really isn’t reasonable to request actions beyond what’s required to protect the original authors and their wishes for the use of the software.

In closing I have to point out that I’m not a lawyer and this is not legal advice. My objections to being required to point that out because some people are stupid enough to take the unsolicited advice from someone they don’t know from a bar of soap is a rant for another day.

With the recent debacle over whether or not the ASF license is compatible with the GPL license, Leo Simmons discusses the arrogance of the FSF and concludes with:

So I might as well stick to the MIT license. But the arrogance of the FSF makes me feel very much like giving them the finger and just going with the ASL.

Personally I agree. I’ve never liked the GPL as a license, it’s just way too restrictive to be considered “free software”. It’s open software, but not truly free. The Free Software Foundation has redefined the term “free” to suit their purposes, but it’s hard to argue that truly free software is in the public domain. You can literally do anything you want with it without every having to worry about copyright law. The GPL however, uses copyright law specifically to restrict what you can do with the software. Yes, it’s less restrictive the what copyright law allows by default, but that doesn’t mean it’s not restrictive.

It particularly annoys me that the FSF feel the need to try and force everyone to use the GPL instead of picking the license that provides the terms they provide. Many people may want to see commercial software using their code - it helps to spread good ideas and opens up job opportunities for them. Personally I think it’s great when companies use code I’ve released, it’s not like I had plans to use the code to make a profit or I wouldn’t have open sourced it in the first place.

The other thing that gets me (as Leo pointed out) is that the GPL isn’t compatible with anything yet the FSF expects every other license to be compatible with it. The day I can use GPL code in my ASL licensed projects is the day I give a damn whether or not people can use my ASL code in GPL projects. In the mean time, everyone except those silly enough to use the GPL can quite happily use my code - in open source or commercial work.

Well I learnt something new today. All this time that I’ve been doing some extremely funky stuff with XSLT (and I do mean funky), I never actually had the idea of the context node quite right.

I discovered this because of a bug I ran into with our updating of XPath expressions that use position(). Essentially in the XML editor I’m developing, we pick out the XPath expressions in the XSLT used to lay out the data for editing so that as their input values change we can update the result like it was a spreadsheet. When the input values change we identify which XPath expressions need to be recalculated and rerun them (using Jaxen) by passing in the context node from the document we’ve been editing.

The trouble hit when we started using position() because it always evaluated to 0. As it turns out the position() function counts the position of the current node in the current context, not necessarily it’s position in it’s parent node. So where I’d been passing in a single node as the context, I should have been passing in a set of all the child nodes from the parent and pointing to the appropriate node in the list as the “current” one we’re processing. As it is, it’s still not actually implemented correctly because we always use the parent nodes children as the context but the actual context may have been different. For instance given the template:

<template match="item">
<value-of select="position()" />
</template>

The context is actually the list of child elements of the current context node whose name is “item”. It wouldn’t include any text nodes and it wouldn’t include any elements that weren’t “items”. So for the XML snippet:

<parent>
<item />
<other />
<item />
<other />
</parent>

The context would be the two item elements, but not the text nodes and not the other elements. Fortunately, for our purposes the approximation we’re using (all child elements, excluding text nodes) is good enough for what any of our users will need to do and significantly more accurate than anything the visual design accompanying our product will actually produce.

I’ll be interested to see if the testing guys pick up on it though.