Does Relying On an IDE Make You a Bad Programmer?

itwbennett writes "Writing about his career decisions, programming language choices, and regrets, Rob Conery says that as a .NET developer he became more reliant on an IDE than he would have with PHP. Blogger, and .NET developer, Matthew Mombrea picks up the thread, coming to the defense of IDEs (Visual Studio in particular). Mombrea argues that 'being a good developer isn't about memorizing the language specific calls, it's about knowing the available ways to solve a problem and solving it using the best technique or tools as you can.' Does using an IDE make you lazy with the language? Would you be better off programming with Notepad?"

Comments

No

[Anonymous Coward]

It's easier to learn the language when assisted by an IDE. Qt Creator is my favorite, followed by NetBeans.

Re:No

[TheDarkMaster]

I agree. With a good IDE, is easier to discover all the language can do.

Re:No

[XenoPhage]

Wouldn't this be more of what the API has available? IDE's don't really help you learn the language, beyond semantics, but they are extremely helpful with providing contextual information about API calls.

Re:No

[plover]

Actually, "learning the language" is the one time that an IDE is not the best choice. That's the time you should be trotting out Notepad and developing the skills and familiarity with the language itself.

Once you've mastered the language, the IDE serves as your reference tool, your refactoring tool, your formatting tool, your reading tool, your analysis tool, and even your testing tool. It makes simple things simpler, which is too simple for someone who doesn't understand the original simplicity.

A good IDE is a speed enhancer for good programmers. An IDE does not make a bad programmer become a good programmer.

Look at it this way: would you give a toddler a pair of crutches in order to teach him to walk?

Re:No

[MozeeToby]

Look at it this way: would you give a toddler a pair of crutches in order to teach him to walk?

That is an astonishingly bad analogy given the popularity of toddler walkers and the fact that every child while learning to walk starts buy pulling themselves up next to something and scooting along it's length.

Re:No

[gordo3000]

I don't have experience where 100% of what I do is programming, but at times, up to 25 or 30 pct of job was coding, and without an IDE I'd be lost. I can never remember any of the semantics of a given language (and I only use VBA and Python), but I do remember roughly what a language can do and an IDE makes it a lot easier for me to find the exact wording of a call, capitalization, etc.

I'd be miserable in notepad, getting hung up on typos, or an extra space that gums up indentation. IDEs allow a lot of folks like me who don't program full time to be able to code useful algos when we need them and walk away, not worrying about the time it takes to re-familiarize myself with a language.

Re: No

[Anonymous Coward]

Exactly. This is the way they teach the basics of the language you learn in school. This is why you also get tested on the basics of a language like variables, datatypes, and polymorphism.

If you never learned the basics ie foundations of programming, you will never use these fundamentals in any of that IDEs you use. I've seen it happen, somebody hasn't learned how to properly separate code functionally and it's all throwing together. They would do this in notepad or they would do it in eclipse or visual studio.

Your knowledge, skill, and experience make you the type of programmer you are. Good or bad.

Re:No

[fuzzyfuzzyfungus]

Look at it this way: would you give a toddler a pair of crutches in order to teach him to walk?

Is the IDE a pair of crutches, or the (massive, in neurologically unimpaired humans) amount of abstraction handled transparently and continually for you? Nobody walks by reading raw values from their inner ear and various sensory neurons and then writing values to individual muscle groups... Does that count as analogous to having an IDE remind you about standard library functions?

Re: No

[MightyMartian]

Frankly, I don't think what they aid with at all is learning the language (beyond perhaps hovering over core statements like for loops and the like to give you basic syntax). What they do aid with is familiarizing yourself with libraries, but before you delve too far into libraries in any language, you should understand the language itself.

Re:No

[Polo]

I think a better analogy is that an IDE to a developer is more like a CNC machine to a carpenter.

It's possible that a CNC machine can allow an experienced carpenter to do his work fast and efficiently.

But for an unskilled carpenter, I see two possibilities:
- the carpenter may limit his designs to what the CNC machine can make (no curved wood objects for one example)
- the fundamentals of carpentry might be ignored (like the properties of natural wood, growth, shrinkage)

In the context of an IDE maybe like:
- only build on one platform
- only create products the IDE way (maybe creating "apps" instead of minimal command line tools or OS internal things)
- allow the developer to ignore corner cases that are abstracted away with IDEs (memory management? interrupts?)

Re:No

[ThatAblaze]

Look at it this way: would you give a toddler a pair of crutches in order to teach him to walk?

That is an astonishingly bad analogy given the popularity of toddler walkers and the fact that every child while learning to walk starts buy pulling themselves up next to something and scooting along it's length.

Or maybe it's a really good analogy, just a bad argument. That sounds more like it to me.

Re:No

[Richard_at_work]

Use something like Resharper in Visual Studio and you can learn a lot about the language, as it offers loads of little "this code block can be refactored this way for this reason" hints - shows you just what can be done and why.

Re:No

[TheDarkMaster]

Yes, thanks for the extra detail. Yes, it was more or less what I meant. A good ide greatly facilitates the work of exploring the api of language and thereby find out what it offers.

Re:No

[JustOK]

It's psteudeo

Re:No

[epee1221]

I do remember roughly what a language can do

