As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
I use full blown graphical IDEs such as Eclipse CDT (Linux) and Visual Studio (Windows) which have features like auto completion, built in debugging, etc. These are features that I feel I can't live without.
I keep hearing about how many people use emacs/vim on a daily basis. How come people still use console based editors when graphical IDEs appear to be easier to use? I know how to use vim and emacs, but for day-to-day programming I just use an IDE as I find myself being more productive.
This is not a vim vs emacs question so please don't argue one against the other, please instead argue graphical IDE against console IDE.
As I'm already familiar with graphical IDEs, am I likely to gain any productive advantage by using emacs/vim instead?
I expect the answer is "maybe not", simply because of the learning curve, and I'd miss the usual graphical IDE features such as auto complete and the built in debugger; but apparently emacs supports auto complete and debugging. However, to someone who uses a standard GUI text editor, I'd probably say that they should use emacs/vim. What do you think?
Related questions:
SciTE user wants to know if they should use emacs.
vi user wants to know if they should learn emacs.
There is an advantage to learning to master a command line editor for those situations where a full IDE is not available. I know people who swear by VIM and people who swear by Emacs. I think the latter is more configurable, but you might not even need that. Since you already know VI, it might be enough for your needs.
I humbly admit that in the few situations where I do need to edit not through an IDE, I just use pico... :(
All that being said, I do have the impression that for some people in certain programmer subcultures and companies, using emacs rather than an IDE is an issue of honor, like using leaves rather than TP on camping trips.
I would always suggest knowing at least one command-line only editor, be it Vi, emacs, pico, ed, etc., even if you do most of your developing in an IDE. If you're more productive in an IDE than in another editor, then by all means use the IDE.
That said, my reasoning is this: say you're installing a graphics driver on Linux, and the driver is not being co-operative. Your version of X doesn't start correctly using the new configuration, and you need to edit your X configuration. You could copy the backup of the working configuration over the edited configuration, start X, use a GUI editor to edit the X configuration, and then restart X, or you could do the edit very quickly using an editor that doesn't depend on X (typically, command line).
Eclipse has built-in support for Emacs key-bindings. The only support I've seen for Vim is a commercial plugin.
You certainly don't need to learn one or the other, and you don't need arguments extolling the virtues of one editor vs. the other, but if you do learn Emacs, you can customize your Eclipse environment to use the Emacs key-bindings (it's under Windows->Preferences->General->Keys). This (in my mind) can greatly increase your productivity in Eclipse as your hands rarely need to leave the 'home' line of your keyboard.
This feature is one (of many) reasons I use Eclipse for my 90% of my development.
I have been an emacs user for nearly 10 years. Emacs is an IDE with X support it is not console based. It does have auto completion it does have integrated debugger. The advantages i consider emacs over other IDE's are you said that you use eclipse in linux and visual studio on windows well i use emacs on both OS's. Don't need to change tools when switching OS's. Also on my daily work i work with multiple languages ruby,c/c++,java emacs supports much more languages than any other tool out there. And once you master using your keyboard you are 100 times faster than using an IDE. You can move around a file in blazing speed. i got my terminal , connection to my database server right in the editor no need to change windows and loose my train of thought. Another nice feature is i can edit files on machines half way across the world just like they are sitting on my local file system.
Disadvantages are both emacs and vi have steep learning curves in order to use them properly you need to invest some time on them but the way i see it why not master one tool that works on all languages and works on all OS's. then to learn how to use multiple tools and learn a new one when you wanna learn a new language.
Using emacs after knowing vim will make that task somewhat annoying. The editor war has been long and there have been many casualties.
In short, you should simply evaluate whether you think the editor(s) you are using currently are not up to your expectations. If you feel hindered, try something new. If you are working just fine, keep working!
Related
After reading books like The Pragmatic Programmer, one thing it strongly suggested was to pick a text editor and master it. I chose to use Emacs and stuck with it for about half a year. However, the one thing that kept pulling me back to a full-fledged IDE was debugging.
After attempting to use xdebug via command-line for a couple of weeks, it was no surprise that the debugging tools that Netbeans/Eclipse provide are far superior to CLI.
So fellas, are there any Linux tools that allow you to place breakpoints and help visualize your application at run-time, or is there a reason why I should stick to suffering through CLI debugging?
Any feedback appreciated!
I'm using Vim all day for coding. But when it comes to debugging, I always take the debugger of my IDE (Visual Studio) because while debugging, I take the mouse and hoover over some variables, edit their values and so on. That's not a task that I'd need a powerful editor for.
That's my advice to you: for coding and editing, take an editor; for debugging take a (graphical) debugger (DDD, Eclipse, whatever). It's not a sacrilege to switch tools, only to take the wrong tools for the task to be done.
Like this: http://www.gnu.org/software/libtool/manual/emacs/GDB-Graphical-Interface.html#GDB-Graphical-Interface ?
Tutorial : http://www.youtube.com/watch?v=vHOzMOzzxDA
Same. I use IDEs for the heavy stuff and Emacs for quick stuff.
The reason to be proficient with a light-weight editor is to be nimble when you know what you want to do. Open this file, find-tag, edit, magit-status, commit, push. Bam. You don't want startup-time & instability to be cock-blocking your effort when you've got at goal. Vim is installed on most servers, and if you're editing on production, you'd better have a goal.
IDEs on the other hand (Aptana for me, PHP) I find are useful for "studying". Debugging, stepping through code, analyzing code, searching (Eclipse's tree-results search over Emac's rgrep ANY day when there are multiple results).
I consider myself quite proficient with using Emacs as a full-fledged IDE via ECB, geben, rgrep, ctags, magit, etc. I used it as such exclusively for over a year -- but in all honesty, it hindered my productivity -- the heavy tasks take too many steps. Now I use Aptana & Emacs really about 50/50 throughout the day.
Light editors for light stuff, Heavy editors for the heavy stuff
there are definitely debugging solutions in vim see http://jaredforsyth.com/projects/vim-debug/, there are more but I haven't tried them, I tend to switch back and forth from an ide to vim.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
I'm a long-term Linux developer, and I've been using Eclipse to do all my coding for years. It's got decent syntax highlighting for a range of languages, good project management, top-notch integrated VCS support, and its Java support is superb.
Unfortunately it's also huge, rather clunky, and has a number of bad habits ranging from files disappearing irrevocably if you accidentally undo in the project view after creating a file, to mysterious lockups where it will sit and think at 100% CPU for a minute, to an extremely clumsy package manager that seems to become more and more fragile the more stuff you install with it. So I'm looking for suggestions to an alternative to Eclipse that I can try.
There are, however, some provisos.
There are two main styles of IDE. There's the Eclipse style, where a project is a directory; moving files in the project moves the files in the directory, so the project view can be treated as a file manager. And then there's the Visual Studio style, where the project is an abstract thing that does not necessarily match the layout on disk, and a project can contain files from multiple directories and moving files in the project doesn't touch the disk. This latter style I cannot stand, as it simply doesn't match the way I work. Unfortunately most Linux IDEs I've found work like Visual Studio. e.g. qtcreator, netbeans, monodevelop, etc.
I must be able to create a raw, unmanaged project, where the IDE doesn't try to build stuff, debug stuff, or touch the files in any way other than just editing them and managing them. This is because most of my stuff tends to get built from the command line. For example, Code::Blocks, which otherwise looks excellent, insists on all projects having a managed build system with build configurations etc, and won't take no for an answer, even if said build system is totally irrelevant to what I want to do. Integrated build systems are all very well but if I can't just point the IDE at a directory full of files and edit them, I'm afraid it's useless to me.
The languages I work in are C, C++, Java, Lua, shell script, Vala, and a myriad of other things, so something with decently robust syntax highlighting would be nice.
I realise that I'm being quite picky, but IDEs are a very personal thing, and, well, that's how I work. I don't dislike Eclipse enough to warrant changing my workflow, but I would like to know if there's something better out there that I can use with the same workflow...
I'm not really a very experienced programmer, I only have about 3 years of experience, but during those three years I have become completely disappointed with every IDE that I used.
I tried Visual Studio, Eclipse, NetBeans, IntelliJ IDEA (that was the most horrible of them, probably), Qt Creator (this one was the nicest, for Qt projects). All of them were too slow, clunky, too "intrusive", had a lot of features I didn't even need and using them was a real pain. So here is what I did.
I uninstalled all those IDE's, installed the good old gvim text editor, downloaded a nice color scheme for it, installed a good font for programmers (terminus), installed a few nice vim plugins, learned the VIM commands, learned how to use my tools (GNU make, g++, cvs, git etc.) and lived happily ever after.
The advantage of Vim is that it's lightweight, does not hog up your system's resources, does not tell you what to do, yet it is powerful enough to be one of the best text editors out there.
However, if you find Vim hard to grok, I suggest that you try Geany, a lightweight text editor for programmers. Also, I have recetly checked out Code::Blocks and it seems close enough to be good. It's not good for Java development, though, but for C++ it's decent. So, you know, pick your poison :)
How about JEdit?
I highly recommend Intellij Idea. As of about a year ago they've got a free Community Edition.
Since you are using Linux why not use xemacs (http://www.xemacs.org/)
To get an idea how to set it up for various languages you can look at this:
http://www.xemacs.org/Documentation/packages/html/prog-modes.html
Then for Java, you can look at http://jdee.sourceforge.net/
Emacs is very flexible, so you can get it to work as you desire, but, it will require more effort on your part that using a standard IDE, such as Eclipse.
When I don't want to wait for Eclipse to load I just use gedit - it's fast and has syntax highlighting.
You can open the sidebar to jump between open files or use the file browser and the bottom panel has a terminal to make in. If you use the External Tools Manager you can add custom scripts to be run by any shortcut key combination.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 9 years ago.
Improve this question
What good IDEs are there for R in Linux?
I've tried Rcmdr and Eclipse, but neither seems to have the same usability as Tinn-R in Windows. Are there any other options?
A newcomer to the scene, which IMO looks very promising - and downright baller - relative to other existing IDEs like Rattle and JGR, is RStudio. It's free software, is cross-platform, looks very polished, and even has features like automatic refactoring.
Update 2012-04-12: I've been running it for a bit on our DB server, and I love that it's a web app that saves your sessions, resume-able from anywhere else. Plotting requires not only no X tunneling or png-writing but is easier to use than out-of-the-box R. Extremely easy to get up and running, and it comes with packages for Debian/Ubuntu (which I use).
The company/development is moving pretty fast, aiming to be the de facto standard IDE for all R users. If I'm gushing, it's probably because I was pleasantly surprised by the quality of the IDE after a long time of using sub-par IDEs, not just for R but for plenty of other languages. So this was a bit out of the blue. I still need more time to really dig into it but I like what I'm seeing so far.
JGR isn't bad:
http://rforge.net/JGR/
Most people I know rave about Emacs + ESS:
http://ess.r-project.org/
But it's not quite the same thing as Tinn-R.
Along different lines ...
If you're looking at a high level functions for data mining, then Rattle is an option:
http://rattle.togaware.com/
and another high level app for interactive plotting:
http://code.google.com/p/playwith/
I have found that the Emacs-ESS combination is well worth the learning curve. I enjoy being able to:
have code and R console side by side
send the current line, paragraph, file, or function to the R console without touching the mouse
easily interact with R sessions on remote computers
enjoy all the editing abilities of Emacs
Here's the website for the project:
http://ess.r-project.org/
Here's a helpful document about ESS in particular:
http://www.demog.berkeley.edu/Refs/ess.pdf
Brand new IDE out there (as of Feb 2011) is http://www.rstudio.org/. Seems very promising from what I've seen so far.
Although Eclipse was mentioned by the OP, I do not know if he ment it with the StatET plugin.
Eclipse with StatET is a really great IDE besides e.g. EmacsSpeaksStatistics (ESS), but as in other environments the user have to learn it's the basic usage first. The only handicap of this IDE could be the relatively high resources requirements as based on Java, but this makes the program OS independent of course.
Why I really would suggest to take the time to learn use StatET efficiently (cauction: very subjective list!):
be able to run your code really fast and easily with comfigurable shortcuts (by Ctrl+r by default),
thanks to the script editor and running environment is heavily integrated, debuging and reviewing your code cannot be easier,
configurabled environments by default (e.g.: R scripts),
you may define templates for frequent commands and those's environment (e.g.: loop, if conditions etc),
highly customizable syntax highlight,
TeXlipse integrated to view and edit tex code with ease (LaTeX support for Eclipse),
Roxygen support for literate programming (very handy at package development to automatically generate Rd files (manuals) from inline comments),
easily extendable with othet Eclipse plugins (e.g.: spell checking, (SQL) database management, image viewer, running external programs like Sweave).
A nice guide to read is A Guide to Eclipse and the R plug-in StatET by Longhow Lam.
Gedit + RGedit plugin + Snippets plugin
You've suggested eclipse; there is a plugin called StatEt which work quite well (even Sweave is supported!).
There is a KDE 4 based IDE called RKward. It's nice because of:
Workspace Browser
Integrating the R console
data.frames editor
Syntax colored editor
GUI frontend for installing CRAN packages
For my case, I would recommend RKward for linux, it is a KDE. I've been using RStudio in Windows, but when I switched to Ubuntu, I find RKward easy to use, and has a good interface.
You can create a data frame without coding it with data.frame() function.
If you are used to Eclipse, StatET (mentioned by mbq) is probably the right choice for you.
That being said I have a more exotic choice to offer that you might want to consider, if you like auto suggestion and pure syntax highlighting is not enough for you. At least for me auto completion of R-Code did not work with StatET.
Now I use Komodo Edit with Sciviews-K and R64. Sending Code from editor to R works really well and the editor offers auto-completion for R-Code which is really nice – in particular if you are new to R. I work on a Mac, but it should be easy to setup for Linux too.
I think it has lost some popularity because it wasn't to stable in the past, but at I feel it's much better now and it hardly crashes in my setup. So you might wanna give it a chance too.
EDIT: If you work on Mac Textmate with the corresponding R bundle might be interesting, too. Recently I am about to switch to Textmate. If you don't care about the $45 for textmate, it's probably the most stable choice I tested so far. But it's only available on a Mac. But hey I am really amazed by this editor (and as you can see I like testing setups ;).
EDIT: I realize this thread is still being read by someone, so I definitely need to mention RStudio. It came out of nowhere and quickly became the choice of a lot of people. And it's well deserved. It still has some bugs (like not being able to stop RSessions) but it has tremendous auto-complete with context help. But at least on my setup (Mac) it's more stable than StatET / Eclipse. Sweave and ROxygen is not really supported yet, but the developers are very active. Definitely worth trying.
EDIT II: Because it's fun to track this here's another edit. RStudio continues to win more and more users. The combination of RStudio, Roxygen2 and particularly knitr integration has likely been the largest contribution to this development. While Rstudio was rather used by applied users and in teaching and has improved to dramatically that there's isn't many situations in which another IDE / editor is a better choice. Being maried to ESS seems like to only valid reason left to not use it. Also the documentation of its ecosystem is just great. The latest: Package development by Hadley http://r-pkgs.had.co.nz/description.html and his advanced programming http://adv-r.had.co.nz/
I strongly recommend learning emacs+ess, but for a more modern-looking interface you can try RKward: http://sourceforge.net/apps/mediawiki/rkward/index.php?title=Main_Page.
I use Geany in combination with R. Geany provides a terminal in which one can start an R session and shortcuts an be defined in order to send highlighted text to the terminal.
www.geany.org
RGedit, great tool if you're keen on GNOME default text editor. Lacks autocompletion in script mode, though... but you can define snippets in a separate plugin (Snippets)... You can send code directly to R session running in the terminal window, tabbed multiple R sesions, there are several GUI templates for common data analysis (t-test, correlation), long story short, take a look at:
http://sourceforge.net/projects/rgedit/
Few months ago (when I gave my blogging skills a try), I wrote a review for RGedit, here's a link (and a little bit of self-advertising):
http://psy-stat.com/?p=12
EDIT:
Oh, and you can use Geany and set it up so you can send code chunks to R session... I've never done it, but I know it's manageable!
EDIT #2:
here's a helpful link: http://sgsong.blogspot.com/2010/08/integrating-r-with-geany.html
This might be what you're looking for. It integrated Komodo and the SciViews package. I found it a bit too fiddley (I prefer vi) but if you're looking for a full blown IDE/editor for R in Linux it's pretty close to Tinn-R for Windows and it's written by the same guys!
Link:
http://www.sciviews.org/SciViews-K/index.html
Rattle: http://rattle.togaware.com/
Emacs with ESS. Probably not as polished as Eclipse, but I do like it.
Personnaly, I use gedit and my console. It works great :)
I recently started picking up vi, going through some tutorials and trying to get used to it. But I still have some questions about it.
It seems to be nice for small one file changes, but as soon as I start to try doing bigger things it seems to be lacking. For example I'm used to have code formatting, import organizing, simple overview over all packages and other things that an IDE gives me. I saw some tutorials on how to use vi as an IDE, but it felt awkward at best.
Now I'm just wondering, what are the typical use cases for vi? Is it typically used to edit small files, or can it be used for larger projects? And if you use it in larger projects, how do you make it work? Or would it be a lot easier to use an IDE with vi keybindings?
People use non-IDE editors like Vi(m) for coding due to the following reasons,
They are non-distractive, allows you to concentrate on the job.
They do not clutter you screen area, offers you more code space
They are faster
They have better/faster/cooler text manipulation at the stroke of the finger
You happen to move your hands out of the keyboard less to hold the mouse, drag it here and there and click.
They also have the flexibility to support other tools like debugger, document viewer, etc.
They also have ways to get things like code folding, etc.
For a normal programmer whose ideal work cycle is sit, write code, test, debug, more code, test debug.. Vi offers a simplistic yet powerful environment to get the work done faster and more efficiently.
For someone who had years of using some IDE, it might be like using some prehistoric tool, but once they have been through the initial days, then there is no looking back. They'd feel like there is no better thing.
Why, oh WHY, do those #?#! nutheads use vi?
I've haven't done anything that you'd call a big project in python (only little test scripts), but I use Vim exclusively for writing large embedded C applications and I have never really felt the need for an IDE.
Vim is fast to start up, extremely fast to use and (with a bit of customisation) can do most things that an IDE can do. It'll do code completion, code auto-indentation and reformatting and it is very good at refactoring. The project plugin http://www.vim.org/scripts/script.php?script_id=69 makes it very easy to manage projects with lots of files and the taglist plugin http://www.vim.org/scripts/script.php?script_id=273 is great for browsing source code. It also allows you to have the C code open side-by-side with python code, assembly code and latex documentation without having to use a different tool for each.
Overall though, I think there is one really valuable thing that Vim gives you that very few other editors do and I would find it very hard to lose that: I can have a window split into three parts like this:
Each of the subwindows can either show a separate file or (as in the screenshot) a separate part of the file. I imagine emacs can do this (although I could be wrong), but I doubt many IDEs can. This can be invaluable for refactoring and for referring to other parts of the file.
I've used VI(M) and Emacs as my primary editors for years... I've tried switching to IDEs but find they can't get out of my way enough. I always end up back in VI(M) or Emacs after a while. One major reason is that I find my hands need to leave the keyboard too much in IDEs as they require the mouse too often... And I'm too lazy to setup my own shortcuts for everything.
Here's why I use it.
it's fast to start up
it's available across multiple platforms and is on all Unix machines
it's fast to use (keystrokes for common operations, operations based around words/paragraphs etc.)
However, I use IDEs for large scale development work, since I can't believe they can be beaten for productivity, given their code-awareness and refactoring capability. I use Eclipse, but I plug a VI editor emulator into it. See this answer for more details.
I saw some tutorials on how to use VI as an IDE, but it felt awkward at best.
There's one thing to do at the very beginning: throw your sense of aesthetics overboard. You will never get the same kind of graphical experience in VIM as you do in a decent IDE.
That said, VIM actually does offer many of the features of a full-blown IDE and has a lot of advantages besides. I use VIM for almost all of my developing work and all of my text documents (using Vim-LaTeX) – even though I've actually paid money for Apple’s office suite, iWorks.
There's one point that's still nagging me, though: I can't get IntelliSense to work. For me, that's a huge problem, especially when using languages such as VB, C# or Java, for which excellent IDE support exists.
So, the learning curve for VIM is steep but once you've passed a certain point it's everything but awkward. In fact, compared to VIM's editing experience, you will find that it's the IDEs that suddenly feel awkward because while they're good at bookkeeping stuff, they suck at editing.
I frequently work on a remote system, programming for a cluster, or editing config files on a headless box. All of these could be done with a file transfer, a regular IDE, and another file transfer, but it is so much faster to just use VIM through SSH.
You can find it (or easily install it) almost anywhere - Runs on all systems that can implement the standard C library, including UNIX, Linux, DOS, Windows, Mac, BeOS, and POSIX-compliant systems.
The ability to log into a remote server and confidently edit a config file is priceless.
Vim is not very good at code awareness. What it is good at is text manipulation. It provides you with the tools for you to edit text, not to edit for you. If you just do "small" edits and don't read up on the occasional "vim commands you wish you knew" you'll never understand the power provided.
code formatting
Formatting is done with =. You can also point equalprg to an external program to do the formatting for you.
import organizing
Vim won't be able to remove unused imports but if you select the import lines
:'<,'>sort
simple overview over all packages
:vs .
This will open a vertical window containing the current working directory :)
In conclusion, vim can't replace your IDE but it will let you edit your text.
As usuall: Choose your tool depending on the work you have to do! ;-) I'm using Vim and Visual Studio. You don't have to choose only one.
If you need an IDE, use an IDE. Vim is made for text manipulation.
It supports any languages. Try to edit a Ruby script with Visual Studio.
Performance on large files is much better than for most IDEs. Try to analyze a logfile having 100k lines and more using your IDE.
It runs on many plattforms and you can use it via a remote console, if you have to edit files on a server.
...
IDEs are specialized tools, which are good for problems they are made for. Vim is an incredible flexible and powerfull generall purpose tool.
This is obviously a hot topic so I'm going to give a list of reasons why I prefer IDE editor for coding.
1) I prefer to be able to fold sections of my code (I don't know whether Vi(m) can) without having to remember the command to do so or type it.
2) I prefer one click compile button/command as opposed to having to remember my compile command and it's library of options
3) I prefer the easier highlight copy paste operations without having to........ aah sod it!!
Well by now you get the picture. I'm not knocking Vi(m) I just think having your the elements and functionality of your coding environment visually represented makes for a clearer head and encourages exploration of options you may not know exists.
I much prefer vim over vi and prefer not to lump them together. Vim provides some features that are really handy and not always immediately obvious. Already mentioned was screen splitting. Also you may want to checkout ctags or exctags. These allow you to jump around the code base from within vim. I can place the cursor over a called method, jump to the definition, jump to a definition within that method, etc. Very powerful for tracing down bugs. Cscope is another similar program.
Vim will also allow you to run arbitrary shell commands within the environment and has powerful search and replacement features.
So an IDE will provide most of those, what will vim provide over a traditional GUI based IDE? That's easy, it runs on the CLI.
This allows me to login to my dev box, run screen (definitely something to checkout for the unfamiliar: http://www.gnu.org/software/screen/) and run multiple vim sessions within my screen session on my dev box. Now when I leave work for the day, I can leave my work session just as I left it, even while running builds. When I come into work the next day I can connect from my environment as if I never left.
Another reason to like vim or vi in particular, is that it can be found on virtually any Unix environment.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
For someone just starting to program, would you recommend using vim/emacs, or should you use some IDE? Like are vim/emacs better suited for more advanced users than for beginners? I'm just wondering because I'm trying to get some of my friends to program.
If they're just starting programming, I'd not recommend VIM to begin with.
they'll have enough on their plate to begin with learning the ins and outs of programming
depending on the language/platform, I think they'd appreciate an IDE with code completion , general language support etc. (I know you can do this in VIM, but it's a lot more seamless in an IDE).
Note. I'm a VIM fan, and I run my IDEs with VIM plugins, so I have nothing against VIM as such.
I note in your comments you're looking at teaching them Java. BlueJ is a Java IDE geared towards learning Java, and may be a useful introductory tool.
When I used to teach C & C++ commercially, back in the late 80s/early 90s, we did all our teaching on UNIX boxes, with vi as the editor. A lot of our clients were MSDOS (and later Windows) users. These guys used to have, on day #1 of a 5 day course, to learn the basics of UNIX and the basics of vi, at the same time as they were learning C and C++. They all bitched like mad (and I couldn't blame them) but they all managed it.
Perhaps we expected a lot more of each other back then. Still, we haven't changed genetically in that short period, so if they could learn vi easily then, programmers today can also learn it, without too much trouble.
Avoiding the subjective question of editor choice, it's not so much about advanced/beginner as learning too much at once. It's probably a good idea to separate the coding learning curve from the editor learning curve. If you're busy learning to code, use an editor you're already comfortable with (doesn't have to be an IDE, could be gedit, etc.). Once you're comfortable coding, you can move on to an editor of your choice if you're not happy with what you already knew. An advanced coder might still prefer a simple editor, and one who hasn't learned too much might still want to work faster and switch to Vim.
Since you say you'd suggest Java to them, Eclipse is probably the way to go. If you were suggesting Common Lisp, I'd say Emacs without hesitation. For Python and the like, I'd say to use whatever text editor they know now; vi, vim, Emacs, Geany, whatever. But for Java Eclipse is a pretty good standard choice.
Whatever editor you choose, have the cheatsheet sticked next to your screen.
People either like vi (or emacs) or hate it regardless of their skill level as programmers.
I am by no means an emacs whiz, but in terms of learning the basics of a new language I think it is handy.An IDE can be a distraction from what you are trying to learn (So you end up spending time learning an IDE rather than a language) and emacs provides both good indenting and syntax highlighting, as well as easy access for compiling, debugging, and accessing the shell.
I know I'm going to get voted way down by the legion of emacs/vi people here, but in terms of learning a language, an IDE with intellisense (or whatever the generic version is called) is absolutely indispensable. For instance, if you use visual studio, you will spend almost no time playing with the IDE. The automatic completion clearly shows the relationships of member variables, and makes it so that you don't have to remember minutia. Scope and type resolution is also invaluable for the beginner. Most important however, is that whatever you are using contains an industrial strength debugger. Logging with strings to a text file is no way to go through life. Even the legion of emacs lovers will probably admit that someone is far more productive with a professional IDE and a beginner is far less likely to get frustrated. Now, if you are going with something opensource/free, your experience may vary.
If you're just starting and you're learning Java, I would go for one of the graphical IDEs. Yeah, something like Eclipse or Netbeans is fairly bloated, but it doesn't change the fact that they make the barrier of entry way lower with suggested error fixes and the like.
vi or emacs in combination with gcc are great, but I would go with something more beginner-friendly to begin with.
If they are beginning to learn programming, it is better to start with a simplae text editor like gedit or geany. But learning to use emacs or vi down the road will be a hugely enlightening experience. It might be be a good idea to learn emacs by using for plain text files (notes, todo lists), so there is not the distraction of learning language specifics.
Run the vimtutor command. It's an interactive way of learning a lot of useful basics in Vim. Vim is very powerful and efficient. You won't learn everything there is to know about it at once. You'll continuously learn more handy features of it as you continue to use it. If you get the basics down, you'll start spending more time in command mode. Do not use the arrow keys. It may feel awkward at first using hjkl keys to move around, but it will soon feel natural and become faster because your hands do not leave homerow on the keyboard. One of the great things about Vim is the user almost never if ever needs to take his or her hands off of homerow.
As for Java, Netbeans kicks ass IMO. Why shouldn't it? It's made by the same people who developed the Java language. So when I am using Netbeans, I use it with jVi plugin that allows me to work with it just like I were using Vim.
vi and gcc, nothing else
Editors seem to be a touchy subject. It really seems to be personal preference. The only reason I ever learned vim was because of the workplace required me to. The only reason I ever used emacs was because of school. Having said that, I think just using the available development tools (VS for .net framework, Eclipse/NetBeans for Java, etc) would be best in my opinion, but again, its definitely personal preference.
It depends on what platform and language you plan to start and then boils down to individual preference. If it happens to be windows and you plan to do C#/VC++/VB then Visual Studio IDE is the best.
I used emacs when I started on Scheme and python and I found it handy.
cheers
I learned Java using a combination of DrJava, BlueJ and Eclipse. I started with DrJava since it had an interactive Java shell. Then I played with BlueJ and finally Eclipse once I thought I knew enough.
Now that I "know" a couple languages I just use Vim.
I'd recommend Vim for anyone working with a text editor, but not at the same time as learning programming.
I don't know about emacs, but I would recommend learning Vim for a beginner in a heartbeat. The vimtutor program is a great way to pick up the basics. It is a bit of effort, but you soon get used to it.
I started using Vim when I was learning HTML, and it was a massive improvement over something like Notepad. It soon replaced nano as my command-line text editor of choice in Ubuntu as it's easy to navigate around fast with Vim. Then, I decided to learn Python and I found it was easy to get started with it because I was already familiar with Vim. Now I'm learning C and it's great to have an editor I'm already familiar with as it means I don't have to worry about getting used to a new IDE or text editor. This means there's less work for me to do.
I've found knowing how to use Vim gives me a significant productivity boost over any other editor I've used. The only downside is the key bindings get burned into your brain, to the extent that I keep reaching for Escape when I want to move around in a Word document!