My first job out of college was at Microsoft. To compound the inherent humor in that, I was hired as a Program Manager and assigned to the Developer Tools group. My product? Visual J++.
This is funny because I pretty much a) hadn't used Windows before moving out there (being a Linux and Mac guy even then), b) all of my practical programming experience (i.e., not CS course-related), had been server-side and written in C, C++, and Perl at Tripod and building WSO, and c) basically never sat down in front of an Integrated Development Environment before. In fact, I remember asking them right after getting the job if they could send me a copy of Visual Studio so I could get used to it, and oh, and maybe if they could send a copy of Windows along, too, that'd be great...
For better or for worse, Sun won their injunction regarding Java against Microsoft around that time, so I had plenty of time to work on other things. Mostly just hanging out working on nascent .NET framework stuff, absorbing C# as it was being finalized, and following Anders Hejlsberg around. He had the office across from mine at one point. Needless to say, mine was the one on the inside. The one without the windows.
I bring all of this up because, years later, I still don't use Windows, still do server-side development in C, C++, and Perl, (though I did learn Java), and I still develop my code in emacs. Well that is, perhaps, until last week.
Over the years I've tried just about every IDE that I've come across. I usually make it about 2 days before realizing that not only was I less productive in the short-term, as I staggered through the learning curve, but I was also quite likely to be less productive in the long term, as I would spend more of my time fixing mistakes that the IDE encouraged. And, like a fair number of people who swear by emacs or vi for software development, I felt it useful to stay as "close" to the code as possible.
But during a discussion of Java debuggers a few people at work mentioned Eclipse, the open-source development environment that recently reached version 3.0. So I decided to give it a shot. I had a quick project that I wanted to do (porting that Perl application I mentioned over to Java), and I figured it was small enough in scope that I could take a chance on a new development environment. And, strangely enough, Eclipse got another strong endorsement when a person I met outside work said his company was porting their very expensive UML-based code generation tool off of their own proprietary GUI and onto Eclipse.
I downloaded the Eclipse binary for Linux GTK2, unzipped it, and ran the eclipse executable.. And, a bit to my surprise, it launched right up. (Linux has come a long way, but not so far that it isn't a pleasant surprise when a downloaded binary actually runs on the first time.) I made some reasonable guesses at the questions it asked when it initialized for the first time, and before long I was looking at a fresh workspace and a new project.
I clicked File->New->Class and up popped a dialog box asking where I wanted to put the code, what package to put the class in, and what to name it, as well as a few other more advanced options. And there it was. The editor itself was responsive and well-behaved and didn't get in the way (even the discrepancies between the key-bindings of Eclipse and emacs didn't slow me down much). The colorization of the code was legible and accurate, the fonts were clean, the highlighting useful, the tabbed interface intuitive, and the background compilation process and problem identifier absolutely brilliant. Half an hour later I had sketched out a couple of classes and written and interface or two.
Which is about when I decided I needed to write a few unit tests. (I usually don't "test first", I test a few minutes later. But I'm normally pretty good about that.) And, seeing as how Eclipse was otherwise impressing me, I took a guess and looked under File->New for something about a unit test class. And sure enough, there it was -- JUnit Test Case. I clicked it and it brought up another dialog box -- which actually let me select which individual methods to write test stubs for. And it did it perfect the first time.
After coding a test or two, I clicked on the JUnit tab and pressed run. And zoom -- the test classes were invoked, and, within a second, a deep red bar appeared across the window -- my tests had failed. So I checked out the stack trace for the exception (right there in front of me), hopped back to the offending code, made the fix, and reran the test. Zip -- an all green bar.
Now maybe I have been suffering too much in life, or maybe I need better things to do, but that was almost -- dare I say it? Yes. It was almost fun.
And at that point I decided that I'd keep working with Eclipse until I was done with the project. I was that impressed. Over the next two weeks I made good use of the built-in refactoring tools (right click -> move and rename are god-sends), the code-formatting styles, the extremely informative and friendly debugger (never said that about a Java debugger before), the Tasks interface, the Package Explorer, and the Javadoc tools.
Additionally, I started getting a feel for the Team Synchronization features (i.e., revision control systems), Ant integration, and the more sophisticated Refactoring tools. I haven't even started looking at the extensive suite of peripheral tools that people have built for Eclipse.
Since the bulk of the Eclipse Platform and all of the Eclipse plug-ins are coded in Java, the environment runs on major architectures, including Windows, Linux, Solaris, AIX, HP-UX, and Mac OS X. If ever there was a tribute to the viability of Java for client side code, Eclipse is it.
I really never thought I'd say this about an IDE (trust me on that), but I recommend giving Eclipse a shot. It just does things the way you'd want. And never does things like it has an agenda beyond being a good development environment (like some other IDEs are known to do).
Oh, and did I mention it's completely, 100% free?