Helping students adjust to using industrial-strength IDEs Something I've often observed is that many students find it challenging to figure out how to use full-fledged IDEs such as Eclipse, Netbeans, Visual Studios, IntelliJ, and PyCharm.

From what I can tell, this is due to a variety of factors:


The UI is often visually complex and intimidating for beginners. This is exacerbated in cases where your IDE unexpectedly changes appearance (for example, after running anything in Eclipse).
Setting up new projects and running even a simple "hello world" program is often non-trivial (you have to pick between several different "project templates", need to adapt to working in this new folder layout, sometimes need to configure your IDE to point to your compiler or editor...)
The IDE can sometimes be unexpectedly initially laggy. For example, IntelliJ will need to "index" your files/your standard library (with minimal visual cues that this process is taking place). This will cause functionality to be mysteriously laggy or missing for about a minute after first using your IDE.
The IDE often introduces several new "metaphors" that need to be explained. (For example, Eclipse has this notion of a "workspace" -- it's not immediately obvious this is actually a folder on your filesystem). This problem is further exacerbated by the fact that a small minority of students don't seem to have a firm grasp of what a filesystem is (which is disconcerting).
It's easy to accidentally screw up the appearance of your IDE. If you accidentally click a small button or drag-and-drop something by accident, you can remove an essential part of your view without an obvious way of getting it back.


In light of these factors (and other ones I may have missed), what is the best way to help students adapt to using IDEs?

I briefly thought about demoing how to install and use an IDE in class, but that seemed like a poor use of class time. My current idea is to provide handouts guiding students through their installation process, but I'm curious to see if there are more creative or effective solutions other people have come up with.

For the purposes of this question, we can assume students have completed at least CS 1, maybe CS 2, and have prior experience using either a text editor or a minimal IDE (such as BlueJ or JGrasp). I'd welcome both language-specific and language-agnostic answers.
IDEs are tools that are designed to solve specific problems.

They're great for stuff like:


Compiling multiple projects that contain a bunch of classes.
Dealing with dependencies on multiple libraries.
Handling stuff related to coding, like starting up servers.
Packaging and deploying your application.


If the students haven't encountered these problems, then honestly they probably aren't ready to use an advanced IDE. They don't have a need for it, and they should probably stick with whatever works for them.

Another consideration is that students need to understand what's going on "behind the scenes" before jumping into using an IDE. At a bare minimum, they need to understand:


Basic command line interaction: How do you navigate over directories? How do you run programs?
System Path: How does your computer know how to locate Java? How can you change this?
Compiling and Running code: How do you compile a .java file via the command line? How do you run a .class file? What is the difference?
Classpath: How do you use a library from your code, from the command line?
Errors: What is the difference between a compiler error and a runtime error? How do you read a stack trace?
Documentation: How do you consult the docs to figure out what functions a class has?


I say they need to understand this, because too often I see students who don't understand what the difference between path and classpath is, or who don't know what the red squiggly lines in their IDE are telling them, or who rely on auto-complete and copy-paste for everything.

All of that being said, I think you should start with a very basic text editor and the command line. Spend some time there and make sure they understand the basics. Then as their projects get more complicated, they'll naturally see the benefits of using an IDE.

Present the IDE as a solution to the problems that they're already experiencing.


"Who here is sick of specifying the classpath argument whenever they compile their code?"
"Does anybody wish it was easy to see what functions a class has without needing to do read through the docs?"
"Now that we know how to export our application via the command line, let's see a quicker way to do that."
"Now that we've learned how to debug using a piece of paper and a pencil, let's see a way to do that automatically."


Then introduce the IDE and point out specific ways to solve their specific problems. Throwing them in the interface and saying "here are 100 different things this can do" is going to be overwhelming. Build on what they already know, and solve the problems they're already experiencing with a more basic editor.

This makes sure that they understand what's going on behind the scenes, which helps demystify the process. It also gives them a good reason to use an IDE, by framing it as a tool that helps make their lives easier, which is what it should be.