Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

I often encounter this when I am helping out someone who is new to programming and learning it for the first time. I'm talking about really new newbies, still learning about OOness, constructing objects, method calls and stuff like that. Usually, they have the keyboard and I am just offering guidance.

On the one hand, the autocomplete feature of the IDEs helps to give them feedback that they are doing it right and they quickly get to like and rely on it.

On the other hand, I fear that early dependence on the IDE autocomplete would make them not really understand the concepts or be able to function if they one day find themselves only with a simple editor.

Can anyone with more experience in this regard please share their opinion? Which is better for a newbie, autocomplete or manual typing?

Update

Thanks for the input everyone!

Many answers seem to focus on the main use of autocomplete, like completing methods, providing methods lookup and documentation etc. But IDEs nowadays do a lot more like.

  • When creating an object of List type, an IDE autocompletes to new ArrayList on right hand side. It may not be immediately clear to a newbie why it cannot be new List, but hey it works, so they move on.
  • Filling method parameters based on local variables in context.
  • Performing object casts
  • Automatically adding 'import' or 'using' statements

and much more. These are the kinds of things I mean. Remember I'm talking about people who are doing Programming 101, really just starting. I have watched the IDE do these things which they have no idea about, but they just carry on.

One could argue that it helps them focus on program flow and getting the hang of things first before going in-depth and understanding the nuances of the language, but I'm not sure.

share|improve this question

closed as primarily opinion-based by gnat, MichaelT, GlenH7, Kilian Foth, user61852 Aug 10 at 1:04

Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise.If this question can be reworded to fit the rules in the help center, please edit the question.

1  
I think this falls into a general injunction: Use a tool. Don't be lazy enough to use it blindly. –  Alex Feinman Jan 26 '11 at 13:52

16 Answers 16

up vote 7 down vote accepted

I think making use of the IDE helps in the learning process. Methods, properties, parameters, overloads and the like are discoverable. With the overwhelmingly huge libraries, Intellisense helps trickle down JIT knowledge. In today's coding environment, it is impossible to learn everything up front, and JIT learning is often the only practical way to quickly become productive.

I understand that using an IDE can be a crutch if you use it blindly, but I think the benefits far outweigh the negatives.

Using templates without understanding what's been pre-built for you, on the other hand, is more of an issue. I think those can be used as a learning tool if the developer takes the time to read through the templated code. But most people don't bother. It could be a great learning tool, though.

share|improve this answer
1  
I meant JIT learning -- not JIT compilation ;) There's so much to learn, trying to learn everything up front is unrealistic, so as long as you understand the concepts, learning the implementation specifics can be done "just in time." –  Mark Freedman Jan 27 '11 at 15:55

IMO, The IDEs will make you more productive. But for beginners it's generally not an good idea to start programming with IDE. Text editors like notepad++, notepad, etc. would be enough.

Also, it is generally not considered as an good idea to start learning the programming with high-level language. I would suggest you to start with assembly language. This will taught you basics as well as patience.

share|improve this answer

Learning takes practice. Programming can be a very frustrating task when you have no clue what you can do nor how things work.

It's impractical to, say, read many books on programming principles without writing a single line of code; one doesn't learn anything this way.

Intellisense is very helpful at giving new programmers the help they need to keep programming, keep practicing, and thus learning.

As was already said, learning specific APIs is not the same as learning programming principles. What will undoubtedly happen is that the new programmers will make mistakes (regardless of Intellisense), and how they choose to fix those mistakes is what will lead them to become good programmers or poor ones.

If you're trying to teach someone how to program, I'd get them to use Intellisense and play around until they get stuck. That's when I'd try to build a foundation by teaching them the reason they got stuck.

share|improve this answer

When we grow up as a child, we are not told that we must understand the intricate rules of the English language before we can speak. We are not told that we must fully understand the proper use of prepositions, conjunctions, and to avoid sentence fragments. We learn by doing. We learn through success and failure.

An IDE with autocomplete helps the new programmer gain confidence by facilitating the creation of programs, while not struggling with remembering every myriad function of a vast multitude of libraries.

If one were to truly extrapolate the view that autocomplete hurts the new programmer because it makes it too easy for them, then you could argue, that reference books shouldn't be used while programming, because the concepts within should be committed to memory first, as not having them memorized slows them down, and doesn't allow them to fully understand the concepts first.

Autocomplete is a tool, it is used to make the programmer more productive. Just as with learning a language for the first time, after we gain confidence and a level of success with what we are learning, we then work to improve our knowledge.

