Hivemind Blog

A post on the 451 Group blog made me think about commercial Open Source business models, and the consequences.

The growth of Open Source has convinced a lot of companies to open their software, but you cannot make money by giving stuff away. Red Hat was one of the first companies to create a viable business model based on support licenses. This model has now branched into several variants.

This is not the whole story. Open Source strategy also depends on environment and infrastructure. Does a company provide a place for community support? Do the developers answer questions there? Does the company give back to the projects it uses? The license used for the code also influences things. Sometimes a combination of GPL and a commercial license is used with the specific goal of making the Open Source version less attractive.

Why licenses

Let’s start with a short answer to the question why you, as a customer, need a license for a product that is essentially free: the gist is that Open Source software comes with no guarantees.
Say you hire company B to implement a solution on top of Open Source product A. Company B will only be able to guarantee their code that was written to adapt product A to your needs; essentially configuration and customization. You’re left with a large chunk of unsupported code.
Because it’s Open Source, you can hire your own developer to look at the code and fix bugs for you, but this usually doesn’t work, and isn’t recommended (in enterprise environments/for longer periods of time). Instead you buy commercial support from company C who are, not surprisingly, usually a company that invested a lot of development time into product A. Got it?

These are some common ways this takes place:

Support License

Taking the ’software is a service, not a product’ paradigm literally, your software is free (the product), but you charge for the support licenses (the service).
There’s a lot of education involved here: you have to sell the necessity of the support license to your customers, and basically leave it up to them to ‘do the right thing’. This is sometimes combined with partnerships that disallow work on unlicensed installation, but also obfuscates why a customer needs to buy a license.

Community/Enterprise

There is a free Community version with an Open Source license that is unsupported. The Enterprise version is functionally the same or similar, but it’s considered tested and supported, and comes with a commercial license.
This dual licensing setup is often used with GPL because it is more restrictive on commercial use. I wonder, if you share the code base, how you contain the viral aspects of GPL to just the community version though.

Freemium

The free version has limited functionality. If you want to extend this, you get the paid version. This sounds worse than the previous option, but in a lot of cases it’s more transparent. It hinges on the definition of ‘limited functionality’: don’t expect old school nag screens or timers. Usually what you get in the free version is good enough for most users, and the enterprise features you do have to pay for actually are features you would only use in an enterprise. So this is dual licensing with functional differences.

Open Core

There is an open source project that provides the core of the software, but the actual project doesn’t provide a free version. In the patron model of the 451 blog, the company provides developer time and infrastructure to the Open Source project, adds proprietary features to the Open Source core, and sells the result commercially. There are caveats, though: there is no direct link between the Open Source project and the company, so the company doesn’t have to provide anything. Also the money you pay for the commercial product might not end up benefiting the Open Source project. This lack of transparency is troubling.

This has been a quick write-up outlining several commercial Open Source business models. Note that there is no preferred model, and that there are many other factors you should consider when picking Open Source software, an implementation partner and a support license.

The quick and dirty: Run everything in 64bit and install Alfresco 3.1 SP1.

Introduction

