As I have been watching the Masters snooker, there has been a great deal of discussion about Ronnie O’Sullivan breaking his cue before the tournament and then managing to play exceptionally well with a replacement which he has never used before. The majority of commentators seem to believe that this shows O’Sullivan’s natural prowess and flair for the game of snooker. I tend to agree.
At the same time, I have been following a discussion about Haskell at Integer Overflow where there has been a bit of a discussion in the comments about there not being an IDE for Haskell and that this is holding back the adoption of Haskell as a mainstream software engineering language. The argument goes that once the code base gets beyond a certain size, an IDE is necessary to simply get any work done. I tend to disagree.
The two situations are somewhat related.
For O’Sullivan, the cue is simply a conduit for getting the snooker skills inherent in his arm and brain onto the table. For other, mere mortal, snooker players, the cue is more than that. For them, the cue is an essential ingredient in their success.
Programmers tend to act similarly with regard to IDEs. On the one hand, there are those than can use an IDE, but it is simply a way of getting the code written. On the other hand are those that cannot function without their IDE. Put the latter breed of programmer in front of a basic text editor and command prompt and they are lost. They need the support and comfort that the IDE they know and love provides.
Imagine if a new breed of snooker cue was invented – the steadi-cue. This cue had the uncanny ability to remain completely steady so that even a rank amateur could make much more accurate shots. It is not inconceivable that a player using such a cue could beat the natural ability of O’Sullivan. However, the snooker purist would be aghast – snooker tournaments would no longer be about who is the best player; after all, you would barely have to practise.
When a programmer uses an IDE the same thing occurs. However, because programmers are not generally judged on their ability but rather on what they produce, nobody has a problem with using the equivalent of the steadi-cue; the IDE. They may not win a best-programmer competition, but getting a product out that works is more important.
Which is all well and good if that is how you want to regard yourself – as a cog in a machine, albeit an important cog. However, if you want to actually excel in what you do, try casting that IDE away once in a while at least. It can be liberating. For starters, you gain a far greater understanding of what is actually going on when you click the “Build” button for example. All those compilation flags you never worry about suddenly become a lot more interesting when you have to figure them out for yourself.
There is also a sense of liberation when the shackles of the IDE are cast off – programming can then occur almost anywhere at any time and a text editor can start up a lot quicker than a fully-featured IDE. Having tasted the freedom, I don’t want to go back.
Still… sometimes I wish I had intellisense.
No related posts.
{ 21 comments… read them below or add one }
I’d disagree… having used Eclipse and Visual Studio for years I was curious about the other camp and spent some time listening to the non-IDE coders.
It seems there is definitely two camps that follow two different sets of tools and practices. The Haskell+QuickCheck, Ruby+runit, etc camp says that all you need to do is write your tests and your code and you’re good to go. The emphasis is less on the IDE since the approach is less about what modern IDEs do.
The C#/Java camp love their Visual Studio and Eclipse because the approach is different. Here you’re using the IDE to explore large libraries of pre-made functionality, as opposed to writing your own. The IDE lets you easily auto-complete functions and use help to peek into their usage.
Not that this distinction fits everyone, since Ruby has ri to explore libraries. Perhaps also pertinent is that Haskell, Ruby, Python, etc all use a REPL for a more intimate interaction with the language and its tools.
In Introduction to the Personal Software Process Watts Humphrys recommends you keep track of syntax errors with an eye toward their reduction. I’ve always thought that was old-fashion advice harkening back to card decks, when compilation runs were expensive in themselves. Also, with IDEs and editors taking on a lot of this checking it just seems pointless.
However, I’m noticing a lot lately that when I’m trying to slam out a solution too quickly, I spend more time just getting things to compile and then, the logical quality of the “solution” is also suspicious.
This is a pretty confusing topic for me. I agree with you about the likes of eclipse or visual studio. But, where exactly does an editor end and an IDE begins? What would you call Emacs? An editor or an IDE? Even if it can do nothing else, just the syntax-highlighting of the haskell plugin makes life a lot comfortable. I can argue that if one intends to excel in programming one should work only on emacs. I can very well imagine some one making a good case of jedit or gvim or even eclipse for that matter.
I don’t think there is anything wrong with IDEs. What I am wary of is being unable to program without one. IDEs by their very definition, make a lot of the lower-level grubbiness disappear. Unfortunately, it is this low-level grubbiness that you need to understand when subtle errors start to arise.
If you only ever program in an IDE, and don’t know what it is doing for you, you are stuck, or at least, you have a lot of learning to do.
For this reason, it is good to learn a new language from the command line – it is purer and lets you see what sort of things need to happen for your code to become executable. The magic is taken away.
I am all for using an IDE, but not exclusively. Use it as a tool rather than the tool.
A coders level of knowledge of a computer system and whether or not they use an IDE are orthogonal – that is people who use IDE’s aren’t wimps or lazy.
Eclipse is fantastic for project discovery with explicitly typed languages – that is discovering types and how they relate to each other without necessarily relying on missing or inaccurate documentation. This is a major use-case. But its a mistake to try to cast this as less important or manly than writing your own libraries – code reuse is extremely important and time saving.
If you do need to write your own library or API, then once again you will be extremely impoverished in the Java world without using something like Eclipse which brings features like compile warnings and errors for missing javadoc (in-code documentation). Automated versiong support in the form of binary/source compatibility checks against different library versions.
The comparison with snooker fails as its a competitive sport – the whole point is measuring the players against each other. Using an IDE is a labour saving device and ultimately only accelerates good and less-good programmers alike.
There is nothing macho about not using an IDE, it just makes you slower.
While you equate the functionality of IDEs with programmer hand-holding, I can’t help but imagine ghosts from the early days ranting about our fancy compilers and all the nasty details we can typically afford to be oblivious of.
I agree it would be sad to know someone who cannot code without the assistance of an IDE, but as a person who had recently spent nearly a decade coding without one, I don’t really have any desire to do that anymore.
It’s about making things easier, more clear, and even if I have to adopt a few external philosophies while forfeiting some of my own, maybe it’s not actually a bad thing. Plus, if you do end up being a cog in some machine, it’s handy to mesh nicely with the other cogs.
You are stupid.
@Tug
Entirely possible, indeed, highly likely. It was just a thought that came to me. What in particular is stupid?
I’ve gone back and forth on the topic myself. I agree that learning how the tool chain works underneath the shiny exterior is very educational, and therefore every programmer should know how to do things with notepad (or its equivalent) and the command line. On the other hand, I disagree with people who dismiss IDE’s as superfluous to the task at hand.
Someone who dismisses an IDE usually does so out of ego, not because they analyzed the available tools and concluded that a simple text editor was the best tool available. “I don’t need an IDE” is something I’ve heard a lot. What I hear when someone says that is “I like asserting my superiority, even if it makes me waste my time”. A real IDE does a lot of stuff that is invaluable, like redlining of syntax errors as you are typing, intellisense, jumping to function/class declarations, back/forwards navigation, bookmarking, jumping to compile errors, auto-formatting of code, selective builds, integration with version management, and on, and on…
For a good programmer, the end goal is user happiness, and that end justifies the means. If the programmatic equivalent of the steadi-cue makes users happier with the end result by delivering better applications faster, put your ego aside and use it.
The argument over features is endless; what I relate to is the feel of the application as I use it. Starting up and using vi feels small and sleek and dangerous. It’s seemlessly integrated with my Integrated Development Environment (linux). Starting up and running IntelliJ feels like driving a tank, and it feels disconnected from the rest of my workstation. This one distiction makes all the difference to me; I think IntelliJ could add a feature called ‘Project Completion’, I’d still want to know if it was fast to type on.
Different strokes, etc. I work with wickedly talented guys who love intellij when cutting Java code. I believe them that it’s good. It doesn’t match my style, so I’m willing to give up some features forbmy personal ergonomics.
Hi!
It’s an interesting topic. I just wanted to basically say “hello!”
I have had a great deal of experience with a piss-poor text editor I created myself and used it to write tens of thousands of lines of code in Ruby and JavaScript mostly. And I refactored a lot of that using it as well.
I just now was experimenting with a new version which will be based on JRuby and core to it has been a component for syntax highlighting developed by someone else for Java Swing. I think from what I read of him he uses NetBeans to develop this handy component.
NetBeans is cool, but the way it works doesn’t quite work for many projects out there that don’t follow its supported “workflows.” At least for me NetBeans falls a little short. I have tried to extend it with JRuby but it didn’t work because there was a conflict when I tried to load a second JRuby instance as the Ruby module of NetBeans makes use of some parts of JRuby for lexing/syntax highlighting of Ruby. And when extending NetBeans it can be troublesome in multiple ways as well… Java in general makes me sleepy, I guess, so it’s easy to procrastinate…
I like to customize my text editors so they do things like launching scripts, showing the output, search directories and their files, do batch replacements of texts using regex and so on…
Out of my experience, I would say that the ultimate support of any framework is in an IDE of some kind. Though text editors are way too handy and hard to kill, otherwise what to tell the Emacs legions out there? And all the other text editors being used all the time to edit HTML, CSS, JavaScript, and all kinds of files, really? But then again, there are IDEs like Flash Editor, Flex Builder, Visual Studio, and so on and so forth that many times are used by folks who would have a hard time saying that they are programmers, as many of them might consider themselves designers or very lightweight programmers…
I think the IDEs have a hard time as well because their strengths end up being so focused on one or another area of development that they aren’t very general either…
I’ve used Eclipse and IntelliJ for a very long time and I’ve tried many IDEs over the years. I also use vi and TextMate regularly.
The biggest problem with IDEs, from my experience, is the people who are enslaved by them. I think that’s the point you are trying to make and I totally agree.
I’ve worked on Java projects where we couldn’t use a better library or a better tool before IntelliJ supported it. Even though that meant using a less productive tool. All that in order for programmers not to feel uncomfortable leaving their IDE and getting hurt by the context switch. This, to me, is absolutely ridiculous. A lot of very cool tools, libraries, programming languages are ignored just because they lack IDE support.
I also despise how slow IDEs are becoming and the overhead of maintaining and configuring them.
On the other hand, I do miss a lot of features from IntelliJ when I am using TextMate or vi. I am not sure what the correct solution is, that’s why I use different editors depending on the task.
Funny, I have been explaining the benefits of working without an IDE to a coworker yesterday. I too find that being able to work in a *fast* text editor is liberating and everyone should try it. My editor of choice these days is Vim, and I keep it around for all kinds of tasks that I deliberately do outside of Visual Studio .NET.
I have been “nudging” members on my team to learn MSBuild since day 1, so that they can both work outside the IDE. I believe it makes everyone think outside the “Visual Studio project” box and helps us grow a real build system and a truly Agile engineering environment.
What makes me sad is the huge number of C# and VB.NET “developers” that do not know how to invoke their compilers on the command line. People, if you don’t know how to do that, please keep the quotes around “developer” when you mention your job title.
Hristo Deshev
It has certainly surprised me how many strong opinions there are on this topic – especially on this post which is just something I threw together while waiting for some more snooker to appear!
Another advantage of discarding the IDE, as Hristo mentions, is enabling the automation of the build process. I recall doing some C# development and instead of using Visual Studio, I used a plain text editor together with NAnt. It was quite eye-opening and enjoyable. However I did miss the use of the VS editor. Eventually I adopted an approach where I used the VS editor, but all building etc was done at the command prompt – this gave me the best of both worlds, in that my coding was productive, but I also had that fine-grained control and understanding of the process.
Real Programmers:
http://xkcd.com/378/
Many Haskell people are proud of not using an IDE. I hope the community give them the chance for showing their real strength by making a very good IDE available. I started development a Haskell IDE June 2007, released the first public alpha February 2008 and just prepare for the first beta. I do this project for fun in my spare time beside a job, the family, and everything (and I’m not one of this hackers that sit in front of the computer every day + my friends are convinced I’m lazy in every aspect). So if I would have been paid for it, I could have developed what I have in 3-6 month. And I am a Haskell newbie and nobody (at least I was when I started). So I’ve come to the conclusion (for myself), that it is very well possible to develop a Haskell IDE that quickly can become very useful.
The fun with the project comes (besides of using Haskell) from that I can implement what I like, and not copy anything (like porting Emacs, VI, Eclipse or anything to Haskell). It is still very little that is done, but I had to implement quite a lot to reach this little. And yet this little it is very useful in my eyes (and I’ve received some encouraging comments). The community has the HIDE IDE project with a lot of well known potential contributors, but the outcome is yet hidden. When I started Leksah I decided I will not do anything for having ‘beautiful code’, but that I will measure my success only from what Leksah can do for its users. Haskell is very tempting in that you have so many possibilities of doing something nicer or at least different, that I couldn’t hold completely to my original promise, so the code is actually not as bad as I’ve planed.
@Jutaro
I had a quick google and came up with this which is assume is your Leksah
. It looks really nice – I seem to remember having a look at it some time ago but never actually got around to trying it out. One question I have – does it support literate Haskell? I tend to write all my code in that form.
Another one of those things I keep meaning to get around to is writing a GUI using Haskell and the various libraries. How did you find that aspect – was it fun?
@Colin
literate haskell should be no problem. The Editor should as highlight it.
But I’ve not used literate Haskell.
It is easy to program GUIs in Haskell and gtk2hs is usable. I missed some libraries, so I wrote something like a (very rudimentary) framework for composable editors and a (very rudimentary) framework for multipane panes in a window. So it is fun.
I used to program without an IDE but I’d certainly never go back now. Particularly for Java development, Eclipse is absolutely invaluable (I’m sure NetBeans is good too, yadda yadda). And it has absolutely nothing to do with not knowing how your projects are built. I build release versions of all my programs using Ant – which is great, because it’s repeatable in any version of any IDE or none – and guess what? Eclipse has nice support, completion etc, when I hand-code my Ant scripts. It has a single button I can click to re-run the last Ant build I did. I’m using Ant, I’m absolutely doing the build by hand, and Eclipse is still making it easier.
The biggest reason we use Eclipse at work, especially with our less experienced programmers, is the version control integration. ‘Work’ is mostly PHP and the Eclipse support for PHP, while much better than a basic text editor (can I live without ctrl-click? no) is decidedly flaky, slow, and memory-consuming. Not entirely its fault; since PHP is such a godawful excuse for a language it clearly isn’t possible to behave as beautifully as the Java implementation…
So there’s not such a massive reason to use Eclipse just for the language support. But it is hard enough to get those less-experienced developers to use version control at all and the Eclipse CVS integration is absolutely invaluable. I would never want to live without it – if you don’t use ‘integrated’ CVS, you have to deal with fundamentally broken, impossible-to-explain behaviours such as deleting files not working. Eclipse, you delete the file, it remembers it and does that with your commit. Then there’s the history view, the annotate view, right-click Compare With Latest, Create Patch, etc. All of these things are possible, but laborious, with the command line and/or with a hotchpotch of GUI programs such as WinMerge. But the chance of getting all our developers to manage that through the commandline? Zero.
Thanks to Eclipse, we get to make sure all our developers use version control – and given a year or so of experience, some of them are getting pretty good at it.
This does have the disadvantage you mentioned above about being restricted in other things because of our IDE. We’d like to switch to Git for version control. But the Eclipse plugin for Git is still under development, nought-point-something, missing features, and flaky. [Not dissing the developers, who still seem to be active - good job, a lot's getting done. But it's not ready yet.]
Git command line is very nice compared to CVS (I’m using it experimentally on a couple of just-me projects) but it certainly doesn’t match up to what full integration would provide. And it’ll be hard enough to get all our developers used to a new version control paradigm even when there is full GUI support… trying to get them to do it in the commandline? Almost unthinkable.
So in other words, it seems like we’re restricted by the IDE – but in fact we aren’t. Without the IDE, we’d still be struggling to get our developers to even use CVS properly. The fact that we can’t use Git is neither here nor there.
The software baseline – compared to everyone using their favourite text editor (probably one that was last updated in 1994 and doesn’t have syntax highlighting or global search), different helper tools, etc – also means that team members have a much easier job supporting each other. Thank the gods for IDEs, that’s what I say.
I think the point being made here is not that IDEs are big evil nasty things that should always be avoided; more that it’s a chance to learn something about what the IDE actually does when you press the compile button.
Hi
To keep the post short.
Better programmers should be comfortable without IDEs.
Better programmers should be intelligent enough to use IDEs if it means a lot of time saving (exploration, keystroke savings etc.).
It is the design and analysis faculty which is important and not that one uses or not an IDE.
The things one can do in jiffy on IDEs are impossible to do with same speed without ones.
Asking to give up IDEs or not wishing for one is like asking a C programmer to code only in assembly always.