share|improve this answer

I have two thoughts on this. The first is that to truly learn something I believe you have to know what is really going on. And with how good IntelliSense has gotten, it can hide some of that to a new developer. For example, I had a web engineering class in college where we actually built our own web frameworks to build our final apps on top of. I came out of that class with that ability to adapt to almost any web framework because I had the understanding of what was underneath it all to begin with. Using an IDE isn't quite to that level but, the point is still there I believe.

However, using an IDE can also do things such as opening up APIs to new developers. When I started coding seriously, the IDE I used help me tremendously because I would do things like type in an object, use the auto-complete to see what methods it had, and then research them using the docs available. This was all done within the IDE and was a great learning tool.

So, yes, I believe it is OK to use one as long as you also take the time to understand what is going on. Just using an object cast without understanding why you had to to it is really bad but, if a new developer sees that you can use an object cast and then looks to see why I see nothing wrong.

share|improve this answer

In my experience, using an IDE for learning the basics of OO i great because it hides some of the complexity of actually writing code while allowing the new developer to focus on the logic of the program. However, soon after learning to program and the basic OO tenets I was, through coursework forced to understand more precisely what pieces needed to interact with each other in source files (not forgetting import statements, instantiating the correct classes, etc) by a programming course where we had to use terminal only Unix machines.

This is possible in school because someone has the 'authority' to force you to use lo-fi tools. It would be much more difficult to achieve in a business or corporate environment.

share|improve this answer

Understanding the concepts and memorising dozens of hundreds of stupid library classes and methods are two completely different things. Intellisense helps to kick all that useless knowledge off from your mind completely, and the earlier you do it, the better. Leave more space for the useful concepts, don't waste your limited resources on APIs.

To answer an updated portion of a question: little syntax details, files layout, compiler and linker invocation are also unimportant compared to the generic programming concepts. Once they're understood a newbie-no-more can go into a deeper understanding of how the low level stuff actually works. It is better to do it when you already know the basics, otherwise chances are you'll pick up a number of dangerous magical superstitions.

For example, DrScheme IDE has a great track record in teaching programming, and its success is mainly due to its ability to help to concentrate on what is really important.

share|improve this answer
27  
+1. I actually had interviews back then where they were asking me to cite the list of parameters for some Win32 API function. Never could understand of what relevance that knowledge might be. –  user8685 Jan 26 '11 at 12:21
4  
@codinguser: and that's not a problem as well. I often can't remember even a syntax of a language I'm currently using (even if I designed it myself). There are much more important things to remember than import statements or how to write a getter/setter pair. And IDEs are doing more useful things - showing types in tooltips, for example. –  SK-logic Jan 26 '11 at 12:49
3  
@Josh K, have you ever heard the word "abstraction"? Do you know why there are different levels of abstraction? Paying attention to anything below the level of abstraction of your current problem domain is stupid and counterproductive. And picking up this destructive habit early in a career is a disaster. It took more than ten years for me to partially recover. –  SK-logic Jan 26 '11 at 16:53
3  
@Josh K, do you insist on understanding what is going on all the way down to syscalls and further? There is no added value in this understanding. Of course a good programmer must be capable of operating on all the levels, including machine codes, but a good programmer also should be able to completely abstract away from an irrelevant stuff. –  SK-logic Jan 26 '11 at 17:18
3  
@SK-logic: I agree, and imports and function calls that you are using directly are not something to abstract away from. –  Josh K Jan 26 '11 at 17:20

I don't see any need to suffer the pain of foregoing tools, even when a developer is learning. I believe the extra time and effort it would take to write the code without the tools would be better spent learning how to write unit tests and debug. Once a user knows how to test their code and step through it as it runs they'll learn plenty about what it's actually doing.

Besides, it's not like using an IDE means the code writes itself. An inept or beginner developer is going to write code that doesn't work whether they use an IDE or not.

I just see the IDE as another level of abstraction when coding. If I'm writing Java I generally don't need to understand how the bytecode it generates works. If a new programmer is using Java libs they don't need to know what package they're in if the IDE can add it automatically for them. In either case if a bug or issue at the lower level may arise (e.g. Class name clash) that causes an error, then it's time for the developer to look at it manually.

share|improve this answer

Perhaps a newbie should simply be working on easier problems first. And no, those problems should not require or encourage the use of an IDE to complete the task. There's more to be gained long-term by understanding the basic concepts. The tools should come after.