Then it seems you do remember something about the language's semantics. Maybe it's the details of syntax you're forgetting?

Re:No

[SerpentMage]

Learning the language with a notepad is IMO a really bad idea. I will give an analogy that I think is appropriate.

I am renovating our houses. In the past you would use a hammer and nail to assemble the wood. These days you don't. You use a cordless power drill with screws, and glue. I was talking to my sister and in Ecuador they do as well as their areas are earthquake prone.

My point here is, would you teach somebody to build a house with hammer and nails? Answer no, because it is a passe art. Now before you all start jumping on me on houses built with nails, that is to save costs. Anybody who wants a quality house will use screws and glue. Likewise notepad, VI, emacs are passe arts. Good at the time, but not usable anymore.

Re: No

[joaommp]

I don't think so. An IDE is not supposed to help you discover a language or a framework, but rather provide you with a workflow that makes you as productive as possible.

Re:No

[fwarren]

Back in the 80's I wrote a lot of code for my Commodore 64 on paper which I would type in later when the computer was available to me. I was in college a few years ago and was required to take a class on Visual Basic. Everyone is class was new to programming or learned with a fancy IDE. We had a test where we had to write a few routines on paper for a test.

Most students had no idea how to form a line of Visual Basic code. They would just start to type the statement and let IntelliSense give them the proper parameter list and then they would just fill in the blanks. This means they were lazy on if a statement used : or ; or if a variable was one-counter or one_counter or OneCounter. It was a disaster. out of 60 students I was the only one who passed that part of the test.

It is not that I am against IDEs. But having worked without them, and having to do the edit-compile-execute-debug loop, I conceptually understand what the IDE is doing for me. I have done the heavy lifting and I appreciate what the IDE does.

The best way to learn what the language can do, is to set down with a manual that has all of the commands and with simple examples, and read it whenever you are in the bathroom. It is much less boring reading something like this when the only competition is staring at the floor.

Re:No

[Zero__Kelvin]

" Likewise notepad, VI, emacs are passe arts."

Comparing Notepad to vim or emacs is like comparing Mayim Bialik to Kaley Cuoco.

Re:No

[Krishnoid]

... it offers loads of little "this code block can be refactored this way for this reason" hints - shows you just what can be done and why.

Oh good -- I was worried if and when Clippy would find work again, what with the husband and little staples to feed.

Re:No

[Greyfox]

Would you need contextual information about the API calls if the API were consistently designed? I remember thinking something should work in a certain way in Java, trying it and having it work that way, back when I was learning the language. Most languages, you learn a few idioms and are basically set. If your in-house software goes off into the weeds, that's really the fault of your developers and not the language.

Re:No

[Greyfox]

I use EMACS for all my development. The young'uns at the office are completely lost without a GUI environment and an IDE. Most of 'em probably don't even know what the link phase is. I fix shared library issues for them from time to time. I can use an IDE if I want to, but like to have more control over my build process. You really have to understand, say, maven, to hand-author a maven build file. If I don't understand my tools, how can I resolve problems when they don't work as expected?

Perhaps knowing when and how to use a hammer and nails would make you a better craftsman than completely dismissing the tools in your toolchest. At the end of the day, that's no better than only having a hammer and thinking every problem looks like a nail.

Re: No

[RabidReindeer]

I don't think so. An IDE is not supposed to help you discover a language or a framework, but rather provide you with a workflow that makes you as productive as possible.

In fact, I've found that trying to learn a language or framework via an IDE can be a very bad thing indeed.

First, because you don't really learn how the language/framework works, you learn how the IDE's generators and editors work. And frequently automated code generators create some really awful, unnatural code, because they're using one-size-fits-all models rather than intelligence.

Secondly, because even with one-size-fits-all, there are a lot of features and capabilities in most languages/frameworks that won't be supported. And when someone who's used to having the IDE do all the work tries to go in and manually remedy the situation, the results can be horrible.

An IDE in the hands of people who know what they're doing can be a tremendous productivity aid.

An IDE in the hands of cheap untrained monkeys hired because management thought that the IDE could replace experience, skill, and talent is disaster on the hoof.

You can tell which is which by swapping out the IDE with Windows Notepad. The skilled people will slow down and grumble about having to do everything the hard way. The monkeys will sit around idly weeping, because without the crutch that an IDE affords, they don't know what to do.

Re:No

[Jane Q. Public]

"That was what drove me nuts about ruby on rails... the constant assertion that it was all so "intuitive" that you could just type in what you expected to work, and it would work by magic."

I don't know who was asserting that. I've been using it constantly for 8 years and I don't know anybody who asserts that.

But be that as it may: please don't think this is a criticism. It isn't about you, but just in general about the subject you brought up.

First is: many people seem to be under the impression that Ruby on Rails is a "language" for web development, something like what PHP was designed to be. Not so. The language is Ruby. Rails is just a web framework built on top of Ruby. They are not the same things at all. If you don't already have a firm grasp of Ruby, you really shouldn't be trying to use Rails. You wouldn't try to become an expert on SpringMVC or Struts without knowing Java first. But lots of people think they can jump into Rails without knowing Ruby first. I have no idea why this is so, but many people get lost that way.

