
Ask HN: Reasonable Java editor for heavily CLI-oriented UNIX types who hate bloat? - abalashov
Hi everyone --<p>Let me give some background to properly contextualise this question:<p>I am the type of programmer that has been doing UNIX (generally Linux, also some commercial varieties) since 5th grade or so, and consequently am very command-line oriented in my habits.  Did mostly C growing up, and a fair bit of Perl later.<p>So, obviously, when I was faced with the real-world need to do some Java, I approached it with my usual arsenal of half a dozen, uh, terminals and vi (VIM) sessions.  Eventually I broke down and started using 'ant' for building instead of Makefiles, but apart from that, this approach has served me well.<p>I wouldn't mind a more Java-aware editor, though;  something that can save me a little time on the tedious task of having to switch in and out of editor windows without having a holistic view of my source tree, as well as provide cross-referencing of symbols and API-specific autocomplete and perhaps online javadoc summaries built right into the editor.  I spend a lot of time juggling all these editors and 15 tabs in my browser.<p>I've looked at Eclipse and NetBeans, but, they're just <i>way</i> too bloated and complicated.  It would take me an enormous amount of time to figure out how to use them correctly and do things the Eclipse Way or NetBeans Way, and I don't think it'd be worth the flexibility I'd be giving up.  Plus, they do far, far more internally than I really need, and I'd have to upgrade half my desktop machines just to stand a hope of realistically running them.  They introduce gigantic piles of unnecessary metadata and internal abstractions I don't really want to deal with for my relatively simple, terse code (as much as Java can be).<p>On top of that, much of my development is server-side and, although I can mount the code tree with SSHFS or NFS or whatnot, local building and testing is essentially useless.<p>So, I was wondering if anyone had any suggestions for a decent editor for someone in this predicament.  I'm imagining something like an "IDE lite," or perhaps a really glorified take on UltraEdit (but not for Windows).  I don't really know.  Something that can get me the aspects of Eclipse that make editing Java code easier without all of the metadata, complicated build processes, user interface bulk, or sheer scope.  Some say IntelliJ is the way to go here -- is it?<p>Thanks very much in advance, guys!
======
whirlycott1
Anybody who writes java code in anything outside of Eclipse, NetBeans or
IntelliJ is wasting their time. It doesn't take an enormous amount of time to
learn how to use Eclipse. It probably takes 15 minutes of someone showing you
the ropes. You need to stop thinking of the problem as "I need a text editor"
because that's almost certainly not what you need.

