Looking Forward to 2010

Last year I put out predictions for 2009. But I don't want to look like I know things that I really don't. So instead, for 2010 I'm going to list the technologies I am most looking forward to seeing come to fruition this year. As a tools developer, it's important to know what things your users will use your tools to build, and for that you really need to know what's going on in the industry. So here we go. I'm also going to forgo my standard 4 or 5 paragraph length so excuse the extra long post. It's just easier for me if I capture them all at once.

Mobile

I blogged about this in the past, but what I see happening in the mobile space reminds me so much of the revolutionary days of the early PC market, back in the late 70's and early 80's when the ability to program computers came to our homes. The same is now happening with mobile devices, all of which have freely available tools and SDKs and anyone can, and is, writing applications for them. And a rare few are even making money at it. It's a race to see who wins and despite the early lead by Apple, it's not entirely obvious to say who will.

In 2010, the momentum will continue to grow. Tablets will be the next battle ground. They should be in the 7 to 12 inch screen size range making them more useful for web browsing than smartphones. They may or may not have a keyboard so we'll have to get used to using soft keyboards with these things, although, there are rumors of patented technologies that should make it easier. And I expect the power of the SOCs used to build these will grow to make them great little gaming machines.

My main interest in this area is Android. I expect to see Android on more and more of these devices. Right now, I find the Android SDK (including the native development kit) weak for gaming and multimedia and hopefully that will be addressed this year. If it is, it will be a real challenger to iPhone.

New Linux UI

Moblin is currently leading a revolution in the Linux GUI environment space. I think it really brings Linux to the masses with a very clean social networking focused interface. Hopefully we'll see a wider deployment of it this year, especially on netbooks. But I expect they'll continue to push it down into the MID space to challenge Android and iPhone there.

The main reason I like Moblin is that unlike Android it really is Linux and uses the same SDK set that you have on Linux desktop. It's the best hope for seeing applications that are easily ported between the desktop and mobile devices, other than web apps, of course.

The other advantage of being Linux and being open source, is that the underlying library that drives the UI effects in Moblin, i.e Clutter, is available to the desktop programmer too. I am very much looking forward to what the Gnome gang have planned for it in their upcoming Gnome Shell 3.0. I am hoping that this and other changes to Gnome for the September 3.0 release will be a real game changer for desktop Linux.

Blender 2.5

What the heck is Blender? And why is a C++ hack like you interested in it? Blender is an open source 3D modeling tool. No, not software modeling, but the real 3D object modeling that you use to build games and simulations. I've been watching the game development industry mainly because I'm a geek with an insatiable curiosity on how developers build things. Building games is one of the hardest computer science problems around. That and you need great artists to make great games. It's a very cool mix of art and science. And the artists need tools too.

The Blender community is a rich mix of that and it's been fun to watch them. The new version of Blender coming out this year is a much needed rearchitecture and a bit of a reinvention of themselves. It looks to be much easier to use and I expect it'll become quite popular. Mix that with the open source software development tools we're doing at Eclipse and I see a much lower entry point for people wanting to join in on the fun.

High Performance Computing

HPC is another technology that I see inching towards the masses. The hardware that the graphics card vendors are putting out is reaching dizzying heights of multi-processing. As the tooling for these cards improves, this power will be more and more accessible to the every day programmer and it'll be very interesting to see what they build with it.

C++0x

I'm not sure whether C++0x will reach standardization this year, but I expect to see more and more of the spec implemented in GCC and other compilers. There are a lot of important new features here for C++ that will greatly improve the productivity of C++ programmers. Will it be enough to fend off the continuing progression of developers to less capable languages? I don't think so since it's still a pretty complicated language. But it should make it more appealing for those that need the power of C++.

Open Source Wins

I usually get called the "Open Source Guy" at work by those more focused on business. But I will continue to champion the need for open source software as a key element of any software business strategy. Why? Because software is damn hard to build and going it alone continues to carry a high risk of failure. If there are opportunities to work in a community, to share in that risk, and to spread out the cost so you aren't covering all of it, how does that not make sense?

At the end of the day, customers care that you give them great solutions, they don't care how you build it. If you ignore all the great work that's going on in the communities, you'll need to keep ahead of that to ensure that they see you as the best provider of those solutions. That doesn't mean competing with open source, that means embracing it and leveraging it to keep your customers happy at a reasonable cost.

Over the years, we've seen companies that have slowly embraced this strategy. Some have a ways to go before they totally get it. Notice that none of the technologies I see as industry changing are coming from Microsoft. But they are keeping a close eye on what's happening in the communities and the little test balloons they've sent over the last year will continue. And I take that as a sign we are right.

Well, that's all for now and thanks for sticking with me to the end. 2010 is going to be a great year for software development. We seem to have broken free from the shackles of the doldrums we've been in since Windows took over our world. It'll be very interesting to see where we end up at the end of the year, but it promises to be one hell of a ride.

Reviewing "Predictions for 2009"

I spend a lot of my time thinking about the future. As an architect, that's probably the biggest tool in your tool belt, a crystal ball. The best designs are the ones that can be used now and a year from now.

Before I blog about what I think will be important things to look out for in 2010, I'd like to review what I said last year about 2009. If it turns out I was totally wrong, then you can take my 2010 predictions with a grain of salt, as you should anyway. So here we go.

2009: The Year of the GPGPU

Well, I'm not sure it was as big as I thought it would be, but we're certainly seeing a lot of momentum behind ATI and Nvidia's monster graphics cards come computing devices. We're still fighting software demons. Nvidia is still pushing it's own CUDA over the "standard" OpenCL that ATI seems to be more on side with. But if you see what some of Nvidia parters are putting together with their Tesla boards, you know the time is soon.

2009: The year of WebKit

While not very visible, WebKit is becoming the standard browser platform for devices including iPhone, Android and Palm Pre, along with the existing desktop browsers, Apple's Safari and Google Chrome. But if you've ever tried to use Chrome as your default browser, as I do, you still run into a lot of web sites that don't render well on it, or AJAX sites that don't even work. Even our EclipseCon submission system had trouble with Safari (although it seems to work fine in my Chrome on Fedora). No, it's actually looks like 2009 was the year for Firefox which is now the most popular browser according to something I read the other day.

C++0x won't be C++09

Now, I already knew that when I wrote it. If C++ creator Bjarne Stroustrup doesn't think it'll happen, it likely won't. I'm even having doubts it'll be C++0a (or C++10, I guess). But I hope it comes soon since it has a lot of great things that C++ developers need that a lot of other languages already have (like lambdas). The good news, is that we've started work on supporting C++0x in CDT's parser. It's going to take a while so it's important we start now.

So all-in-all, it wasn't a total failure. But then, I think I was probably stating the obvious at the time. There were no shockers, but it was fun to do. I'll give my thoughts on 2010 just before the New Year so stay tuned.

BTW, I'd also like to share my best wishes for the holiday season with you all. It's a time for reflection and I'm sure I'll do my share. 2010 is going to be a big year for me and I'll need to prepare. Merry Christmas to all!

The path to a successful e4 introduction

The last time I blogged my thoughts on e4, I got quite a storm back at me. I don't have much against e4, and frankly, I'm not to concerned about it. I am the C++ guy and in my opinion, we should be making tools and libraries to make rich client applications easier to build in C++, which is what most rich client apps are built with anyway. But while a lot of what e4 is surrounds innovation around RCP apps, the intention is that it should go beyond that. We should be able to leverage e4 in our tools.

My fear, confirmed by many, is that the projects won't invest in e4 to ensure it gets adopted by the tools on the Eclipse trains. But, it's not really that. It's that the vendors that pay the committers working on those projects aren't interested enough to invest in it. All the begging and pleading won't really change that. In my years of open source experience, I've only seen that work when there was an obvious need that was going unfulfilled. I'm pretty sure that's not the case with e4.

So if we want e4 to succeed, it's up to the community to make it happen. In fact, I've challenged the Eclipse Architecture Council to lead the charge. If we believe in this architectural change and are sold ourselves that it needs to succeed, we need to take on the task of selling it to others, especially the vendors from whom we need approval. It should be what the Architecture Council is about.

How we do that? We need to show e4 running. In particular, we need to show prominent projects from the train running on e4, if not the entire train. And, of course it needs to work well and be easy to do, i.e. cheap. That requires a really good compatibility mode for e4, which is promised by the e4 team. And we need volunteers to do the builds, report bugs, and fix them.

"Build it an they will come" only works in baseball movies. Nothing sells a new idea like showing it in action and proving how easy it is to adopt. That will take work. Hopefully we'll get the few bodies we need to get the ball rolling and give us something to run with. If we have enough people that care about e4, this shouldn't be that difficult to accomplish.

"Eclipse Labs", the Eclipse game changer

Ian hinted at it in the recent flurry on Planet Eclipse and Mike just offered an extra teaser. For me, the concept of an Eclipse forge, or "Eclipse Labs" is set to change the way open source developers see, consume, and contribute to Eclipse, and more importantly, to dramatically change the culture at Eclipse.