Second is: Rails is very much what they like to call "opinionated". It works according to a certain logic and mindset. If you don't care for that logic or mindset, you probably aren't going to have a good experience with Rails. That's just the way it is. Rails core developers are very open about this and not even a little apologetic about it.

Third: as a general-purpose language, Ruby (apart from Rails) is very nice in many ways. In some ways it is more consistent than many other languages. Probably the main drawback is that it is a cross-platform dynamic language, and doesn't have close ties to any particular system APIs. So it doesn't do "native" apps very well unless you use JRuby with Java UI add-ons, or MacRuby, or the like.

Re: No

[nwf]

Yes, using bad analogies is like cutting a tree down with a fish.

Re:No

[Darinbob]

She's the one on the show with Mayim Bialik.

Re:No

[coinreturn]

... it offers loads of little "this code block can be refactored this way for this reason" hints - shows you just what can be done and why.

Oh good -- I was worried if and when Clippy would find work again, what with the husband and little staples to feed.

Wait, Clippy is a chick?

Yes

[Anonymous Coward]

Real programmers use butterflies.

Re:Yes

[Sigma 7]

It leads people to rely on building the application with the IDE instead of issuing standard Makefiles

In other words, it causes the programmer to rely on an automated build system instead of an automated build system.

Re:Yes

[Sigma 7]

Visual Studio IDE doesn't have makefile support, but it does include nmake.exe which is good enough. However, it doesn't support autotools, since that's a Unix-specific script.

I don't like autotools myself - modern apps that use it still perform checks concerning string.h in addition to trying to detect if something is Ansi C. Anything failing those checks should be considered too outdated to be worth bothering about (especially with the software not being designed to run on ~20 year old hardware.)

Re:Yes

[rev0lt]

Offhand, yes, you are a less effective programmer if you rely on the IDE. I've seen many "programmers" that get completely lost if the IDE doesn't autocomplete everything for them.

That is a broad statement. Autocomplete is awesome when you're getting your hands into an existing codebase, and quickly need to be productive. It is also awesome when you have medium to big projects (between 500K lines, hundreds of classes/interfaces/whatever, and several million, thousands of classes/interfaces/whatever). I've seen many programmers completely lost at debugging *because* they were using a debugger - they wasted time identifying specific problems in their routines, while the whole approach was unsuitable - they would usually realize it after fixing the routine the first time, instead of looking at their code and trying to understand how could/would fail. Not all languages are equally suited for it, but those that fit the pattern (usually OOP stuff), works well.
My personal reason to use an IDE is syntax highlighting, project management features, and multi file navigation (it is common to have between 40 and 100 files open). Autocomplete is awesome, but it is a cherry on top of the cake. I could probably work without a full-blown IDE, but it wouldn't be the same thing.

Yes it does.

[Anonymous Coward]

I say this knowing next to nothing about programming. So, I might be incorrect.

Re:Yes it does.

[pixelpusher220]

Yes. I say this as a 20 year programmer. I'm quite happy to have my competition toiling away in Notepad while I'm rolling out version 14 :)

No...

[Anonymous Coward]

It makes you a bad programmer in the same way that using an automated spell checker on your novel makes you a bad writer.

i.e. not at all.

Re:No...

[SJHillman]

I would argue that it's more like relying on Word's grammar checker. The suggested way may be technically correct, but you should still know when the IDE isn't doing it the right or best way. And sometimes something is correct in the local context but incorrect in a larger context.

Re:No...

[Imagix]

BTW: There was some research done a while back that did show that using spell and grammar checkers improved the bad english-skills people, but actually made the people who were already good english-skills people worse!

Re:No...

[CCarrot]

BTW: There was some research done a while back that did show that using spell and grammar checkers improved the bad english-skills people, but actually made the people who were already good english-skills people worse!

That's it, blame the spelling and grammar checkers...

Does using a saw make you a bad carpenter?

[Anonymous Coward]

See subject.

Re:Does using a saw make you a bad carpenter?

[hey!]

If you're a bad carpenter, I suppose a powerful saw could make you a worse one. At least it allows you to make a bigger mess.

I've been a programmer for over thirty years now. When I started out, programming was about figuring out how to do things. Now it's much more about figuring out how to get someone else's code to do something. This shift was probably inevitable, as we try to get systems to do more and more. Very few of us have the luxury of being able to get away with just reading section 2 and 3 of the Unix manual; now we need to work with frameworks.

It's not like back in the day when you could code your own alternative to qsort as long as it worked; working with a framework's facilities is mandatory if you want the framework to do all the magical under-the-cover things it is supposed to do. We used to read the Unix manuals cover to cover from section 1 (commands) to section 7 (special files). Compilation and linking takes forever on a CPU running in the single digit MHz range, so we had plenty of time on our hands. That small but complete knowledge set, plus emacs, and we were cooking with gas.

These days you'd need to have loads more *static* knowledge to really know the APIs you're working with.So having things like pop-up parameter entry and a manual for the framework integrated into the IDE is nice.

But for me, the thing that finally got me away from emacsfor good was refactoring support in IDEs. And that's where the power saw analogy comes in. Refactoring is powerful, but it's also possible to drop down the refactoring rabbit hole and waste a lot of time frobbing around with the code. Refactoring is part of a suite of best practices that have to be implemented together (including source control, unit testing and project management). A clumsy and careless programmer can do a lot more damage with a powerful IDE, a skilled programmer can get more done.

