The other day I read an interesting blog post from Luke Palmer the other day
titled IDEWTF. In the
article Luke discusseshow IDEs appear to be falling behind in the
state-of-the-art compared to creative tools like Photoshop, Premiere, AutoCAD,
etc. Luke's main point is that as developers we should be able to create and
use the best tools for our craft. IDEs should be much more advanced than they
currently are. While I agree with his point in spirit, I'm not sure that making
our IDEs do more is the best thing for developers.
In 2003, a study
(pdf)
was conducted by a psychologist named Christof van Nimwegen. In the study 2
groups of people were asked to play a logic game. The game involved transfering
colours balls according to a set of rules. One group was given a piece of
software that assisted them in playing the game. For example, the software
would highlight moves the player could make at a given point in time. The other
group was given software that was not helpful -- it would not highlight
permitted moves.
In the beginning, the group that was given the helpful software was able to
solve the problems faster than the group that had the non-helpful software.
However as the study progressed the group that was given the non-helpful
software became much more proficient. In the end, the group using the
non-helpful software was able to solve the puzzles using fewer extra moves, and
produced fewer dead-end states where no more moves were possible.
The two groups were brought back in 8 months later to re-run the tests and try a
different, but similar, logic puzzle. The group that had initially used the
non-helpful software hit the ground running, so to speak. Not only were they
able to solve the puzzles faster than the group using the helpful software but
they were able to adapt their knowledge to the second puzzle.
This study suggests that helpful software, or software that offloads complexity
from the user onto the software, makes us reliant on it. This doesn't say that
it's a zero-sum game in which by the IDEs getting smarter the developers must
get dumber. Far from it. I believe that we need to strike a balance between
HAL 9000 and Notepad.
If the IDEs become too smart, and coddle the developer too much the developer
will learn to rely on it. Automatic correction of syntax, imports, exceptions,
etc are not in and of themselves bad. They certainly improve productivity. But
the developer then learns to rely on their presence, like a drug. If the
developer ever tries to work with a language that doesn't have the kind of
tooling their used to they will pay a huge cognitive price up front, something
that might be enough to scare them away.
So where do we draw the line? Which features improve both long term and short
term productivity, and which cause dependence? I think the line is right
between those features that do something automatically for the developer and
those that provide advice. A feature that does something for the developer
effectively offloads the cognitive complexity from the developer to the
software; the developer is freed from having to think about it -- at least
that's how they see it. With features that simply provide advice to the
developer the IDE is allowing them to be more productive without having to pay a
long term price.
An IDE like Eclipse has many of types of features. The classic example of an
automatic feature is "Quick Fix". When Eclipse notices that something is wrong
with the code that it can fix, it allows the user to tell the IDE to fix the
problem for them. Developers that are experienced without the IDE will probably
understand what it's doing. They would have been able to make the correction
themselves without the help of the IDE. To them, this automatic feature is
simply a way of improving their productivity. For the less experienced
developer however, its mode insidious. Because the user doesn't understand what
the IDE is doing, or why it needs to the user becomes more dependent.
Eclipse also has a variety of features that are designed to assist the
developer. Call Hierarchy, and Class Hierarchy are two great examples. The
developer still needs to understand what these features are used for; the tool
simply gives the user advice, quick information that helps them make a decision
or explore a code base. These features still cause a sort of dependence, but
since the developer understands what the tools are for, and why they need to use
them the dependence is less insidious. Without these tools the developer can
still do her job, but productivity might be affected. In contrast with
automatic tools where the developer wouldn't be able to do his job.
So, do smarter IDEs cause dumbening? You be the judge.
Footnote: I know "dumbening" is not grammatically correct. The word comes from
a Simpsons episode where Lisa worries that she's losing her intelligence and
writes in her journal:
Dear log. Can it be true? Do all Simpsons go through a process of dumbening?
Wait, that's not how you spell dumbening... waaait, dumbening isn't even a word!