Beta

×

Welcome to the Slashdot Beta site -- learn more here. Use the link in the footer or click here to return to the Classic version of Slashdot.

Thank you!

Before you choose to head back to the Classic look of the site, we'd appreciate it if you share your thoughts on the Beta; your feedback is what drives our ongoing development.

Beta is different and we value you taking the time to try it out. Please take a look at the changes we've made in Beta and  learn more about it. Thanks for reading, and for making the site better!

Does Relying On an IDE Make You a Bad Programmer?

samzenpus posted about 5 months ago | from the speak-up dept.

Programming 627

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?"

cancel ×

627 comments

Sorry! There are no comments related to the filter you selected.

No (3, Insightful)

Anonymous Coward | about 5 months ago | (#46327175)

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

Re:No (5, Interesting)

TheDarkMaster (1292526) | about 5 months ago | (#46327283)

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

Re:No (5, Insightful)

XenoPhage (242134) | about 5 months ago | (#46327331)

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 (5, Insightful)

Anonymous Coward | about 5 months ago | (#46327645)

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 (5, Insightful)

plover (150551) | about 5 months ago | (#46327499)

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 (5, Insightful)

MozeeToby (1163751) | about 5 months ago | (#46327589)

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 [amazon.com] 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 (5, Informative)

gordo3000 (785698) | about 5 months ago | (#46327599)

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 (1)

Kielistic (1273232) | about 5 months ago | (#46327617)

Parents hoist their children up by the armpits and allow the children to direct themselves with the movement of their feet and legs all the time. Probably not the best example unless you actually think an IDE is literally always a crutch.

Re:No (1)

geekoid (135745) | about 5 months ago | (#46327643)

If you understand software engineers and standard design principle, do you really need that great of knowledge of the language?

Yes (5, Funny)

Anonymous Coward | about 5 months ago | (#46327189)

Yes it does. (2, Informative)

Anonymous Coward | about 5 months ago | (#46327201)

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

hah php programmer (-1, Troll)

Anonymous Coward | about 5 months ago | (#46327203)

a php programmer dares criticizes other programmers' reliance on useful tools. lol. This story is trash.

Yes (0)

Anonymous Coward | about 5 months ago | (#46327207)

Yes, it does. It leads people to rely on building the application with the IDE instead of issuing standard Makefiles or using build systems like autotools or CMake.

Re:Yes (1)

Gaygirlie (1657131) | about 5 months ago | (#46327333)

Yes, it does. It leads people to rely on building the application with the IDE instead of issuing standard Makefiles or using build systems like autotools or CMake.

Why do you assume that an IDE wouldn't be able to generate standard Makefiles? I don't know about Visual Studio, but all the IDEs I've tried have certainly been able to use autotools and standard Makefiles.

Re:Yes (0)

Anonymous Coward | about 5 months ago | (#46327517)

> all the IDEs I've tried have certainly been able to use autotools
You say that like it's a good thing.

Re:Yes (3, Informative)

Sigma 7 (266129) | about 5 months ago | (#46327613)

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 (5, Funny)

Sigma 7 (266129) | about 5 months ago | (#46327533)

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 (1)

robthebloke (1308483) | about 5 months ago | (#46327539)

No it doesn't. Good programmer != good build engineer. You can be a superb code architect without knowing anything about CMake, or you can be an expert in the build process whilst being a merely competent software engineer. Every so often you'll find someone who is superb at both. Software development is a team exercise, so it doesn't really matter if some people are better at one than the other, the only thing that is important is that your team can cover both bases.

No... (5, Insightful)

Anonymous Coward | about 5 months ago | (#46327221)

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... (4, Insightful)

SJHillman (1966756) | about 5 months ago | (#46327355)

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... (4, Interesting)

Imagix (695350) | about 5 months ago | (#46327483)

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!

Does using a saw make you a bad carpenter? (2, Insightful)

Anonymous Coward | about 5 months ago | (#46327225)

See subject.

Maybe (0)

Anonymous Coward | about 5 months ago | (#46327235)

But we'd definitely be better off without Beta.

does relying on a hammer make you a bad carpenter? (2, Insightful)

Anonymous Coward | about 5 months ago | (#46327245)

Its a tool. Used appropriately you're fine.

Re:does relying on a hammer make you a bad carpent (1)

lbmouse (473316) | about 5 months ago | (#46327395)

Just exactly how would one use it inappropriately? Inquiring minds must know.

Re:does relying on a hammer make you a bad carpent (1)

BootSpooge (61137) | about 5 months ago | (#46327469)

Hammering in a screw? :-)

Re:does relying on a hammer make you a bad carpent (1)

Peter Dowdy (3542479) | about 5 months ago | (#46327513)

We use a tool called ReSharper, which will look for .dlls that match the namespace of classes you try to use. Sometimes it does this wrong; i.e. it picks an out of date .dll from a /bin folder in a project that's not part of the solution you're working in. Then it's really aggravating as you try to figure out why you can't rebuild the dependencies for that project. This is an example where careless use of an IDE can screw you over. Used properly, however, ReSharper is very, very nice.

IDEs are good. UI builders are bad. (5, Insightful)

Calavar (1587721) | about 5 months ago | (#46327265)

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. (3, Insightful)

Daetrin (576516) | about 5 months ago | (#46327493)

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. (0)

Anonymous Coward | about 5 months ago | (#46327501)

Don't forget the uselessly inflexible "project files" and associated build systems.

Re:IDEs are good. UI builders are bad. (1)

kthreadd (1558445) | about 5 months ago | (#46327503)

I would say that's true in particular for UI builders that produce code. I find UI builders that produce non-code tend to be better. Glade for GTK+ produces XML for example, just as if you had written it yourself. You can edit it if you want to, or write the XML from scratch and open it up in Glade if you want to fix something visually.

Xcode/Gnustep has an interesting approach which is worth mentioning. The UI builder does not work like a traditional UI builder, instead you work directly with the actual objects. Back in the days the way you saved was litterally as an binary object serialization.

Re:IDEs are good. UI builders are bad. (1)

Qzukk (229616) | about 5 months ago | (#46327591)

focused too much on graphical UI builders that produced brittle, often subtly buggy UIs

That's funny, back in the day UI libraries were brittle, often subtly buggy. See also: every dialog box form ever, when you try to use it on a Netbook with a 600 pixel high screen and the UI fails to implement some form of scrolling.

Re:IDEs are good. UI builders are bad. (0)

Anonymous Coward | about 5 months ago | (#46327615)

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.

Syntax highlighting and folding are editor features (vim ftw!), not features of an IDE. Code completion is imo detrimental to code quality - it will make sure the code compiles, however if you the programmer routinely forget which control structures are in use, you very likely make mistakes. Compiling those only makes them worse. Nothing wrong with autocompletion of strings, though.
Incremental compilation is not particularily useful in my experience - it will catch typos instantly, but that is counterproductive, it disrupts the flow. When I'm done thinking, I'll worry about typos (or rather, just correct them in one go).

The core is other thing (0)

Anonymous Coward | about 5 months ago | (#46327267)

As a programmer i use in the past, for years, Visual Basic 6.0 and then change to php / objective-c c. I must admit the auto-complete and IDE of VB 6.0 was part of the boom around VB related products, but, the matter is other.

Is not the goodness of VB ide, the core is the painful no availability in PHP with the same quality.

Walk before you can run code (4, Funny)

DiamondGeezer (872237) | about 5 months ago | (#46327271)

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

Re:Walk before you can run code (1)

JoeMerchant (803320) | about 5 months ago | (#46327477)

No, no, no! This is Slashdot, we need a car analogy:

Does relying on pre-made rubber tires make you a bad driver?

Re:Walk before you can run code (1)

bobbied (2522392) | about 5 months ago | (#46327573)

No, no, no! This is Slashdot, we need a car analogy:

Does relying on pre-made rubber tires make you a bad driver?

No, but it does make you a BAD mechanic.. You mean you don't make your OWN tires, mount them with a crow bar, balance them by spinning them on your finger using lead you smelted yourself? Shesh!

Re:Walk before you can run code (0)

Anonymous Coward | about 5 months ago | (#46327623)

(slaps pipe out of hand) Der machine ist nicht fur der fingerpoken, mittengraben, or rachenmachen!

No. (1)

dmomo (256005) | about 5 months ago | (#46327277)

Is "relying" an overstatement? Yes.

No (5, Insightful)

mikecase (1991782) | about 5 months ago | (#46327279)

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?

.NET in Notepad (0)

Anonymous Coward | about 5 months ago | (#46327281)

Good luck with that...

Not notepad... (0)

Anonymous Coward | about 5 months ago | (#46327289)

... vi you insensitive clod!

Re:Not notepad... (0)

bobbied (2522392) | about 5 months ago | (#46327621)

... vi you insensitive clod!

Only as necessary to get EMACS running!

So Now we have a CLASSIC flame war!

Viva La Unix! & FLAME ON!

Programming is not about rote memorization (5, Insightful)

grasshoppa (657393) | about 5 months ago | (#46327291)

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 (-1)

Anonymous Coward | about 5 months ago | (#46327465)

1) There is no such thing as photographic memory. This has been tested my a ton of researchers around the globe, and nobody who claims photographic memory has been able to prove it in a controlled experiment.

2) Just because you're too lazy to learn an API, and to become adept and referencing a standard, doesn't mean other people are somehow super intelligent. They're just not as lazy as you (and, no, you're not lazy in the "good" way that many elite programmers are).

3) Memorizing the API is like the least taxing thing about programming. If you're constantly searching for ways to make that aspect of programming easier, then your priorities are all screwed up. Learning about an API and memorizing common routines or methods is the first step to understanding a component architecture.

I'm a highly paid and experienced developer, but my degree is in the law. There are many comparisons made between software engineering and legal work, but the most obvious one to me is that in both you have to memorize a ton of stuff, but also must learn how to use reference works. And in both areas, technological crutches to knowledge management often do more harm than good. An attorney with an expensive subscription to WestLaw is not going win more cases than one with a stack of dusty books on his shelf, because there's no substitute for understanding the relationship between components and concepts; and once you understand the relationships, querying the details is child's play.

Re:Programming is not about rote memorization (3, Insightful)

HornWumpus (783565) | about 5 months ago | (#46327635)

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.

Its like picking a language (1)

Neruocomp (513658) | about 5 months ago | (#46327295)

Its all about whats needed to get the job done. If it works, great. If not, move on to the next thing. The job is whats important, the philosophy can come second.

"Would you be better off programming with Notepad? (1)

Gaygirlie (1657131) | about 5 months ago | (#46327297)

Eh, I don't think so. IDEs are great and all that and what tools you use doesn't matter in the end; what matters is that your code does what it's supposed to do reasonably-efficiently and without any "misfeatures." These tools usually also allow you to reach your goal faster than if you were to do everything manually, and in many cases time is money -- hobbyist coding being a separate issue. The language, the tools and so on really matter only in cases where you're developing for very limited systems, like e.g. embedded systems.

That said, I never found an IDE I felt at home with and I've always just typed everything away manually in Nano in a Linux-console...

sometimes you ONLY get to use an IDE... (0)

Anonymous Coward | about 5 months ago | (#46327299)

OpenWRT for example. There's almost no way to be able to compile and package it without their "IDE".

Of course (0)

Anonymous Coward | about 5 months ago | (#46327303)

Much in the same way power tools make you a bad carpenter or scalpels and anesthesia make you a bad surgeon.

Efficient (0)

Anonymous Coward | about 5 months ago | (#46327305)

It makes coding much more efficient and less error prone. Being a good programmer is knowing how to solve the problems and translate the solutions into easy to read well structured code that works (has been tested) and is maintainable.

Anecdote (5, Insightful)

dsginter (104154) | about 5 months ago | (#46327313)

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 (1)

CastrTroy (595695) | about 5 months ago | (#46327625)

I had the exact opposite experience. For my first programming course in university, we were told to program everything in notepad, and compile using the command line (using Java btw). Now that I know how to properly use an IDE, I realize how much time I wasted trying to debug things with many calls to system.out.println. While the IDE can be a little overwhelming at first, programming without a proper step-through debugger is painful.

you must be kidding (2)

ThatsDrDangerToYou (3480047) | about 5 months ago | (#46327317)

"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 (3, Funny)

GweeDo (127172) | about 5 months ago | (#46327319)

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

Re:Apple (0)

Anonymous Coward | about 5 months ago | (#46327481)

Presumably code coverage should have caught that, so I guess they don't unit test either.

Re:Apple (1)

geekoid (135745) | about 5 months ago | (#46327595)

Ha, nice.

gotos are always bad.
goto fail;
goto fail;

Fly By Wire (3, Insightful)

sycodon (149926) | about 5 months ago | (#46327321)

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.

IDEs lack good editing (1)

Anonymous Coward | about 5 months ago | (#46327335)

All the IDEs that I have used lack good text editing features. I end up having to reach for the mouse. Fail.

So I always end up back in Vim.

Real programmers don't need the handholding of GUI tools.

Re:IDEs lack good editing (-1)

Anonymous Coward | about 5 months ago | (#46327367)

"I'd crawl over an acre of 'Visual This++' and 'Integrated Development That' to get to gcc, Emacs, and gdb. Thank you."
-- Vance Petree

Re:IDEs lack good editing (1)

kthreadd (1558445) | about 5 months ago | (#46327515)

I would say that given how much functionality is in Emacs that's pretty much an IDE.

Re:IDEs lack good editing (0)

Anonymous Coward | about 5 months ago | (#46327507)

You should have seen it... I had to move a mouse and click on something. Oh momma, it was awful! Hold me...

Re: IDEs lack good editing (1)

Noughmad (1044096) | about 5 months ago | (#46327647)

Did you ever try Kate or KDevelop with its vi input mode? I don't use vi myself, but am interested in how that works out.

Yes (3, Insightful)

Imagix (695350) | about 5 months ago | (#46327337)

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.)

No (0)

Anonymous Coward | about 5 months ago | (#46327339)

Using an IDE doesn't make you a bad programmer. Solely depending on a single IDE however isn't great.

I'm a .Net and PHP programmer. Yes, I use Visual Studio for .Net but I use a fairly simple text editor for PHP (specifically Geany).

With my .Net programming, I know where a vast amount of the APIs I will be requiring are (eg. if I need to read/write to a file it's under System.IO, if I need threading it's under System.Threading). I know generally what I will need to use to get the job done and if I don't, I am generally searching the internet for my problem. I don't need to remember the full API for every single one of the classes I will be using, every method they expose and every argument for those methods.

The IDE for me allows for simple things like auto complete the methods and members that are set, lets me know straight up but syntax errors (after several years, it is still easy to forget a semicolon occasionally) and provides me syntax highlighting (though most more advanced "notepad" like programs do this).

Is that a crime against programming? No, I don't think so. Can I still code without an IDE? Yeah, just a little less efficient.

The problem would come if the person couldn't program and was relying that the IDE would magically fix the issue. I don't know any developers that actually think like that.

Re:No (0)

Anonymous Coward | about 5 months ago | (#46327565)

I probably should also add that IDE generally having debugging tools built in that programs like notepad don't really support.

Now being a PHP programmer and not having debug tools, I could just dump what I want to see to the screen however not all .Net applications can do this easily. Yeah building a .Net site might be able to easily enough but building a Windows form application, not so much.

Obviously, there are pros and cons to using various IDEs with various ones costing a small fortune (Visual Studio - unless you want the express edition which is actually does everything I need and is allowed in a commercial environment) or the ones that don't need a bunch of configuration.

Visual Studio comes with the compiler already configured and ready to go when it's installed. Geany, my text editor of choice for PHP, could let me do .Net development IF I configure it for debugging and compiling. Not a terrible thing, just that extra thing I need to do.

I will admit though, I am also biased to the default syntax highlighting colours. I like programming C# in Visual Studio because it's default syntax highlighting is awesome for the dark theme (in the latest versions of Visual Studio). I like programming PHP in Geany because it is such a simple editor and I like it's default syntax highlighting.

I can change it's syntax highlighting but I have no real reason to, I'm quite comfortable with my tools and happy to keep on programming with them.

Yes, if you rely on boilerplate code it generates. (4, Insightful)

Anonymous Coward | about 5 months ago | (#46327343)

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.

Tools are Good (1)

Thyamine (531612) | about 5 months ago | (#46327345)

All tools have pros and cons. In general, yes IDEs are good. Is it possible to rely too much on a tool, and not understand enough of the language? That's possible, sure. But that's not regarding IDEs specifically, that's just in general. I'm sure there are some old school CLI geeks out there that will thump their VI totems and say the only real devs use text editors, but that's just an extreme, of which there are many. Be a good dev, and use the tools that make you efficient. Don't use them as a crutch to shore up bad practices.

Of course! (0)

Anonymous Coward | about 5 months ago | (#46327349)

I'll only hire Electricians who don't use tools! They best be making their wire using rocks to scrape together copper shavings! I'd rather them punch a hole through my wall bare fisted than use a drill. Drills make you weak!

No, in fact, hell no (0)

Anonymous Coward | about 5 months ago | (#46327351)

>Does using an IDE make you lazy with the language? Would you be better off programming with Notepad?

No, in fact, hell no. Leverage the tools available to you. Notepad should only be used in dire emergencies, it's undo function only goes back 1 step.

There is no way I can memorize every overloaded call of every object in a framework, nor would I want to. Using notepad is the equivalent of not using Google to look stuff up.

What the hell, is it the 90s again? (5, Funny)

glwtta (532858) | about 5 months ago | (#46327363)

Up next: do you really need source control?

Re:What the hell, is it the 90s again? (0)

Anonymous Coward | about 5 months ago | (#46327619)

Up next: do you really need source code?

FTFY

Maybe the question is a bit misleading (2)

codepigeon (1202896) | about 5 months ago | (#46327381)

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.

WTF (0)

Anonymous Coward | about 5 months ago | (#46327383)

It is a shame that vim and emacs are still mostly uncontested as editors for programming. Program analysis and transformation should be integrated into the IDE. If it was available every programmer would use it. If you disagree, read this book: http://i.imgur.com/INBvStO.png

Take the current SSL debacle on Mac for example. The duplicated goto statement clearly caused several lines of code to become unreachable. Obviously, not a single tool in the toolchain informed the user about it (although the optimizing compiler certainly took advantage of it). It there was proper IDE support, the bug would have been shallow.

Many Java IDEs have toy examples of what future IDEs should provide: Eclipse, for example, allows refactoring. However, this is not standard. In fact, renaming a class in an industrial C++ project probably requires human intervention.

Depends more on the developer (1)

Anonymous Coward | about 5 months ago | (#46327393)

Relying on a sophisticated IDE can definitely contribute to keeping someone a mediocre developer, but it doesn't do it by itself. Likewise, it's easier for someone who is a bad developer to skate by with a sophisticated IDE, because it helps them figure out the answers to problems without them always really understanding the answers.

That said, a great IDE can maximize the efficiency of a great developer, just like a fast car will make a fast driver even faster. If you choose not to treat Visual Studio like a crutch, and use the time that it saves you to continue learning more and better methodologies, you will become a better developer.

For me, Visual Studio saves me a lot of time that I would waste on trivialities. I can use that time to focus on writing good code, learning new techniques like extension methods and yield, and putting more energy on good use of source control like check in comments and branching.

Are there bad developers in my field? Absolutely. I think there are more than there would be in the Java world, because Visual Studio can make it easier to "fake it" for longer than you might with another language. This can be solved by a better recruitment process to weed out people who are just looking to hop onto a contract for 6 months before their employer realizes they are useless.

If you are in school, it's worth punching out a few small applications in Emacs or Picos or Notepad or whatever the kids are using these days ... just to prove you can. But once you have a job, and you've proven yourself a few times, you should use the best tools available to you.

If you are really worried about being a bad developer, spend an hour a day on Codewars.com.

New IDEs (4, Insightful)

snookiex (1814614) | about 5 months ago | (#46327407)

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.

They're just tools. (4, Insightful)

wcrowe (94389) | about 5 months ago | (#46327431)

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.

Using it? No. Relying on it? Yes. (0)

Anonymous Coward | about 5 months ago | (#46327433)

IDEs are great, and obviously can increase productivity, especially if you use all of their features. That said, I think all programmers should know how to do things in the backend, using nothing more than Notepad and a CLI and build-scripts. Once you can do this, you'll have more appreciation for an IDE and also be able to use it more effectively.

On a related note, I cannot stand projects where the build is tied to the IDE. Everything should be scripted and buildable without the first step being "start the IDE". The IDE should be a front end only, decoupled completely from the back-end build system and tools. If you can't write IDE-less build scripts, I would say that yes, you are a poor programmer.

Short answer: No (0)

Anonymous Coward | about 5 months ago | (#46327449)

If anything, using an IDE will nearly always make you a better programmer through efficiency and discovery. Watching people work without IDE's is excruciatingly painful.

Bad programmer, maybe. Bad OS choice, Def. (-1)

Anonymous Coward | about 5 months ago | (#46327455)

Never understood the appeal of IDEs.
Seems to be a Windows thing.

It just looks to be an application that tries to correct the faults of the underlying OS.
Use the correct OS, and it's more of an integrated development environment than any silly little GUI program could ever be.

I don't want all my stuff crammed into a single GUI window.
No 2 inch high terminal, thank you. I want a proper multiplexed terminal.
No silly expandable tree view of files & directories, please, I want a real file manager.
I don't need a pressable button to "run" or "debug" my program, but thanks for offering.

Yes and No (2)

inhuman_4 (1294516) | about 5 months ago | (#46327457)

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.

Re:Yes and No (0)

Anonymous Coward | about 5 months ago | (#46327629)

If the only benefit you get from an IDE is adding boilerplate code then:
1.) you're using the wrong language or frameworks - find ones that don't need boilerplate.
2.) You're not really _using_ the IDE, or it's not really an IDE.

Yes if you don't know what's behind the curtain (1)

ffkom (3519199) | about 5 months ago | (#46327459)

It does not harm to rely on some IDE to provide a syntax reference or such. But in real life, programmers "relying" on an IDE do so on a much broader base - they often do not even know what happenes behind the curtains of that IDE when they press some "make"-button.

And that's the real issue: Programmers who do not know what "makefiles" are, how dependencies are being tracked, what "compilation units" or "object files" are, they are completely lost when the linker stops with some cryptic error messages telling about some "PIC incompatible symbol" or alike.

Also, programmers relying on IDEs are prone to also rely on 3rd-party code without asking questions. When their application fails, they claim its not their fault, because the crash dump shows some library function on top.

And lastly, programmers relying on IDEs often dislike to understand concepts before using foreign code - if they are asked to "support SSL" in their application, they press some key to search for function names containing "SSL" in their name, and if the function vaguely seems to fit, they call it. They don't start by reading the generic introduction documentation part of the library they are using.

Yeah, call the above stereotypes, but I've just seen a lot of statistical correlation.

depends (0)

Anonymous Coward | about 5 months ago | (#46327475)

Have you changed your code to make the IDE happy? Do you find yourself not writing a four liner to verify syntax with the compiler cause it's not worth the trouble to go through the project creation wizard, or do you even still know how to run cl, gcc, etc.? Is your file and directory layout a complete mess but you don't care cause you always look at things through class view? If "intellisense" fails to pull up the name of a method do you disbelieve in its existence? Do you read API documentation or do you only read what intellisense tells you? Do you write what should be done in Perl or Python in C# or Java because your IDE can't handle Perl syntax or do Python whitespace correctly?

Yes it does make you a bad programmer. (0)

Anonymous Coward | about 5 months ago | (#46327487)

The most pessimal, unscalable, problematic code I've seen was wrought by IDE monkeys who only cared about getting the thing to run, and thus were prone to short term thinking.

Would you be better off programming with Notepad? (1)

fozzy1015 (264592) | about 5 months ago | (#46327523)

Not if you need to actually debug it.

Would you be better off programming with Notepad? (1)

RailGunner (554645) | about 5 months ago | (#46327529)

No, but you might be better of programming with gVim...

I thought we were done with this stupid idea. (2)

Max Threshold (540114) | about 5 months ago | (#46327541)

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?

I use Edlin, you insensitive clod! (1)

MobyDisk (75490) | about 5 months ago | (#46327547)

Would you be better off programming with Notepad?

If having the most limiting tool available makes you a good programmer, then I recommend using Edlin. Or perhaps punch cards?

As a novice... (1)

quintessentialk (926161) | about 5 months ago | (#46327549)

My scripting/programming is exclusively in Matlab and similar tools so I can't weigh in here EXCEPT as a novice programmer. I tried in past to play around with android (which is java) and separately to relearn what little C/C++ I learned in my college days. As a novice, learning a new IDE is a sizable wall to climb. These tools are not documented with beginners in mind, and I was spending most of my time just trying to get hello world programs to build and link correctly when I wanted to learn the language instead. The IDE was an impediment at my level -- but maybe I was just learning the wrong way. When I was taught C++, it was 'learn C first, learn objects second, learn STL never'. The new strategy seems to be encourage use of standard library containers right away. Similarly, if I were to learn proper IDE use from the beginning (and I include visual interface layout tools under that heading) my experience would be different. I _have_ used tools which look like IDEs when preparing LaTeX documents (LaTeX is a typesetting markup language used in technical publication). Autocompletion of commands and previously defined labels (variables) is invaluable. I'm an inaccurate typist with a bad memory. Even if I weren't, I suspect computers are better at remembering those kinds of details than I am.

Does CAD make you a worse engineer? (4, Insightful)

geekoid (135745) | about 5 months ago | (#46327555)

The answer is: No.

An Analogy (0)

Anonymous Coward | about 5 months ago | (#46327561)

I suppose this would be like asking if a carpenter was better at his craft without his power tools? These tools are used to increase productivity and keeping certain procedures consistent. While it may be flattering for the carpenter to say he created a piece of furniture from hand tools carried down by generations, if he can get the same quality out of power tools then what difference does it make?

Not bad, just lazy. (1)

Earl The Squirrel (463078) | about 5 months ago | (#46327563)

As one poster wrote, using a spell checker when you write a novel doesn't make you a bad writer. That's true, but it doesn't make you a better speller.

An IDE doesn't make you a bad programmer, but it doesn't make you any better at retaining the language specifics (any more than a spell checker helps you become a better speller... people don't use it to "improve a weak skill" they use it "instead of developing the weak skill"... )

I've seen plenty of folks who can think, but couldn't do ANYTHING without an IDE. That's like a carpenter who uses an electric circular saw, but couldn't use a hand saw if the power was out....

Nice try! (2)

geekoid (135745) | about 5 months ago | (#46327569)

This is just the emacs/vi argument dressed up.

Notepad?! (1)

jones_supa (887896) | about 5 months ago | (#46327583)

Would you be better off programming with Notepad?

Notepad is crusty and not better than anything. Notepad has a glitchy word wrap, it does not allow different color themes and it does not show line numbers, for starters.

Go ahead.... (1)

ArcadeNut (85398) | about 5 months ago | (#46327597)

You can throw out the IDE and use Notepad if you want, but I'll stick with my IDE and be done in a fraction of the time, with less bugs and better quality code (thanks to all the tools I use in the IDE). Less bugs because the IDE will help with cut down on cut & paste errors with code analysis. Higher quality of code because of things like auto formatting, code analysis, etc...

As many have said before, it's about solving problems, not memorizing the 100 overloads for a specific call. I know what the problem is, I know what I want to do to solve it, why not let the IDE help me do it faster?

Tales from another Stupid Web Monkey (1)

Nethemas the Great (909900) | about 5 months ago | (#46327631)

This guy is a web monkey that spent his day playing drag and drop games in a UI editor. From his perspective, yes, the IDE made him a bad programmer. The trouble is, what he's talking about really isn't an IDE in the complete or even normal sense. An IDE is a toolbox with many tools, a saw, a hammer, a screwdriver, perhaps even a CNC machine, but ultimately writing software isn't about sitting down and George Jetsoning the CNC machine all day. If that's what you've done with your software development career that's unfortunately, but don't blame toolbox, blame the carpenter.

what a load of crap. (0)

Anonymous Coward | about 5 months ago | (#46327641)

i don't want to abondon slashdot, it's a long time friend, but it's getting more and more difficult to enjoy visiting this site.

please post less of this bubblegum bullshit and get back to intelligent relevant technical stuff.

no an IDE does not hurt programmers. if you think programming is about memorising programming languages you're doing it wrong.

as the others have said: programming is about solving problems, languages are tools. wasting time in notepad hunting down elusive bugs seems way more stupid.

that said... if you can't get anything done if you are faced with just notepad and a browser; you aren't a programmer in my book.

fuck beta, soylent rips.

Perhaps if DICE had used an IDE (4, Funny)

gman003 (1693318) | about 5 months ago | (#46327649)

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

valgrind (0)

Anonymous Coward | about 5 months ago | (#46327651)

Real programmers never allow memory leaks to creep into their code so valgrind is a real waste of time. Not. What a pointless story.

Load More Comments
Slashdot Login

Need an Account?

Forgot your password?
or Connect with...

Don't worry, we never post anything without your permission.

Submission Text Formatting Tips

We support a small subset of HTML, namely these tags:

  • b
  • i
  • p
  • br
  • a
  • ol
  • ul
  • li
  • dl
  • dt
  • dd
  • em
  • strong
  • tt
  • blockquote
  • div
  • quote
  • ecode

"ecode" can be used for code snippets, for example:

<ecode>    while(1) { do_something(); } </ecode>