I know a lot of the history and actually part of that is how I ended up in this job. It all goes back to an acquisition that IBM did way back in 1996 in a prior company called Object Technology International or OTI. At that time were specialized in the Smalltalk language and tools, and as Java started to take off the team was targeted towards building Java tools and originally the first one that came out was Visual Age for Java. I’m sure some remember that, written in Smalltalk, actually for those who remember it my sort of claim of technical fame is that sort of funky repository that lived underneath it was something that I wrote a long time ago, with some colleagues, of course, so they got tasked what would be the next generation of the tooling platforms. There was a really good group of people, guys like Erich Gamma, John Wiegand, John Duimovich, Dave Thomson, Steve Northover who had built many different frameworks, many different tools over the years and they brought all that experience to bear to Eclipse, or I should say, what became Eclipse. The interesting thing that happened was in 2001, IBM made the strategic decision to open-source it, which at that time was a much more novel and original idea then, than you might think of it is now. Back in 2001 for IBM to open-source something as large as Eclipse was a very big deal and in addition to that one of the things that they did that was very clever it was, to my recollection, the first open-source project that got started with a consortium as well. As the consortium grew and it became clear that spinning it out into a separate independent foundation would be a great idea and that’s what happened in 2004. So the Eclipse Foundation has been an independent organization now for 10 years, although I still get asked if I work for IBM, it takes a long time to change people’s perceptions.
It was the year when the 3.0 shipped. So the foundation was created in January of 2004 and in that June was the launch of 3.0 which was a very big deal at that time, because that was the version that changed the plug-in model over to the OSGi standard and it was also the release where the rich client platform was first launched. So it was really that year was, when you think about it, momentous in the history of Eclipse, because it was the creation of an independent foundation and a technology choice for the modularity system that has really stood the test of time and the beginnings of the rich client platform and the evolution of Eclipse away from being just a tooling thought into being much more of an application platform which has since grown into bringing Eclipse into runtimes and other areas as well.
3. That was the time when the code was moved from a CPL into an EPL type license?
That process started when the foundation was created in ’04. I think it was actually the release in ’05 or ’06 before it was completely done. That switch from the Common Public License to the Eclipse Public License was actually a really big job. We had to change every file header in the repository, and that’s enough, but we actually tracked down every single contributor of a line of code to Eclipse since the day eclipse.org started and got their permission to do their relicensing. There were over 600 people that we tracked down. In the end there was a few people that we couldn’t track down, we ended up actually rewriting 1000 or 1500 lines of code because we couldn’t find the author, but yeah, that switch was a very big deal.
Alex: I think that subsequent to that the EPL was marked as the successor of the CPL as well, which then made it much easier.
Yes. Unfortunately that didn’t happen until 2009, so all those sequence of events made sense but yes, it would have been a lot easier if that’d had happened originally, because then we could have just relicensed.
Alex: And I think JUnit was one of the last holdouts of these things by Kent Beck, which was CPL for quite a long time.
As far as I know it still is.
Alex: I thought they’ve changed over to EPL, because they found the going forward clause. Maybe it’s still CPL.
I think JUnit is still CPL. The one that just recently has switched is JRuby, just a couple of weeks ago actually. It was a very fortuitous meeting I ran into Charles Nutter at Fosem in Belgium over a beer, I’ve never meet the guy and we were talking and I didn’t even know that JRuby one of the licenses that they use is CPL and when he found out how easy it was to change the EPL, they had it done two weeks later. It was great.
Alex: And the growth if the Eclipse platform, I think, with the various different tools and so on, has really shown the success of having the IP that we have in the Eclipse Foundation, so you’ve got CDT and you’ve got the products that are coming on board with the machine to machine that Paho and the Mihini and ones that I can’t remember the name.
Yes. It’s a common, a constant I should say struggle if you will, for those of us that are in the Eclipse Foundation and the Eclipse community to communicate the fact that we do more than a Java IDE, there’s something like a 6 or 6 and a half billion Java developers in the world that use Eclipse as their development platform and certainly within enterprise IT , when you say Eclipse, people say, yeah, the Java IDE, but the fact is that we have over 250 projects at Eclipse ranging everywhere from machine to machine protocols to Virgo, which is a full Java EE web profile server and pretty much everything in between so, there’s an enormous variety of technology at Eclipse. One of the really important changes that’s happened just recently – by recently I’m saying in the last 18 months to two years – is the board made the explicit decision that an Eclipse project doesn’t have to be written in Java, doesn’t have to be using the Eclipse plug-in model or OSGi, we’ll take projects based on any technology. What we care about is primarily is will they follow our development process, will they follow our IP policy or are they willing to be members of an open transparent and meritocratic community? Those are the thing that we care about now as opposed to any particular technology statement.
Yes, exactly, so Vert.x is a great example although at least is based on the JVM. But we have Orion as well, which is primarily a JavaScript development platform. We have Mihini which is written in Lua, so we are definitely seeing some projects coming on board which are bringing us into new languages, new technology domains and so on.
Alex: You mentioned all of the strengths of Eclipse but one of them we didn’t touch on or maybe touched on a bit with the CPL is the attention to licensing and software and traceability and so on which I think is I think a very strong component of the Eclipse Foundation and the way that it deals with trademarks and so on.
Well I think, we really believe strongly that the Eclipse Foundation sets the highest bar when it comes to intellectual property management, we have Janet Campbell who’s a lawyer and staff of two people sharing and Pablo who scrub our code base day and day out, make sure that all of the third party dependencies that we’re bringing into our code base have clear code providence on their own, we’re checking for license incompatibilities. All of the projects that come to Eclipse that had a previous life, we assume, ownership of the trademarks so that we hold that in trust for the community, so we don’t have any single vendors that own names of our projects. All of that attention to detail, having the professional staff to back that up is absolutely one of the value adds of the Eclipse Foundation.
Yes. Absolutely, and we think that the path that we’re seeing right now with Vert.x, where you have a project that was started at GitHub and became important and became successful and started to attract corporate interests because they just wanted to use it in their products and searching out and finding a home at a vendor neutral foundation, we think that that’s going to be a pattern where we’re going to see happen quite a bit at GitHub and other places. Social coding and going to where the developers are is absolutely important in today’s world. I really honestly believe Stephen O'Grady’s “Developers are the new kingmakers” paradigm, I fully support that, but I think that migration from “I have an idea, I want to build some code, I want the best tools to do that” and then over time realizing that there are other matters at stake in terms of clear intellectual property – those are the things that attract other participants and corporate support to the projects. And we actually think of that as sort of balancing the interests, places like GitHub are very strong in terms of grabbing developers and making it easy for developers to build code and build cool new projects. But once projects become successful then there come other stake holders in the project beyond the developers and those are the users and the consumers of the code and the services that the Eclipse Foundation adds on top around on intellectual property management, around enforcing meritocracy and transparency, those are services that actually are mostly in the interests of the adopters, not just about the developers.
Yes, so we think Gerrit is a great tool, it’s a great addition. I’ve built systems like that in the past and the workflow of pushing to Gerrit and kicking off a Hudson build so the committer who wants to bring that contribution in doesn’t even have to look at it until it’s been built and if it can’t be built there’s not much point in looking at the code. And then doing the IP checks and then having the review of the committers on the team and before bringing the code in that whole workflow I think is really desirable and we are pretty happy with Gerrit on the front end of the projects. Not every Eclipse project uses Gerrit today but we certainly see more and more moving to it all the time.
Well actually that’s sort of implementation detail, at this point; I think that the more important point is that we’re going to be moving into contribution license agreements from our past practice of asking the famous three questions on Bugzilla “Did you write this code? Do you have the rights to give us this code? Did you include anybody else’s code?” Basically when we move to the CLA we’re going to ask those questions once every three years as opposed to once every contribution, so that’s going to dramatically streamline the workflow of bringing contributions. I think one of the fundamental shifts within the Eclipse community over the last year or so is that we’re absolutely dedicated to doing things to bring more contributions into Eclipse and to wherever possible to embrace the social coding ethos wherever we can and I think that’s a sort of a theme that you’re going to see continued at Eclipse for the foreseeable future.
I can’t really comment on any other projects that might come on board, except perhaps the Mylyn M4 one which Tasktop just announced this week, which is really going to be for the first time start bringing the server side of ALM into the Eclipse world, which is quite a change. Up until now Mylyn has been entirely client side, at least the pieces that were open-source, so I think that’s going to be a big addition. But I think Eclipse has got long and deep roots in Agile in general, and has been a big part of a lot of the ALM stacks that are out there and I certainly expect that to continue, both on the open-source side and in terms of being a platform to build commercial tools on top of.
Project management 0. Technical perspective, our webmaster team is 2 people, and in terms of process support, we have Wayne Beaton who is the Director of our open-source projects and helps the processes move forward and Nathan Jervey who helps build tools on our web properties for the developers and committers to use. But I think it’s a misunderstanding to think that is the staff of the Eclipse Foundation that makes the release train possible. We provide some amount of support but it really is a community led process. So if I was to point at some people out the community that make the release train possible it would be guys like David Williams who is the chair of the planning council and he is really “the guy” who makes the release train process work, and Markus Knauer or who is the head of the Eclipse packaging project that builds those packages at the end of the process and populates our download page – those are guys that are obviously being supported by their employers, but they are not employed by the Eclipse Foundation doing this in support the Eclipse community and the support that we are getting from IBM and EclipseSource for those two guys is absolutely critical to the way Eclipse works.
Absolutely. So the way we try to think of ourselves is sort of force multipliers. We try to avoid having our staff being the linchpin of activities. We have to enable the community to do things and then try to get out of the way. Now there’s a few places obviously like the intellectual property management, where you know, we control that process, we have staff to do that. In terms of actually keeping our servers up and running, we have to do that and we have great track record in uptime and so on. But in things like development process and so on, it really is about enabling the community to be successful as opposed to running the thing. There’s no way you could do something like Eclipse in a hierarchical command and control kind of way, it really is a community led process. I can’t remember who coined this phrase but I’ve heard it recently and it’s absolutely true “Your community is your capacity” and the more that we can enable the community around it, in and around Eclipse to do great things from the Foundation perspective, the better the community of Eclipse will be.
I think our sort of historical strength in tools is going to continue. I think that the things that we are seeing around modeling in model-driven developments, I think the Eclipse modeling community has done a wonderful job and that community are the thought leaders for now for modeling, whether it’s domain specific languages with Xtext or graphical editors, the new Sirius project proposed by Obeo for being able to build graphical editors is, I think, a big step forward, so those tools, the stuff that’s happening in PolarSys around building tool chains for safety critical software engineering, that’s really interesting stuff. So building those kinds of tool chains and supporting them for the long term, that’s going to continue and there’s amazing stuff happening in there. Runtimes, SAP NetWeaver Cloud just shipped based on Virgo and I think that’s a real testament to the technology that we’ve got there, certainly expect that to continue to grow. I’m personally thrilled with the stuff that’s going on in M2M, I’m spending my evenings at home playing with Arduinos and Raspberry Pis and Lua and Koneki and Paho and all that stuff, building some home monitoring stuff for my cottage, it’s just enormous fun and that’s obviously a huge area, potential area of growth. We’ve got some good technology there and I certainly expect to see more of that. I could rattle along for a long time but there’s lots of great potential for Eclipse. I am hoping that we will start to expand into new areas.
I think I can certainly give you one example, I think Eclipse is under-represented in terms of open-source projects in big data, for example. I’d love to see some projects come our way from that space. Similarly projects in the Cloud. Actually pass kind of systems, I think there’s some potential there. Actually I should mention Orion, if I’m talking about Eclipse futures, because I think that’s actually incredibly important to the future of Eclipse. We’re basically trying there to repeat the success of Eclipse as a tooling platform but doing it in the web and for those who don’t know what Orion is they should come to orionhub.org and try it out. It’s extremely hard to explain without actually seeing a demo or playing with it, because I’ve seen this happen so many times, no matter what I say or how I talk about it, people go “Oh yeah, it’s Eclipse running in a browser”, and it’s absolutely not Eclipse running in a browser, it’s completely different experience, completely different code base but it has the model of “build a platform for building tools for a particular platform” is being repeated with Orion, except this time the platform is the browser not the desktop and I think Orion is going to be a very big part of Eclipse’s future.
Alex: Mike Milinkovich, thank you very much.
My pleasure.