Should newbies use IDE autocomplete (Intellisense)? [closed]

Question

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.

Answer 1

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.

Answer 2

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.

Answer 3

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.

Answer 4

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.

Answer 5

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.

Answer 6

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.

Answer 7

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.

Answer 8

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.

Answer 9

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.

Answer 10

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?

Answer 11

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.

Answer 12

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.

Answer 13

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.

Answer 14

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.

Answer 15

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.

Answer 16

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.