It takes a lot more discipline, knowledge (of the know-how variety), and professionalism to be a good programmer these days. Back in the day there were very good programmers, and *terrible* programmers, and not much in between. These days there are more programming jobs than there are people gifted at programming, so what you see is a lot of mediocrity. Consequently all those powerful tools are neither a panacea nor a plague. Mediocre programmers will produce mediocre results no matter what they use.

Re:Does using a saw make you a bad carpenter?

[phantomfive]

If you're a bad carpenter, I suppose a powerful saw could make you a worse one. At least it allows you to make a bigger mess.

This is exactly right. When Autocomplete first came out, I thought, "wow, this is cool, it makes it easier to find functions in the code." Then it dawned on me that someday people would write code that is impossible to understand without Autocomplete.

And that day is now. If your code is not understandable without Autocomplete, or using an IDE, then you are a mediocre programmer. You don't know how to organize your code cleanly, so work on that and improve.

does relying on a hammer make you a bad carpenter?

[Anonymous Coward]

Its a tool. Used appropriately you're fine.

IDEs are good. UI builders are bad.

[Calavar]

Who ever said using an IDE is bad? IDEs are powerful tools that improve developer productivity. The problem with the older generation of IDEs (especially older versions of Visual Studio) was that they focused too much on graphical UI builders that produced brittle, often subtly buggy UIs and unreadable code and encouraged the writing of spaghetti code. Remove the useless UI builders, and you are left with syntax highlighting, code completion, code folding, incremental compilation, and lots of other useful tools that increase productivity.

Re:IDEs are good. UI builders are bad.

[Daetrin]

I'm an okay programmer (I'd estimate that i'm maybe in the 25-50th percentile, far from a star but still able to provide some value) but my memory for names is horrible. I'll often remember there's a function that does X but not remember the name. With code completion i can narrow in on the right function pretty quickly. Without it i'd have to either go check old code to see what function it was i used in the past or do some searches online to rediscover it, either of which would take much longer.

Re:IDEs are good. UI builders are bad.

[Reapy]

That was the biggest thing I got out of switching to an IDE. I don't know why but I started writing java in ultraedit (have moved on to sublime text, good stuff) for a long while, but I finally got to the point where I had to refactor a mid sized program and finally got everything going in eclipse.

I guess I've always been a bit scared of older IDEs and what they might change or move around if I don't know what all the buttons are, but I guess now a days they are great. The refactoring is huge, it feels much safer to rename something knowing the IDE also understands its scope rather than a find and replace and my brain. I used to have to judge how long it has been since I'd worked on some code, or how big it is, against whether it was worth the 'risk' of renaming a variable or function. Usually unless I had just written it that week, I let it go, but since moving to an IDE i'm able to keep past things consistent with new things much more quickly.

Auto complete is pure awesome, I'm not sure how I lived without it. I used to copy things I had to frequently reference right in to where I was typing just to speed up typing them, much nicer now to get a drop down list that will fill it out as you type.

But yeah as everyone has been saying, they are powerful tools, and while you should understand what is going on under the hood as much as possible, it is important to know how to be as productive as possible too.

Re:IDEs are good. UI builders are bad.

[tttonyyy]

IDEs with any form of wizard for "creating stuff" potentially take away the underlying understanding that a programmer might use to come up with something better.

But, for code navigation, a good IDE is totally indispensable, particularly with large codebases of someone else's code. What could be more useful than hovering your mouse pointer over a structure variable and having a little window show you how it was declared and what members it has? Or telling you all the places the current function is called from?

A good IDE shouldn't get in the way of coding, but nor should it take over the coding for you.

Walk before you can run code

[DiamondGeezer]

I remember the days when all real programmers needed was a magnetized pin and a steady hand *puffs pipe*

No

[mikecase]

An using an IDE doesn't make a bad programmer any more than using a table saw makes a bad carpenter. It's just a tool, if it can help you be more productive, why shouldn't you use it?

Programming is not about rote memorization

[grasshoppa]

Look, it's nice when you are well versed enough in a language to not have to lookup method/function names, nor their arguments. But let's face it, it's hardly the mark of an amazing programmer to have a photographic memory.

Programmers solve problems. Being able to understand the problem well enough to develop a solution for it is far more important a skill. Writing well documented code using a uniform style further boosts the quality of the output by helping make it maintainable.

An IDE is, at worst, neutral in this regard, if not beneficial for assisting in the last point.

Re:Programming is not about rote memorization

[HornWumpus]

Just because your degree was memorized, doesn't make memorization an objective good.

If I can be as productive (or more) then a memorizer by using autocomplete (and knowing more or less what the necessary function calls are if not the operand order) then I've just saved the time used in memorization. Also the autocomplete guy will be productive while the memorizer is still hammering soon to be obsolete information into his brain.

Henry Ford Sr used to ask prospective engineering hires trivial technical information. If they knew the answer he wouldn't hire them, if they told him where to look it up he did.

Anecdote

[dsginter]

When I was in college, I started immediately with an IDE - largely with no development experience. This was a struggle because the IDE was doing things that I did not understand. Ultimately, one of the elder geeks (a properly bearded and pony-tailed Yoda) suggested that I start at the beginning and develop with a text editor and the command line. This worked. Once everything was properly understood, the IDE is useful for saving time and catching typos. But I still need to "go back to the beginning" in order to find out what I am missing sometimes.

