I've been using IDE's for various languages over the years (VS, IntelliJ, Eclipse, NetBeans, FlashDevelop, etc), and i've always found them slow and cluttered (yes i know windows can be hidden, rearranged and what not). Recently however i've learned and become somewhat proficient with VIM and have been using it for as many projects as possible.

My problem is i've grown quite attached to the various features that the IDE's provide (intellisense, refactoring, embedded docs, the list goes on). Does anyone have any advice for how i can overcome these crutches and become truly IDE free?

+43  A: 

I don't understand why you would want to become IDE free? Why is programming like they did 20 years ago a virtue? It sounds like you just want to do this because that's what all the "uber" programmers do. Intellisense, refactoring, etc. are all tremendous evolutions that increase productivity. Our job is hard enough modeling complex business problems, why do you want to make that harder with an inferior development environment?

We might as well give up on programming languages and write machine code instead ;-)
Heheh... 10010010000010010011101000100100100100010010010.. <-- just nonsense... :-P
Paulo Santos
+1. I have yet to witness a Vim or Emacs user who can actually perform common editing operations faster than me.
Or try refactoring 100s of code files in a type safe way.
@FogleBird Stop looking over the shoulder of inept Vim/Emacs users!
Terry Lorber
Fine, that's your opinion, and it's a popular one. But I take issue with "programming like they did 20 years ago". VIM is continually being updated, improved, changed, and fixed. For example, floating point support was just added to the scripting language. Most IDE's don't even have a scripting language.
I guess i can say that i was more interested in hearing about ways that a text editor can compete with an IDE, and obviously out of the box, an IDE can beat a text editor hands down. Sure with enough customization, vim or emacs can mimic some of the features of IDEs but they will most likely never be able to completely replace them except in the most simple situations.
Jason Miesionczek
+3  A: 

I don't see a point in going extreme either way. I use a combination of find, grep and vim for most of my production troubleshooting efforts but when I need to work on coding new classes from scratch, I'd use an IDE still. It just makes sense as I have no use for remembering things that an IDE can easily do for me.

+2  A: 

The various features that IDEs provide are not crutches. Giving those features up are what would be crippling.

Not to say that you can't be a good programmer without using an IDE, but given two identical programmers, the one using a high quality IDE will wipe the floor with the other.

Maybe, but very slowly ... :)
le dorfier
If you laid end-to-end all the developers who use an IDE, we'd all be a lot more comfortable.
+1  A: 

I guess the question would be 'why?'.

I tend to not use IDEs when I am trying to learn a new language. Right now I am using gedit to learn C but even with that I use line and bracket highlighting, auto-tab, and syntax highlighting + some custom build/run scripts.

Use an IDE when your programming is a means to an end. The purpose of an IDE is to speed up your work.

Use a simple text editor when your programming is the end itself.

+3  A: 

The best way is to view the IDE as training wheels. When you can anticipate everything it's going to hint and autocomplete for you, then you can start trying it on your own.

Probably the biggest incentive will be how much more quickly things will happen when you start up the editor. :) At least my experience with IDEs is that they sell a lot of hardware.

le dorfier
+1 this is the only answer I see that actually answers the question. Once you become used to the APIs, the syntax, etc. (which takes experience) you don't have to rely on the IDE to remind you anymore. Other programs can sometimes substitute for IDE features, e.g. access documentation in a web browser, or run compilations in a terminal.
David Zaslavsky
Dave Markle
+8  A: 

Some quick tips that have worked for me

  • memorize the entire API space I'm working in
  • use console output debugging
  • use search and replace for rename-refactorings
  • count braces, parens by hand to make sure they match
Scott Weinstein
Talk about being an inefficient programmer. If one of my developers memorized the .NET API I would wonder why he wasted all that time and didn't work on building cool websites.
+1 I do M-x new-frame, grab it, and then beat my colleagues with it if they have the gall to stop by, interrupting me, only to ask "How do I reverse find in a CString?"
Terry Lorber
Ho the irony ... love it !
if i knew someone who memorized .NET API i'd buy them a duplo set.
Matt Joiner
+3  A: 

You can use a modular system like JEdit or Emacs. These programs are text editors, but are extensible to nearly a full IDE style application. Get it set up the way that feels the most comfortable, then start removing extensions you think you can do without, one by one.

However, don't think that IDEs are completely unnecessary they are a very good tool to use in many cases.

Shawn J. Goff

Editors? IDEs? Real programmers use butterflies. src

Patrick Gryciuk
+2  A: 

I have purchased viEmu for Visual Studio, and I use jVi for NetBeans. There's also a vim plugin for Eclipse but I stopped using it because it lagged on my computer and sometimes missed my keystrokes, which got very unproductive. By doing this, I don't have to choose between vim and an IDE. The vim plugins are emulators and so aren't perfect, but they've got all the most important functions I find.

Ray Hidayat
+2  A: 

What it sounds like to me is that you are disatisfied with the speed of IDEs, and you want something as fast as a text editor (with the low memory footprint) but can still be productive.

Ignoring the question of if this is worthwhile (that can only be ascertained by productivity comparisons which really vary from person to person, and can vary depending on the team, as well as the language), here are some ideas for making it work:

Use a text editor with syntax highlighting. These are commonly available (like Notepad++) and do not slow things down. Because they are regex based they are only 95+% accurate, but good enough.

Next, look for the capability of scripting chunks of code. For Java, there would be BeanShell, or perhaps favor a language like Ruby or Python which have that inherently, and develop/look for macros which let you select a chunk of text and pass it to the script runner (to quickly check syntax when you are not sure). Depending on the language, it may also be fairly trivial to get a macro which selects an API call and figures out how to open the documentation in a browser window.

To really be productive, though, you will need to really know your API and your text editor very well, and develop a lot of muscle memory, and be fast at developing little macros to do redundant tasks.

It's not my cup of tea, but the people I have seen who are productive that way follow that kind of path.

+7  A: 

@Jason Miesionczek: I hope you realize that using a text editor is a great way to learn the nuts and bolts and moving parts needed to actually compile something useful - but it's no way to be productive. As you imply in your question - Intellisense, refactoring, and other automation is really helpful - so don't give these features up just because they "hide" certain mechanisms.

Farmers use tractors - not because farmers don't know how to till the soil - but because time is money.

@everyone else: I think the OP already clarified that he wants to know how he can overcome the IDE's ability to "hide" the mechanisms behind coding and building apps. I think this is a valid point, especially for Microsoft products - because there is SO MUCH automation going on, that sometimes I don't even know which files need to be checked in to source control...

So in response, I think if you really don't want to use an IDE, I think it's pretty clear that a text editor and documentation are ALL you have. You can build or find utilities to help you recover some of the nice features you had with an IDE, but at that point - you are building an IDE!

Jeff Meatball Yang
+1 for "Farmers use tractors"
+12  A: 

If you are using Windows then there's definitely no point in switching to VIM. In UNIX/Linux however, the shell IS the IDE.

The most important point to get is that VIM is just the text editor. Don't do everything in it.

  1. Your shell (BASH, etc.) is for managing files and directories.

    • You can't beat the shell integration you get with SVN/CVS/Git/etc.
  2. Window management can be done with GNU Screen or using BASH job control (^Z, fg, bg)

  3. intellisense is available for VIM/Emacs, but never under-estimate the power of just the built-in auto-completion.

    • Does intellisense auto-complete column names in query strings?
  4. The most advanced refactoring tools in most IDEs are child's play compared to what I can do with keyboard macros in Emacs.

  5. embedded docs: If you are doing C/Perl programming then the available man pages are usually sufficient.

    • Making a macro to look up the function under the cursor is easy.
+1; Shell + Editor =~ Unix IDE. Most of the other answers seem to come from Windows programmers, where shells are not part of the culture. The lure of this kind of workflow would be hard to understand without having experienced it.
Learning curve is also quite steep. To become so efficient with these tools one must spend oogle time on the environment. With modern IDE's this comes almost free. Sure I can program a good refactoring. but personally i'd rather just use it
I'd say the learning curve for a full featured IDE like Eclipse or Visual Studio is just as steep. And with a real macro system like what comes in Emacs you don't have to make a refactoring program, just do it once and keep pressing C-xe.
right now i am running Arch Linux using wmii
Jason Miesionczek
wm_eddie: regarding point 4, could you give few examples of the most useful macros?
@Newtopian, I find IDEs to be maddenly inefficient. The ONLY IDE I happily open is Visual C++. For absolutely everything else give me Shell+Editor. Debuggers, version control, and the rest can all be done on command line in linux.
Matt Joiner
+1  A: 

How to wean yourself off? I believe that it all starts with a good build script. Knowing how to make a build, FAST, from the command line is key. This is one place where IDEs hold you back. If you're not doing your own builds, and you're letting the IDE autogen it all for you, you're missing out on a lot of flexibility.

So instead of memorizing the API space, learn the build language and how to run the compiler and linker the way you want. Keep using your IDE to edit. Then, as you get comfy with that, you can switch to whatever editor you like without much friction. But IMO if you start editing in another editor, but use the IDE to do your builds, you'll be a lot worse off, especially if you do end up deciding that the IDE is good for something after all!

Dave Markle
+1  A: 

Install emacs and don't look back.

Terry Lorber
I almost downvoted this, the Church of Emacs is evil!
There's definitely no way to look back with emacs. Unless you write a LISP based plugin to do it.
Dave Markle
@rascher It's not a church... it's a Cathedral of Diamonds!@Dave Markle Chortle inducing.
Terry Lorber

You could probably get a lot of the features of an IDE in VIM if you learn how to configure it correctly. But ultimately, the question is WHY would you want to do that? Why mess with configuration for each project, when you have something working that is much easier in an IDE already. I think time would be much better spent learning whatever language you use, than learning how to use a text editor, powerful as it may be.


I personally use emacs as my editor, and then the tools of my OS to do the rest.

On Linux, I always use the shell to do everything. manpages for documentation (oh how I miss these when coding on Windows), grep to... er, "grep" files, scripts to do useful things, etc.

Try to find external tools that do the jobs that you want VIM to do, that your bloated IDE did for you. Modular is good.


This is Mac OS X specific, but I love TextMate. It's a text editor with "half-auto-completion" and a number of shortcuts to docs etc. So you can get some help if you want it, but it's still a text editor.


Buy a 2nd monitor.

+2  A: 

the pragmatic programmer has a good section on text editing that hits home for me. the core principle is that once you learn a powerful (and extensible) editor then you can slice and dice code with efficiency, very little effort, and without regard for language you happen to be working with at the time.

a good IDE can be a good editor providing that it supports the various languages and text formats you routinely edit.

on that note i'm a bit disappointed that visual studio doesn't have built-in support for file types such as .ini, .cmd, .bat, .reg, and so on. seems like this would be trivial to add and would make developers more likely to rely on that editor for everything.

(aside: this is very different from relying on an IDE as a crutch. every developer should understand every bit of code in their project and not rely on wizardry.)


Jewel S
+2  A: 

I guess you seem to be asking "what does an IDE do for me?" and "what are alternative to [bloated IDE of choice]?" and "How can I learn how an IDE does these things?"


  1. vim does a lot of neat things besides 'editing'. vim will do auto-indent (==), and some autocomplete (ctrl-P). When churning out code, that's what you're doing right there.

  2. You can write your build scripts by hand. Not that that is a particularly efficient way to do it, but you gain a huge appreciation for what eclipse does in the background. Also, you will have full control of dependencies, and know exactly how the build process works. No more "I can't even build it without netbeans!"

  3. Which means, learn either make or one of the java build-script-things (ant?) You can definitely write java buildscripts in make, and makes pretty darn useful anyway.

  4. If you are writing C code, indent is a pretty useful tool - though vim's pretty-printing is often good enough.

  5. Learn grep for searching through files (especially the -n, -R, and --color options!) As an added bonus, you'll start learning regex.


