The IDE divide

Via Keith: the IDE Divide raising some interesting points regarding developers who are language oriented vs. developers who are tool oriented.

While the division probably isn’t so clear cut in reality, as this response points out, it is an enlightening simplification.

Personally would say I’m language oriented and often mystified by the alternative point of view. My resistance to the unified IDE (EMACS / VIM excepted) is based primarily on wanting the most “raw” access to the source code as possible, rather than what I would regard as a “dumbed down” view which makes me dependent on the tool (and the vendor).

I’d also rather keep pace which changes in a language’s functionality vs. changes in a tool’s features / interface (which tend to be more frequent and frustrating, IMO).

Which is why I found the Oliver Steele’s arguments enlightening, because I find myself agreeing with things like this;

Here is an example from the apache merlin web site


ReferenceDescriptor reference =
new ReferenceDescriptor( Widget.class.getName() );
ComponentModel model = (ComponentModel) m_model.getModel( reference );
model.commission();

Widget widget = (Widget) model.resolve();

Notice how you have to type everything three times. Just reading that makes me angry.

…except that the tool oriented developer probably won’t be typing, or at least not much, things like autocompletion / wizards / drag and drop / code generation etc. having saved the effort.

Oliver alludes (my interpretation), without stating, that this is an aspect of the static vs. dynamic language divide.

To me it sheds alot of light on why we’ve got Perl / Python / PHP / Ruby(etc.) programmers on the one side (language-oriented) and C++/Java/C# on the other (tool-oriented) and both groups think the other is nuts.

So when a C++/Java/C# programmer says their platform is more maintainable than ‘X’ dynamic language, perhaps what they’re really referring to is better tools. And what they don’t see is dynamic ‘X’ doesn’t require tools to the same degree, to be equally maintainable (by a language-oriented developer).

Could be that the way to identify a developers mindset is to ask “What do you see as the future of programming?”. Those that lean towards “programming by pictures / visual modelling / source editing will die” are in the tool camp while those that suggest “more expressive / more power / closer to natural langauge / intuitive syntax” are in the langauge camp.

And I can’t escape my mindset: think the ancient Egyptians have something useful to say about the longevity of hieroglyphics…