Everyone seems to be looking for a technical solution to keeping Eclipse relevant, e4 case in point. In the end, that's not enough. We need to grow the Eclipse community beyond it's traditional realm of corporate engineers, into what we more traditionally think an open source community should be, free. Free to work on what you want, free from someone saying no to your contributions (within reason, of course). To be free as you are when working with SourceForge, but still be a member of the Eclipse community.

I'm still waiting to hear the details on the rules and mechanisms for the Labs. But if it turns out like I think it should, ;), then I'm super pumped. Pumped enough to bring Wascana out from the freezer and make the real Eclipse C/C++ IDE for Windows that should rightfully be an Eclipse community project, not hidden out on SourceForge. That will require the Lab to ship GPL'ed software, i.e. the GNU tools, and LGPL libraries. Is Eclipse ready for that? I'm hoping.

Multi-Core Programming, Paradigm Shift Required

I just caught myself sending 4 tweets in a row on the same subject. That's probably a sign I have a blog entry topic at my finger tips.

I was reading an article entitled "Microsoft's top developers prefer old-school coding methods". Whoever picked that title clearly missed the point of the panel discussion he was covering, but it's an awesome read.

The panel involved a handful of distinguished engineers from Microsoft and they were discussing the future of programming technologies. And hilarity ensued! It reminded me so much of the discussion we had about JavaScript at the end of the Ottawa Eclipse DemoCamp last week. There was much hilarity ensuing there as well.

At any rate, I totally agree with what these guys are saying. Everything we're doing to innovate in programming around graphical programming languages and concurrent programming is crap. Here's some of my favorite quotes from the article:

re graphical programming: "when you have 500 things, graphical programming is completely unusable. You zoom in and zoom out and you lose all context. I think it's just smoking dope." (a similar comment was made about using JavaScript to build complete apps at the Camp).

re managed code: "lets developers perform above their level of competence. It's like antilock brakes". (They were talking about CLR, but I'd include Java in that).

re abstractness: "programming is getting so abstract, developers will soon have to use Microsoft's Natal to write programs through interpretive dance." (That I don't want to see).

But the one quote that really confirmed what I had been thinking about multi-core programming: "It will be a long time before parallel programming becomes mainstream. Because of the bias towards sequention programming, we'll still be reinventing ourselves as parallel programmers 12 years from now."

This was a classic Ward Cunningham "A-ha" moment for me. I had hoped graphical programming could be an answer to break the sequential rut we're stuck in. But the usability of building complex programs graphically kills that. I think at the end of the day, we still need to look at hardware description languages such as Verilog and SystemC as holding the key. They are all about concurrency since the hardware they model is too.

Diversity is not the only answer

Dave Carver started it and Pascal fed the fire. If you missed it, there are confusing and highly inaccurate statistics captured by the Eclipse Foundation that measure diversity in the Eclipse projects. Stats or not, there are a lot of projects where it's clear, there is one vendor paying a very disproportionate number of comitters that work on the project. And it's not always IBM.

But I think that misses the point. For open source projects to survive you need one key ingredient. Be OPEN! Simple, no? One reason that non-diverse projects suffer is that most of the decisions are made behind closed doors at that company. How many times has some feature or project just showed up one day, all the key decisions leading to their creation happening hidden in meeting rooms instead of out on the mailing lists. What kind of trust does that build?

A couple of Eclipse Summit Europes ago, I received the biggest insult I ever recieved working in open source. Having just joined Wind River, one of the attendees suggested that the CDT was just a Wind River project. After all the work I've done and career limiting decisions I've made to be as vendor neutral as possible in my work on CDT, I was hurt. But it drove home the point. Wind River was the elephant in the room, at least by perception, and that hurts trust.

I think Eclipse has a lot to learn from other successful open source projects. If we truely want to continue the success, we need to be real open source projects, not only in governance, but in culture too. That starts by dropping the vendor centric nature of the Eclipse projects and opening them up to everyone.

Linux Distros, The Great Melting Pot

I've been talking a deeper look at Fedora lately as Fedora 12 was just released and I was checking out all the MinGW cross-development packages available there. While I was there I looked across all the packages included in the "Everything" folder. I even gave eclipse-cdt a try and was impressed to see 6.0.0 there (although 6.0.1 would have been more impressive ;)). It's also impressive to see so many of the Eclipse projects represented there. And just looking at the breadth of open source content, almost every open source project I've looked at is included, including the bullet physics engine, OGRE and Irrlicht game engines, blender the 3D modeling tool, clutter and mutter and even an early preview of the new Gnome Shell.

It's an incredibly rich set of libraries and tools, and it's got me jazzed for Linux again. And given the corporate virus scanner has finally found my Windows 7 install and is doing it's best effort to kill performance, I'm thinking again of going back. Windows 7 is pretty and I'm very productive in it, but I can see that the Gnome Shell has some of those same characteristics as I played with it on the Dell Mini.

The Linux distros are a great melting pot of open source technologies, and I think Eclipse is perfectly positioned to be the IDE of choice to work with those treasures. But playing with it, there are still a lot of architectural challenges we need to overcome to get there. Even just loading Photran (the Fortran tooling) and CDT together is a mess as both projects try to present pages for the properties. The big challenge we face in the Eclipse community is working together to make this better. I've mentioned this before, but the projects really do operate as silos, even Photran and CDT and we've tried hard not to do that, it's just too easy.

But it takes a group of people with the vision and the gumption to drive that vision home. I'd like the Eclipse Architecture Council to be that but as with all things Eclipse, it's really up to committers and the vendors that pay them to make this happen. Here's hoping someone does.

Chrome OS, it is what it is

I guess I got caught up in all the hype over Chrome OS. It's an idea I've bounced around for years as I mucked around learning about embedded Linux. Replace the standard Linux desktop UI with only a browser and throw it on a mobile device. With everything on the web these days, or at least a minimal amount to do something useful, why not?

But I could never escape the idea that you had to have at least some local applications to do things when disconnected, or to take advantage of the CPU and graphics power using native tools for things like games and multimedia.

So I downloaded a build of Chrome OS from gdgt.com to give it a try under VirtualBox. And, BTW, you got to love the tech community and how quickly they get activated when something cool comes along. While the release is about a year away, and the build shows it, you do get a sense of what Chrome OS, or Chromium OS which is it's proper name, is.

 You log in with your Google account and, bang, you're in the Chrome browser looking at your Google stuff.

But it is what it is. There's no application menu, no app market, or anything like that. Everything you do is over the web. I did notice an extensions mechanism, and maybe that's how you take advantage of the native environment, maybe not.

When I had thought of a Web OS, this summer, my thoughts turned to the Eclipse Run-Time and using that in conjunction with the browser to have local apps written for the Eclipse platform. I would also think you'd want to launch 3D and multimedia content full screen, or something. But that's not what Chromium OS is. It's web or bust.

So while Chromium OS is interesting, I'm way less excited about it. I think the door is still open for a netbook Linux platform that combines local native apps with the Web experience. Moblin is certainly making strides there for the consumer space. And I've been trying out the GNOME Shell which offers an experience much like Windows 7 for the power users. This story isn't finished yet.

Visual Programming for Multi-Processing

I spent a little time on the weekend taking a deeper look at the Unreal Development Kit (www.udk.com), and I continue to be shocked that they are giving out all this great technology to you and me to play with. And it really blew me away when I saw their Materials editor. There's a tutorial here, http://udn.epicgames.com/Three/MaterialsTutorial.html.

Take a look at how you program the materials algorithms. You lay them out graphically and hook up data flows between components. The order of execution or the parallelization of the algorithm is automatically inferred by the declarative nature of the model. When you're ready, these get generated into optimized shader programs that download to your graphics card when drawing the 3D models that these materials wrap. Very cool and very efficient.

This is very similar to what I found with the SynthMaker program that came with the FL Studio audio workstation software I've been playing with too. There you define the algorithm for software DSPs and GUI controls that change values using the same paradigm.

To see it in two places now, I'd love to have this available to the general public for any kind of application. Would it really be more efficient to write general multi-threaded and multi-process algorithms that way or would the modeling tools get in the way. Epic and SynthMaker felt it was right for their users, is it right for everyone? You know, I bet we could build this using Eclipse modeling tools and try it out...

Openness Shades of Grey

Motorola's newest phones are hitting the streets and promise Android goodness thanks to the latest Android release 2.0. Now if you think of Android as an open souce platform, you may have run over to the Android Open Source Project and tried to download the 2.0 source to see how they made it.

Uh, no. Android isn't that open. In fact, neither is it really a project. Android developement is really done on internal trees at Google and at the various device vendors. And the Android gang are pretty open about that on their mailing lists. I just wish they'd drop the open and project and just call it Android Source.

The unfortunate thing is that many in the community are naive to the shades of grey that exist in our industry. And complaints in the open tend to give projects a black eye. But each level of greyness has its purpose. For Android and most other projects that Google does, they want the flexibility to evolve the platforms quickly. Like it or not, truely open developement is slower.

Other projects need to be open to help grow the popularity of their technologies and to find people to help them build it. That's certainly what drives us on the CDT to be as open as we can.

The Eclipse Platform is an example of how projects change as their needs changed. No one complained when IBM started the Platform project 8 years ago and maintained almost full control of the project. It was necessary to ensure a great start, which it did. But over time, they've opened up as they realized they couldn't do it on their own any longer. So you change to maintain success.

I think the shades of grey are fine, as long as the licensing allows downstream projects to be as open as they'd like. And I see that happening with Android with the Android x86 project, for example, which is very open and just incorporated someone's code for better 3D support.

It's all good. People need to take a good look at the projects they follow and understand why they are structured the way they are to manage their expectations.

Unreal Development Kit

Wow. Unreal Development Kit. Free. Or at least free for free content. I've always wondered how developers create content for the big game engines, id and Unreal. And now I know and I have it installed on my laptop. For free. Can you tell I'm beside myself here. Check it out: http://www.udk.com.

At any rate, Epic has released their development kit for free. It's a great gesture and a great way to get hobbyists and students and even small start-up shops using their engine. It seems to be complete, including their famous editor, amongst a plethora of other tools that help you create full games that you can distribute (for free, of course, otherwise you'll need to pay for a license as you should).

Looking back at the archives, my second blog entry after saying "Hi", was on digital content creation tools for Eclipse. I conjectured that having such tools would be very cool. And I think it still would be.

And playing with the UDK, I don't see any technical reason why such tools couldn't be created using Eclipse technologies. With integrations with the various programming language and domain modeling frameworks and tools, and being able to run on Windows, Linux, and Mac, and target those and game consoles and mobile devices, what a great game development environment that would be.

That was my dream for Eclipse back in 2005, and it's still a dream I have for it today. All it takes is a community of like minded dreamers to make it happen. Oh, and some money to pay for the dreamers. Thus the dream...

It's Crunch Time

I haven't blogged in a while so while I have my head above water, here's a few notes on what's happening lately.

It's crunch time for me and my Wind River Installer team as we put the final touches on our next release of our p2-based installer. Our focus now is on on-line updates and installs which is a pretty exciting capability for our customers and support teams. I haven't blogged much about what we're doing there but I think it's time to start spreading the word. p2 is a great install engine. It can be used for more things than just OSGi bundles.

Unfortunately, our p2 stuff is intermingled with older install technology and what I can only describe as "legacy" UI framework. So we can't contribute much from that yet, but I want to switch focus and replace our legacy with a more modern framework, that we can use to replace the p2 UI that exists today. You really need to understand p2 to use the current one, and that's not something most end users do.

There are a few other things I have my fingers in. I'm still mucking with Android and my wife gave me the idea to build puzzle games. I think that's a great mobile app, something you can do while waiting for your next flight, or what have you. I'm still following native development for Android and plan to write a plug-in that automates the project conversion step to add CDT capabilities to Android projects.

I am also taking a look at Moblin. I bought a Dell Mini 10 and installed Moblin on it. It gives me another native platform that's actually GNU/Linux (Android is just Linux, BTW) to understand better how to use the CDT with it. That feeds into my technical focus on the CDT which will be on build. But I need to get out of the product release crunch before I get further with that.

I also am trying to find some time to look at a WebKit SWT Browser widget. There has been some work there for the embedded web project, Blinki, and I'd like to see if we can make it more generally available. Everyone who's deployed Eclipse on Linux knows the pain of the ever changing versions of XULrunner. I'm hoping standardizing on WebKit would solve that, but we need to see how well it works first.

Anyway, back to bug fixing.

A Good Leader is a Good Architect

I've been whining (yeah, that's pretty much the word) a lot recently about the state of contributions to the CDT and about the struggles I face even internally to get more time to spend on open source. I've been pretty frustrated and depressed about that and it's showing in my writing.

