Do modern IDEs make us dumber?
charlespetzold.com
charlespetzold.com
When you're working with a large number of source files, the ability to have auto-complete, parameter guessing, getter/setter creation, auto-builders, and real-time code syntax/quality/checkstyle/pmd/findbugs/etc... validation means you can write working code more quickly.
The ability to refactor/rename across an entire project with a click of a mouse means I'm much more likely to refactor as the code evolves, leading to higher quality, more readable, more extendable code. Seeing class hierarchy trees with one click, jumping to view the source of a method I'm using, remote debugging totally integrated with my source code, etc... is all really valuable.
Sure, drag-and-dropping everything in some IDEs means you're missing a lot of the core stuff in programming, but at least for me, I am more productive using Eclipse than I was using Emacs and the shell.
I think his point is broader than that - he's arguing that IDEs encourage/are symptomatic of/cause bloat of the APIs and encourage bloat in other areas (e.g. generated code).
However, I think this article misses a trick by not mentioning functional programming.
FP reduces the surface area of many APIs considerably. It also "fixes" all the code generation issues with a much more elegant solution (i.e. macros).
http://osteele.com/archives/2004/11/ides
Here's my take:
The ability to write in a language that doesn't require excessive amounts of boilerplate code means I'm much more likely to refactor as the code evolves. Seeing an algorithm on one page, localizing and separating the logic cleanly with higher level constructs, easily translating the intuitions in my head to a coded solution, being able to dive into any part of the code without getting lost in the redundancy and residue of IDE vomit, etc... is all really valuable. Getters and setters that take up more than one very short annotation are eyesores, and the mere act of coughing them up into the code was never a bottleneck to programming speed no matter how bloated they get.
The act of automatically renaming classes or variables, along with all the other code-shoveling refactoring support that IDEs provide is a miniscule subset of what refactoring is really about. The real refactoring work is done in your head. You need to look at the code and comprehend it in ways that aren't obvious, so that you can reorganize it to be simpler or maybe extendable. This kind of work cannot be done by an IDE; however, it can be aided by using a nice expressive language that gets to the point and doesn't distract you from the problem.
When it comes down to building, deploying, and automation of other menial tasks, I'm not stuck with what the IDE developers give me. A good language is like putty in my hands. An IDE locks me down and cumbers me, giving me little in return other than a graphical debugger and quick syntax help. Once you have mastered the command line, it becomes painfully obvious what the IDE cannot do. An IDE is a static cockpit with lots of cool doodads and buttons. I can make my own doodads and buttons and they will do exactly what I wish and they will do it exactly how I wish.
I am a language maven.
I've heard this argument many times and I can't quite understand it. Even if the few supported operations like rename/pull up/inline/extract are only a subset of all possible refactorings, I still do these things multiple times an hour. I want them to be automated. I hate bloated IDEs just as much as the next guy, but I do miss automated refactorings when in vim or emacs.
Vim is kind of like an IDE in some respects. I like it because it focuses on text editing and doesn't stick its nose into the actual programming decisions where it doesn't belong. If I wanted my editor to interfere with my programming logic then I'd probably take the jump to emacs, where I know it will obey me rather than forcing me to obey it, the latter accurately describing the experiences I've had with Visual Studio.
And, like I said, the act of performing the textual refactoring isn't where I spend most of my time anyway. Most of my programming time is spent thinking about how to proceed, placing those thoughts into the context of my program, and translating those thoughts into whatever language I'm using. The more I can speed up those bottlenecks the better.
This has totally been my experience. Moving a method or variable up or down in the inheritance tree, extracting part of a method, inlining method calls: all of this is architectural refactoring. I've found the much of my refactoring time isn't spent in moving methods around and modifying signatures; it is spent in modifying the algorithms and data organization. Not organization in the sense of whether variable belongs in sub- or super-class, but in the sense of whether some subset of data should belong in a particular class, or some new delegate class I construct. That new delegate class might not be a subset of the class I'm splitting apart, so requires more than just some automated extraction process. I can't help but create a mental picture of all of this as a sort of architectural autopilot -- it can handle making minor course and altitude corrections, but still expects you to have thought about things before pressing the 'engage' button.
The projects I work on are often pretty big (e-commerce websites for Fortune 500 type companies), and while an algorithm may live on one viewable screen of one class, a single business process or requirement will almost always span multiple JSPs and many classes. An add to cart action will need to check inventory, shipping rules based on hazardous flags on the SKU, shipping options and costs based on the customer's zip code, run through a whole pricing pipeline to apply coupons, discounts, BOGO type specials, and so on. Therefore to write that, or later alter or debug it, I will need to navigate through multiple files, to specific methods. And IDE means I can go directly to the source a method I call with one mouse click or key-combo. This is faster than finding the file, opening it, and finding the correct method (even more so when you can't just search by method name due to overloading).
I don't know exactly what you mean by "residue of IDE vomit". My IDE doesn't write code (with the exception of getters/setters). I do. Maybe Visual Studio does write lots of code for you, I wouldn't know. Real refactoring always starts in your head, no matter what tool or lack of tool you're using. You always plan it out in your head. It's just a matter of when its time to make the changes, are you searching for names to edit in 20 files by hand or not.
Maybe there's a difference in what we're talking about when we say IDE. In my opinion:
Dreamweaver = bad HTML IDE: because it lets you create page with dragging and dropping, so you don't actually understand how markup works, or how a dom tree is parsed, and it generates tons of awful HTML code behind the scenes.
Eclipse = good Java IDE: I write the Java code myself, but the IDE makes common tasks faster, and provides intelligent auto-complete, which means that I don't have to memorize every method name and parameter order of every class in the J2EE + Framework of choice stack.
I guess I feel that most of your complaints about IDEs don't apply to (or at least line up with my experience) writing J2EE apps in Eclipse. I used to use Emacs, bash scripts, and Ant, for years so I know what the alternative is.
You say an IDE is like a static cockpit, but in Eclipse at least it's pretty easy to make your own doodads and buttons that do whatever you want, or use the doodads someone else already created.
For me, an IDE is like toolchest with a little robot attached. It keeps all my tools in one place, so they aren't scattered all over my garage, I can add whatever custom tools I want to it, and the robot knows that when I pick a 18mm socket up, I'll almost certainly want the 1/2" ratchet next, and hands it to me, instead of me having to go dig through the stack of ratchets to find it. And if I'm using a torque wrench, the robot calls out the correct torques for the bolts/studs I'm working on at the moment.
The robot doesn't work on the car, and the toolchest doesn't spit out assembled engine blocks, but they mean I spend less time hunting for tools around my garage, and more time working on the car.
In this sense of productive, IDEs can be quite detrimental in careless hands. IDE can make developers more prolific, generating very quickly blocks of code that perform particular tasks, but I've also found that it can cultivate a more manufacturing method of coding, where developers just bounce on the '.' and tab keys and glue bits of 'sensed' method calls together. It makes development fast, and that means any productivity metric based on providing code meeting specified requirements is satisfied swiftly. It also means that the developer spends far less time thinking about individual blocks of code; this can have very deleterious effects. A single line might consist of 12 method calls strung together, because the developer didn't take the time to go back and assess things like readability. A particular method might calculate the incorrect result when passed data it wasn't originally designed for, rather that throwing an exception or gracefully degrading its functionality. A method or class definition might likewise make unreasonable assumptions about dependencies, requiring a large amount of rewriting; rewriting which could have been avoided if the developer had taken a few minutes to step back and examine the implications of their work, and how the design could change to make the code clearer and simpler.
To be clear, I am not blaming IDEs for careless, fragile code. What I am saying is that IDEs can be a magnifier for carelessness, allowing a developer with a proclivity for banging out code as fast as possible without regard for quality to do so much faster. What time they spend reaching for the documentation for a particular class or framework would give their mind a chance to think about what they are working on, and possibly come up with a more long-term workable solution to what they are building. I'm not saying it's a panacea; I guess what I'm saying is that I'm not totally opposed to artificially slowing down developers who would otherwise write code faster than they can reason about it. I suppose the other solution is just to identify them as careless, and remove them from the project.
I also worry about your dismissive stance toward the “core stuff of programming.” I’ve found it is this core stuff that makes for the simpliest, future-proof code, because the core stuff allows for reasoning about design, not just about functionality.
You can do all this from Vim.
It's simplistic to say that IDEs make us dumber. Auto-completion can lead to a vagueness about code structure but refactoring tools can greatly aid programmers to complete repetitive error prone tasks.
The fact that a repetitive and error prone task needs to be done at all is sometimes (not always, I acknowledge) a sign that your code is redundant and, well, crappy. I think it's a good idea to step back and decide whether the redundancy is legitimate. An IDE doesn't encourage that kind of thinking. Remember, someone after you has to go and read that code, and the IDE is not going to hide the redundancy from him or her. At the end of the day someone is scratching their head and staring at a whole lot of text.
I noticed a big difference when I transitioned from Visual Studio/Netbeans type coding to Emacs. I stopped hunting through class hierarchies and started, you know, actually learning the libraries I needed to use. Emacs lets me be the magician.
I haven't programmed using XAML, but it reminds me of the .ui file produced by Qt Designer, which I've edited by hand at times.
That is, some path to your solution should always be immediately obvious and that simplest path should always be the correct one. Clearly an unachievable goal in the general sense, but surprisingly doable overall in statically typed languages. One example: I know I have to call A.F(B), so I know that I need to construct B, which offers B.ctor(X) and B.ctor(Y), but I don't have an X, so clearly I need B.ctor(Y) ... etc. IntelliSense would have pointed you right to it!
I used to have a tendency to thumb through IntelliSense (and sometimes I still do!), but have taken to reading the docs before starting because most of the libraries I interact with are just too complex! The real problem is, that the majority of code that I consume isn't documented at all anyway, so hunting through the class hierarchies (or code directly) is all I've got.
For the record, my tools are: C/C++ = Visual Studio and Source Insight; C# = Visual Studio with Resharper; Java = IntelliJ IDEA; Python = Wing; Javascript = gggrrrrrrrr; XML, HTML = Notepad2; Other text files = Notepad2 or Visual Studio; whichever has the focus :-)
I'm actually quite proficient at Vim. I used it day in and day out at Google for 3 months. It just drove me nuts. Vim (and presumably Emacs) are fantastic general-purpose text editors. Too bad I only spent a tiny portion of my time editing general text. I spend the vast majority of my time editing CODE.
For me, that leads to better organized and better encapsulated code.
I guess I consider emacs ad IDE (or at the very least toolkit to build a personalised IDE). What about smalltalk? I don't think most would think of that as "dumbing things down" yet it really invented all the good things that IDEs have ?
that might reflect the relative dumbness of the two
no amount of popularity can change that
it's not like i'm advocating writing code using cli or sed
I like features like IntelliSense (when they work properly). I mean really, if you don't like features like this then perhaps you should consider removing auto-indent from your editor -- perhaps it's making you too lazy. As for me, I'd rather not remember API minutiae if I can help it.
That's not to say I don't learn APIs. I do and it's important to understand a system completely. But sometimes I forget the order of arguments to some random function.