No woodworking craftsman would jump straight to using a high horsepower surface planer without understanding the intricacies of both the type of wood and the hand plane first.

(Note: autocomplete and intellisense are two drastically different things).

Intellisense, in itself, isn't bad. It's only bad when it is used a crutch to guess at functionality without reading or understanding the underlying documentation or implementation.

Side point: If the language requires an IDE to code for you, the language is probably at the wrong level of abstraction for the problems that you're trying to solve.

share|improve this answer
2  
+1 for the side point. I'm a fan of learning multiple language, so you know when a language isn't a good fit for a task. –  Michael K Jan 26 '11 at 14:58

I would be the first to say that IDEs are a boon to productivity, even if I often complain about their quirks. However, I learned BASIC, C, C++, Java, Python, Perl, PHP, and several other languages without anything more than a text highlighting editor and the compiler/interpreter for the language. I actually learned Java in Notepad!

Learning an IDE propmotes "magic" - the idea that "it works; doesn't matter how." Abstraction is good; magic is bad. A programmer should know, or be able to find out, everything going on in a project. A good IDE is designed to take care of the bookeeping, not controlling the project. Properly used it is a great tool. But what craftsman starts out using a CNC router?

I think that the way I learned (having to type everything and know the compiler well to build a project) has helped me immeasurably when I did finally start using IDEs. For instance, a Java project is not a little folder in Eclipse project, but a collection of classes in a package structure with some XML files for paths, configuration, and deployment. I would not want to build a large enterprise application without an IDE, but I can build small ones. That makes it easier to understand the structure of large ones, and when I want a specific behavior in the build, say, I know how javac works, so I can tweak the actual build prompt rather than trying to find that magical combination that doesn't exist in the build configuration. I also believe I have a deeper understanding of error messages and how to find and fix them. IDEs promote the feeling that since there aren't any red underlines, the code much be right.

I would not teach using an IDE. I think that beginning projects are small enough that the arguments for managing complexity are moot. If you are teaching Java, for example, you can place all your classes in the same folder and javac *.java. You don't need an IDE for that! This argues for keeping projects small, little more than proof-of-concepts. Minimize the overhead, and concentrate on teaching the concept the students need. Bigger projects in which an IDE would be useful belong in either more advanced SE classes or dedicated projects.

As for help with finding classes and API research, again, I believe this is moot if the projects are kept small. Again in Java, javadoc is very easy to read. No one can keep the whole API in there head anyway, and ther will be a time where you will need to research an API without the benefit of an IDE. Like, in other languages, or if remoting into a server where you can't open the IDE. Teach how to find documentation, not "press '.' and you can see what an object's methods are."

Any programmer can learn an IDE, but knowing an IDE does not make you a good programmer. Black humor aside, "magic" is never a good word for a programmer to use.

share|improve this answer

Having taught and tutored students that are new to programming, I find that autocomplete/intellisense sometimes causes more harm than good. Yes, they can write a program using it. Yes it compiles and runs and might even do the thing we asked them to do. But they don't understand what they are doing.

When they don't understand what is happening, it becomes less programming and more hacking a solution together to get marks. I found that happened a lot with students as what we asked them to do became harder, they just hacked until the got something working. This always became clear when the midterm came around and students were asked to write simple methods by hand...they couldn't.

Yes autocomplete/intellisense helps us (professional developers) a lot b/c it speeds us up. We don't have to memorize all different methods and parameter lists, but at the same time we also can hazard a guess at what parameters a method is going to take b/c we have the experience with programming to know.

Newbies don't. They will wait for their IDE to pull up a list of methods, they will scroll through that list until they find one that maybe is what they need, they will look at the parameters it needs and see if they have them to pass in....and at the end they will have hacked something together that they can hand in.

And, at the end of the course when they got their pass, they would walk away from their programming class with a shallow victory, many never to take another CS class again b/c they didn't understand anything they did or why they did it.

share|improve this answer
2  
I will be cynical and say there have always been that type of student in CS. If they want to learn the Intellisense just helps them do things quicker, rather than spend time looking up each function name in Google or a book –  Mark Jan 26 '11 at 14:49
4  
@Mark, I agree. I guess I made my answer too broad in scope implying all students. But I will say this, after introducing and IDE with autocomplete to course's development environment the number of students who didn't understand when up as did the number of failures on the first midterm. The number of questions I received diminished by a lot, but I learned it wasn't b/c students were understanding better, but b/c they could get programs working without taking the time to understand. –  Tyanna Jan 26 '11 at 14:59