But the conference calls we've been holding to plan for CDT 6.1 are definitely a bright spot, and they're something I will get some energy and inspiration from. The gang that is contributing, while generally being individuals instead of the teams of people we had in the past, are really smart and have some great ideas. And that's something we can definitely build upon.

Analyzing my participation in these calls and in my day job at Wind River, I am really coming full circle to something I decided a few years ago around the time the CDT was just starting. I am an architect, not a project manager. I love technology and building things and making them good. With the CDT, the indexer was my main challenge and I had a good team to work with and mentor and at the end of the day, it's really good.

I had the same idea with the build model, but I chose to be a project manager for that portion and not get involved technically. I regret that now since I see a few bad decisions that are leading to the current mass of issues people are having with it on the cdt-dev list. Working with Leo from Intel who was there at the beginning too, we are trying to piece together what we were trying to do and I think if we step back to that time and move forward again, we can straighten things out.

So, I think that's how I get out of my current funk. I plan on doing less project management and do more technical architecture work and lead the CDT that way. The team that we have now are very new and there are others hovering around looking for ways to get started. They could benefit from the experience of the few that are still around from the early days when we had a good vision of what we're trying to achieve. And maybe we can grow some new leaders to help the next generation.

Looking around at projects that are successful, those projects get that way because they are lead by good designers that can communicate well, empathize with the customer, and mentor others to do the same. When you don't have a "Sugar Daddy", as I refer to the companies that invest heavily in open source projects (see Google and IBM), you need to lead in ways that make the open source team successful. And almost always, that means focusing on technology and architecture. A good leader is a good architect. And good leaders make good projects. And good projects attract contributors. And that's the answer to my riddle.

Android Notes and Ideas for Eclipse

Here's a few notes on things I've been doing with Android. I'm under no delusion that I can actually create an app for Android. My wife wouldn't be too happy if I spend the time it would need. But I am finding that this is a great exercise getting into the mind of a mobile developer and is giving me ideas on how to improve the CDT and the Eclipse platform.

I've been working towards constructing a game engine, something I've always dreamed of doing. I am starting with the physics/collision detection engine and looking to open source for solutions. I started with box2d and wrote a little demo that had 20 "marbles" (ok they look more like squares, but squares are easier to render with OpenGL :) that rolled around the screen as you tilted the phone. Essentially, I configured it to alter the gravity of the "world" to match the orientation of the phone. It's a neat demo and gave me a hint at how to use engine and how much horsepower it needed.

But in the long term, I'd like to support the 3rd dimension (love the Simpsons episode when Homer fell into the 3rd dimension :). There's another open source engine called bullet that does it. Interestingly it's very similar to box2d and maybe a bit more mature. So I ported that and got it working with the marbles demo. I was worried about performance, especially since bullet uses floating point instead of box2d's fixed point and my phone doesn't have hardware float. But it was fine, and it allows me to march ahead with bullet for both 2D and 3D physics.

Now, doing this all in Eclipse using Android's plug-in and the CDT for the native code has been generally a good experience. There are a couple of things that are still needed. One is a way to automate the steps adding the CDT nature and builders to Android. And there are some things that don't work. CDT's scanner discovery, which scans build output looking for include path options, no longer works for my projects since I upgraded to CDT 6.0.1. Setting it up for cross compilers has always been a pain, and now it just seems to not work :(.

The other thing that bugs me now, is something that has always bugged us in the CDT community, and despite raising several bugs, has never been satisfactorily addressed is the Eclipse build system. I've set my Android project to reference the physic engine library project to control the build order. But when I go to clean my Android project, which is small, it cleans the referenced projects too, which aren't so small. What makes it worse is that it kicks a rebuild right away so you can't just clean your project and leave it that way.

Hopefully with the new openness shown by the platform team we can get something done there. But we're all a little jaded from the history and we need to overcome that first.

No where's that open source hat?

One of the points from my EclipseCon talk on building communities was "Wear two hats." Essentially, to successfully attract new contributions, you have to show that you are working in the best interest of the project as a whole. Of course, you also need to make sure the project is meeting the commercial needs of the vendor you work for or else that might not last long.

This is something I've done always in my life at Eclipse. At times, I may have been too much with the open source hat and not enough commercial, but I always had a team with me to compensate for that so it worked out. I do believe that has been one of the main reasons the CDT project has been so successful growing a diverse community.

But as the CDT matures and the vendors who have made big investments in CDT reduce that investment to allow their developers to work on other things that are more important now, I get worried about how we're going to finish off things off. The CDT build system still needs a lot of work to undo and clean up some of the architectural decisions of the past. There are a few guys interested in helping, but these guys are just part-timers, not the dedicate investment we need to be successful.

All I have to hope on is that vendors will put on their open source hat and work for the common good. In theory, working with other such vendors to build a kick-ass build system would help them in the long run and should be cheaper, since they are benefiting from the investment from the other vendors.

But "theory" isn't a place we all live in and few vendors have the vision and long term planning to see that formula work. In fact, what makes it worse, is that vendors tend to see their "improvements" over base Eclipse functionality as a competitive advantage over the free Eclipse. And, trust me, I have seen first hand the view that the freely available Eclipse eats at the bottom line. And there is some validity in that since you can't charge the premiums for development tools that you used to, or so customers believe anyway.

