Posted by: jsonmez | August 3, 2010

Why The IDE Has Failed Us

There is so much talk lately about using VI instead of Visual Studio, or VI in general instead of whatever IDE you normally use.

If you never had the fortune of being introduced to VI, it is basically a bare bones text editor designed to be used without a mouse and focused more on manipulating text than creating it.  VI is on just about every platform you can think of and will be for the foreseeable future.

It is not my point today to bash VI.  VI is a great text editing tool that can make you a wiz at slinging lines and words around your files.  VI is the evolution of text editing because when you are using VI you are actually programming your text.


The problem with IDEs

Basically there are two problems with IDEs.  One I think is a valid complaint, the other appeals to engineers wanton desire to be simple, pure and take things apart.

The Bloat

The first problem with modern IDEs is the bloat.  The IDEs are big beasts that take up lots of memory, are fairly slow to load and tend to have so many bells and whistles that they feel messy and clunky.

As I write this part of me thinks “what’s the big deal?”  I’ve got a pretty fast machine, it can run VS2010 pretty well.  But, there is something that doesn’t sit right for me and I am sure for other developers.  The IDE should feel clean, but it doesn’t.

I’m not sure if I can completely identify why IDEs have suddenly gone sour in our mouths.  Perhaps part of the bloat problem is that the IDE has kind of become a swiss army knife instead of a focused tool.

Strangely enough, I think part of the problem might be tools like Resharper, that are helping us a little too much.  The tool is so good that sometimes you wonder what life would be like without all those little hints and the IDE doing so many things for you.  Perhaps sometimes you feel like you are “cheating.”

The Imagined

Then there are the imagined problems with IDEs.  The ones that don’t really have any justification, but some of the “cool kids” like to talk about on their blogs.

If I can summarize what I gleaned from the argument here, I would say it basically is… IDEs that give me auto-complete, intellisense, and visual designers rot my brain.  To really program I should be able to write code without the help of an IDE.

I couldn’t agree more with that statement. 

As a matter of fact, for that reason I don’t use electric toothbrushes, because it is not really brushing my teeth. 

I also abhor graphing calculators, it’s not really calculus unless you are cranking it out by hand. 

Email? Psha, everyone knows the pure way to communicate is by registered mail typed from a typewriter.

Oh, and don’t get me started on those GPS things.  You are not really navigating if you aren’t using a map and a compass, seriously.

Sorry for all the sarcasm, but I hope you get my point.

What is the solution then?

Is it to abandon the IDE and jump over to VI and notepad to edit our files so we don’t “rot our brain?”

I know that is the popular stance among the best and brightest right now, but sometimes the best and brightest are wrong.  Sometimes they are so bestest and so brightest that they can navigate with a map and a compass better than you or I can with a GPS.

I think the solution is to bring more VI-ness to IDEs.  The good thing about jumping to VI is that you can sling text around like nobody’s business.  The bad thing about jumping to VI is that you are forgoing some of the most useful productivity tools in dealing with APIs and libraries.

Why can’t we take the good VI-ness and put it into Visual Studio?  Looks like someone already has (ViEmu.)

The other part of the problem is the bloat.  Honestly, I think Eclipse deals with this fairly well, by making everything modular.  Unfortunately, some of the modules look plain ugly and don’t integrate well into Eclipse, but with Visual Studio you have to pull out a swiss army knife with 50 gadgets on it when you are just trying to eat some beans with a fork.

The answer is modularization and perhaps some competition for Visual Studio and some of the other IDEs that are a bit bloaty.  Perhaps we need an IDE that is built up from a VI or Emacs heritage?

I know for sure the solution is not to throw the baby out with the bathwater.  IDEs have made some truly amazing advancements that help bring the level of abstraction of software development to a much higher level. 

Features like intellisense have made it easier then ever to hit the ground running with a new API like never before.

Automatic refactoring tools built into IDEs, and with add-ons like Resharper, have made refactoring code so much easier and so much more accessible.

Ctrl+Click goto definition and backwards / forwards navigation to jump to parts of the code greatly increase productivity.

I don’t need to go into all of the features of modern IDEs to make the point that there is value there and a large amount of it.

So before you abandon the IDE, consider strongly why exactly the IDE has failed us, and consider whether jumping to VI is really the best solution to the problem.  If you don’t know what problem you are trying to solve by jumping to VI, you might just be following the “cool kids” and drinking their “cool aid.”