Lots of other good answers so don't consider this a complete answer, but it is good for newbies as well as experienced users to see a complete picture of what functions they have at their disposal.

In Delphi I can hit ctrl-j and I'll see a list of every single possible thing I could ever syntactically expect to work.

I don't necessarily agree, but I have read arguments to the effect that programmers should not even look at private class members of objects that they use and in this way, auto-complete gives every user an instant API reference.

Newer IDE's let users and language developers put meta-data in their intellisense which further enhances the ability to read and understand what the functions do, without reading the source (which is something that they shouldn't have to do anyway).

Perhaps, it is best for newbies to actually read and understand everything they implement. But, maybe it would be a better question whether or not newbies should be allowed to include or import whatever namespaces or units they want without documenting why they are including it.

share|improve this answer

In the beginning, it's hard enough to build something that works, so anything that helps the brand noobie the better. A new programmer is going to need someone more senior to get them to think about whether array bound lists or linked lists are going to be the better match for the problem at hand. They each have their strengths and weaknesses.

Whether the newbie has an IDE, or they are browsing the API docs online, there isn't going to be any real difference between the code they create. While dealing with the pain of writing syntax errors can be a learning experience, there is too much to learn to worry about that at the very beginning.

You don't learn to walk the tightrope by going straight to the high-wire without a net. You start by walking a rope that's inches off the ground. I'd venture to say that most of us work with an IDE, and some sort of build script (Visual Studio's build script is created by the IDE but it is there). Most of us do not build our classes by hand with a text editor, and then invoke the compiler by hand. Why should we impose that on a newbie who has far more to learn?

share|improve this answer

Learning the hard way usually stays with you.

As a newbie, please DO NOT use IDE. Use the command line, learn from your mistakes. This'd also help you understanding compiler and linker options more closely.

So when do you use IDE? When you are designing something huge or working on a huge codebase with loads of classes, methods and variables.

share|improve this answer
7  
What's the point in understanding compiler and linker options if you don't know yet what is a compiler? It normally ends up in a mess. I spent more than a decade clearing up my own mess created by a too deep and too low-level exposure in the beginning (MACRO32, Fortran, DCL...). –  SK-logic Jan 26 '11 at 13:22
2  
Agreed. It does not make sense to learn assembly before learning Python or C#, for example - it just frustrates you more. Generally, you learn high level concepts and then filter down into lower level concepts, or other nitpicky things. –  DMan Jan 26 '11 at 16:44

The issue with IDEs and development environments in general is not so much things like autocomplete as the use of templated solutions (file|new|project) where lots of "interesting" things have already been done for you and are, to varying degrees, hidden.

For someone who, broadly, understands what's going on underneath the hood this is helpful - but for someone learning what they need is rather less.

There's also the question of the time taken to fire up a heavyweight IDE...

I think therefore that using something lighter in weight and being able to run up applications in which you have written every line of code yourself has considerable merit - especially as using a text editor and a compiler demonstrates the important point that you don't need an IDE etc to write software but that doesn't mean that I want to use a text editor for long and that does present challenges in terms of debug - you want to be able to do breakpoints and you want to be able to single step through code as this will make it easier to understand what's going on.

Of course we can further confuse the issue by considering things like Python where you have a "live" command line...

Good question, no single good answer - except that you want to make learning a progression and starting with a text editor and a compiler (or a command line interpreter) will allow you to focus on the basics of syntax and logic before you progress to more complex stuff which will be easier to do with a more powerful development environment.

share|improve this answer
2  
Honestly, I see the time taken to fire up the IDE as negligible. I spend dozens of hours using my IDE between firing it up. It certainly saves more than the extra 30-45 seconds worth of time it takes to start just in code completion alone during that span. –  EricBoersma Jan 26 '11 at 13:41

Using autocomplete is not a bad thing at all.

It is simply for speed, and for me would be a sign of someone starting to get a grip of the IDE and using it well.

I don't understand how NOT using it would help them learn OO for example.

share|improve this answer
1  
I'm all for autocomplete when you've mastered the basics. Speed is good when you know what you're speeding up. But when an IDE automatically fills a parameter based on a local variable of same type, or adds an import statement, it just works and some newbies don't really understand it. –  codinguser Jan 26 '11 at 12:25

Not the answer you're looking for? Browse other questions tagged or ask your own question.