It was a lot easier in the early days of Eclipse when everything was new and everyone needed development tools, especially on the C/C++ space. The vendors that kicked off the CDT found it easy to wear the open source hat because they really needed the help. Everyone fears the elephant in the room, so don't be one.

But now that the development tools are "good enough" the investment is no longer there to take it to the next level to make them "best in class". And as much as users of the free Eclipse see the deficiencies and raise bugzillas to have those deficiencies fixed, I have to feel for them.

As long as Eclipse is staffed solely by vendors making money on Eclipse-base product, the free one isn't going to be great. Now, also in that magical place called "theory", an Eclipse.com funded to do development would help as much as Mozilla.com helps Firefox. But it doesn't work that way in the Eclipse ecosystem and that makes the poor project lead who likes to wear the open source hat wonder whether it's worth it anymore.

Remember PluginFest?

It's been a while since it was held. The Eclipse PluginFest was a really cool event organized by Ian Skerrett and hosted by the folks at Symbian in London. It was part marketing event and part engineering event intended to show how off the promise of Eclipse as a platform by doing some interoperability testing between the different products, focusing at the time on the embedded/mobile market. For the most part, it was a success, especially for tools up the stack like analysis and modeling tools.

But one thing that was clear then and is still true today is that plug-ins from platform providers, generally vendors that provide tools for building applications and customizations for their operating systems, don't mix. In fact most of them assume that you are not building for other platforms and many of them have their own version of the Eclipse platform.

But as I take a look at the mobile space, it is clear that an application developer if they want to hit the largest possible market, are going to have to target multiple platforms. I don't see one winner taking hold yet. iPhone is in the lead, but Android is making progress, and the others are hungry for a piece of the pie.

The question is who owns that problem? I looks to me, anyway, that the platform vendors are actually more interested in locking developers into their platforms. That is most obvious with iPhone and the fact you can only use Macs as development hosts. The Android plug-in assumes you are using Eclipse only for Android development, breaking a number of UI guidelines along the way (I don't want to hear from it if my current workspace has no Android content, damn SDK location dialog, grrr).

I have no answers. My hope is that the newly renamed Sequoyah project looking at tools for mobile can be a focal point. That will require more vendors to participate in it. I think it'll also require the developer community to stand up and demand more from the vendors and maybe Sequoyah would be a good venue for that. At the end of the day, who is looking out for the poor app developer who needs to deal with all this?

Phone Games To Hurt Console Market?

Just read the NY Times article here that claims Apple is casting a shadow over the console game market. Of the 758 games shown at this week's Tokyo Game Show, 168 were cell phone games. That's a big number. I'm not sure if the premise is true, but it does open your eyes to a change that is underfoot.

And I think that's were my excitement over the mobile software space is coming from. These cell phones, like my personal HTC Dream Android phone, are decent little gaming machines. Now you aren't going to play first person shooters like I was earlier today with Halo 3 ODST, but for casual gamers they're a hit. And we see it today with the iPhone. When someone shows me their iPhone, it's usually to show off a game running on it.

Android has some growing to do to be a good software platform for mobile games. Good games need to get all the horsepower they can out of the phone without draining the battery, i.e. you need to write as much code to run natively as you can. Until Android gets support for OpenGL and other platform libraries needed to make games into their NDK, gaming on Android will be on a slow growth curve. But once it's there, watch out.

The new platform that caught my eye this week was Moblin, and not just because Intel owns Wind River (my employer). There was a big teaser announcement on Moblin, which until now was a netbook OS, being ported to run on Atom-based phones of the future. Taking a deeper look, I was pleased to see that Moblin really is a Linux "standard" distro with all the gaming libs you need, like OpenGL, gstreamer for audio, SDL for IO, that you get on a desktop Linux distro. I can't wait to see Atom in a phone and see how it compares to the iPhone and Android platforms of the day.

As I keep mentioning here in this blog, it's a great time to be a programmer if you get into the mobile space. There's so much innovation there, and so much opportunity to create something new. And being a non-traditional environment, it's a great place for Eclipse based tools to become the defacto standard, especially the CDT with it's flexible toolchain support and all around IDE goodness. There is activity going on in the community to bring that goodness to these platforms and I can't wait to try them out.

CDT 6.1, We're not done yet!

We had a couple of really good planning sessions so far this September as we put our plans together for the next release of the CDT, CDT 6.1 for Helios. We've been focused on Build and Debug. We'll continue to move the sticks forward for the editor and parser based features, but build and debug still have some major work to do.

On the build side, we're focused on improving the CDT Scanner Discovery mechanism that scans build output to try and figure out the include paths and defines that you are using for your build. That information is fed to CDT's parser to replicate the parse your compiler does. And that gives us pretty good accuracy to enable things like open declaration and content assist. This work will be a big challenge as we have a bit of a rag-tag group of part timers to try and get this problem area for CDT integrators and users fixed up. But it's a great challenge for me as a project lead to see if we can get as much done as we can.

On the debug side, there's some exciting news. As Ken Ryall from Nokia has been blogging lately, they've been working on a new debugger that's much more tightly integrated with the CDT, and they're ready to contribute it. Essentially, it's a replacement for gdb. Now you can argue whether that's a good thing or a bad thing, but I think it's a good opportunity to improve CDT's debug ability. And of course, it'll be able to sit along side our gdb support which continues to be important for a number of vendors.

But part of Nokia's work that has me most excited, is the native Windows debug support. This is an important step towards finally getting a complete Visual C++ integration for the CDT. I have a build integration almost ready to go. All that was left was debug support. While it is still missing support for Visual C++, Nokia's Windows debug API support gets us maybe half of the way there.

The other good thing about Nokia's work is support for gdbserver as the small agent that does the bit twiddling. Those who've done embedded development know about gdbserver as that's how you do remote debugging of targets using gdb. Reusing gdbserver gives Nokia's work a huge leg up for embedded developers working on all platforms that support gdbserver.

So despite being 7 years into our program, there is still work to be done on CDT. The community is still vibrant. We don't have the big vendor contributions like we used to, other than Nokia of course, but there is still a lot of work to be done and individuals and smaller vendors who are interested in helping. So to quote Monty Python, we're not dead yet :).

Eclipse Tools for Mobile Needs Some Buzz

