Slashdot Mirror
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?"
It's easier to learn the language when assisted by an IDE. Qt Creator is my favorite, followed by NetBeans.
Real programmers use butterflies.
I say this knowing next to nothing about programming. So, I might be incorrect.
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.
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.
See subject.
But we'd definitely be better off without Beta.
Its a tool. Used appropriately you're fine.
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.
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.
I remember the days when all real programmers needed was a magnetized pin and a steady hand *puffs pipe*
Tubby or not tubby. Fat is the question
Is "relying" an overstatement? Yes.
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?
Good luck with that...
... vi you insensitive clod!
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.
Mod me down with all of your hatred and your journey towards the dark side will be complete!
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.
Physics is like sex. Sure, it may give some practical results, but that's not why we do it
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...
OpenWRT for example. There's almost no way to be able to compile and package it without their "IDE".
Much in the same way power tools make you a bad carpenter or scalpels and anesthesia make you a bad surgeon.
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.
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.
More
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
If only Apple has been using an IDE that looked for unreachable code...
Unstable Apps: Our Android Apps Don't Suck
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.
When Fascism comes to America, it will call itself Anti-Fascism, and tell you to give up your guns.
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.
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.)
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.
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.
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.
I will shred my adversaries. Pull their eyes out just enough to turn them towards their mewing, mutilated faces. Illyria
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!
>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.
Up next: do you really need source control?
sic transit gloria mundi
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.
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.
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.
Just exactly how would one use it inappropriately? Inquiring minds must know.
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.
Open Source Network Inventory for the masses! Kuwaiba
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.
Proverbs 21:19
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.
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.
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.
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.
Hammering in a screw? :-)
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?
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.
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.
Not if you need to actually debug it.
No, but you might be better of programming with gVim...
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?
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?
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.
The answer is: No.
The Kruger Dunning explains most post on
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?
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....
This is just the emacs/vi argument dressed up.
The Kruger Dunning explains most post on
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.
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?
Visit the Arcade Restoration Workshop @ http://www.arcaderestoration.com
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.
Two of my imaginary friends reproduced once
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, we could have avoided Slashdot Beta.
Real programmers never allow memory leaks to creep into their code so valgrind is a real waste of time. Not. What a pointless story.
My wrists thank me for using an IDE with good auto-completion. Fewer keystrokes = win over the long haul.
Then the answer is "No".
FYI - Yup, the answer to the question that the title of this article asks is "No" in a recursive fashion.
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.
Does using a compiler instead of entering your own hex, make you a bad programmer?
An IDE is just a tool. It can be used as a way to improve productivity and also could be used as a crutch to let you template/wizard your way through stuff you don't fully understand.
Seems like people are hung up on autocomplete and the intellisense... The greatest part of an IDE is the built in debugger (IMO, of course)... It's much less time consuming and error prone to have all things configured in one place - compile, run, debug, repeat.
Notepad is essentially what we ARE programming with using an IDE like Visual Studio. The paradigm is the same, enter with a keyboard, edit with a mouse. But you know, the last time I looked I had ten fingers, not one. And as a touch typist, taking my hands off the "home" position, is darned inefficient. Now, I'm not trying to argue that "vi" is what we should be using, but I'm way faster editing with "vi" than with either Visual Studio OR Notepad. Why is it that the IDE's have advanced development functionality in every way but one? Are all you guys hunt-and-peckers (or all the developers at Apple and Microsoft)? Even worse, with regards to editing the IDE/Notepad paradigm took a big step backwards and stayed there while the rest of the process has pushed on to better things.
The answer to this question is going to be drastically diferent for web application development in ASP.net than it would be for firmware development in C++. These guys are speaking from the web application side of the world, that context really shapes this debate.
The question these two are discussing really is: "Is it wise to become dependent on the GUI wizzards in Visual Studio to develop ASP.net applications?"
Notepad has enough bugs that, if you accept them, you most probably are a lazy and incompetent programmer as well.
Real programmers use SATA, so there.
It can make your life easy, but it won't write the code for you.
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.
Let me rephrase how I understand AC's point: It causes the programmer to rely on a proprietary automated build system instead of a free, portable automated build system. An IDE that exports to Make or another common automated build system lets people rebuild the program without having to procure and install a copy of the IDE.
IIRC an IDE it is an app that provides a text editor, build/run automation and a debugger. All to be easily accessed from some menu/shortcuts system. How can any of these components, separated or integrated, impede the intellectual development of a programmer?
Unless, of course, the programming language that the IDE implements is a retarded one..... then blame it on the language, not the text editor.
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.
It supports screwing yourself as the main feature
But we'd definitely be better off without Beta.
How so? Sony v. Universal (the Betamax case) helped establish the "substantial noninfringing use" doctrine. For example, an IDE may be used to create an infringing clone of a copyrighted computer game, but because it has other noninfringing uses, the IDE's publisher isn't liable for contributory infringement.
Yes. If you were a Real Programmer (TM) you'd focus your mind and flip bits on the motherboard.
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
... there's something else that might. It's the ever-increasing percentage of functionality we implement through choosing, including, configuring and glueing together existing frameworks and libraries.
But remember, when you're programming on a DG Eclipse, Speed kills.
Oh look, it's this thread again.
My biggest complaint about IDE's and why I don't use them often is that I have to program all over. My home environment is not the same at work, is not the same 'on location' is not the same 'on the road,' etc.
I program in the leanest way possible. I use the tools that will be available (or be made available) wherever. That means I use text-editors. I use 'vi' in Linux/Unix shells and I use Notepad++/Sublime on Windows. That way, where ever I am, I always have my 'tools' with me.
If I had the luxury of a more stable 'situation' for programming...meaning I knew I'd always be at the same desk, using the same IDE every time I wanted to do something, then I'd definitely learn it and use it. However, constantly switching platforms, languages, desktops, operating system makes it a bad idea to 'get used to' or 'rely on' any tool that can't be expected to exist in the next situation.
--Welcome to the Realm of the Hawke--
Hammering in a screw? :-)
Works great with wood screws. Try it some time.
IDE should HELP you, but you should still be able to program without it.
If you cannot do it, then yes, you are a bad programmer.
And if a language is so rubbish it cannot be used without an IDE, than it is a bad language.
...you wrote the IDE yourself :)
Being a bad programmer is a state of mind, leave the tools of the trade out of it.
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.
Use the right tool for the right job.
IDE == application and UI programming. Usually lots of business logic or use cases.
text editor == optimization or network programming. Usually non-UI graphics, socket stuff, bit banging.
oh and lastly (flamesuit ON)....
vi == everything else.
If you can get the job done and get a paycheck what difference does it make?
love is just extroverted narcissism
In what you earn from doing what you do?
Argue anything you want but the one who earn the most obviously do the better thing vs the one who do the worst regardless.
You could for instance write a portable OS in C and a very platform specific in Assembler (less relevant point today but whatever) and make the argument why either is the better approach than the other but if one makes nothing and the other make billions that argument isn't worth all that much longer anyway.
The result is much more relevant than why or how.
It's actually easier and quicker for me to use than an IDE. I usually use Bash as my shell and Kate as my text editor (Kate is similar to Notepad++ in functionality which is what I used before my switch to GNU/Linux). when I compile projects I either use a simple Makefile or CMake depending on the size of the project. I've done OS detection and resolution with Makefiles before.
while
Visual Stuidio?
Get free satoshi (Bitcoin) and Dogecoins
Unless you are writing your own OS and device drivers and your own language and standard library and firmware etc ... there will ALWAYS be parts that are hidden to a programmer - and that's the way it SHOULD be. Unless you have the source code AND you go and trace all the way down to the hardware, you do NOT really know how your program works. And with today's level of abstraction, this question about IDEs making you a bad programmer is complete non-sense and so are all the answers saying it does.
And I for one do NOT miss the days of Win32 - OS/2 PM programming in 'C' with all that boiler plate code. Ninety percent of my time was writing the same shit. And I do NOT miss fucking around with make files - and I hope there's a special place in Hell for the guy who decided that different types of white space (tabs, spaces) mean different things.
That's why on the rare occasions these days when I need to compile a C FOSS program (from source and a makefile), it's NetBeans because its makefile to project creator ROCKS!
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.
Harrison's Postulate - "For every action there is an equal and opposite criticism"
So I've seen a little bit of just about everything. Coding in hex, writing by hand typed in by someone who doesn't know the slightest thing about code and even putting things together with drag and drop. While using an IDE does not make you a bad programmer, in my experience the people who have never tried to program in vi/vim, TextMate or Notepad++ etc tend to be terrible programmers. An IDE is almost like a drug. It lets you do amazing things on the surface but sooner or later things come crashing down if you don't take the time to check under the hood now and again.
I will note however that the best thing about using an IDE is when it forces you to use source control. The worst is when it blindly let's you link against third party libraries you know nothing about like whether they are even supported on a current OS.
Code completion is great. Trying to remember the exact syntax of internal libraries is one thing, but trying to remember how all the functions are overloaded when dealing with custom libraries is even worse.
Err... did it have an "int" here and a "char *", or was that a String... damn.
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).
I had a professor in college once who would give lower grades to people who solved the smaller programming problems he assigned, themselves. Problems like solving the 8-queens and Towers of Hanoi, etc. The reason being was that these were well known problems and already had solutions available out there, so you're wasting your own time by not leveraging those solutions. His goal was to teach us to use our network- our friends who already took the class, books, the internet, whatever it took to get the problem solved better, faster, without wasting our own time re-inventing the wheel.
My take-away from this is that if there are tools that make a programmer's job easier to accomplish, easier to manage, and more likely to succeed, especially on larger teams with larger projects, you're a complete fool to think you're too good to use anything more than a scratchpad and punch cards. If your attitude is to do it in notepad/emacs/vim, etc, you have no place in modern development. Get over your ego and quit wasting everyone's time with your buggy notepad code.
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."
I started writing code on a VT102 with a line editor (edt)... I progressed to 'vi' on a vt320... That was paradise... Until I switched to an IDE and have never looked back...
Xterm and vi FTW!
I tried typing code in Notepad. It works for short programs. With larger programs and many classes, I use Netbeans. Netbeans has a nice file manager. I can also press one button in Netbeans to compile the code.
No more typing Javac "file.java" in the command prompt for big projects for me.
just use VI and solve the problem
"I don't pitch OpenSUSE Linux to my friends, i let Microsoft do it for me
Obviously, of course vi(m) is almost acceptable too ...
or teco, but only if you need to write assembly code (or lisp)
all other IDEs are of course for sisis....
If you're relying on the IDE to auto-insert upwards of 90% of the code for you - which is typically the case with Java - just to keep yourself sane, you're probably just developing for a bad language.
Your status as a good/bad programmer is independent of this.
Now bring on the emacs vs vi flamers ;)
I work with a team of total code nazi's building mathematical models for big pharma. unless everything is coded from scratch it's unacceptable. ode solvers, graphic plots, everything. It's ridiculous and makes jobs on the department take weeks longer than they should. Anything that lets you focus on the problem rather than implementing the solution is a bonus.
I agree with that an IDE should be used as a productivity enhancer. But only after you have understood what it means to compile and how it all fits together.
Personally I use Emacs for most C/C++ development and Eclipse for Java (with emacs key-bindings)
However I have seen occasions where the support given by an IDE makes an organization get away with a rather smelly code base. Where the IDE becomes more of artificial life support then a true productivity enhancer. This is what I see as the greatest risk of an IDE, that you can get away with bad code for far longer then if you did not use an IDE. Which will cause you to hit the inevitable complexity wall much later and with more severe consequences.
While when using non or less helpful IDEs (like emacs or vi) you have to structure you code much better to keep it maintainable and understandable. You will hit the complexity wall sooner, which will make it more natural to refactor and rework code that has become too complex at a point where it is not very costly to do so. In my opinion you will get more intimate with your code and build system, which gives you a better understanding of what really is going on.
Personally I would not trust a programmer that can not use a text editor and a command line to build at least simple applications.
My ide formats my code in pretty ways. It tells me when I've likely fatfingered an = vs ==. It tells me when i have linked a library i probably dont need. Etc etc.
These are all things I should do. But they shouldn't take any brain power.
Ie, I believe one *should* be able to code in vi. But you'd be an idiot to do so by choice.
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.)
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.
As a Python developer, the only IDE I use is vi. I do all my dev work via ssh on Linux boxes, so dealing with a gui or even text-based IDEs is just too bothersome and non-priductive.
It means you're a bad developer because you're using .net to make webpages. You should always use the right tool for the job.
As a professional musician, I obviously use the crappiest, most basic gear I can lay my hands on, or else I will be a crappy musician from not knowing how to *really* play the guitar.
Just like my violinist friend who ditched the $800,000 Stradivarius for a cheap $50 violin bought from a pawn store. He says it makes him feel more like a "man", and that only "wimps" played a well-made instrument like a Strad.
The weird thing is, many people would believe that to be a truth.
If it doesn't default to white on black then I have trouble believing anyone uses it as a serious tool. Simple as that.
Last time I tried to use Visual Studio, the startup time was taking longer than it did to install, so I dumped it in favor of anything else.
A significant issue for me is the the amount of time spent on maintenance of the IDE software itself (all the plugins, dependencies, updates, etc) vs. the time it will save me in actually being productive. I've spent more frustrating hours updating eclipse, android sdk, java/jdk, VS, and all the plugins than I have tracing bugs in my own code. When the IDE is working they are a great help, but god forbid you have to update anything! I've had far less wasted time using vi/emacs and cli/cmd compiler access, and knowing how to use these is great for times when the GUI or IDE is not functioning correctly. So my vote is use both.
Over the past few years, I have been modernizing the literal development of a lot of the software where I work. A lot of the developers came straight out of college to interact with a lot of older, anti-IDE developers. Additionally, I have been strongly pushing (but not so singlehandedly) using recent, open source/standard build tools rather than ones written inhouse.
Naturally, they decided that that must be the best thing for them because real programmers do not use IDEs. Fortunately, this was not my first job, so I came here and refused to switch to vi or emacs, and I have constantly pressed developers (particularly younger ones) to use IDEs to be more productive as well as to spot errors sooner.
With a lot of our software being written in Java (the rest being C++), we have a hodgepodge number of developers sporting Eclipse, but the recent majority has been IntelliJ. The quality of code has gone up significantly amongst the people that have adopted IDEs, and this has been pushing the bar up for the rest that do not as code reviewers are starting to spot the issues that their IDE warns them about, which they otherwise had no idea about. In the case of Java, there is a lot of abuse of generics by people not aware of how to use them, but IDEs catch issues earlier than the compilation step for beginners--and those that simply don't get it.
Personally, it's my opinion that not using an IDE makes you a bad developer excluding a few exceptional cases (e.g., areas where IDEs are not allowed, which is a good reason to know how to use tools like vi at--at least--a basic level). And, unfortunately, time only keeps proving me right with very few exceptions.
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.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
To admit that you've an IDE helping you is too hard for rockstar programmers.
Shame that I cam in so late because I think I have the definitive answer.
First of all, if writing the code for a GUI, then a WYSIWYG IDE is a must. Something like Delphi.
Second, for everything else using an IDE does not make you a bad programmer. Relying on an IDE does.
Always with the screwing. Get your mind out of the gutter. He was obviously talking about perfectly innocuous uses but incorrect uses for a hammer like reaming.
Whoever was teaching you in freaking college should not make your life easier with an IDE. I hope they were fired.
That makes no sense.
You're basically saying:
Toolbox: application and UI programming
Screwdriver: optimization and network programming...
An IDE is just a bunch of tools grouped together., including a text editor.
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.
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.
And did you exchange a walk on part in the war for a lead role in a cage? - Pink Floyd.
Hammering a screw with an IDE means job security in government work.
I like an IDE because if highlights the errors and the spelling mistakes and integrated debuggers just rock in my opinion and so do the code suggestions and refactoring tools. (At least in the java space.)
I don't need one to program though and I do all my GOLANG work using , compared to intelliJ, a basic text editor (sublime).
Can I program using a basic text editor.. yes.. do I choose to now days... no... Why?
Lack of productivity, you would have to be a complete dickhead not to use an environment that helps you to build code faster.
Given that I started using a tool called EDTASM+ I think just about anything is an improvement.
Actually, a hammer does make you a bad carpenter. It's the least skillful and least effective method for joining pieces of wood together.
Don't complain about syntax, grammar, or spelling. There is no.hell like input on android.
Real Programmers don't need an IDE to get their jobs done-- they are perfectly happy with a keypunch, a Fortran IV compiler, and a beer.
The first link leads to rambling blog post that's barely coherent. Why is this news?
Will an IDE make you a bad programmer? No. But there are some downsides to consider: Interviewing.
If you can't write a for loop without the IDE, you will struggle to get a job. I am amazed at the number of people I interview who can't write code on a whiteboard or in a shared google doc. These people have a degree in CS. They might actually be incompetent, or they might be so dependent on an editor that they never learned the syntax of a function call in a language they claim to have years of experience in. I can't risk hiring these people.
If you're a bad programmer, your code with an IDE will be bad. If you're a good programmer, it won't. Stop blaming the tools.
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
Its OK to use an IDE to help you, but its not OK to need one in order to do your job.
there, you found your answer. those who promote notepad .... they're in the lala-land. just hope you'll never have to meet them or maintain their code.
Lack of fundamental software development skills and knowledge of the underlying environment is the true issue. Perhaps I'm a bit crusty, but I think that all new programmers should spend the first 2 years of their careers coding from the command line.. a shell of their choice (bash/ksh/etc), vim or emacs, a build tool (ant/make), using scripts to start, stop, and deploy your own services, knowing how to configure and actually use a remote debugger instead of splattering code with unnecessary print statements, learning how to trigger stack traces and interpret them, merging code by hand, etc. After this "apprenticeship", they would graduate on to "journeyman" status and allowed to use an IDE if they want to, but they would always have the strong foundation to fall back on in times of need. More importantly they could train new generations of programmers.
My department has standardized .NET as our platform of choice. Before this standardization, we had used a variety of technologies, including perl, which didn't require an IDE to use.
Later, we hired a bunch of .NET programmers, and most of them are totally reliant on an IDE. We showed them how to maintain our perl programs using vim as the interface. Most of them didn't get it. It reminded me of how we talk to non-techie types, where once we start using techie words, their eyes gloss over and they can't comprehend it. These .NET programmers had that same reaction. They didn't feel comfortable working in that environment and made excuses like, "that is old technology" and "nobody uses it anymore". But, there are advantages to using perl (less memory, fast text parsing, etc.) that .NET doesn't have, so we continue to use it.
Assume a disciplined programmer who knows limits of his or hers capability of dealing with complexity. Say the programmer has to implement a certain subsystem, with certain number of dependencies with frameworks and other subsystems. Does using autocompleting IDE lead the same programmer to produce more coupled and less testable code than the developer relying on his limited memory while using traditional tools? If the answer is yes, this would naturally lead to additional refactorings. It's complicated.
Maybe..
Refactoring changed the IDE equation. Now, using a tool that understands that code is code, not text is needed to support Refactoring. Given that, you might as well throw in auto completion (Intellsense) for objects, classes, namespaces, etc. Part of the value of the Java, C++ and .Net ecosystems is great tools. And, my hats of to IntelliJ, which brings some IDE tools to Ruby and Python and even JavaScript. Worth the license fees to me.
One can become too dependent on anything. But there's no reason to use a better tool. I'm developing in .Net land now, and VS + Resharper makes me more productive without question. It presents me the information I need in context, quickly and effectively. Nothing wrong with that.
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.
You will pry my syntax-highlighting from my cold, dead hands.
http://en.wikipedia.org/wiki/Betteridge's_law_of_headlines
The most important characteristic of code is readability by future maintainers (after running). Maintenance of existing code is typically about 2/3 of the long-term cost of software such that emphasizing the writing stage is the wrong target.
If IDE's generate verbose (bloated wind-bag) code, then it's counter to maintenance because it generally slows readability.
Code bloat should be reduced, not automated.
For example, good code will do something like this:
However, many IDE's make it too easy to create this instead (and/or don't recognize the shorter version):
Plus, the service object "path" often changes over time, and if we hard-wire the full path, we have more to change, which may also risk more errors.
Table-ized A.I.
So you're saying that one can be a good programmer if they don't know how to compile their code? Really?
Get. Off. My. Lawn.
If you NEED the IDE to compile and package everything, one of two things is wrong:
1) The IDE is broken by design as it is not a pure front-end as it should be
2) The build maintainer is an imbecile.
There are no other options.
Program via the toggle switches on the front panel or go home. Paper tape is for wusses. (IMSIA 8080)
The same argument has probably been made back when engineers were switching from punch cards to text editors. All of it has happened before, and all of it will happen again. To me, it's not what you use, it's what you do with it. I work in an environment where most people use vi or emacs to program in C++. I can code circles around them in Eclipse, even though it's not "cool", with less effort, and better code in the end (thanks to refactoring features and code tooltips). I do use vi as well, for smaller, simpler changelists. But for something a couple hundred lines or more - forget about it.
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.
If /. were still true to itself there'd be an argument between vi zealots, emacs fanatics, and ed enthusiasts, with one lone guy crying out about EDT.
If you want to pat yourself on the back for having the most precise rote memorization of the basics, go right ahead. I prefer to leverage as greatly as possible the work of those who are not me. Call that "lazy" if you will, but I still manage to do what my colleagues cannot.
I personally use command line tools and editors. I don't know, it comforts me to use a customised UNIX shell and having 100% control. GUIs in general make me feel like I lost something, some power that I have surrendered to the GTK devs. When I have to use a GUI, I use Openbox(my customised Arch Linux Openbox).
But IDEs are fine, they make you efficient. Just dont expect to learn the fundementals and models and concepts of programming with them.
I have never used an IDE much, but some time ago I read a post by a very experienced pgmer who said that he did not like the .NET IDE because it forced him to think in a bottom up way rather than a top down way. He could not just put in a routine name or object method and leave any paramters blank, or call a non existent method. He had to get all the bottom stuff defined before he could define the top stuff.
And until he got the top stuff conceptualized he did not really know what the bottom stuff would do.
So an IDE can force a certain process on you, that may not be ideal.
pgmer6809
Its probably a little late in the game to post anything that isn't going to be buried in the comments, but nonetheless:
I got into programming BECAUSE of its amazing ability to make lives easier for people. It solves problems, lets people do even more with less effort and gives people the ability do things without much knowledge.
So this argument goes against the very purpose of programming to me. Of course you should do everything you can to make it as easy as possible so that you can focus on bigger problems. That's the very principle of what programming is.
If I found out one of my employees was purposefully using a difficult text editor just to show off his mad programming skills, I would fire him.
I use kate. The syntax highlighting lets me see at a glance when I've made a mistake, there's some useful tools, but it's still lightweight enough to stay out of the way. When I've used IDEs it feels like they're getting in the way throwing unnecessary distracting stuff at me and second guessing everything I type.
This space intentionally left blank
Most of the most useful VIM key bindings in the visual studio editor.
http://visualstudiogallery.msdn.microsoft.com/59ca71b3-a4a3-46ca-8fe1-0e90e3f79329
Nowhere in that first article did I get a sense that the author was complaining about IDEs at. He was complaining that he wasted his life as a .Net programmer when he should have jumped to PHP, Linux and MySQL because he knows he's last off the .Net ship and it's rapidly sinking.
I've recently tried both Visual Studio and Eclipse for C. I have to say they are both where Pascal IDEs used to be in the 1990s, though Eclipse is a few years ahead.
However all that is just a part of the environment you develop in. It's more than the editor and compiler. It's also the operating system (in a wider sense) you are developing and deploying in.
It makes a difference whether you have a well structured system in front of you, where you can reach your goal by a series of orthogonal steps, or you have some knocked together system which barely works and is missing essential tools.
If I had a nickle for every slashdot post with the title "Using an IDE makes you a faster/slower/dumber/smarter/sexier/thinner/holier/racist/terrorist programmer", I'd be a richer man
Fast Federal Court and I.T.C. updates
Of course IDEs - or at least good IDEs - can be a tremendous help.
However, if you don't understand that an IDE, a programming language and a platform or framework are three totally different things, you will be screwed sooner or later.
If all you know is to click on stuff in an IDE, you will be screwed sooner or later.
If all you know is to use a graphical debugger, you will be screwed sooner or later.
You will only have to go lower level than that in maybe 0.1% of possible situations, but when you do, it will be for hard problems and it will really matter.
I get the impression we've discussed this particular question at least twice before on /. but I'm too lazy to search.
Like every tool, an IDE per se does not make you anything. It doesn't make you better if you're crap and it doesn't make you worse if you're good.
Overreliance however, does make you worse. If you are a good programmer, you can work with or without an IDE and depending on your style and habbits, it might or might not make you a bit faster or productive or reduce errors or whatever. Basically, it comes down to personal preferences - whatever works for you.
However, if you cannot program without using an IDE, then you are a crappy programmer. If you use a tool, that's one thing. If you require a tool (that's not required by the task per se) then your skills are lacking.
Assorted stuff I do sometimes: Lemuria.org
from a /bin folder
Wouldn't that be a \bin folder?
... that all the work other programmers do in the IDE, I do by hand whilst my mind solves the next problem.
So far I haven't encountered an IDE that lets me habituate these tasks as easily as my plain old text editor does. That means no IDE so far lets me parallelize my efforts in the same way as my text editor. Though I would be the first to admit that habituation is also - but not exclusively - a question of how long one tries.
It's not that IDEs are bad, it's that in my experience they're in the way of my being effective. In part, it's because they rely on the use of a gesture device so heavily - anything that lets me use the keyboard tends to be better for me. Insert obligatory personal/anecdotal evidence warning here.
I think there is an argument to be made that IDEs with fairly complex UIs will resist habituation, and many IDEs fall into that trap. Whether or not that's true should be examined carefully rather than debated aimlessly, though - and even if it's found to be true, then an entirely different question would be whether better habituation *generally* leads people to parallelize tasks, as I described above.
I am quite experienced in developing software (daily job for over a decade) and I wrote millions of lines of code. I don't use an IDE because I don't like to depend on much software while developing. It also helps to be portable (which is quite important!) and helps to hop to other workstations without headaches. And lastly an IDE does not have the power of a decent text editor (which is quite obvious, because such a decent text editor has been optimized for many years to support programmers and it can never compete with this massive crowd of people steadily improving things).
BUT...
Fortunately, most people respect my choices because I am one of the more important developers in our company, but I can see that many companies actually force tools upon developers, which is quite bad in my opinion. Tools are always to be selected for a specific problem. Programming happens in the brain. Tools are just supporting the output. Consequently it does not depend on what tools you use to decide if you are a good developer (I admit, it can be a hint) but on the way you approach problems.
I think part of that is because for many of the programmers who aren't very good, that is mostly what it is. Like those programmers you find that can only do Java, because that's what they were taught in university. They didn't actually learn how to solve problems, they memorized Java syntax and grammar and can now, poorly, apply it to attempting to solve problems.
Also you seem to see some programmers who think it is at least part of what makes it mysterious, difficult, or "hardcore" or whatever. You see them on Slashdot hating on IDEs as various kinds of crutches and saying that only by programming in a good text editor do you REALLY understand what you are doing. They seem to worry that if what they do is accessible, then anyone can do ti and they'll be worthless.
Of course as you point out that isn't what good programming is about. It is about problem solving, a very particular kind of problem solving at that. However there are plenty of programmers who aren't very good, and for a number of them I think memorization is how they try to convince themselves they are useful.
Being a good programmer is as much about using the right solution for a problem as it is using the right language or system for a solution. .Net isn't the right tool for every job, neither is PHP.
The most common type of code I get an IDE to generate (for Java) is hashcode and equals. I could write it myself, but it is very important that they are done correctly, and an IDE will do it quicker than I could anyway.
Does knowing how the inside of a car works (clutch, gearbox, internal combustion engine and such) make me a better driver? Yes, it does! Does it make my wife a better driver? No, it does not!
My wife is a bad driver in the first place, she does not understand the physics involved and the many aspects to driving!
Apply the same analogy to IDE vs "text editor" and we end up in the same boat. I am a good programmer so the results text editor or IDE a like will be good. Personally, I prefer a text editor but then I like to know things are being done "my way"! In ten years I've never felt the need for an IDE and the ones I've tried have just slowed me down, I mean, lets face it. They are pretty complicated things to use compared to lightweight knowledge in my brain and a text editor!!!
Good programmers improve their environment. So given a text editor and a compiler they can make an IDE.
Bad programmers just don't.
I've worked with Eclipse and I could only hope it would make me somekind of programmer, because I didn't quite get to programming with it. I fought with it for a few days and gave it up.
For a project I'm currently working on I have to use IAR Embedded Workbench and while it doesn't get in my way, it also doesn't really add anything. 'Find definition' and such almost never works for some reason, code completion is waaayyy to slow, and debugging is a pain (using printf and the UART is much easier to work with).
Then I've worked with Renesas High power Embedded workbench (if I'm correct). It looks a lot like the IDE that came with the dev environment of ST7 I've worked with and this wins by a very large margin. It's a fast, working and no-nonsense IDE.
For my Python and C development on linux/windows I'm using Geany since three years or so. It's a very nice lightweight IDE, doesn't try to be smart, doesn't get in my way, doesn't hide things and is stable.
The code should be all there is in my opinion. It musn't rely on switches / includes and other stuff somewhere hidden in the IDE's dialog boxes.
...just sayin'...
Nope, that's not what does it.
...who also knows about a dozen other languages, I must say that Rob Conery should be really, really glad he didn't choose PHP. I really could use a good IDE with an integrated debugger that allows you do step through the code as the page is generated (like Eclipse) and a kind of linter that warns me of all the evil mines in PHP that you thread on when you use some innocuous feature together with another or in a situation that PHP considers special. And a lot of things that make IDEs even more useful, like a large, sane and typed class library, are simply absent in PHP. .Net is still more usable than PHP, but why would you not use it? It's a tool and a very useful tool at that. Why would you refuse to use a saw when building a house and insist on only using a chisel instead? And why the comparison with PHP of all things? I get the feeling that Rob wouldn't even have asked the question if he had some in-depth experience with the alternative.
Even without an IDE,
Before even thinking about using PHP, read these:
* me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design
* phpsadness.com
* phpwtf.org
* quaxio.com/wtf/php.html
My life is hell.
"Relying"? Sure. If you are actually incapable of writing code without being prompted as to what to type, you are a pretty bad programmer. More to the point of the underlying questions.
1. You can do more with an IDE, especially if you are any good at programming.
2. Getting back to the fundamentals and doing things the hard way is a great method for anyone to refresh and strengthen any particular skill set.
Think about this: a great chef is probably not doing his best work over a campfire, but even an expert chef could use campfire cooking as a practice to improve the depth of his knowledge and work. The same generally applies to almost any human endeavor.
Programming in a text editor is like carpentry without power tools. Sure you can do it but why lower your productivity.
You should use the proper tools available for the appropriate job.
"Does using a word processor make you lazy with the language? Would you be better off programming with punch cards?"
Modern copyright is theft of culture from everyone and it retards the progress of the useful arts and sciences.
to any controversial headline for an article. It certainly applies here.
I copy the debugging symbols file to the web site directory, open up the equivalent source in Visual Studio, select the server it's running on and Attach to the process. Not exactly difficult and I didn't start the program from the IDE.
Some of the most useful things in IDEs: syntax checkers, code completion, debugging tools, profilers, etc. These are the things developers use all the time.
Many IDEs also allow the integration of outside tools like bug trackers and source control. That means, rather than having a directory of your project open(or having to open one) to commit code, you can commit changes right from your IDE. Then you load the relevant issue in the bug tracker, but still in your IDE, and make comments, advance the work flow, etc.
The entire point of an IDE is to make a programmer's job easier. The question should not be "Does relying on an IDE make you a bad programmer?" it should be "Does your IDE make you a better programmer? If not, why?"
An IDE is a tool, not a mindset. You can write as much or as little code as you like in an IDE and you don't have to spend time hunting around on Google for the specific API call that you've only used once in 5 years or spend a couple of hours trying to figure out what happened after you missed a curly brace out and your code threw a very obscure error.
Yes.
No.
Craftsman use tools.
Coder's Stone: The programming language quick ref for iPad
Really, the IDE Fx (replace x with 1 to 12) key is not a build tool. You can have the ide call your build tool, but you need to have a proper build tool. Be it make, imake, ant, maven, .sh script, .bat script, just have a properly maintained and documented build process for gods sake.
It is silly to think about somebody that programs in these days using Notepad. It is possible in theory but, come on! A programmer should not struggle to do her work. I think it was Joel (on Software) that mentioned some very important rules about programming: 1. A programmer should always be able to step into her code. 2. A programmer should always be able to inspect the state of the program (variables/registers/memory/...) However, it is very questionable to rely on a particular IDE/tool To a serious extent it is even questionable to rely on a particular language. Being a programmer is about developing programs. About algorithms. The ability to develop algorithms that address one problem or another is the trademark of a professional programmer (and sometimes it is hard to get). I have seen in my professional live wonderful IDE-s raising and even dying (take Delphi for example). I have seen the advent of plenty of new programming languages. And, while understanding that there is a time and a place for everything (yes, I did program using Notepad at some point in my live and yes, I do use Visual Studio/Eclipse/XCode today) one thing never changes: I always develop algorithms.
Does relying on nail-guns and chop saws make you a bad carpenter? Effective use of effective tools can make you a more effective ... whatever you're doing. Of course, they're also more likely to help you nail your foot to the floor or saw off a finger, or a hand. They must be used with caution, care, and some basic knowledge helps, too.
Using an IDE doesn't hurt you as a programmer. Relying upon one when coming up to speed with a new language may not hurt you either. Continually relying upon one surely hurts. Using one as a productivity enhancement while being able to program without it should be the goal.
Eschewing useful tools out of fear of being a “bad” programmer makes you a bad programmer.
It doesn’t matter how deep your knowledge of the language or environment is. A well configured IDE will allow you to complete your job more quickly. It makes research navigating around a codebase much more straight forward. There’s no reason to do textual searches in a simple text editor when an IDE can parse the language and show you actual references to a symbol, not just things that happen to be named similarly.
All of the “uber” programmers I’ve known who avoid IDE’s are universally less effective than even mediocre programmers who use tools to make their jobs easier. The type of programmer who avoids tools out of the belief that doing it “by hand” is better generally waste more time tweaking their environment, going on architecture astronaut treks, and generally doing everything they can that isn’t actually writing code that gets the job at hand done.
Car analogy: You can change a tire with a wrench, and maybe a long piece of pipe to use for leverage. Or you can use a pneumatic impact driver and get the job done quicker, with less damage to the bolts, and put back together tighter (less chance of bolts loosening, tires rolling down the road without you). Any mechanic who tried to hold themselves up as a hero for doing it the hard way would be laughed out of the shop (and probably out of a job).
Be a Software Simian. Not using tools just makes you a dumb code monkey.
Nowadays I only write scripts (PHP, Perl, Python, Bash, sh) and I debug with print, error_log, echo and exit/quit().
XKCD:Xeric Knowledge Comically Dispen
I'm a reasonably good typist, but I still depend on Visual Studio mainly to catch my typos and correct them as I make them. But...
I think an IDE DOES help you learn a language, and even to become better at it once you reach the intermediate stage. My argument for this is the context sensitive help and examples. It's great to highlight a command, hit F1, and get a summary of how it works, and all the parameters and options and a snippet of code showing it in action.
Actually, let me clarify, I think an IDE can be a big help learning a NEW language. It won't teach you general programming concepts. It might help if the autocode generation and wizards had more/better comments and variable names.
Relying on .NET makes you a bad programmer....
An IDE doesn't make one a bad programmer. However, it does provide enough of a crutch to fool bad programmers into thinking they're good programmers.
Chelloveck
I give up on debugging. From now on, SIGSEGV is a feature.
Notepad, though? Seriously? At least you might be able to run Brief, if you can find an old copy, the best programmer's editor ever.
Meanwhile, excuse me, I need to go vi that file here at work.
mark
Half a century of development a question like this is actually asked? Most probably by a bad programmer.
Learning a language is one thing. Writing applications is another. Using an IDE can saves you countless hours of brain cycles. Especially, if the languages you are using requiers a lot of extra work. In the early eighties IDEs split into two groups: those that helped one program and those that created applications. Why did IDEs come about? To reduce the complexity of creating applications. And, then what happened? Language developers knew this and IDEs became part of the cycle. Certain languages for no good reason require complex syntax to do simple, repetitive things. There are so many options in some object languages, it borders on ridiculousness. If you want to learn to program, start with hardware. Write your own language. Then write your own IDE. Write your own application generator, using the IDE. But beware, such programming can suck the color out of your hair and give you white highlights.
I used to whine to friends that didn't care they were using more cycles than needed to get a problem done. They would just make the minimum user requirements to include a faster computer. Yes, with enough power pigs can fly.
IDEs have their place, but so does vi and assembler (it has been ages since I really wrote a program in binary, but yes, I have done that too).
So in conclusion, I think it takes more vigilance on the part of the programmer to write good code using IDEs. But so does OO languages, and interpreted and pseudo-interpreted languages to keep the program workable, maintainable, tight, and reduce code and data bloat.
... "When you pry the source from my cold dead hands."
Jokes :-)
If you need an IDE to be able to do anything at all, yes you are a bad programmer.
Sure, it makes you more productive and helps with testing and building, but it also hides the details that you really do need to know.
If you can write good code without auto-complete and refactoring tools and test them manually and manually build the software, you are good to go.
IDE's are all too often used as crutches by people who treat programming as a black box.
Does relying on a power nailer make you a bad carpenter?
I was taught in my Theory of Programming Languages class that the effectiveness of available IDEs for a language was one measure of a language's useability and I wholeheartedly agree.
I know, I know, but really, it doesn't even do syntax highlighting. Coding in notepad would be worse than emacs. If you want to punish a coder, make him use notepad
You can know how to use a terminal on a headless server, write your C code in VIM or EMACS, and compile your code with GCC, and be totally content and remove any overhead, but as long as you understand these tools I don't see any harm in using a program that links your libraries and throws you right onto the starting line with the click of a button. You can only write the same 20 lines of code and manually set paths so often before you're writing your own templates and doing the same thing the IDE would do for you anyway. It's typically natural to start programming in an IDE, but those who rely on it, rather than choose to use it, and never eventually venture down to the command line to build their program from scratch are only seeing half of the picture and will never fully grasp the basic concepts of what they're doing.
*nt
+1
Anyone who uses PHP can be safely ignored.
I suffer from dyslexia and commonly transpose letters. IDE features like auto complete and 'suggestions' are helpful in making sure i dont make a silly spelling mistake that would prevent the program from running.
Options like notepad cant detect the small imperfections like a transposed letter in a variable name. Troubleshooting that issue in notepad is a troublesome line by line review of the code to find the mistake. Then figure in the fact that when reading things, the brain will correct many spelling mistakes without you noticing, making it even more difficult to detect the minute error. In an IDE not only will it auto compete the variable name for me after typing the first few letters, but (some ides will) also advise me that i am referencing a variable name i have not declared yet if i end up typing the variable name incorrectly.
Does having dyslexia make me a bad programmer?
Does using an IDE to make sure small things like spelling are in order make me a bad programmer?
I dont thnik so :p
Whether you code in notepad, vi, or whatever in text, or use an IDE, that has absolutely nothing to do with being a good or bad programmer. Having been a programmer for over 20 years, IMHO what makes bad programmers is "object oriented languages". First, I'm sorry C# is not a language, anymore than VB.NET, JavaScript, or PHP is. They are methods of scripting using major parts of other peoples code. When complete, the script can in some cases be converted to binary and used sort of like a real language module, but NO C# is not a language. the fact that Microsoft chose to use "C" in the name is a fraudulent attempt at best to give stature to a scripting tool that falls very short of the mark. Scripting languages are a way to make programming "more accessible" to the masses, but they are not a good way to build applications. C# and VB.NET are SO heavily separated form the "programming" that a new word should be defined (just like all the terminology that was altered to match up with the "hipster" object oriented stuff. Won't see robots programmed with Object oriented code (at least not important ones) nor nuclear reactors, space craft, airplanes, or even cars. WAY too bloated and slow to be of use for anything other than transaction processing. Don't know why someone would dis IDE's and not see how sloppy and frankly unskilled coders today actually are. Borland had IDEs for "C", so did IBM and even Microsoft (though Programmer sWorkbench was more of hammer than a scalpel. There were IDEs for Pascal before that was cool as well. Trouble was people who wanted to be programmers wouldn't or couldn't work with pointers, arrays, structures, and other complex aspects of programming. That is what game us Visual Basic in the early 1990s. Arguably the first wide spread object oriented language (albiet one that didn't do much useful). then of course C++ (essentially extra headers and classes to "C") riding ":C"s popularity as well. I could live with C++, as you could still do "real programming" with it. C++ compiled down to reasonable size, yet still provided hardware interaction. All the "new scripting tools" like C# and VB.NET are is fancied up ASP. SO PLEASE don't go making fun of how others "code" before you understand why most of the "coders" today really aren't coders at all but actually scriptwriters, copying other peoples work (good or bad).
"Any sufficiently advanced technology is indistinguishable from magic." - Arthur C. Clarke
I am new to programming and I'm using Bluefish running on Linux. It's a great way to learn using an IDE, that's for sure!
I don't think if IDE can make you a bad programmer but otherwise it can helps you to be a better programmer. I think IDE is just a tool to help you finish your task. IDE tells your mistake, help you to write better code, in short words IDE save your time and let you focus on problem you have to finish. I agree with "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." Can you imagine if there's no IDE at all? Think about present situation not in the past where there were not many programming languages.
All those young whipper snappers running around with shoe boxes full of punched cards! Lazy bastards! Just toggle it in like a real programmer!!!!
Sure enough, the cow costume was hanging up next to the superhero outfit and sailors uniform. (S,Spud)
I like lightweight IDEs. Sometimes a good source editor like ConTEXT or Visual Studio 6.0 (gasp!!!) is all I need to make me happy.
Emacs is complicated enough that it makes you a better programmer just to use it.
-- Did you try Tao3D? http://tao3d.sourceforge.net
So the question is does it make you a bad programmer to solve the same problem using one tool versus another?
Is Federer a bad tennis player because he uses a graphite & kevlar racket instead of a wooden one? I doubt it but he may have difficulty adjusting over a game to using a wooden racket. Is that really such a problem?
It's not like IDE's will be declared illegal at any stage.
I am new to programming and I'm using Bluefish running on Linux. It's a great way to learn using an IDE, that's for sure!
But you didn't mention whether it was a great way to learn programming.
That's what all the excitement is about. I often have to point out to the inexperienced that when they come for advice, I don't care what their IDE setup is, because the IDE won't be there when the app runs in production.
Relying on IDE alone will give you problems when your IDE lets you down. An IDE is still a piece of software with bugs and feature gaps. If you can't fall back to a non-IDE dev process then you are too reliant on a single tool and not a prepared programmer. That said, modern IDEs have so many productivity aids that you would be extremely unwise not to use one as your 'primary' tool.
Does Relying On an Car Make You a Bad Walker?
After thinking about this question for a few minutes, I realized it has an excellent quality: It's provocative. I found good arguments on both sides of the question, which means there will be a balance between at least two points of view, and discussion will be promoted. The main quality of the question is that it can't be answered correctly.
My opinion is that IDEs are great for helping productivity, when they promote learning. Once you outgrow them, and they begin to limit knowledge, or they hide parts of the system you need to know about, they limit productivity. It's all about how your knowledge is scaling. When you first learn to use an IDE, you're learning. When you have learned everything, it's time to move to a new development environment, or add another language, or delve into debugging at a lower level. YOU need to evolve, and sometimes the IDE helps that, other times it hinders that. You need to decide, and be prepared to decide again later.
The answer is different for different IDEs. Some are made to be stupidly easy, for beginners. Some are made to fill in gaps in professional systems. Most are just stopgaps.
As said here, an IDE can help both beginners and professionals. But they can hurt people trying to get from the former to the latter.
To work for both, IDEs need this:
Help the programmer to make modules quickly, as generating with templates.
The generation should be driven by setups such as dictionary definitions.
Allow the programmer to modify the modules as necessary, using the method they prefer.
Help the programmer to find the defined symbols and structures and cross check for errors.
Be able to repeat the generation many times over the life of the app, without loosing the mods.
Be able to link in modules generated in other ways, as in external source, DLLs or APIs.
Use modules in more than one language.
Use different databases and file types in the same app.
Generate fully linked native code, as well as other scripts.
Allow the programmer to write new template scrips to generate specialized modules, and derive them from existing templates.
Have robust third-party add-ons available to expand capabilities.
Have a Debugger that can show you what is happening from source level down to assembler and Hex level.
I use the Clarion rapid application development system. It is not perfect, but it at least makes a start at all of these.
It keeps the application information in specialized databases for the app modules and the dictionary.
It has an embed editor that shows you the source but enters your new code into the app database, so it is included on the next make. Or the next edit.
But it also has a text editor for looking at the generated (or external) source.
The proprietary Clarion language has native types for tables, queues and dynamically assigned strings.
But it also has compilers for small modules in C/C++, Modula-2 and Assembler.
And it re-generates changed modules on every make before the compile and link. Fast.
... and a carpenter is better off with a hammer and saw. Real men rip the boards from trees with their bare hands and force them into usable shapes with sweat, spit and colorful language. Which is how you should write your assembly code: burn it into tree bark with nothing but your steely glare.
A beautiful mind requires no debugger.
If you have a duck that can't fly, what good is it? Well, it can still swim, and in the end, you usually spend more time eating its legs than wings anyway. As such, it overcomes the disasterously obvious loss of thier primary means of going south, but at least can still navigate waterways to make it there.
Similarly, if a developer cannot code without a UI, its as if they lost full use of thier arms and part of thier brains when they lose the UI. They have a major handicap to over come, in this case they have to type properly and learn about library contents and dependencies. The way to overcome this is to use google, books, and ask thier friends for help. In the end, thier lack of language knowledge will drop thier productivity to the point that would be equally achieved if they fired them and then hired someone with downs-syndrome to do thier job.
Yes. Over-reliance on an IDE makes a developer retarded when they lose that ide.
Oh FFS. What has slashdot come to. Arguing about whether an IDE affects how good a developer you are? Use vi and stop fecking whinging.