As always, you can subscribe to this RSS feed to follow my posts on Making the Complex Simple.  Feel free to check out where I post about the topic of writing elegant code about once a week.  Also, you can follow me on twitter here.


  1. I do wish VS would become more modular. There are so many features I will probably never touch or need.

    When Windows Server 2008 was released there is a Core installation mode that installs the bare minimum services to start the server. You are then prompted with a command line interface to snap-in what ever services and features you need. No GUI needed and with PowerShell scripting you can spin up servers fast.

    That would be a nice advancement for VS, a core installation which is basically a text editor with intellisense. Then you just snap-in the additional features as needed.

    Maybe even an Office-like installation where you can setup features to install the first time they are used.

  2. I found a free extension for VS2010 that give you basic VI commands: VsVIM.

    I blogged about VI and this extension:

    • Sweet, thanks for the info. Looks pretty good. I’ll have to check it out.

  3. I really don’t have a problem with “bloat” in Visual Studio. I only show the windows that I actively use, and I turn off any of them that I do not need/want. Visual Studio runs just fine on my 5 year-old emachine, my wifty quad-core, a D510 and an E5510. If anything, I would say that bloat comes in the form of needing to run on the .NET framework; however, I am willing to accept this for the power of the languages.

    As far as “brain-rot” goes: I disagree completely with the built-in features rotting your brain. You made some excellent analogies. There is absolutely no reason for humans to do any non-thinking work. I know what method I want to call, I know which combobox I’m trying to address on my form, I know what I want it to do, why should I have to memorize the name. I can identify it in a list. Thank you intellisense. There is no benefit to memorization. It is not productive. The focus for the developer should be on solving the problem at hand, not remembering the names of all the methods in the class they wrote six months ago.

    • Yeah, excellent point about the memorization.

  4. I’m using eclim for android development currently. It is vim but with a headless eclipse backend driving intellisense and resharper style refactorings. I use ant for building and installing to the phone and logcat for debugging. My setup is somewhat similar to this

    I am a C# dev professionally so I set up all my favourite resharper keybindings in vim.
    I am far more productive in this environment than I am with eclipse. As far as I’m concerned, this gives me the best of both worlds. For me at least, it’s preferable to using vim style keybindings within an IDE.

    Just wish I had the same thing for Visual Studio…. sigh

  5. Your bloat argument fails when you mention ReSharper. ReSharper doesn’t come with Visual Studio. I haven’t used anything for visual studio i had to pay for. (not a statement just how it is). VS 2010 loads up nicely, i love the new extension manager. I have been waiting for a more connected experience with visual studio.

    But lets talk abotu all the features 85% of developer sdon’t use and should. Debugging. There is so much built into visual studio to help you debug an issue. I could see many developers thinking this is bloat but it’s somehting they should learn.

    You state that “everyone” is talking about VI. I got to this site form a tech link site. I read these sites everyday and no one seems ot be on a VI kick. And who uses VI on windows? Pretentious developers who work alone. Speend maaters, collaboration matters. meh

    • I assume that a majority of VS developers are using Resharper, but even without it the bloat is rather large.
      I agree with you about debugging, it is definitely needed.

      Not everyone is talking about VI, but I have seen quite a few posts of recent on the topic. Perhaps it just seems that way in my circle.
      Thanks for the comments.

  6. For people that don’t like GUIs and menus, vi (or emacs for that matter) is an IDE. It used to be my primary IDE until I realized that I had to commit a lot of commands to memory and when my memory started failing me, I was becoming less efficient at coding. Now I use a combination of eclipse and command line as my IDE. That is, for most of my development, I use eclipse, but I have a bunch of ant scripts for packaging and deployment (tasks that are so brain-dead that they can only be trusted to automation). But I totally agree with your POV that IDEs tend to make you brain dead. – Arunabh Das

  7. One of the things I have noticed with the vi/vim/emacs users is that they are all scripting language users (I use vim and my primary language is Perl, the second most frequently used language is SQL).

    There are no good IDEs for dynamically typed programming languages, especially once you get into runtime code evaluation with eval.

    Given a programming language which eschews redundancy, IDEs are not very useful. IDEs don’t work well with functional programming either, including with C++ templates.

    Chris makes a point about memorising names. I very rarely have to memorise names, or even repeat them so often that typing them becomes painful (vim and emacs both offer autocompletion, FWIW).

  8. I actually see Visual Studio already becoming more modular. The big step forward in Visual Studio 2010 is the extension manager. I believe as soon as the next version of visual studio we’ll start to see a bunch of features become extensions – installed by default, but easy to disable or even uninstall.
    It also provides 2 really cool things – competition and faster releases for the parts.

    Take the solution navigator, not yet ready to replace solution explorer, but it’s close, imagine that with everything. Choice is good.
    And since it’s not so tightly coupled extensions are easily updated without updating the whole IDE.

    • Yeah, you are correct. I just hope it gets there fast enough. 🙂

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s


%d bloggers like this: