Hari's Corner

Humour, comics, tech, law, software, reviews, essays, articles and HOWTOs intermingled with random philosophy now and then

IDEs versus plain text editors

Filed under: Software and Technology by Hari
Posted on Fri, Apr 20, 2007 at 15:42 IST (last updated: Wed, Oct 29, 2008 @ 22:27 IST)

Here's my take on the IDEs vs. plain text editors issue. In my opinion, these are the pros and cons of both. No solution is the best solution for all occasions and all programmers and I myself have been torn on this issue in the past. So to clarify myself here's what I think of IDEs and text editors.

IDEs

In my opinion, a great IDE is one that reduces programming time by half and provides significant advantage for development in a particular language. I don't believe in general IDEs for all programming languages and if I use a C++ IDE, I believe that I should be a more productive C++ programmer (depending on my own level of competency). Likewise, a PHP IDE should provide all the features I need to build complex and intricate PHP/XHTML scripts with significant development advantages over plain editors (by the way, Quanta Plus is the best web development environment I've come across till date).

Here are my list of pros of good IDEs:
  1. Provides significant benefits like project management to keep things organized, seamless integration with other productivity tools like debuggers, profilers, versioning systems and GUI editors for particular libraries.
  2. Provides editing convenience for specific languages. For instance, a C++ IDE should provide me with function auto-complete for library functions, function tool-tips, class browsers, code folding to browse code easier, integrated help system for that particular programming language and other minor things like auto-indent, syntax highlighting and so on.
  3. Provides quick code generation and templates for commonly used programming projects - for instance, a GTK project, a KDE project, a OpenGL project and so on.
  4. Provides a sane build environment without manual intervention, the necessary compiler and link flags and switches for successfully building an application; provides convenient organization of frequently used project settings and so on.
  5. Usually provides extensible plugins which allow programmers or third-party developers to add more useful features as necessary.
And the list of Cons
  1. Proprietary project formats might make it difficult for programmers to work with other IDEs or tools simultaneously.
  2. Adds more bloat to smaller projects - usually creates a whole lot of extra files and an entire project tree. Might also add unnecessary features which programmers might not want in their projects.
  3. Memory and resource hogs. Some IDEs are so memory hungry that even 512 MB of RAM might not be enough to run them without a significant slowdown.
  4. Sometimes becomes too complicated and so the programmer spends more time fighting with the IDE than with the problem at hand.
  5. Are not always stable. Some IDEs are known to crash frequently when handling huge projects and might be prone to memory leaks.

Plain Text Editors

Plain text editors are quite useful for programmers in that they usually get out of the way and allow programmers just to write code. In my view, they're extremely useful because they aren't tied down to a specific programming language and many of the modern ones also come with some benefits of IDEs without all the bloat.

Here are my list of pros for plain text editors.
  1. Usually not tied down to a particular programming language. Allows freedom for the programmer to write all programs in a single favourite editor and compile them from the command line.
  2. Are small, lean and responsive. Also many of them are oriented to editing features which programmers find hugely convenient.
  3. Most modern text editors provide a whole lot of syntax highlight support with the ability to customize.
  4. Most text editors focus on ease of use and simplicity. So programmers spend less time in fighting the features and can focus more on the task at hand.
  5. Many text editors are also highly customizable and extensible through scripts and plugins.
And the list of cons:
  1. No context-sensitive help for programmers. In particular no function tool-tips or auto-completion, no project management, class browsing and other useful IDE features like debugging. Programmers will spend more time in browsing the online documentation separately for all such issues.
  2. Usually doesn't take care of providing a sane build environment for programmers. No Makefiles, no language specific settings, doesn't take care of compiler and linker switches, library settings and so on. In short all these have to be handled by the programmer separately which can be a significant waste of time.
  3. For large projects, some text editors might not be suitable - particularly when editing multiple files at the same time and some kind of file/class organization is needed.
  4. Programmer might waste more time in customizing the text editor to be more productive wants rather than focus on writing code.
It will remain a never-ending debate for generations to come. ;)

2 comment(s)

  1. For some reason, I get the impression that text editor con #4 was aimed at my recent blog post :wink:

    Comment by Dominic (visitor) on Fri, Apr 20, 2007 @ 17:51 IST #
  2. Not particularly. I was thinking of vim, yes, but didn't mean to target your post. I agree that vim needs some customization because the defaults provided by different distributions are not exactly the same. Debian makes it more user-friendly while Slackware defaults to vi-compatible mode.

    Comment by hari (blog owner) on Fri, Apr 20, 2007 @ 22:06 IST #

Comments closed

The blog owner has closed further commenting on this entry.