Re:Anecdote

[vux984]

I realize how much time I wasted trying to debug things with many calls to system.out.println

The point of your university course was not to maximize your output productivity, but to teach you how to program.

For example --
For my first calculus course in university I had to manually evaluate derivatives and integrals. Now that I know how to use Maple, and matlab, and R I realize how much time I wasted.

Right?

Well, sure, but the goal of the calculus course was to teach me the math, with no eye whatsoever toward generating the answers as quickly as possible.

Writing code manually in a text file, compiling it to object, linking it to an executable, and debugging it with println teaches you how things work under the hood. Picking up an IDE later on lets you leverage all the power that tool gives you, but still, in the back of your head, you know what's going on. That's valuable.

While the IDE can be a little overwhelming at first, programming without a proper step-through debugger is painful.

Ironically, a debugger "originally" is a separate thing, you can attach it to a running process, load a symbol table, set breakpoints etc. Its great that they are part of IDEs, but this invaluable skill of working with a debugger separately is frequently overlooked.

you must be kidding

[ThatsDrDangerToYou]

"Does using an IDE make you lazy with the language?"

Yes.

"Would you be better off programming with Notepad?"

Um, hell no. If you have to ask... Studio and other IDE's make me more productive. That's their job. If I had to fish for declarations of variables every minute and remember all the intricacies of the language, I would, well, be living in the 70's. If I couldn't use an IDE I wouldn't have time to /. QED

Apple

[GweeDo]

If only Apple has been using an IDE that looked for unreachable code...

Fly By Wire

[sycodon]

IDEs are to programming as anti-lock brakes and Traction Control is to driving, as fly-by-wire is to flying, as any assistive technology is to anything else.

If they didn't exist, someone would write one because they are so useful.

Yes

[Imagix]

Offhand, yes, you are a less effective programmer if you rely on the IDE. I've seen many "programmers" that get completely lost if the IDE doesn't autocomplete everything for them. They have no sense as to how the program as a whole hangs together. (Note the specific phrasing of "rely on the IDE". Not the same as "uses an IDE". Not using the tool is silly. Requiring the tool is the problem.)

Yes, if you rely on boilerplate code it generates.

[Anonymous Coward]

Also, "Would you be better off programming with Notepad?" No. A decent text editor is a must. Many programmers who "don't use IDEs" actually use text editors which are actually more powerful than many IDEs.

What the hell, is it the 90s again?

[glwtta]

Up next: do you really need source control?

Maybe the question is a bit misleading

[codepigeon]

It seems to me he is asking if it makes you a bad programmer to rely on auto-complete, not just relying on an IDE in general:

Mombrea argues that 'being a good developer isn't about memorizing the language specific calls

As a recent C# convert, I can tell you that for me, it has become quite addicting.

New IDEs

[snookiex]

The problem I see with IDEs like VS is that the hide a lot of complexity to programmers, which is good to boost your productivity, but the fact that you don't really know what's going on inside can back-fire if you are starting as a programmer. I've always thought that it's a good thing to do low level tasks at the beginning so you can build yourself up and don't depend on a specific tool.

Re:New IDEs

[Alternate Interior]

Exactly. Boosting your productivity is great. But hiding what "it" is doing is not. I started developing with QBasic and soon after Visual Basic, and it took years to understand how you'd develop without a GUI builder. The IDE hid too much complexity, set me up with bad assumptions, and it took a long time to learn what it was doing underneath. Knowing now, I'd have a much better grasp of how to organize code sooner, and I'd be a better developer for it.

TL;DR = Use them for the productivity boost, not to avoid learning or thinking.

They're just tools.

[wcrowe]

I'm glad somebody tagged this "idioticstory" because it is. Developers use whatever tools are available. Sometimes if the tools aren't available, they write them themselves. I've used development tools of one kind or another over the last 30+ years, and there are a few I've written myself. Frankly, I think that if you don't use development tools, and don't ever think about writing your own, you're a little like the clueless user who just knows, "I click here, then I click here," without any understanding of what they're really doing or trying to accomplish.

The use of complex tools is what separates us from the rest of the animal kingdom.

Yes and No

[inhuman_4]

There is nothing wrong with using and IDE, that doesn't make you a bad programmer. Relying on an IDE does make you a bad programmer. Lets face it, there is a lot of boiler plate boring crap involved in programming. Using an IDE to handle the mundane stuff makes a lot of sense. But if you can't do your job without it then you are probably not very good at your job.

Using a calculator doesn't make you bad at math. Being unable to do math without a calculator makes you bad a math.

I thought we were done with this stupid idea.

[Max Threshold]

Relying on an IDE makes you a more productive programmer. Programmers who think they're elite because they use some primitive text editor are simply wasting time. If that's your attitude, why are you writing code on a computer at all? Why not go back to punched cards? Or cuneiform on clay tablets?

Does CAD make you a worse engineer?

[geekoid]

The answer is: No.

Nice try!

[geekoid]

This is just the emacs/vi argument dressed up.

Perhaps if DICE had used an IDE

[gman003]