I attended my first Sequoyah (Eclipse tools for mobile, except J2ME, but that's another story) meeting today. Why am I? Well I'm getting more and more into mobile app development in my hobby time, at least for Android anyway, and I'm turning that into a personal focus on better support in CDT for mobile application development. We can then make this available for platform vendors who want to better support developers making applications for their platforms.

My plan is to start by building a set of plug-ins that automate at least the build setup for Android JNI development. Debug is another story and maybe someone else can help with that. And we can look at what's needed for other open source mobile platforms down the road as well. And maybe some other vendor will come along and help out.

But, as I dig into what's happening with mobile at Eclipse, I'm a bit surprised, and disappointed, about how little there actually is. Motorola is putting forth a great effort and contributed a significant amount. As with most vendors (almost all) that contribute to Eclipse it is mainly focused on their own commercial needs. But they also don't seem to be getting much help from anyone else. It takes multiple companies to make a platform and it's sad to see that isn't really happening, despite all the marketing buzz surrounding Pulsar.

And I was also saddened to see Craig Setera's blog for help for the Mobile Tools for Java project. MTJ is probably the project hardest hit from vendors coming and going that I've seen. And after the push to get Craig's EclipseME project merged in for the reboot, I was hoping for greater things there.

On the Sequoyah call, I was asked for advice on how we could solve these things. Man, it's tough. You really need a community, and in particular, a vendor community, that has a vested interest in contributing. We had it easy with the CDT. Everyone needed an extensible C/C++ IDE and it made business sense to invest a person or two to help make it happen. I had it pretty easy as a project lead, and I feel for Craig and the Motorola gang as they try to get this thing going.

The only thing I can come up with is a trick I used in the "dark" days of the CDT after my team at IBM were reallocated. "Create the need". Find something that vendors will see the need to invest in. Usually, this is in the form of some platform piece that they know they need and that multiple vendors can work on, and then show that not enough people are working on it so it's going to suck in their product too.

I'm not sure that's going to work here since there seems to be a huge hesitation to make contributions from the vendors who could be contributing. But that was true with the CDT in the early days too. It was the QNX+Rational show for quite a while until Intel and TI broke the ice.

At any rate, I'm posting this as an attempt to help Eric C out. I'd really like to see Sequoyah succeed and for us to have a nice set of platforms and examplary tools for mobile app development at Eclipse. But that won't happen without growing the community and we'd certainly be interested in your thoughts on how we can make that happen.

Apple leading the way in multi-core programming?

One of my pet study areas is programming paradigms, something I've done since my university days looking at SmallTalk (object-orientation) and Ada (safety critical). The next great next battle line is how to take advantage of multi-core machines to do parallel computing without blowing our poor programmer minds. Intel is doing a lot of work in this area and it's really interesting that Apple is doing the same. I'm not sure why, but good on them.

The two technologies that seem to have sprouted from them and are supported in Snow Leopard are OpenCL, the Khronos standard for mixed GPU/CPU computing, and Apple's Grand Central Dispatch, a task parallelism extension to C, C++, and Objective-C with something called Blocks. There is a recent report from Hardmac.com that shows some real significant improvement form these technologies.

I don't know much about either, but this is definitely something I'm adding to my reading list for those nights I can't get to sleep (which if you're following me on twitter you'll notice are happen regularly).

State of the Doug

I've been tweeting a lot, but tweets tend to be temporal things that disappear after a short time, so I figured I should blog some of those things. Assuming anyone really cares, but that's part of the mystique and something I call the "cricket factor", when you tweet or blog, and no one's listening, and all you hear back are crickets in the night. But anyway, here's what I'm up to lately.

I made quite a splash recently stating my frank opinion on e4. I had lots of good feedback on that and I pissed off a few people. But I met my objective of making people think about it. To summarize, I worry about the stability of the platform and how e4 will impact the hugely understaffed projects up the stack. And I don't like RAP. If you're running web apps, follow the investment in JavaScript engines and put your UI code in the browser. Which also means I don't care much about the e4 UI work either. But as one e4 committer mentioned to me, "it's fun". I'm sure it is.

As cool and interesting my investigation into GWT has been, I barely get a day a week to do open source work and I still have a couple of things I want to do with the CDT, i.e., help clean up the build system, and support JNI debugging. And I want to spend my hobby time on other things. So enough of that. A lot of people get GWT and how it works well with Equinox, so it'll live on without me.

As for my hobby time, I am getting more and more pumped by what's happening in the Android space. So I'm turning back to that and hope to feed my curiosity on game development by making games for Android. Not sure I'll ever get far enough along to get something on the Android Market, but it'll make a good winter activity. And who knows, maybe we'll see Android running natively on Intel chips some day.

So that's where I am. I have way more ideas than time to work on them having a family and all. But I'll continue to blog and tweet things as they come to me, at least as they relate to open source, and maybe that will help others, or maybe it'll just feed the crickets.

Using CDT for Android Native

Android has a native development kit (NDK) which can be used to create JNI native code for Android applications. In this video, I show how I convert an Android project in Eclipse to add the C/C++ nature to it and set it up to build the shared library that gets included in your Android apk file. This gives you all the power of the CDT in combination with the JDT to build Android apps with native code. Except for debug, though, as JNI debug remains the lost holy grail for the CDT...

If you want to look at the code from the demo, you can clone or download from http://github.com/dschaefer/androidDemo.



Link to YouTube

Time to break down the Silos between the *DT's?

What started out as a personal need for writing and debugging JNI-based applications, both based on Eclipse and for Android, has turned into something bigger, a lot bigger. The hardest problem we face for what I'm doing is supporting multiple debugger technologies in the same debug session and ensuring a nice seamless experience. Showing both Java and C/C++ stacks merged together and stepping back and forth between them would be the cat's meow.

As I'm starting to hear from the greater Eclipse community, there is need for cross language/cross technology debugging in other areas as well. One example is Rhino which is being used by the e4 team to support writing plugins in JavaScript. Having a debug session with JavaScript and Java in the same stack would also be awesome. Similarly, we have JavaScript or ActionScript running in the browser interacting with a Equinox server, or maybe PHP running in Apache. Web applications are the manifestation of distributed applications and, as promised, those applications tend to involve multiple languages.

Traditionally, the language tooling projects at Eclipse have lived in silos. The CDT team has have very little interaction with the JDT team, for example. And that's not generally the fault of the team members. It's just a symptom of the lack of investment in Eclipse towards common technologies. Being an engineer, I have no idea how to solve that except to ineffectively whine about it. ;)

But one objective we've had with the CDT was to ensure that the C wasn't just for C/C++. Many of our frameworks are language independent as much as we practically could. We haven't had enough investment to be able to push that out to the general Eclipse community, but we do have projects like Photran (Fortran) and the fledgling Hibachi (Ada) and the new but remote ObjectivEclipse (Objective-C) doing that.

I think in particular, our new debug framework, DSF, could be used for much more than C and related languages. DSF started out as a solution for the difficult debug environments we face in the embedded space and actually started as the Device Debug project of DSDP. We've migrated it down into the CDT in 6.0. We've often quipped that it really should be down in the Eclipse platform itself. There will be challenges, technically and otherwise, to make that happen.

What I want to do is start prototyping multi-language, multi-debugger debug sessions based on DSF. That would initially include Java and C/C++. I'll also take a peak at JavaScript debugging and consider how that impacts it. I'm confident the flexibility we brought with DSF can be leveraged to make the Eclipse side of this relatively straightforward. The bigger challenge will be co-ordinating the different debuggers.

If others are interested in this work, we should co-ordinate our efforts. Let me know and we could set up a mailing list to talk about this area, and hopefully we can start breaking down the silos.

Using Git GUI with Eclipse

Here's my next set of screencasts showing how I use git and git gui in particular with my Eclipse projects. There are two parts. The first shows how to set up a workspace based on a git clone repository, i.e. copying a remote repository to your local machine and setting up an Eclipse workspace for that repository. The second part is how I commit and push my changes to the remote server as I develop code. Hope this is useful.

BTW, This is best viewed by clicking on the YouTube link and watching it full screen in HD mode.

Part 1 - Creating your Workspace

Link to YouTube

Part 2 - Committing and pushing a code change

Link to YouTube

The JNI Debug Problem

One thing I noticed the other day was that I'm doing a lot of JNI coding lately. In our Wind River Installer, based on p2 BTW, I have native code for doing a few things like compression and getting at the Windows registry. The CDT has native code for doing advanced process management, and getting at the Windows registry. I've played with Android native development which is all based on JNI. And I was thinking of hooking up the ALSA library to do Audio management with my prototype "Eclipse OS". That's a lot of Java/C coding. And, unfortunately, all without a debug solution :(.

JNI debugging was one of the early goals of the CDT. Unfortunately, it has never really materialized, at least not generically in a way we could incorporate into Eclipse. And given that I see a strong symbiotic relationship between Java and C/C++, I am getting more motivated to tackle this problem and see if we couldn't come up with a solution that we can integrate into the JDT and CDT (or maybe just the CDT).

But the first thing you run into when looking at the code, where do you start? I'd like to be able to step into native methods, hit breakpoints in native code and see up the stack all the way into the Java stack. And really have an integrated debug experience where you don't have to do much of a paradigm shift when going between the two worlds. And given the way the Debug platform is structured, that should be possible.

So there's different ways to slice the cat (not that I slice cats, I like cats). You could add an extension point to be able to plug in native handling into the JDT debugger. I'm not sure what the JDT gang feel of that, or whether they've hopefully thought of that. Another solution would be to build a new Eclipse Java debugger component, but base it on CDT's Debug Services Framework. That may make a more natural solution, but I fear it would be a lot of work and it would take a lot of investment to reach parity with JDT's debug solution.

I'd like to hear what the community thinks. What is the right solution. Hopefully we can come together, find the development resources, and finally reach this Holy Grail for the CDT.

What could an Eclipse OS be?

I got some really positive feedback on my quick little demo of the "Eclipse OS" prototype that I've started building. So I've started to capture ideas on the github wiki for the repository that I created there. Feel free to add your thoughts there, or here. Maybe if there's enough interest we could grow a little community around the idea. If not, that's fine too. I'm really just exploring a role Eclipse technologies could play in a browser based "OS" such as the announced Google Chrome OS.

Here's the link to the wiki and here is what I've started with: http://wiki.github.com/dschaefer/eclipseos

What should the Eclipse OS be? Take one of those new fancy 10" netbooks. Install enough Fedora to xinit the Google Chrome browser with the Flash plugin (necessary in my books for a full web experience) and launch an Equinox standalone server. What local web applications would you need to manage your netbook? Feel free to add to this list.

• Power Off. To shutdown the OS and power down, i.e. run the poweroff command. (Update: this is the first app and is now working).
• Install Manager. To install new web apps into the server using p2. Integrate p2 with yum to install native components that the web apps may need.
• Audio Manager. Similar to ALSA mixer but as a web app. To control the volume of the audio in the least. This could be a good first test of writing native code to help implement the service.
• File Manager. To look at and manipulate the files on the system, maybe even open them in the browser.
• Connectivity Manager. To manage wireless and wired network connections.
• Power Manager. To manage power saving modes.
• Office “Suite”. To prepare documentation and presentations while disconnected, like on long flights.
• E-mail. For those who would like offline access to e-mail.
• An IDE so I can build my web apps locally (thus the connection with my Web IDE (W-IDE) prototype).

Screencast Test

