Saturday, June 30, 2007
So after switching to the Sun JRE, things are much better, even on my Core Duo laptop. And I was able to run it successfully on my 666MHz beast of a machine, albeit, it was still pretty slow, but no worse than everything else that runs there...
Friday, June 29, 2007
Well, I am pleased to announce "CDT for Windows". This is a distribution of the Eclipse Platform and the CDT with the MinGW GNU tool chain for Windows and a Java Runtime wrapped up in a simple Windows installer. With a few clicks you'll be up and running debugging a C++ application.
The distribution is on SourceForge at http://cdt-windows.sourceforge.net/. It's currently at version 0.9.1 and contains the Europa Platform and CDT 4. My objective is to get it at a 1.0 level by the end of September with CDT 4.0.1. I have also included the SDL portable multi-media library. My hope is to get the wxWidgets portable application library into it as well.
As with the CDT, I really want to build a community around "CDT for Windows", mainly since I'm doing most of the work in my spare time (I've got a lot of work to do at QNX and the CDT too, you know :) and need to share the work, which really hasn't been too much so far. I've only done light testing so feel free to give it a spin, raise any issues you may find in the SourceForge tracker.
I think it looks pretty slick for something that only took me a couple of days to put together. I hope you find it useful as well.
Download instructions are available on our web site as well. There are lots of other ways to get it too. The Eclipse download site has the Eclipse Platform and the CDT in a single zip file. If you are on Linux, I'm sure you'll see it soon in your favorite distribution. If you are on Windows and want to build Windows application with GNU tools, check my other announcement ;).
Wednesday, June 27, 2007
Whatever the minimal required machine for Eclipse is, this ain't it. What a mess. It took forever to do anything. And all I did was create our Hello World project, build, and fire up the debugger. Now, I am using Apache's Harmony JRE which is still pre-release, so maybe that's not helping. But it's amazing to see what memory starvation does on big software.
One thing I've heard off and on over the years is people complaining about the sluggishess of Eclipse and the CDT, especially on older Unix machines that had multiple users sharing resources. Now I see why. Luckily, developers using Eclipse usually have plenty of horse power and memory anyway and this isn't as big an issue as it was a few years ago. But we still need to watch out. Even running the CDT on my 512MB, 1.8 GHz AMD Linux test machine at work has issues.
Saturday, June 23, 2007
I have a webinar scheduled for July 12 and I invite you all to attend. I'll be walking through all of the features of the CDT with focus on what's new. I hope you'll be as impressed with the new CDT as I am.
But for now, I need some sleep. It won't be too long before I need to get back to work bringing CDT 4 to my QNX customers and start planning for next year and CDT Ganymede (the next Jupiter moon after Europa you know, at least that's what they tell me...).
Tuesday, June 19, 2007
The latest shiny object is the new ANTLR version 3, a fancy new parser generator. I've followed ANTLR with interest for a few years and we almost used it for CDT's parser back in the 1.x days. But at the time we felt that hand coding was the only way we could successfully deal with C++ ambiguous statements (e.g. x * y, is that expression, or a declaration of a pointer to x).
The new version comes with an LL(*) parsing mechanism that uses infinite lookahead (the *) to decide what rules a sentence matches. If you aren't familiar with what all that means, Terence Parr, the author of ANTLR, has written a great book that explains it all for you. The book itself is interesting since right now there is very little documentation other than the book. But it's only $24 dollars for the "non-dead tree" PDF version and is an interesting way to help fund the work.
But, this is essentially how Johnny C and I wrote the CDT parsers. We start at the high level concepts and break them down into finer grained detail until you get to the individual characters, creating an Abstract Syntax Tree (AST) along the way. You can base interpretation choices on where you are in the analysis and by looking ahead into the source stream as much as you need. It's a very powerful technique.
With ANTLR, however, you can specify the grammar at a higher level and have it generate a lot of boilerplate code for you. It may be the one parser generator tool that can convince me that it's better than hand coding. But to figure this out, I decided to try building a parser. Mike and the CDT guys at IBM are already working on a C parser using LPG, an LR parser generator (LR is bottom up, which, while faster, doesn't allow you to easily use context information when resolving rules, I prefer LL) and extending it for UPC, Unified Parallel C. And since I need to resolve some extensibility issues for GNU versus MSVC, and having a lot of experience in the past, I decided to try a C++ parser.
Now if ANTLR can handle that, I'm sold. It'll be an interesting journey and should allow me to try out some ideas on improving how we did some of the things in CDT's parser. Also this is just a prototype and I don't really plan on replacing CDT's parser with it. But it will help me learn ANTLR more and help me help others in the Eclipse community who want to use it. And who knows, another shiny object may fly by and take me on a totally different tangent anyway...
Thursday, June 14, 2007
So now the press is trying to figure out how Intel will productize that. I think the article asks some pretty irrelevant questions, like "Will they be x86 cores? Will they run today's applications?" And the response is that they are working on it to make it easier for programmers to deal with.
But I think that's a mistake. Why would you run your favorite e-mail program on an 80 core machine? Eclipse, now that I can see, especially if you've ever debugged a run-time workbench and saw 30+ worker threads going at it. But really all we're doing there is taking the same old paradigm and stretching it beyond it's limits. The hardest bugs I've had to solve were when multiple threads were contending for the same resource and someone forgot to synchronize them. Happens time and time again.
No, 80 cores are great. Mix that with 128 stream processors like those on the latest GPUs, and there's some massive horsepower that we can take advantage of. You can hide all the complexity behind good compilers and run-times, but I don't think you'll get all the benefits of the hardware. I continue to believe that we need some new programming paradigm where we stop thinking of programs as a sequence of operations and more like a network of data flows. Turning to objects was the first step, but I think there's further we can go.
Wednesday, June 13, 2007
Well, the past couple of weeks I've had to change some things. The first one is to meet Europa's guideline of having our jars digitally signed for security. That way, when you download the CDT, you know you're getting the officially blessed version from Eclipse. I think the risks are pretty low, but it is possible for someone to make a set of zips that look like the CDT but aren't and do something nasty things. The infrastructure created by the Eclipse team makes it easy to do the official signing so I figured why not.
The other issue we've been running into lately is the sheer size of the CDT builds. They passed the 400 MB mark with all 9 platforms and the two main features, runtime and sdk, that we build. With only 10 GB (now 15 GB) of disk quota at eclipse.org, we kept bumping into the limit and constantly needed to clean up builds. When you take a close look, the 9 platforms are almost identical except for the small shared libraries that we have in the cdt.core fragments. The update site, as a result, is much smaller, around 40 MB, since you don't get that duplication.
So while I was wearing my release engineer hat anyway, I figured I'd fix all this. The recommended way to get the CDT is using our update site. We will have the runtime feature, the main one that you download, on the Europa update site. That feature along all of the others will also be on the CDT Europa update site. All this will be explained on the CDT's website when we release. The jar files will also be compressed using pack200 to make downloads a lot faster and save bandwidth on the Eclipse servers and mirrors.
The other big change is that we will no longer be releasing feature and platform specific zip and tar.gz files. Instead, we will have a single zip file called the CDT Master that is an Archived Update Site. So you can install normally via our update site on Eclipse.org, or you can download this zip and install it, still using the update manager, but from the zip file instead. We are currently doing our nightly builds this way, and it works well.
This will hopefully make the CDT easier to get up and running while saving a lot of space and bandwidth for Eclipse. It's good all around, but it is a change and, as always, I'd like to hear your feedback on it.
Friday, June 08, 2007
Subject: [ANN] - CDT project changes
Date: Fri, 7 Jun 2002 17:20:34 -0400
The Eclipse Tools PMC is pleased to announce some exciting developments to the CDT project hosted on eclipse.org. First, QNX will be contributing some C/C++ core technology from their recently announced product to eclipse.org. We believe that this will enhance the value of the technology hosted on eclipse.org and bring some industrial strength technology into the CDT project.
And so it began. Five years ago yesterday, the new CDT project was born. The QNX team had just gone through six months or so of compressed development in a remote location affectionately called the "Toolshed" (we're known as the Tools team). They had basically gone from nothing other than the source to Eclipse and JDT to come up with a fully functional C/C++ IDE. But QNX is an RTOS and run-time company. Tools enable that business but take a huge investment to do really well, and it was becoming clear that a lot of good can come if we would share the work and benefits of that work with others in the open. A handful of other vendors liked what QNX had done and worked together on starting this new direction for the CDT.
A meeting was held at QNX headquarters on July 17'th of that year in what turned out to be the first ever CDT Summit. In attendance were people from QNX, Rational, Red Hat, and MontaVista. From day one, we enjoyed the spirit of "co-opetition", co-operating competators, that still lives strong today. Here's a fuzzy picture of Sebastien Marineau from QNX on the right, the first CDT project lead, who really got this whole thing off the ground. He's sitting with John Prokopenko, a senior architect/manager from Rational and a mentor of mine.
I was at Rational at the time and this was my first exposure to the new CDT. And as we know now, it became a career changing moment for me. Who knew then that I'd spend the next five years living out a dream of mine, to make a software development tool that would help thousands of software developers write better code faster. I wouldn't have passed that up for anything.
There are many people to thank for getting us here, including Sebastien and the team here at QNX for having the vision to share their great work with the world. To my former co-workers at Rational/IBM (who coincidentally I had lunch with today) for helping get this crazy DOM thing in place. To the gang at Intel (especially Leo!), TimeSys, Chris at TI now at IBM, and everyone else who formed that initial spurt of a community outside the original two, to all the product vendors and users and contributors that now form what I estimate to be our 400,000 member CDT community.
Thank you all! And happy 5th anniversary!
Over the last year, this has all changed. With the great bug reports we've been getting from the community and the volume of patches we've been getting from contributors, and the great work of our army of committers, I am happy to say that CDT 4.0.0, is the first .0 release of the CDT that I feel really good about. I'm sure everyone will be pleased with it from our open source community to the vendors that adopt it.
In the spirit of openness, I have to admit I have been very dissatisfied by our previous .0 releases. And I think I need to share what happened so that we can learn from it. Here are the "lowlights" of previous CDT .0 releases (BTW, the CDT 1.x.0 series actually went pretty well, so we'll start with 2):
- CDT 2.0.0 - first introduction of our new parser-based indexer and search. This was a dramatic change to the way we did indexing and the start of our performance woes. In fact I rewrote the CDT scanner (tokenizer) in 2.0.1 since it was brutally slow. We also introduced a new build model that wasn't really ready for prime time and really needed to be exercised with more tool chains.
- CDT 2.1.0 - This release was to meet one of the contributing vendor's product needs and was done while the other vendors were focused on the next release. It was a bit difficult to watch the extent of work they were doing mainly on their own. This really showed the need to standardize our releases (thanks Callisto, Europa, etc!) and how the model we had been following can't scale as the number of contributing, and consuming, vendors increase.
- CDT 3.0.0 - This was the big DOM release. Again, massive changes to the indexing and search framework done by one vendor. Even worse, that vendor later had to withdraw its resources on that massive bulk of code due to business reasons. This really showed us the need to have a diverse set of committers working on each component. Contributors will come and go, and you need to build a robust community to survive it.
- CDT 3.1.0 - Yet another new indexing framework. With the contributors to the original index gone, I took it upon myself to finally throw out our failing assumptions, 100% correctness as a requirement being the big one, and focus on a new strategy to address performance. At the end of the day, this new strategy is the right one and correctness was still pretty good. The problem was that I did it myself and bit off more than I can chew. It was an absolute necessity to get it done, though, but I did do a lot more work for 3.1.1 to make it product quality.
It's been a while ride over the last 5 years on the CDT (BTW, it was 5 years yesterday, I need to blog about that too!). I think we've learn a lot from it, probably enough to write a book about it. Being in the open, I hope others can learn from it too. At the end of it all, I think the most important aspect of any software platform project, commercial or open source, is that of community. And the most important job of a project is to build that community. And that there is probably nothing harder to do than build a community. As our industry goes through this shift, we really need more examples of what to do and what not to do. Then, hopefully, we won't have to always go through pain like this.
Monday, June 04, 2007
The other number that caught my eye is the estimated 176 person years of effort to build all this. I'm not really sure how they got that number but looking at the breakdown by developer, it seems pretty reasonable. At a loaded labour rate of $150K US, that's about a $26M investment, which points back to the main reason I think the CDT is successful commercially. Not many companies could afford to do that on their own.
Taking a look at the contributors list, also reminded me of all the people that have worked on the CDT over the years, 32 in total. And although some have moved on, their contributions were huge and still pay a important role in the CDT today (thanks, John and Alain!). And we have new blood to take over and they are quickly catching up, especially the gang from Intel and Wind River, and the new team at IBM and Symbian are starting to role, and of course, our debug keepers from ARM, Nokia and Freescale.
On the eve of our biggest release, CDT 4.0, it was nice to sit back for a moment and think of all the great contributions we've received and the great people we've worked with over the last 5 years that play such a big part in getting us where we'll be tomorrow.
Despite his crass style, Linus does make a lot of points I have to agree with:
- CVS sucks. SVN tries to be a better CVS, but the problems are so fundamental and SVN doesn't make enough strides to make it much better than CVS.
- Merge is the key feature of any source control system. We've gotten used to CVS's weakness at merge and Eclipse's CVS support helps a lot. I actually think the SVN Eclipse plug-ins are a step backwards since I haven't seen a successful merge with them yet.
- Source control systems should allow everyone write access, at least on branches. I would love it if everyone who customized the CDT could do it in our main repository so we can see what they did and make it easier to incorporate their improvements. I'm not sure that is even possible in CVS and it requires central administration at least in SVN. I guess with Linus's GIT, allowing this is it's number one advantage.
I'm actually a big fan of Rational's ClearCase because of it's ability to manage branches and merges. It was a behemoth to manage, and a lot of people found it hard to work with, but I really appreciated the ability to work in a private branch and make occasional merges back to the main line. I'll definitely want to look at GIT and see how it compares. Of course, we would need an Eclipse plug-in to work with it...
BTW, when I visited Google during EclipseCon, I saw this stage. It's in their cafeteria and you can see people getting drinks in the background. I wonder how many other cool visitors they get like this.