Perhaps if DICE had used an IDE, we could have avoided Slashdot Beta.

Perhaps a better question would be...

[jdkc4d]

Perhaps a better question might be what is the best way to teach someone how to code? With or without an IDE? The first language I learned in college was C, and we wrote C inside of pico. It was a huge pain in the ass, but it made you have to know what you were doing. If I am writing C# these days, I love the auto-complete features in Visual Studio. I wonder though, if I had learned in an IDE first, would I be less likely to use a language that maybe doesn't have an IDE? When I build UI's in Visual Studio, I just use the drag and drop system. I dislike having to go and edit those generated files when I need something to be a particular way. Assuming everyone is as lazy as me, I would wager that someone that has only used an IDE is considerably less likely to try their hand at a new language if doesn't have an IDE.

No

[jgotts]

Whether or not you use an IDE ought to say very little about how good of a programmer you are.

What makes a good programmer is someone who can produce stable, maintainable code in a reasonable time frame and someone who isn't worried about getting fired in order to fight for these goals. One part of maintainability is readable code and the other part is being able to communicate what you've done through documentation, written or oral.

Over the decades I've found that it makes no difference what tools you use, or what your age or educational or cultural background is. It doesn't matter so much whether you write few or many tests. You need to be patient, stubborn, thorough, curious, a problem solver, a voracious reader, and a great communicator to be a great programmer, and you need to have been doing it for at least 10 years. But companies should not shy away from helping to give someone those 10 years, because the best programmers will still do good work early on in their careers.

If you write code that just works but is unmaintainable by anyone and you hole up to write your code and you have no ability to communicate what you have done then you are a horrible programmer and you should be fired. There is a myth among some people that these are actually great programmers. These types of programmers tend to be, but are not always, extremely well qualified in terms of their educational or other experience but they make life difficult for all the other programmers that have to maintain their fragile junk. Fortunately, this type of software is less common in the free software community because this type of programming is called out.

Does using an airplane make you a bad superhero?

[istartedi]

Yes. If you were a Real Programmer (TM) you'd focus your mind and flip bits on the motherboard.

Re:Notepad has the same problem as an IDE.

[Shados]

IDEs are 80/20 solutions.

Typing speed is squarely in the 20. Hunt and peckers? No, but I may as well be. On a 1 month project, there's probably, what, 8 hours of typing at most? Even if you could make me type so god damn fast that I would type the entire code -instantly-, that would only save 1 day of work. The biggest part is the thinking, discussion, architecture, the stuff you don't even need a computer to do.

Then once you sit down, its about reading the code, analyzing it, re factoring it, debugging it. For all those things, typing is almost irrelevant. If your typing efficiency actually makes a dent in your productivity in the grand scheme of things, your job is probably outsourcable.

Now, as I mentionned in another post, in some type/size of projects, IDEs like visual studios may actually slow to a crawl to the point that non-typing-related tasks may get bogged down by performance and inefficiency. Then yeah, its time to switch editor.

But until then? If you can type 30 character per minute and are doing something significant, you're probably not slowed down much.

Notable exception for prototyping and testing out snippets in unfamiliar environments (like when learning a new programming language). You're likely to type/run/type/run/type/run a LOT.

Probably not.

[ttucker]

Being a bad programmer is a state of mind, leave the tools of the trade out of it.

Please Stop.

[zakkudo]

99% of the time if you hear someone questioning the utility of using an IDE, notepad was never in the running as a serious option to begin with. Just stop it. Don't say it's name. Notepad is a 24 year old joke stuck in the 90s feature-wise. The runners are programs like Sublime Text, BBedit, Text Wrangler, gedit, Jedit, notepad++, or even vim.

Just because someone tells you that you should drive your car less doesn't mean they are forcing you to walk everywhere you go on your feet. You can bike. You can ride your motorcycle. You can ride the bus. You can ride an electric bycycle. You can rollerblade. You can ride in someone else's car. You can ride the train. You can fly in a plane.

Anyone mentioning Notepad seriously in their comments on this article has no knowledge of what a proper text editor is and have an apathy to find out so they can actually contibute meaningfully to the conversation.

Re:Please Stop.

[Aryden]

And there is also something to be said about an editor that helps you identify an issue, even when in another file so that you don't have to try to decipher a cryptic log message due to a variable not being instantiated correctly in a different file. Sure, I can use NotePad++, and I do quite often for really simple scripts/reading files, but when I really want to sit down and knock out something that's more complex than "Hello World!", I'll fire up netbeans and have at it. It's also helped me learn quite a few languages due to showing me where I made my mistakes (like grading a paper in school) and helping me to debug.

Re:Please Stop.

[Jane Q. Public]

"I think the point was that there's something to be learned from writing code in an editor that doesn't offer any handholding whatsoever. I don't think anyone is advocating doing this in production scenarios."

Depends on what you mean by "handholding".

Editors like Sublime Text and TextMate have macros and the like, but they are a far cry from an "IDE" in the common sense of the term (like Visual Studio for example). Generally speaking, they might have syntax highlighting, auto-indent, global search etc. but they are still just editors, not even close to IDEs. And millions of people use them for coding professionally every day.

Re:Please Stop.

[RabidReindeer]

