Guest post by InfoWorld’s Rick Grehan takes an in-depth look at Opa, MLstate’s attempt to provide a single language for Web app development, and one of 10 cutting-edge programming languages that could shake up the future of IT. “With Opa, you write your Web application as though it were a single-tier program, and the compiler handles the knotty details of partitioning your program and deploying the resulting components to their proper domains. The compiler also builds the communication infrastructure among application components, and that infrastructure is invisibly managed by the runtime. The security weaknesses inherent in today’s Web applications are virtually eliminated.”
Not sure I would be keen on all layers of my application being tied into the one product. Everything seems to be closely coupled to the platform.
Even with ASP.NET Tech it is possible to layer the application and “swap” bits out.
I know, the FSF says it is a free license, but I think they are wrong, by their own definitions. I discussed this issue with Stallman when he visited my town and IMHO he didn’t provide a convincing argument to the contrary.
Look at freedom 0:
Well, if your purpose is to provide a web service, you are out of luck with the AGPL. You are not free to do it unless you release all your private changes, and any other program that connects to it. If there are conditions, then you are not free, period.
It comes down to who is the user of the software. If you run this software on your server, you are the user. Those who use your web service are users of your web service, not users of the software.
Of course you can say that they use it inderectly, but
the same can be said of the customers who buy bread from a baker who is using a database to keep track of sales. So, the concept of private, unreleased software would disappear. In the AGPL world there’s no privacy.
If you take a step back, the problem with proprietary licenses is that the user has the software in his hands, but he’s not allowed to share it, or even look at it too closely and build something too similar (a modified copy). With unreleased software this problem simply does not arise. So, there’s no loophole to plug here.
But wait, the GPL says you can’t release modified software binaries without the source. So it puts some restrictions on freedoms 2 and 3 (freedom to release copies). This apparent contradiction is solved by stating that source code is a precondition of freedom 1 (to inspect and study the program). I think this statetement is false, becase you can always reverse-engineer the binaries.
It’s also an unfortunate confusion of negative and possitive freedoms. For instance, to really understand the software, you don’t just need the source code, you also need some knowledge of programming. Should the distributor give you free lessons?
Despite all these caveats, the GPL in practice does what a free software license is supposed to do, which is promote an environment where legal restrictions don’t get in the way of people who want to use, inspect and modify software, and release their findings whenever they want, where every user has those freedoms, whether they are private individuals, nonprofits or companies.
In contrast, look at the conditions to use the AGPL-licensed Opa framework: according to the article, it’s free until you make one million dollars with your web service; then you have to pay. It doesn’t sound like free software at all.
First of all, let me state that I will capitalize the words Free and Freedom when talking about FSF, to differentiate the software license terminology from the general usage of free and freedom.
That’s the old war between the GPL and BSD licenses. I prefer to look at the meaning of Free as “something can not turned into un-Free”. Regarding AGPL, you can of course use it to provide a web service and you might even not need to release changes because you haven’t actually made them. And even if you made them, it might not even be a problem to release these changed if requested. I’ve successfully used AGPL software in the past, no problems there per se.
This has nothing to do with privacy. It’s software code, same as GPL, but plugging a so-called loophole. It’s mostly looking at the problem in a different light, really.
Actually no. The GPL says you must provide the source code when requested. It’s a subtle, but very profound difference.
No, you can’t always reverse engineer the binaries. It’s awfully hard and time consuming and sometimes it’s even illegal to do so.
You don’t need free lessons, you just need the tools to study the software, thus the source-code requirement.
I would agree with you, but I didn’t found that million dollar condition anywhere on Opa’s website or source code.
Thanks for your answer. I think this topic should be discussed in depth.
Fair enough. I like clarity.
I tend to use lower case unless there’s a real risk of confusion. For instance, if I say “freedom 0” it’s obviously FSF terminology.
When I speak of free-of-charge software I say “free of charge” or “gratis”.
Also, we must distinguish what the FSF declare to be Free from what can be called free according to the FSF definition. I mean, if the FSF says “this program is Free software” then it is, by definition, “officially FSF Free software”.
But just as it makes sense to say that Tolkien could have made a spelling mistake in some Elvish sentence, the FSF might in principle be wrong about a licence, if the concept of software freedom is to have any life of its own (and therefore any relevance). I can say that a piece of software is “free according to the FSF definition” even if it’s not “officially FSF free”. It may sound pedantic, but that’s another matter.
So where shall we put the capital “F”, in “officially FSF free” or in “free according to the FSF definition”?
I see a few problems with this definition.
First, there’s already a term for what you mean: copylefted.
Second, in a literal sense there’s no way to turn free software released under a BSD licence into non-free software. The original software remains free forever. Only a modified version could be nonfree. I know, you can say that the modified version is still the same software, in some sense. But still, the original did not become unavailable, so it was not “turned into” nonfree software.
Third, according to your definition, only copylefted software is Free. That would mean the BSD license is nonfree. I never heard the FSF make such a claim.
Fourth, what about dual licencing? If nonfree derivatives are a big no-no, you have to remember that the copyright holder can release all the nonfree derivatives they want.
That’s all true, but it only means that you don’t have problems with the AGPL if you are willing to obey its terms and conditions. The same can be said of an EULA. But what if you do want to make changes and not release them? You can’t.
It has nothing to do with the privacy of your home, but it does have to do with the privacy of your private work. The “loophole” they plugged is private software. With the GPL you can have it, with the AGPL you can’t.
Ironically enough, the more the FSF refines its concept of Freedom, the more it strives to “plug loopholes”, the more it looks like the principles of Open Source, rather than Free Software. The AGPL may well fit into the OSS framework. After all, it does guarantee that everything will be developed “in the open”, as opposed to “behind closed doors”. In contrast, the FSF was supposed to be all about empowering the user, giving them all the Freedoms a user may need as a user, and only restricting their ability to deny those Freedoms to other users. That’s why the concept of private software seemed very central to the idea. With the AGPL and also, I think, the GPL-3, rather than plugging a hole in copyleft it looks like they opened a big hole in the concept of private software.
It makes no difference for those who would like to keep the source code unreleased.
True, but my point is, you can always “inspect” the binaries and “try to learn how they work”. Of course it may be very hard, but as long as the distributor does not use IP law to prevent you from doing it (ie he didn’t make it illegal), he’s not restricting your Freedom to inspect the software he *gave* you.
It’s not about what you need, it’s about how the distributor must behave in order to respect your Freedom to inspect the program he gave you. Some people can reverse-engineer a binary, others need the source code, still others may need documentation, and so on.
Of course, if he doesn’t give you the source code, he’s not being very helpful, but my point is, he’s not getting you into a moral dilemma either. You don’t have to decide whether to respect the law or to help your neighbor; you can do whatever you want with what he gave you.
Here:
http://blog.opalang.org/2011/09/opa-license-strikes-again.html
There was no reason to throw in (to “zip” the argument / so it must have counterexample?) a bit silly “stating that source code is a precondition of freedom 1 (to inspect and study the program). I think this statetement is false, becase you can always reverse-engineer the binaries” (sure, you can do that, but what you can learn that way is… limited; in the same vein you can argue that strong DRM or obfuscation a’la Skype are not a problem, after all “you can always reverse-engineer”), your post was interesting enough without it.
BTW, one could easily argue that a major motivation behind availability of code (and the surrounding landscape of tools or “hacker culture”) is, yes, educational in nature.
Edited 2012-02-09 00:06 UTC
Didn’t MIT try this with Curl like 12 years ago? Although their delivery was more similar to JRE.
Edited 2012-02-03 15:13 UTC
I think it’s an interesting idea, in principle, but I think that Lucas identified its primary failing at the top of this thread. Web applications aren’t monolithic beasts. You might pull together client code, server code, web services, proprietary code, etc into a single application; in other words, multiple tiers that aren’t easily defined by a single language. That said, I think it could be great for a lot of fundamental uses where the requirements aren’t as tough — and it could really speed development and deployment a lot.