Jun 112010

I’ve been using IntelliJ IDEA for the past 7 years and anyone who knows me will tell you that I’m an IDE snob. However, over the past 7 years I have been using the exact same configuration for IntelliJ IDEA and all of my project files have rarely changed. Over those 7 years I would merrily install the new version of IntelliJ IDEA and when it asked me to import the configuration from an old version, I would. Likewise, when new versions of IntelliJ IDEA tried to open an older project file it would often ask me if I wanted to upgrade the file format to the new version and I would.

Over the years my IDE configuration files and project files seemed to becoming less and less stable. I assumed that even though I was upgrading consistently, IntelliJ IDEA was managing all that complexity behind the scenes without any problems. This is not the case. But let me be clear, this is NOT an issue with the IDE, but the user.

In order to innovate things must change. Often that change is not backwards compatible or backwards compatibility is not always perfect. If you really want to innovate, you should just toss backwards compatibility out the door and charge forward (but that’s a topic for another post). The folks over at JetBrains have been innovating on the world’s best IDE for years. They have also tried and mostly succeeded at providing working upgrade paths between versions because often they break backwards compatibility. However, nothing is perfect and there comes a point when you must wipe the slate clean and start fresh.

I decided it was time to start fresh with IntelliJ IDEA. Here’s what I did:

  • Un-installed IntelliJ IDEA completely
  • Deleted all the preferences, caches and logs
  • Deleted all my IDE project files
  • Re-installed IntelliJ IDEA fresh
  • Re-configured IntelliJ from scratch
  • Re-created all my IDE projects files by hand

At first I was really annoyed at having to do this process. But now that I’m mostly finished, I’m glad I did. I noticed that a number of files I had been using (i.e. .eml files) were no longer needed and IntelliJ was probably just dealing with them since they were there, even though it really preferred to use a different structure. I’d much rather use the new methodology instead of an older one, which might not have the same level of support and integration, and could unexpectedly break at any time.

I think I’ll be doing this refresh again each time IntelliJ releases a new major version. Might as well keep things clean and charging forward.

Dec 052008

I’ve been working on a decent sized C++ project recently and since the application will be used on a Windows server, I wanted to stay close to that platform. I fired up the latest Visual Studio 2008 version hot off the presses with my MSDN subscription and boy is that thing a piece of junk. It is like working in the stone ages. I mean writing C++ is bad enough and then I have to battle with the worse IDE imaginable?

I think not.

So, I grabbed Eclipse and NetBeans and fired both up. Eclipse, is a beast and I wanted to avoid it at all costs if possible. I’ve never liked Eclipse, no matter the version, and they haven’t improved the issues enough for me to really use it for Java development. However, I found the Eclipse C++ integration decent, but still pretty rough. The Eclipse interface is so clunky that it makes it hard to be productive.

Next I grabbed the latest NetBeans (6.5) and fired it up. I have to say that it started pretty darn fast for a Java IDE. It also has a really decent layout and configuration system. The C++ support, although experimental for on the fly error highlighting, is impressive. After tweaking my colors and battling through keymappings I’m actually productive. NetBeans lacks a number of editor features that are required these days, including multiple clipboards, duplicate lines (has this but no keyboard shortcut), join lines, etc. Besides this problems, I like it.

On the flip side, IntelliJ is still great. 8.0 is just out and it adds a number of new great features and more language support. However, I think that IJ is probably getting close to needing a good chunk rewritten. The configuration system is becoming clunky, the projects difficult to manage, and most aspects of the IDE are beginning to fail.

The speed is horrible, the memory consumption off the charts and the productivity increases that we all used IntelliJ for are is slowly being integrated into the other IDEs. I think IJ is still the best, but their margin is slowing being reduced. If the folks over at JetBrains want to stay competitive they are gonna need more speed, more productivity, more simplicity and more power. These things are all hard to get at the same time, but I’m confident that they will find at way.

For now, I’m gonna give NetBeans the full shake-down, log a ton of bugs and wait for 7.0 to see how many they fix. I’d say my list is pretty short at this point and I could envision a full switch to NetBeans with 5-10 enhancements if IntelliJ continues its slow decline.

Only time will tell.

Feb 152007

Besides my reasons for loving IntelliJ with respect to the keyboard support, I have found a new reason why IntelliJ will always be a better solution and well worth the money.

They actually fix bugs. You buy the product and report a bug, they take it seriously, even if it is something somewhat minor. Here are links to two bugs I’ve filed, one for Eclipse and one for IntelliJ:



As you can see if you look at the dates of these, the Eclipse bug, which in my opinion is pretty severe if you use the keyboard as your main form of interaction with the IDE, was opened 4 years ago. Yep. 4 YEARS! And it isn’t even closed yet!

Now if you look at the IntelliJ bug, it was opened 20 HOURS ago and is already closed and back ported! This is just one of many examples of this type of treatment. I’ve opened 10-12 bugs with Eclipse and the turn around is usually a year or two. The most shining example of this horrible lag is the “Default line terminator bug” located here:


This took five years to fix and this is one of the most fundamental settings that ALL text editors have! The ability to change the default line terminator for new files…. I mean come on people! On the flip side, IntelliJ bugs are normally fixed within a day or two and at the longest a few months.

Plus, it must really say something about the engineering of these two products to see how quickly bugs can be fixed. The better the system is engineered and tested, the easier is will be to update and fix. This might be a bit controversial, but I believe it.

So…. IntelliJ will always win until Eclipse figures out that usability and fixing bugs is far more important than adding new features.