Anyone mentioning Notepad seriously in their comments on this article has no knowledge of what a proper text editor is and have an apathy to find out so they can actually contibute meaningfully to the conversation.

There's a difference between a text editor (and proper or not, Notepad is one) and a code editor.

IDEs like Eclipse have multiple code editors for different uses such as Java, C, SQL, Python and so forth. In the case of Eclipse, they're usually plugin options.

Emacs provides code editors but calls them "modes".

The point is, that a text editor can do generic text, but if you want to type in API calls and generic code, you have to type it all in yourself. A code editor is sensitive to the desired product and can suggest auto-completions for API calls, plug in boilerplate and the like. Back in the Bad Old Days, all we had to create code with was text editors and a stack of manuals printed on processed dead trees. And we liked it. At least until IDEs came along and we liked that better.

Then there are code "wizards", which are another species of skunk entirely.

Relying on an IDE doesn't make you a bad programmer. But if you are a bad programmer, you don't just rely on an IDE, you depend on it.

Re:Please Stop.

[Darinbob]

Some of my first programming in 1981 was on an IDE, but then they went away and it was just plain old editors for awhile. When IDEs came back they were crufty animals that were worse in every way compared to good editors like emacs, vi, TPU, etc. But they were used on systems where an IDE made sense: no built in compilers, no built in text editors, no built in searching programs, no built in shell, etc. The problem though is that the IDEs were jealous, they wanted to do everything and refused to work with other tools.

Part of this comes down to programmer style, and how they were raised possibly. Unix style of picking great tools that do specific jobs and using them together, or a picking a single all-in-one tool that does most things moderately well. Another divide is between programmers writing portable code for multiple systems, and programmers who have only ever used a single system in their careers.

Who cares?

[avandesande]

If you can get the job done and get a paycheck what difference does it make?

Let the IDE holy wars begin.

[Virtucon]

I can tell you from experience from the development side of things that having a good IDE and proficient knowledge of it's features can greatly improve productivity of a team. You still need to know how to compile at a low level and what the various link and compiler options are and you should know how to use a native debugger but if you want to be productive and not worry about the minutia of details then use one. An IDE doesn't make you a better programmer but it does make you more productive and you can focus on learning those nuances and skills within the chosen programming language more easily, allowing you to gain more proficiency.

The whole "you don't need an IDE" may be true but it's like hunting bears without a rifle. Sure, you can hunt bears without a rifle but if you have one it's much easier and you get less bloody.

IDE for search, refactoring, etc

[Brian_Ellenberger]

I'm surprised that so many of the comments for IDEs are restricted to things like autocomplete. IDEs do far more than that. Things like smart refactoring (beyond GREP/Replace), code searches and navigation (find references, go up and down the object hierarchy, find impls), and debugging (attach to remote process, breakpoints, etc).

No, it makes you a great programmer

[Anonymous Coward]

This is a perfect article for the 80's. You know, when computers had less computing power, less space, well less of everything. Yeah, in those days you could know a whole API of some library. Hell, you could know everything about programming the IBM PC (or any of its compatible clones). Secondly, you didn't have to write that much code because you couldn't write that much code. Remember, computers paled in comparison to today's machines. Your application fitted on a floppy. It does not require a DVD to install. Sure, in those days, you had no excuse if you couldn't cut it with vi (or your favorite text editor of choice).

IT'S 2014 FOR CHRIST'S SAKE! With the tremendous computing power we have today software has grown leaps and bounds. There are many APIs to know, and some APIs are large (like they have mini-APIs hiding inside). The programs we write are very large in size because they are feature rich. Maybe we aren't writing each line of code, but we construct programs module by module and they end up becoming very large because today's users take for granted a minimal set of features that would be considered Star Trek advanced back in the 80's. IDEs are not a crutch for dealing with millions and millions and millions of lines of code, it is a necessity. I'd really like to know how anyone could manage today's software with vi. Yeah, it could be done if you didn't value your time and had nothing better to do in life.

I look forward to tomorrow's article titled "Does relying on the web for reference material make you a bad programmer?"

I can't wait for next week's "Does relying on industrial equipment make you a bad skyscraper builder?" And here are some comment's from next week's article:

"My daddy used a hammer and a saw. Why can't today's construction workers do the same thing when building the Burj Khalifa?"

"Yeah, I second that. They build the pyramids with sand, water, and good ol' elbow grease. Technology makes us weak and unskilled."

"Guys, it took a long, long time to build the pyramids. It takes less than a decade to build a modern skyscraper. This is not exactly an apt comparison"

"Shut up, idiot! No true construction worker needs heavy machinery. You must be gay."

Re:Proprietary vs. free build system

[beelsebob]

But that's a one time cost, while maintaining makefiles is a many time, extremely high cost.

Re:What Language?

[Shados]

He's explaining it wrong and its detracting from his point. Webforms was basically the server side ancestor of the currently very popular AngularJS. Pieces of functionality (not just UI) were encapsulated in components ("web controls") that had their own life cycle, would ensure ids were unique, could contain their own css and scripts in their own DLLs.

You'd then drop them on a design surface (or stick them in XML code), sure. But that was just a convenient way of inserting the snippet. You weren't designing your app Front Page style or anything, it just didn't work for anything meaningful.