After asking around twitter, I had a number of people recommend TechSmith's Jing for doing screencasts. These are the same guys that do the masterful Camtasia which is a more full featured, i.e. expensive, solution. Jing does a good job at capturing my screen and audio. It's limited to 5 minute videos, but give that my main purpose is to share quick ideas with my blog readers, I think that's fine.

So here's my first screencast test. I'm showing the current state of my "Eclipse OS", i.e. Fedora minimal install + X + Chrome Browser + OpenJDK + a standalone Equinox app server. There's not much new here. But I'm really just learning how to use this media. One thing I learned as you'll hear half way through, is that my laptop fan kicks in. Drives me nuts, but anyway. Expect a lot more of these in the upcoming weeks. And hopefully, I'll improve the quality as I go to (like talking louder :).

Update: uploaded to Youtube which gives a much better viewing experience, especially in fullscreen mode.

Update 2: Planet Eclipse seems to filter out the embed object. Click on the title to come to blogger to see the real thing.

Eclipse OS?

I left a pretty cryptic entry last time. Essentially, I am trying see how easy it is to build a Chrome OS using Fedora as a base. It was pretty easy, and I have the instructions on how to do it. I'm going to put together a series of Jing screencasts (my new favorite screencasting tool), to show you how. That'll take a few days to get together, especially given the beautiful weather we're finally getting here in Ottawa.

But I wanted to show you a screenshot of the final result. Because, not only am I doing a Chrome OS look-a-like thing, I'm also putting Fedora's OpenJDK and an Equinox server application on it to run applications locally. In this case, it's the GWT Greetings app that you get when you create a new GWT project in Eclipse.

As I mentioned when I first heard of Chrome OS that it would be great if we could put Equinox on there to run local apps. Now I have a chance to expand on that idea and see whether it makes sense. Once I get the instructions together you can try it to. Could this be a start of an Eclipse OS?

Chrome OS Preview?

I'll be posting more on this later, especially how you can do it yourself. But I've built what could be the upcoming Chrome OS. I did it starting from the Fedora 11 net install and added what I needed, which wasn't much. Here's a teaser screenshot until I can firm up the recipe :)

Web apps make me think MVC

I'm blogging more than I'm coding lately, so I'll try to keep this brief. But I noticed someone mention MVC while I was googling around for practical information on GWT. After I thought about it a while, building a web app is a great example of the Model-View-Controller paradigm.

The model is data you store or derive on the server. You can use GWT's RPC mechanism to get at this data. The Controller is also on the server. You can send commands, like build my project, to it via GWT RPC too. The server may then farm that out to other specialized servers to actually perform the action. The View is the JavaScript code running in your browser that takes the data and draws it using GWT's widgets and invokes the control using GWT's Handler mechanisms. Having a well defined RPC mechanism, and having a requirement to reduce the traffic over the wire to help with responsiveness, you get pushed to keep your web app MVC clean.

Now, relating this back to my mobile app interests, I can easily see the View portion of the app being replaced by the native widget framework for the particular platform. As I've mentioned in previous posts, I don't think running a web app in a browser in a smartphone is a good idea. I know the browser on my Android phone is really slow. You're better off using Android's native widget set in Java to accommodate the form factor. That's what mobile app building is all about. What I need now is an implementation of GWT's RPC mechanism in Java using Android's communication APIs, and really interesting things jump into mind.

What this leads you to is having three View implementations for my web-based IDE, that I'm now calling W-IDE. One in the web browser using full GWT, one in Android using Android's native widgets but still communicating with the services defined in GWT, and one using the regular Eclipse desktop UI, theoretically using those services as well.

Now, yes, that's three implementations of the same thing, and I know how that rubs people the wrong way. But my theory is that they are, in fact, not the same thing. Depending on which of the three you have, you are likely to need different workflows. Running Eclipse in a 24" monitor, it's OK to have all those views and taskbars and such visible all at once. In a browser running in a 10" netbook, not so much, and you'd really like to make it page based to take advantage of the browser's history mechanism. And in a 4" smartphone, I really struggle with any workflows that make sense, but they certainly would be limited to one view or editor at a time.

At any rate, this is sure turning into an interesting journey of exploration. In the end, we may decide that this is all crap and IDEs are meant to run on desktops only and that using RAP's server-centric architecture is OK to render in the browser (which if you can't tell yet, I'm not sure I agree with). But this is a 5 year journey and we have time for the different technologies involved to mature and we'll see. I think we have a lot of time to figure this out.

And, yeah, I guess I failed at keeping this short.

Are we de-evolving or on a natural evolution?

Talking around the office about a future with web-based IDEs, it was interesting that people are starting to get it, or at least, not scoff that it's something we'll ever to deal with. There are some good aspects to it for the tools business. At the least it's a great way to quickly get our products out to customers with minimal install fuss (the bane of my existence these days at work), and it's a great way to get immediate feedback on what they find valuable.

The question that needs to be answered is why now? I remember back in the 90's we were clamoring to get away from the client/server model. Everyone wanted a PC or workstation on their desk and former stars of the server world, DEC in particular comes to mind, faded away. Servers found a new life thanks to the web and it seems now, about 20 years later, we starting to climb back onto the client/server bandwagon. Why did we get away from that architecture and what's happening to make us want to go back.

From what I know, looking back, I think one of the biggest problems with servers in the 80's and early 90's was their sheer cost. They were expensive machines. You could buy 100 PCs for the cost of one of these things. Worse, yet, they didn't provide 100 times the compute power. The price/performance ratio made PCs a smart bet. They are both cheep and powerful. That, and they provided freedom to the user. If the server went down, they could keep working, and if they wanted to install some "forbidden" software, they could do it. It was really refreshing come to think of it.

But as any IT professional, or installer guy, would tell you, maintenance of all these machines is a nightmare, for the admin, and for the bottom line. As employees of larger companies well know, there are companies making money on software that beaver away in the background making sure all the other software is kept up-to-date and on the up-and-up. And, of course, some of the more rogue employees know how to uninstall that software and get it out of the way ;).

What the old server model provided was that ease of maintenance. You installed software on one machine and all your users had instant access to it. Of course there are risks to that as all of us tweeters had to deal with today, but with an improved focus on security and robustness with these critical server apps, like we had in the server era, those should become rare.

That, and looking at the cost of servers these days, the costs are way down. I would think that the price/performance curve is turning towards the server side. And just look around your workplace and count the number of CPUs sitting idly. It would be an interesting study to figure out what percentage of CPU power companies have is actually being used. It might make more sense to spend more on servers and less on desktops. You don't need that much power to run a web browser, especially with the ever improving JavaScript VMs that we are finding in them these days.

It's not really far fetched today to see a future, say five years away, where all of our apps are running on servers, in the "cloud" say, and we are accessing them through "dumb" terminals running web browsers, which is what Google's Chrome OS and I'm sure others will provide. The economics are right. The culture though is something else. Are users ready to give up the freedom that traditional desktops provide? I think so, but only if the applications provide significant new value. Tools that integrate with other web apps to allow collaboration over the web could provide that value. Running desktop-style apps that simply display themselves in a web browser, will not.

Time to come clean. I'm a Google fan-boy

I appreciate all the comments on my last blog or two about how e4 is doing a lot of the things I am trying with GWT. I don't dispute that. It's even interesting that RAP is planning to build on top of GWT. That's fine. I respect what the e4 guys are doing, it's a huge task and they are trying to modernize Eclipse as we all agree is necessary.

But I'm just wondering if using GWT directly while using OSGi web services to hook up to the IDE things I need in Eclipse, which is essentially IResource and up, is a better architecture to get us to a web-based IDE. And right now I'm trying to keep it simple and avoid any layers on top that e4 may be providing. Maybe there's a compromise choice. And I'll be open to that once I fail, which will not surprise me in the least. But I need to see first hand at what's possible in the GWT world. In the short term, that probably means I will appear to be anti-e4. But I'm used to being the bad cop by now, I guess.

So why am I doing this? OK. I admit it. While I have no contractual relationship with Google, I am a Google fan-boy. I have an Android phone which I am learning how to build apps for. The Android momentum will be unquestionable over the next few months as new handsets land like the rain in Ottawa this summer, including ones from our Eclipse friends at Motorola. Chrome is my default browser, although I'm using IE8 on my 64-bit Windows 7 laptop to check out its progress (which is actually impressive). I'll go back to Chrome once I get the RTM build installed. I use Google Mail for my Eclipse mails and am finding it nicer to use than the Outlook I use in my day job and I can access it anytime, anywhere, especially on my Android phone.

Google Wave and Chrome OS are technologies I am very excited about, and I have no doubt they will have a dramatic impact on our industry. And it's Google Wave that I have an eye on for this IDE work. That is my end goal. I believe following Google's way of doing things is important in that journey. And while not all Google products use GWT, Wave does, and it was the excitement for GWT I heard in the Wave lead's keynote at Google I/O which has driven me here.

And maybe that makes me the Google fan boy at Eclipse, so be it. You wouldn't bet against Microsoft in the last decade or so. I don't think you should be betting against Google now. And while the relationship is good on the tools side, I want to help make sure Eclipse isn't on the outside looking in when it comes to these run-time technologies.