Eclipse in particular does nothing like what you claim ("unnecessary metadata
and internal abstractions") except one or two files in the root of your
project's directory tree. Upgrading your machines to support Eclipse means at
worst spending $20 to buy 2Gb more memory, which doesn't seem like a lot to
me.

All of the requirements you mention (plus a lot more) are available today in
Eclipse. And you don't want Eclipse because of a few poorly defended
misconceptions that you are clinging to. Go back and give this a second look
and get someone to show you the ropes with it over lunch. You will never look
back.

I have personally converted two people like you: die-hard emacs users who will
never use an IDE because you tried them ten years ago and they sucked then.
Neither of these two fellows would ever go back to that world now that they
know what they're doing.

You won't regret the few minutes it takes to learn basics.

~~~
javanix
I'm the complete opposite of the OP. My intro CS courses were taught using
Eclipse, and I am constantly using it (for lack of a better, free, option) at
work. I am getting more and more fed up with the bloat in Eclipse. Running in
a Linux environment results in hard-to-diagnose crashes fairly often, and the
memory overhead is, quite frankly, unacceptable.

I would gladly move to something lightweight like the OP asked for. Most of
the features in Eclipse aren't useful to people working on relatively small
projects, and the features that _are_ useful (code completion, refactoring,
nice library integrations) could probably be deployed with much less overhead.

~~~
whirlycott1
At my company, we've had people use it on WinXP, Vista, OS/X and Linux. Nobody
ever suffered from crashes. There are a few different flavors of Eclipse and
it sounds like you were using the kitchen sink version. There's a smaller one
which everybody I know seems to use that may be worth checking out.

------
mcav
Emacs?

For command-line folk, either Emacs or vi would probably make the most sense
long-term. They often have plugins to add functionality to make them more IDE-
like. Learning curve's a bit tougher though, and might require more effort
than it's worth. I still haven't completely switched over to Emacs yet, but it
might pay off in the long run.

~~~
arghnoname
I used emacs for everything and relatively recently got into the situation of
having to do some java.

<http://jdee.sourceforge.net/>

It handles that too. I like having one editor that can follow me everywhere.
Maybe Eclipse or the others work better for java or more out of the box or
some such thing, but to me there's a huge benefit to having my programming
editing behaviors consistent in a terminal, my desktop, PHP, perl, C, C++,
java, etc. (with mode/language specific enhancements of course).

If I grew up on Eclipse I'd probably feel the same way I suppose about it.

------
jm4
I love IntelliJ, but if you think Eclipse and NetBeans are bloated you'll
almost certainly think the same of IntelliJ. Keep in mind, though, you do get
a lot of features in return for all the "bloat"-- refactoring, intentions,
inspections, better navigation and too many others to mention.

Programming in Java is tedious and a good IDE makes things much less painful
so maybe you'll want to reconsider. Unfortunately, there's not much middle
ground between plain old text editors and full fledged IDE's so your options
will be a little slim.

You may want to check out JDEE for emacs. Setting it up is a little
complicated, but it's probably going to be a little snappier than an IDE. You
could also try jEdit. There are various Java development plugins so you can
pick and choose the features you want.

<http://jdee.sourceforge.net/> <http://plugins.jedit.org/list.php?category=5>

------
taxcollector
I have been meaning to check out eclim: <http://eclim.sourceforge.net/>

~~~
abalashov
Whoa! Holy crap!

------
rjurney
The pain of Eclipse's bloat is real, but the speed with which you can learn
new libraries through its features is worth it. I won't come within 10 feet of
Eclipse for anything but Java, but its so great it makes Java fun because I
can effortlessly zoom through definitions in multiple layers of libraries and
figure out what is going on faster than in any other language/IDE.

And I don't even like Java.

------
mdoar
I get funny looks for using emacs for Java work, but it loads and runs fast on
all the different platforms I work on. I have used and support people using
Eclipse, and generally I like the ability to find definitions etc, but the
refactoring rarely proves essential. As for autocompletion, if you can't hold
the whole core language in your head, there's something wrong somewhere ;-)

~~~
whirlycott1
The java language is actually very small and easy to remember. The standard
library, on the other hand, is huge. If there's any glory in remembering what
the constructor arguments are for a certain class, it's lost on me.

Plus, in the real world, many of us use what we call "third party code" which
could be as simple as something as a database driver or some kind of utility
class. If you think you're going to remember perfectly everything all the
time, then you are dreaming.

And on refactoring: if you don't think it's essential, please do yourself a
favor and find someone who can give you a tutorial. Refactoring is _the_ key
feature of all of these IDEs.

Say you have 100K lines of code in a project. You want to move a class to a
new package. In your world, you spend a week doing it and probably typing
javac over and over on the command line. In my world, I can do it in less than
5 seconds and know the IDE is 100% correct. When you have power like that in
an easily accessible frontend, you tend to use it. That benefits your code by
making the big ugly maintenance tasks into afterthoughts.

~~~
silentOpen
> In your world, you spend a week doing it and probably typing javac over and
> over on the command line.

Perhaps you should learn to use the command line if you think refactoring
without an IDE takes a week. :-/

~~~
trapper
How long would it take you to refactor say an entire package hierarchy in an
open source project like jfreechart? Id love to see a video of how this
happens as evidence.

------
_debug_
ablashov, I have to chime in with the others here and let you know that
Eclipse does so many things for you, that in direct contradiction to what you
assume, it is actually difficult to set up Emacs or Vi to do the same for you.
One example is whole-workspace refactoring : Let's say you decide that a
function (method) needs to take an extra parameter, a boolean, but actually,
that is just to cover some corner cases, i.e., the argument will be false in
most cases, but true for 5% of cases. But that method is used in 326 places.
Guess what : changing method signature and refactoring ALL the code that uses
that method is just a few actions in Eclipse. Eclipse --> Refactor --> Change
method signature --> Add new parameter, boolean isCorner, default = false.
You're done. It changes all 326 references to your method and rebuilds the
project.

Truth be told, Eclipse is a key reason for Java's popularity. It makes working
a pleasure and helps you focus on the actual work, not on the mechanics of
how-to-get-it-done.

~~~
whirlycott1
I'll go further and say that Java is a horrible experience without Eclipse.
One of my colleagues at work said today that (1) Java sucks without Eclipse
and (2) Eclipse's wonderful features wouldn't be possible without all the
things that makes the Java language suck.

~~~
fhars
That is Seibel's corrollary to Greenspun's Tenth Rule, no? Every sufficiently
complex java program need a programmable IDE to make up for the half of Common
Lisp not reimplemented in the program itself.

~~~
whirlycott1
I had a conversation about refactoring with one of the giants of the Lisp
world earlier this week about this, actually. The parts that make Lisp so
powerful are the parts that also make it so hard to build reliable refactoring
tools. Refactoring is something you need in any language. Otherwise, the
implicit presumption is that you always get your software architecture 100%
right the first time around.

------
stuff4ben
I'd give JEdit a look. It's been a while since I've used it, but when I did
several years ago, I appreciated how lightweight it was and it just worked.
Nowadays I use Intellij on Ant and Maven based projects.

------
ismarc31
If you know emacs: <http://jdee.sourceforge.net/>

------
dforbin
it seems really weird to me you find netbeans complicated. There's a reason
java developers use bloated IDE's for anything more than quick edits. Spend a
week in Netbeans and I bet you a lap dance you keep using it.

~~~
_sh
I'll second that. As a seasoned eclipse user I had another look at Netbeans
recently. It seemed pretty much the same for me, and offered no compelling
reason to switch. Until I poked around the profiler.

Well, let me say there's no going back for me. The Netbeans profiler gives me
confidence from knowing exactly what my application is doing, and exactly what
that third-party library is costing me. The coverage, allocation stack traces,
and jvm heap monitoring are fantastic. Seriously. Take a look:
<http://www.netbeans.org/kb/60/java/profiler-intro.html>

So yeah, I'll take a slice of that action and throw a pole dance in on that
lap dance you bet. And it didn't even take me a week before I realised.

~~~
whacked_new
If you jumped from Eclipse to NetBeans, there wasn't any pain from the
different plugin offerings? I don't enjoy installing two IDEs for the same
language, but that's what I end up doing, unhappily.

~~~
_sh
No pain at all. I don't rely heavily on plugins though. The important bases
were covered: refactoring, vcs integration, and the usual javadoc/outlining.

Perhaps the only things I missed were getting a method's signature when you
hover over it with the mouse, and the live variable value when you hover in
debug mode. But these are so minor that I feel if they're not already there
and I somehow haven't set them up, they'll be in the next release. But as I
said, I get so much more confidence by being able to charge in to my code's
runtime and poke around that it's worth it.

------
papaf
I was in the same situation a while ago and ended up jumping to netbeans with
the free and excellent jvi plugin. However, I feel your pain and when I
recently started using scala on a hobby project I was really happy to be able
to just use vim again -- partly because the netbeans support isn't so good for
scala and partly because the language "feels" like it doesn't need an IDE.

------
abalashov
All right, you guys convinced me to give Eclipse another shot. So, I'm going
to really try to get into it this time before I knock it.

------
catch404
Eclipse,emacs and maven works for me. I use the emacs for making quick changes
and often end up working within it. Still couldn't go without having eclipse
along side though.