The issue here is with the framework providing an overly complex leaky abstraction over too many things, and the issue remains if you use Emacs to do it. Again, case in point: the problem is absolutely there with AngularJS. But since you don't drag and drop the controls there, and it has a marginally better architecture (ie: its not dog slow), people feel better about it...

Too many people confused the IDE with the framework (TFA contrasts PHP, a language with a web framework that revolves around pure text rendering, usually wrapped with 3rd party MVC frameworks, to a heavyweight component based framework). It would be kind of like blaming a Ruby on Rail IDE for a programmer's reliance on Rail's scaffolding.

It depends.

[DdJ]

If the IDE is helping you catch typos and quickly dig out references like method names, that's one thing.

If the IDE is providing so much scaffolding for your project, "wizards" and such, that you don't actually understand what's going on, that's another thing.

(I've seen both.)

Re:does relying on a hammer make you a bad carpent

[Anonymous Coward]

Using it to help you do a task you cannot do without it.

I.E. when the IDE fails to help you can you still do the job?

I'd liken it to a surgery robot. I as a non-medically trained person should not assume this will let me perform surgeries.

But it may help a skilled surgeon quite well but he can take over if the robot crashes where as I cannot.

Sadly I see most using the IDE as a normal person trying to code like a developer.....

Personally I use a combination of Vim+Nerdtree+tagbar for C/C++/Python and eclipse when forced to deal with Java. I'm also a believer that Java nearly requires the IDE purely because it's grown into a bloated mess that can barely be managed without one.

But real languages and such.... nah just use Vim and properly open the documentation for whatever class you are using instead of typing SomeClass(DOT) and waiting for the IDE to tell you what's there.

When doing C++ coding for instance you cannot just be happy "knowing" what functions are available... You need to know return codes, what headers those are found in, are they typed or enums, etc. Then all the quirks like if this function is thread safe, signal safe, block/wait free, etc.

If you are just blowing through using the IDE without knowing all those things I'd say it's hurting you more than helping. Cannot tell you how many bugs I've fixed where I was just being a tard and expecting some function to do A when clearly in the documentation is some text saying not to pass a B into it... and surely enough I've passed B.

I'd bet that moving to Vim for C/C++ development did more for my actual programming chops than any "shortcuts" eclipse provided. That an learning command line git after years of cvs/svn. That too really helped.

Re:Proprietary vs. free build system

[tepples]

But that's a one time cost

It'd be a one-time cost if all projects used the same graphical IDE. It's not one-time if you have to obtain Eclipse for one project, Code Blocks for another, Visual Studio for a third, CodeWarrior for a fourth, etc. A lot of the IDEs' project file formats don't diff well either, which makes them harder to handle in version control.

IDEs can help learn language

[SuperKendall]

in XCode the extensive LLVM warnings can reveal a lot of issues that pertain to incorrect usage of the computer language, not just the APIs.

meh

[kcmastrpc]

probably too late to jump into the discussion but I work with several developers who shun the use of IDEs, they're all 'VIM or die' mentality. The funny thing is their code is full of problems, from undeclared objects to undefined variables - all over the place. Much of the code is completely untestable and I'm constantly cleaning things up because my IDE picks up the stuff they missed because they are all gungho hacker devs. Bad developers exist regardless of what they write code with. I like my IDE personally, integrated debugging tools, code hint/completion and built in stuff like LINT make it easier for me to get actual work done.

Troll food

[TapeCutter]

I have been using visual studio professionally since version 1.5 on windows 3.1, ie: 20yrs. I do not write (serious) .net programs and never have, VS is not the only IDE I am familiar with, but it is my favourite with "eclipse" a close second.

You sound like someone who tried it once, found it was different to the QT you love and gave up. If you want a job coding you would be wise to explore it a bit deeper than you have. Not suggesting you give up QT but in my (considerable) experience you often don't get a choice of IDE when you take up a programming job. For example: The large code base I currently manage and help maintain is cross-platform C/C++ which aside from running on win32/64 and windows itanium, is also expected to build and run on various flavours of linux, sun, hp, and aix. I'm not going to change all my build scripts just so the new guy can build a private development version with QT, nor will I pay for a commercial QT license when the department already has an MSDN subscription that comes with the defacto industry standard IDE for windows.

In the end, potentially yes

[Lawrence_Bird]

From personal use/observation - they are helpful to get you up and running on a new language or one you have not had much exposure. They catch errors, help with syntax and api calls. But after a certain point they start to become more of a crutch.. almost training wheels. On reason for taking the training wheels off is to prove you actually can ride the bike. The same might be said of an IDE - after some period of time (months? years?) are you able to code without it? Do you really know what it is you are doing? Is the IDE holding back your own creativity?

Every each case is different, there is no black and white on this but I do think it may be worth stepping away from an IDE from time to time just to make sure you've not become over reliant.

What a stupid question!

[mtthwbrnd]

Does driving your car make you less able to walk?
Does turning on the tap make you less able to dig a well?

What do you want? Do you want us to only write 1's and 0's to prove how "pure" and "clever" we are!

Of course IDE's are better. They are designed to make us more productive. Yes, some people are very happy with vi or emacs. Good luck to them.

But IDE makes better programmers because they can focus on the problem they are trying to solve rather than truing to remember the exact syntax and semantics of how to do it.