You can use both the IDE and the text editor.

The IDE for refactoring, documentation, search, usage, build tool integration, seamless different tech transition (yea, idea), tasks/issue integration, time tracking integration, code/libraries experimentation.

The text for... well.. whatever else makes you happy, and for cases when you don't have the IDE, such as ssh command line, test/integration machine (this is when you want to have the build tool at hand, and don't rely on the IDE for build tasks).

Mercer Traieste
+2  A: 

Jason, here's the thing: learning VI will take you years. And once you learn it, you'll have at your fingertips an immense and addictive power you never thought possible. However, it's a power that not everyone necessarily wants or needs.

If you plan to program for a while, because it's a good job, with good pay -- and then hopefully get promoted to manager or something or start your own business, go ahead and use the IDE. It's fine. Plenty of people do this and there's absolutely nothing wrong with it. If that is your career path, you don't have time to really learn VI, and you shouldn't bother.

On the other hand, if you actually really LOVE programming -- if programming is something you are passionate about and that you would do for free even if nobody paid you -- and you plan to program for your whole entire life until your fingers don't work anymore -- then learn VI.

There are VI scripts that you can download that give you intellisense, refactoring, etc. But IMO, by far the biggest win with VI is the ability to record and play back macros.

Macros give you wings, like Red Bull. The types of motions that you make to edit the text might seem odd when you first learn them, but when you start to fit them together into sequences and play back those sequences as macros, you will begin to understand that those strange keystrokes (capital A to position the cursor at the end of the line of text -- 0 to position it at the beginning -- w to skip a word -- etc) are like little cog-like Anime robots that can assemble themselves into a giant Transformer beast that can decimate any text-transforming problem you throw at it.

I can't tell you how many times someone gave me a file with messed up formatting or something and they thought I would have to write a program to fix it and I just opened up VI, typed in some macros, and fixed it right in my editor. I've had people watch over my shoulder and ooh and ahh about this -- and I don't say this to brag or to say that I get satisfaction out of that, but I'm just trying to impress upon you that VI itself is a powerful and impressive platform.

Add to that that you are using a tool that has continuously been improved and tweaked and fixed and debugged and added to for more than 30 years, and you've got something really special.

You get out of it what you put into it. This is true across all realms of human endeavor and it's true here. Put the time and effort into learning VI, and you'll find yourself in a world of efficient coding you didn't even know existed.

p.s. I forgot to mention one other thing -- what happens when language X, the one you are programming in, goes out of style? Time to learn another IDE. Unless you know VI, in which case, your old friend is still with you.

+1  A: 

I don't recommend you to quit IDEs. Going from IDE to notepad can be quite painful (you will miss Intellisense and breakpoints A LOT). The only way to abandon IDEs is to uninstall them and start with notepad. Again: I don't recommend it. IDEs are designed for making you more productive and they use to do those boring tasks we don't want to do (creating the code for a blank form, the events for a button, etc).

I use Notepad for writting little dlls in C++ and... oh! I really miss Intellisense and a lovely IDE that corrects my syntax errors...


I thought Visual Studio 2K5 and 2K8 felt slow and "bloated" until I upgraded to a midrange SSD drive.

After making sure you have plenty of RAM, putting your IDE on a speedy disk drive is often one of the best performance upgrades you can make - perhaps even moreso than CPU speed. See:

After upgrading to a SSD and making a few SSD-related tweaks to Windows, Visual Studio 2005 loads about as quickly as a text editor for me on a 2.4ghz Core 2 Duo laptop.

Should we have to buy an expensive disk drive just to run a "modern" IDE in a responsive manner, when the uber-3l337 UN1x c0derz happily run EMACS on 386s with 32MB of RAM? Well, there's no doubting that plenty of coders are extremely productive without IDEs, many moreso than IDE jockeys. More power to them. But if you prefer to use an IDE and coding is how you make a living, should a few hundred dollars should be a dealbreaker? Up to you to decide, but worth considering, I think.

John Booty