GWT + Server-side Eclipse = W-IDE

Someone once asked me why we break up things between ui plug-ins and core plug-ins. My theory was that we could eventually swap out the ui with something else. I didn't really believe that at the time, and I'm not sure how well architected our CDT plug-ins are to allow that, but it sounded good.

So as I begin my journey down the road of web-based IDE's it really struck me that this was the time to swap out the UI. My theory goes like this. Google are the experts at creating web applications (and you may disagree with that, but stick with me). They have a framework for building them called the Google Web Tooklit, GWT, which allows you to program your UI in Java which then gets compiled into JavaScript. And, they have a really cool RPC mechanism, again all in Java, that overlays Servlets. Hey, Equinox plus Jetty gives you Servlets. Why not swap out the Eclipse UI code with a GWT implementation that talks to our Core code using Servlets?

A big thanks goes out to Ian Bull who reminded me of the example project he created last year that shows how to use GWT with Equinox OSGi. I have extended that a little to call into the Eclipse workbench, right now calling Platform.getOS(). This is the start of my prototype web-based IDE using GWT as a front end to the Eclipse IDE Core parts. And I am pumped the deeper I get into it. Feel free to follow along as I check my prototype into http://github.com/dschaefer/w-ide. Feel free to fork that and join in the fun. (BWT, I need to show you the cool way I'm using git, stay tuned).

As Ian says, "GWT + OSGi is a great platform!" And I am starting to see why. It really is. So much so that it confirms my earlier conjecture that Equinox would be a great addition to Chrome OS and I hope Eclipse people are talking to Google people about that. Wouldn't it be cool to see Equinox serving up local server pages, presenting a p2 install web UI to download and install bundles into your favorite mobile device. Yes, it would be cool.

Oh, yeah, and here's my vision

Ian pointed out that I actually didn't state what my vision for Eclipse was. I noticed that after I posted, it was probably the wrong title for what I ended up writing. I'll try again, maybe sooner than later, I'll actually get my point across.

I do have a vision for Eclipse, or rather, Eclipse as an IDE. Eclipse is so much more these days, I really need to differentiate myself. I am an IDE guy. Eclipse started as an IDE, turned into a great IDE, let's keep it that way. Maybe that's my vision. Keep a good thing going with focus on stability and quality.

I also have a vision on where IDEs are going, and I mentioned that in a previous blog where I stated the prediction that the desire for software developers to write software using mobile devices will drive that vision. But in the end, I think it's more than that.

This vision comes from watching the Google I/O keynote on Google Wave. If you haven't seen it yet, do so. Whether Google Wave is the right technology or not, the workflows they present are the future. I have no doubt of that. And it's all about collaboration, including real-time collaboration, through your web browser. And that let's it run on any platform with a web browser, which is pretty much everything.

I was especially struck with the demo of the team working and commenting on documents. Everything becomes a document, or a Wave in Google's terminology, and everyone can contribute to it. And it keeps track of who contribute what and when.

The first thing that popped into my mind, being the IDE guy, what if the document was a source file? Wouldn't it be cool to post a source file for review, have people attach comments to it, maybe even edit it to propose changes, maybe even work on it together live? Pair programming accross the internet? Doesn't that make sense in the global world we live in with software teams spread accross the world? Working in the same environment I do other collaboration. A bugzilla front end in Wave is a natural, integrated with my source in Wave, a truely integrated development environment?

Given that as a vision for IDEs of the not so far away future, how does Eclipse fit in. We have so much invested in making Eclipse a good IDE, I'd hope to keep as much as I can. And I think we can, removing the UI front end, which would be handled in Wave, and providing services that provide access to all the good information that our indexers and such provide. Even providing access to remote build and test machines to complete the edit, build, debug cycle. I think there's a significant role for Eclipse there, and thanks to Jetty and the HTTP Equinox/OSGi service, we could do that today.

So that's my vision, long and short. In the short term, though, I need to keep customers happy and try and convince new customers that Eclipse is right for them. And that's where stability and quality are criticial. And that's where I'm coming from. I'm Walt Mossberg, uh never mind :).

What is the Vision for Eclipse?

I'm on vacation, it's rainy, so I might as well write and maybe provide a little more insight into my thinking on e4.

Now, to start, I must first apologize for the tactless way of bringing this up as I did. As the title stated and I tried to reiterate throughout the entry, these are my fears for how the CDT fits in with e4. Nothing more, nothing less, and certainly not meant as a personal attack on anyone working on e4 (and no, despite common belief, I don't work on e4). It was really targeted at those outside the e4 community to take some time and understand how e4 impacts them.

I've sent a request for feedback to the cdt-dev list, so if you're there or even if you're not, please send me a response. I really want to know what the needs of the CDT community are so that I can properly feed them to the e4 team. The feedback I have so far, and so far it's been private, but that's OK, is that e4 is OK if we don't have to do anything significant to adopt it. Which then brings up the point of why adopt it if we're not going to take advantage of any of it. The other feedback that I got is that e4 isn't solving problems that our community has. Hopefully I'll get some more information. But, so far, it does justify asking the question and justify my fears.

My biggest fear for Eclipse is apathy. We're all working on our projects and being successful at it. As I said, I'm a happy user of the Eclipse SDK and CDT, especially with the new CDT 6.0. And I'm bragging about it to the Android NDK community as we speak. I know a lot of people question e4. I just happened to be dumb enough to blog it out loud.

My Biggest Fear for e4

A buddy of mine noticed that I don't get as many comments on my blog as I used to. He thought it was because I wasn't being controversial enough. He's probably right. Most of my readers follow this on Planet Eclipse and I haven't really commented on that much lately other than the great fun I'm having using it for my Wind River Installer work and for Android native development in my hobby time. I'm just a happy user now, I guess.

"Linus is a wise man"

Following Ian Skarrett on Twitter, he points us at an article in Linux magazine where they discuss Microsoft's Linux driver patch that I'm sure you all heard about. They quoted Linus, who is indeed a wise man with a cool head. He's just happy to get a contribution from a new member of the community and doesn't care who it is. That's certainly one of the big factors to the CDT's success as hard nose competitors worked together peacefully. It's the only way to be successful. Don't let emotions cloud your judgement.

Selfish need drives contributions

The other thing that Linus pointed out was that "I agree that it’s driven by selfish reasons, but that’s how all open source code gets written! We all scratch our own itches". He's bang on there. All of the vendors I work with on the CDT are contributing to it to make their products better. I'm sure that's true for many open source projects. For the most part that's a good thing, since open source users get the benefits of that work. But it also means, if there is a feature you need that none of the vendors do, you aren't going to get it. And as much as we beg people to contribute, it rarely happens. ~350,000 open source CDT users, ~3 contributors, that's pretty rare.

What does this mean for e4?

Well as much whining as the CDT community has done over the constraints we have to deal with via the IResource system, we only got one contributor to the e4 flexible resources project. And even there, the changes being done should end up in the 3.x series and isn't a major break from current system. So I can only assume that vendors are dealing with what they have and the need isn't really there for them. But I do know there are some big open source users who need it. Time will tell if they are big enough to invest in it.

But my biggest fear is the rest of e4. There are some pretty major changes in it. Will the contributor community feel the need to adopt it? And what do you do when certain vendors don't want to adopt it? What do we do with the CDT if none of the vendors step up to support e4? Stay on e3? What if Mylyn decides to support e4 and drop e3? What if we're forced to adopt e4 if the rug gets pulled out from under us on e3? And don't let backwards compatibility fool you, there is a massive verification activity in the least to make sure old plugins work on the new platform.

My big fear

I've stated this before, and it remains true today. We're headed into uncharted waters with e4. I fear that the contributing vendors to the CDT will not put the effort into supporting e4, because they don't have the need. And I think this is too big to artificially "create the need". Eclipse can't afford two platforms. Yet that's what we seem destined to have. A lot of CDT vendors consider the CDT finished. We have very few new features on the horizon. That will likely mean less contributions. How are we supposed to pull off adopting a new platform? That's my biggest fear.

Project Navigator: Apologies to all

I have to apologize to the Platform team and Francis in particular for my earlier complaint about duplicate entries showing up in the Project Navigator. It turns out that the problem was actually all CDT, or more specifically, how I set up the CDT part of my combo JDT/CDT/Android project.

By putting my source and build output into their own subfolders in the the project and setting the C/C++ Paths settings to point to them and not the root Project folder, the CDT stopped trying to display the other folders in the project in the navigator, the JDT folders in particular. No more duplication!

My disappointment has turned into happiness. I can now work on my Java and C++ files using the same perspective. The only thing that still doesn't make sense is the tool bar where the new Class button still depends on the perspective, but that's minor.

I'll have to come up with some way to automate the creation of what I call JNI projects that have the mix of Java and C/C++ so others don't run into the same thing I did. Maybe an improved Convert wizard.

At any rate apologies all around and thanks!

Mobile will drive "IDE in the Cloud"

I'm in the middle of making some last minute code changes for work before I start my vacation, or staycation as I hear lots of people calling it these days. We have a pretty big JUnit regression suite to test our p2-based installer, and I made the mistake earlier this week of not running it and ended up having to rewrite the algorithm to solve scalability issues. Lesson of the day, don't create too many Java objects in long running native code, Lord knows when they get garbage collected.

This mobile machine's hot, man!

The main reason I didn't run them was because I was working at home with my laptop that day. These long running tests create some massive heat build up in my machine. I lost a hard drive a few years ago doing something like that and it's made me nervous ever since. I really don't think laptops are built to handle the intensive compute and disk workloads that I need as a software developer. I think I'm pushing the envelope too far. In fact, I was going to start this blog while the tests were running earlier this evening but the heat knocked out my wireless.

The ultimate mobile developer platform?

I'm sure you've all been following the Chrome OS "shiny object of the week". The technical details of the OS itself and the supposedly sinister plot by Google behind it aside, there is no doubting that the designs for the upcoming sub-netbook, aka smartbook, machines are pretty exciting. All day battery life, integrated 3G or WiMAX connectivity anywhere, and with big enough screens to actually be useful. And, yeah, looking at the processors that allow you to do that, you aren't running Eclipse and gcc on these things to any great scale. But I'd love to use one of these things around the house or on trips to write code with. Especially if it lets these burn marks on my legs heal ;)

Mobile will drive IDE in the Cloud

So assuming you want to write software using a mobile device, how would you do it? And, you know, after all the naysaying I did about "IDE in the Cloud" at EcilpseCon, I finally get it. Wouldn't it make sense to have a workstation setup where you keep all your development tools and do your builds and run your tests, and then be able to access that all from a web browser anywhere in the world? from any mobile device in the world?

That flexibility will drive demand for this architecture, for similar reasons we used this architecture in the pre 1990's where we used to have dumb terminals connected to powerful DEC VAXen (at least they were powerful for the time). What we're talking about isn't much different than that, only the terminals, i.e. the mobile devices, are a bit smarter. But then the compute servers are probably equivalently faster if not more so.

An opportunity to simplify

And, yes, we do use VNC and other remote desktop protocols and clients to accomplish this today. And maybe you can so something similar in a browser (in fact I know you can, ever see WebHuddle?). But with these things I think you'll run into the screen size issue. Myself and a lot of my Eclipse community colleagues have presented Eclipse on 1024x768 projectors and it's brutal. The IDE just doesn't scale that small to be useful. But this is the screen sizes you have to deal with on mobile devices.

While working through this new architecture and solving that problem, I think it's also a great opportunity to simplify the IDE. New users find Eclipse overwhelming with all the views and toolbar buttons and menus, it's really tough to know what to do next once you fire it up. Being in a browser opens the door to new ways of working. I think we're still trying to figure out how to do content creation via a browser, and from Google Apps and Microsoft's upcoming web-based Office suite, we'll learn a lot and maybe some of these things can be applied to software development.

Is it time for a new platform?

Mobile is driving a lot of change in the software and device world. I really believe the software developer will be able to benefit from it. But I wonder whether the platform we've built with Eclipse is the right vehicle for this. I know the IBM team is scrambling with e4 to address that. But I'd like to see real innovation here, something that breaks away from the old desktop IDE paradigms of the past. Maybe Eclipse's "Black Swan" is out there. If it is, we'll have to make sure we recognize it and welcome it to the community.

Android versus Chrome OS in Netbooks?

Just a quick one. There were a lot of rumours about Android running on laptops, with Acer especially. Now they're wondering if Chrome OS wills squash those plans. People, Android was never meant to run on netbooks. You are worrying about something that was never going to happen in the first place.

If you ever watch the Android UI presentations at Google IO, they pretty much confirm that. At one point one of the designers commented that Android developers need to deal with screens with more pixels, but to deal with that by checking density, not physical screen size.

All Android apps are being built assuming a 4" screen. It would suck if you try to stretch an android list widget to a 10" netbook screen. Big screens isn't what Android is about.

Update: I just read that Schmidt and friends just mentioned the two projects working closer together in the future. Chrome on Androids Linux/BSD OS but without the Java based UI and the Dalvik VM that drives it makes sense to me.

More Thoughts on Chrome OS

As quickly as it came, the hype has died down over Google's announced Chrome OS. There hasn't been much to stoke the fire so it's died down naturally. And that's a good thing. There's a lot of lead time to figure out how we all fit into this story, if we want to fit in at all. Here are a couple of more thoughts that came to me as I read all the stories. BTW, it seems some writers have already played with the OS, or they're making a lot of assumptions...

Equinox as a local app server

One of the coolest features of OSGi and the Equinox/Jetty implementation at Eclipse is as an app server. This is something I've always wanted to spend more time with. I don't think Chrome OS will be successful without some means of running local applications and the marriage between Equinox and the Chrome browser is a natural. I'd hope the two of these groups are talking.

GWT or SWT browser edition?

To be honest, I'm a neophite when it comes to what's happing with running Eclipse in browser mode, be it RAP or the new e4 SWT browser stuff. All I've seen are demos that try to make the browser look like a desktop app. I think that's doomed to failure. The more you make it look like a desktop app, the more users are going to expect it to work the same as a desktop app, and that just isn't going to happen.

I'd take this opportunity to reinvent my application's UI, to break away from the paradigms that the desktop has locked us into and to come up with cleaner, more workflow driven UIs. Having good tooling is still a must. The Google Wave guys were quick to pour praise on GWT which they used to build the Wave app. I'd pick that if I were starting down this road.

Is there a role for native in Chrome OS?

Believe or not, I think the answer is yes. We'll I'm sure you believe that I think that but anyway. Chrome supports the NPAPI native plug-in API that was started by Netscape/Mozilla/Firefox and is now supported by WebKit/Chrome/Safari and Opera. If you have the need for a high performance app that does it's own rendering, like a game say, then NPAPI is for you. Google already does this for it's O3D graphic rendering API. You can too.

Now, what you can also do with NPAPI is present your C++ objects for JavaScript scripting in the browser using this interface. Now didn't Dave Thomas say something about C++ and JavaScript being the future in his Eclipse Summit Europe keynote last year?

ARM versus Intel

It's not a secret that Intel has an offer to purchase my employer, Wind River, on the table. That hasn't closed yet. But I have to agree with the analysts who see this will help ARM and it's partners. More interesting, though, is that this will really be the first time that ARM platforms and Intel platforms will be running the exact same software platform. It'll be pretty easy to see who's netbook/smartbook/mobile solutions are better. More importantly, it'll drive both of them to raise the bar, which at the end of the day benefits the consumer like good healthy competition does.

Google Chrome OS

Google announced it's initiative to build an OS around it's Chrome browser. About time. The idea of having a browser based Linux platform is one of the things that had driven me to play with Linux in the first place. It was clear from the experiments I did that this was easily possible. Webkit with a good JavaScript engine is a great choice for that, which is what Chrome is. I guess it just took Google's might to make it happen.

So why would Google invest in something like the Chrome OS. It's easy, and people have speculated on it for a long time. Google wants you to spend all your time in a browser. Why? Because it changes the game. Commerce has move to the web in droves and Google wants to get you closer to that so it can get it's cut for getting you there. It's been a long time coming and the planets are finally aligning to make it happen.

Firefox could have done the same, but Google has the dough to make something like this happen. Which again calls into question why this couldn't have been done in an open source project to start with. But I fear the Gnome/KDE bun fight has taken the Linux community's focus away from how the desktop is really evolving. Google knows where things are going. It's helping to drive them to begin with.

Will this impact Windows? I don't think so. We're creatures of habit and Windows already has a good browser experience. Will this impact Linux desktop? Probably. At the least it could be a better place to go if all you want to do is get away from Microsoft, which, if you are Joe average consumer, would be the only reason you go to Linux. Mind you this Joe developer is pretty happy on Linux. Even then, I am sceptically waiting to see a good browser based IDE experience.

But is the web ready for this? I'm not sure. A lot of people are saying Google Docs is pretty good. GMail is my e-mail client of choice outside of work. I could IM using the browser I guess. I think Google Wave will shake the cart here providing a slick collaboration environment that redefines all these things, so we'll see. I'm sure once you adopt a browser-based OS you'll find out quickly whether it sucks or not.

So what does this mean for Android? As I've stated here and on Twitter (dougschaefer, BTW), browsing on a 4" screen blows. I really struggle with trying to pan around a web page to find the information I need. This is not to say that web services aren't useful on smartphones, it just that they work much nicer if there is a thicker client to format the data to the platform, and to just manage the data bandwidth better.

Probably the most interesting aspect of this that crossed my mind is that the Palm Pre already is browser based OS. It's also based on Webkit running on a Linux platform. So the real question is - will Google try to get Chrome OS into the smartphone format? I swear the Chrome and the Android guys don't talk to each other. Or this strategy would already be figured out before the announcement.