Beware the IDEs of March

Do integrated development environments (IDEs) make for larger programs?

The IDE has been around for a long time. Turbo Pascal offered it, with its editor/compiler combination, back in the early 1980s. The USCD p-System had an editor/compiler too, also in the early 1980s. Integrating the editor and compiler was the cool new thing back then, and was a big step up from the previous world of separate editors, compilers, and debuggers.

Our concept of the IDE has changed little since then. We've added things, such as debuggers and code generators, and beefed up the editors with re-factoring capabilities and pop-up help for variable and type definitions, but the core idea remains the same: provide a single tool that lets a programmer do everything.

I'm not sure that this has been a complete success.

I will admit that development with an IDE is much more convenient, especially with debuggers that let you step through your code. Support for refactoring is nice. The automatic build (encompassing 'make' and hiding the administration of 'make') is a boon.

Yet I have some skepticism.

At a recent computer geek meeting, the conversation got to the topic of IDEs. We discussed the two big IDEs: Microsoft's Visual Studio and the open source Eclipse. As programmers, we shared our frustrations with both products. And then we had some interesting comments.

All of us, when writing in Perl or Ruby, avoid IDEs.We use the old-fashioned method of editing the file, saving it, and running the program. (We can omit the compile step since Perl and Ruby do that for us.)

We also avoid large programs. When a program gets to be large enough that the edit-run cycle serves us poorly (and with other languages one would switch to an IDE), we re-factor the program into two smaller programs. By keeping the program size small, we can stay with our (beloved) editors and skip the IDE.

If this is true for a large number of programmers, then I would expect to see a certain distribution or program size and IDE usage within the development community. I would expect that languages without distinct compile steps (such as Perl, Python, and Ruby) have a measurable number of projects that are developed without an IDE. I would also expect that languages with separate compile steps (C, C++, C#, Java) have a distribution weighted towards the use of an IDE. That is, the compile step encourages one to use the IDE. I would further expect that C and C++, with their distinct header files and more complex dependencies would have a greater reliance on IDEs.

Also, I would expect that projects without IDEs would have smaller code sizes than projects with IDEs.

We might see correlation between IDE usage and program size. Note that I use the term "program size" here, and not "system size". A system performs some set of tasks and consists of programs. One could develop a system with one large program or multiple small programs. My conjecture is that the use of IDEs leads to systems with larger programs. (Yes, I realize that that last statement implies causality, and I have yet to show correlation.)

I'm not sure how to go about showing causality, or even correlation. One would need the proper studies of development teams and projects, with some way to compare the different project sizes. One would also have to account for the affects of language and team size on the program size.

I don't say that IDEs are harmful. I think that they have their place. Yet IDE-less development also has its place. Developing in IDEs may have more costs than we think.

It's a conjecture that will keep me piqued for a while.