You can mount an Alfresco installation as a Windows Share using the CIFS extension. Alfresco incorporated the JLAN project ( http://www.alfresco.com/products/aifs/ ) to provide CIFS functionality. It offers several mechanisms to achieve this, but on Windows the preferred one is based on the Win32 NetBIOS api (which I think offers the advantage of being able to run ‘true’ windows shares next to it). More on CIFS configuration here

JLAN/Win32 NetBIOS uses a combination of JNI and DLLs. Because of this you need to make sure you have a 64bit JVM. A 32bit JVM will not work on a 64bit OS. If you have to install the DLLs manually, get them from alfreso svn and install them in your path.

The Bug

So, we now have 64bit java on 64bit windows and Alfresco can find the DLLs. Unfortunately, there is a bug in Alfresco 3.1 where the CIFS server starts up normally without logging an error, and the share shows up in explorers Network Neighborhood, but it cannot be opened or mounted.

As the bug notes, this was fixed in Alfresco 3.1 SP1 (or 3.1.1). The version of Alfresco you can download from http://www.alfresco.com/products/ecm/enttrial/ is not SP1. As far as I know SP1 is only available to partners or existing Enterprise licensees, using network.alfresco.com or partners.alfresco.com.

Downloading the 3.1 SP1 war and using that to build my Alfresco installation solved the problems. I was now able to mount and browse the Alfresco CIFS share.

Tomcat in 64bit

One final challenge remained. Until now, to have precise control over the environment Tomcat was running in, I had been running from the command line, which in Windows means running the catalina.bat file, which directly calls java. In order to run Tomcat as an NT Service, you need the tomcat6.exe executable, which, you guessed it, only comes in a 32bit version, which messes up the full 64bit stack.

To get Tomcat to run as a service on a 64bit stack, download the 64bit tomcat6.exe executable (or find the exact tomcat version or architecture you need). Rename the old tomcat6.exe to, uh, tomcat6_x32.exe or whatever, and copy the new tomcat6.exe to the tomcat/bin folder.

You can still use the tomcat6w.exe gui to configure the service, so make sure it points to the correct 64bit jvm.dll. Under the java tab set Java Virtual Machine to: [JRE_HOME]/bin/server/jvm.dll or [JDK_HOME]/jre/bin/server/jvm.dll

Restart the service and check the Tomcat Manager webapp (assuming you created a user with the ‘manager’ role). The ‘Server status’ link should tell you the architecture you’re running. Another check is that in windows’ task manager tomcat6 doesn’t have the *32 flag.

Ah, yes. Erlang. The language that lets you do:
perms([]) -> [[]];
perms(L) -> [[H|T] || H < - L, T <- perms(L--[H])].

I spent most of my weekend going through Joe Armstrongs Programming Erlang which as an excercise contains the following:

Write a ring benchmark. Create N processes in a ring. Send a mes-
sage round the ring M times so that a total of N * M messages get
sent. Time how long this takes for different values of N and M.

I actually had the biggest problems with creating the ring. See, you can easily set up a ring datastructure, but each node should be a process and so each node should point to the pid of the next node. I could set the pid when creating the node, but I was always one pid short. Like that magic trick that, oh never mind.

The first light came when I realized that you didn't need to set the pid when creating the node, but you can send the process a message that contains the pid to connect to (by changing its state, not setting a variable). This led to the first solution, where I create a list of processes, and after that, loop through the list to connect the processes.

-module(ring).
-export([start/2, loop/0]). 

ring(N, N) -> [link()];
ring(N, M) -> [link()|ring(N+1,M)].

connect([F], H) ->
  F ! {gate, H};
connect([F|[S|T]], H) ->
  F ! {connect, S},
  connect([S|T], H).

link() -> spawn(ring, loop, []).

loop() ->
  receive
    {connect, Next} -> loop(Next);
    {gate, Next} -> gate(Next)
  end.

loop(Next) ->
  receive
    Msg ->
      io:format("~p... ", [self()]),
      Next ! Msg,
      loop(Next)
  end.

gate(Next) ->
  receive
    {1, Msg} ->
      io:format("Done with ~p~n", [Msg]);
    {N, Msg} ->
      io:format("Passed gate, ~p more rounds to go~n", [N-1]),
      Next ! {N-1, Msg},
      gate(Next)
  end.

start(N,M) ->
  Ring = ring(1,N),
  [H|_] = Ring,
  connect(Ring, H),
  H ! {M, "Hello, world"}.

I needed two more things after this: I wanted to make the main process part of the ring, instead of spawning the whole ring, because I felt this would allow me to control the number of loops that were made more easily. And in trying this I discovered a more elegant way of setting up the ring: one node spawns another node that sends a message with it's pid back to the original node.

-module(ring2).
-export([start/2, loop/1, ring/3]). 

ring(1, Pid, Main) ->
  Pid ! {connect, self()},
  loop(Main);

ring(N, Pid, Main) ->
  spawn(ring2, ring, [N-1, self(), Main]),
  receive
    {connect, To} ->
      Pid ! {connect, self()},
      loop(To)
  end.  

loop(Pid) ->
  receive
    Msg ->
      io:format("~p... ", [self()]),
      Pid ! Msg,
      loop(Pid)
  end.

gate(Pid) ->
  receive
    {1, Msg} ->
      io:format("Done with ~p~n", [Msg]);
    {N, Msg} ->
      io:format("Passed gate, ~p more rounds to go~n", [N-1]),
      Pid ! {N-1, Msg},
      gate(Pid)
  end.

start(N, M) ->
  spawn(ring2, ring, [N-1, self(), self()]),
  receive
    {connect, To} ->
      To ! {M, "Hello, world"},
      gate(To)
  end.
  

I didn't get round to doing the actual benchmarking, but it was a great puzzle and I can't wait to delve deeper into erlang.

Twitter has hit another big surge. For example: In the post below, I was somewhat critical about the pricing scheme of Junit Max. After I posted it, I twittered about it, and literally minutes later got a tweet back from Kent Beck. Being directly addressed by the creator of Extreme Programming makes me humble.
Kent said (this is a public tweet so I feel I can repeat it):

@rogier tx for the link. pricing is *such* a non-linear problem. $2/mo, $200/mo, hold out my hand and look pathetic. i’m open to suggestions

Me, I was just peeved I couldn’t get a closer look at this new piece of kit. Thinking about it a bit more:

• Open Source is driven by meritocracy. For instance, you could write the best unit-testing tool, because you want to be known as a unit-testing guru. Obviously, there’s no value there for Kent.
• One thing Open Source traditionally handles badly, is the case where there’s a lot of business value in the code, which is why Google open sources everything *but* it’s algorithms. It seems JUnit Max gets a lot of its power from the Optimizing Test Runner, which is an algorithm that could only be written by a domain expert.
• But, while it is understandable these things cost money, there’s still the question of traction, or momentum. If the software would be free you would be building one hell of a customer base, given the amount of Java developers using Eclipse and JUnit. The revolutionary nature of the tool dictates that you need to use it to get hooked. And you could still sell support contracts on top of it.

Anyway, I think I’m going to whip out that creditcard anyway, and let you know how it goes. It also got me thinking that it should be possible to associate a unit test with a Mylyn task, and make the task only complete when the tests succeed.

I’m a little annoyed with two potentially beautiful products. First, I’ve been doing some reading on XP lately, and I noticed that Kent Beck was working on a new project, along the lines of ‘change the way you run unit-tests forever’. The secret project came out of the egg this morning (I think) and is called JUnit Max.
Kent says:

JUnit Max is an Eclipse plug-in that helps programmers stay focused on coding by running tests intelligently and reporting results unobtrusively. Every time you save a Java file, Max will run your tests and report errors like compile errors. In addition, Max runs the tests most likely to fail first, so you only have to pay close attention to test results for a second (literally) before getting back to coding, even if you have a long-running test suite.

Nice, that. Unfortunately, if you want to use it, you’ll have to pay 2 bucks a month to subscribe to the Eclipse Updates, and that, I dunno, just doesn’t feel right. This is the first time I encounter a for-pay Eclipse plugin, and it just seems like such an outdated business model. Don’t get me wrong, it’s not the money, it’s just the fact that I cannot try it without whipping out a credit card.
I expect that if they adopted the pay-as-you-like model, which is used succesful in the music business, the revenue would be comparable. After all, this is about creating traction for a new way of doing things.
The second annoyance came from Nexus, the “powerful and robust Maven repository manager” created by Sonatype, who do commercial support for, and also publish a wonderful free book on Apache Maven. I noticed they had a new version out, which upon quick reading, offered LDAP integration, something we’ve been waiting for. Unfortunately I discovered after upgrading that the LDAP integration is only included in the $2995 Professional version. I cannot justifiably call this crippleware, but it stings. And of course, someone will come along and offer free, open source LDAP integration for Nexus, of which Sonatype then says:

“There have also been a number of simple LDAP plugins created by third-parties, and while we certainly believe that our own LDAP is more capable the fact that there are already competing options is a testament to the flexibility of the product. “

Just a quick linkdump of two agile posts:
Obie Fernandez (of HashRocket fame) writes about when user stories become to big, and an insightful reply by Bill de hÓra

I’ve long had a rule when browsing on the internet: Don’t spend time on one site repeatedly looking at variations of one thing. This rule helps when browsing lolcats, dilbert back issues, amazon, etc.

I’ve also long ignored this blog. I have about 6 posts published and another 6 have been languishing in my drafts folder for about a year.
Read more…

So, they say to run CouchDB, the much hyped lightweight JSON and HTTP database thingy, you need MacPorts, in order to install Erlang, ICU and build the Couch. Actually building from source didn’t turn out to be a problem. Erlang was a straightforward

./configure
make && sudo make install

ICU was a bit more interesting. I couldn’t get the scripts in the downloaded .zip file to work, but the tar.gz functioned better. ICU comes with a runConfigureICU script that needs the OS as an argument: MacOSX. After running that I used gnumake instead of standard make:
gnumake && gnumake install
Finally, building CouchDB: I am an adventurous type so I went for the latest SVN. Mind you, CouchDB has seen some recent restructuring. The readme talks about doing a ./configure, but there’s no such file. Although it looks like you need to autoconf manually, I found out from their mailinglist that all you need is bootstrap -C.
In my case, I needed to give ./configure a –with-erlang option, having installed Erlang from source:
./configure --with-erlang=/usr/local/lib/erlang
After that is regular make && sudo make install
Phew! sudo couchdb et voila! http://localhost:8888/_utils/index.html

Update: Of course, the day after they had to come and show off Timeplot, a cousin to the original timeline project. I like this stuff because it’s such a combination of visual skill, pragmatic thinking and programming excellence — virtues that I think are missing from a lot of academic discussions these days. Looks like the simile tools are on a converging path by the way.

The Simile guys posted a cool video about their newest product, Potluck. If you don’t know Simile, it’s a project in M.I.T’s computer science lab, CSAIL, it’s about Semantic Interoperability of Metadata and Information in unLike Environments, and it’s where Stefano hangs out these days.
Other projects worth looking at are Timeline and Exhibit. Both backed by JSON data (or RDF, XLS, BibTex), the first is a dynamic timeline visualizer using some Google Maps tricks, the second is a facet browser, very useful for your search frontends. Go take a look, they have nice demo’s.
One thing that Potluck reminded me of is DabbleDB, an data-centric web application built by a very smart guy, on the Seaside framework, in Smalltalk… yeah! That begs for a Hackers & Painters quote.
Their video, when I first saw it, really blew my mind. That’s where Open Data is going!

On friday the week before I was boasting to Bart about how I knew Gnarls Barkley before they became really popular, by virtue of the Zuivere Koffie/Linke soep torrents I used to download every month (it seems they have stopped now). He told me it was arrogant to make such a statement, and the next day I found this t-shirt design at Threadless.
Last friday I was talking to Bart again (you know, friday afternoon beers and heated discussions) and he mentioned how he thinks Subversion is fundamentally flawed, and we should all move to ‘this scm linux kernel hackers are using’ — we thought it was bitkeeper, but actually it’s Git.

Imagine preparing a release and some of the features just don’t cut it. You want those out of the release. Unfortunately, all the code is in trunk, so you’ll have to selectively revert some of the changes, making sure you don’t break anything. Git allows you to do this, by virtue of feature branching, which basically means each feature has its own branch, and selecting patches for a release. It gives you some visual tools for this as well. Also, Git gives each developer a local copy of the entire development history, which presumably aides distributed development. Sounds good, no?

The next day, of course, there was a link on del.icio.us‘ popular page, documenting how to move from subversion to Git, and in the comments was a lot more talk about ‘cool’ versioning systems, like Mercurial. I guess people once thought CVS would never go away, until Subversion came along. It’s nice to see ubiquitous tools still developing. One problem seems to be Git c.s. don’t do svn:external.

Anyway, back to the music, just to show off: If you know Daft Punk, and think they’re geniuses, listen to Palms Out Sounds’ Sample Wednesday on Daft Punk and be ready for a surprise: either you’ll think they’re total frauds, or you’ll have even more respect.

(And get del.icio.us’ playtagger, a bookmarklet that turns mp3 links to embedded players)