
Why not just use an IDE if you want IDE features? - kemayo
http://davidlynch.org/blog/2011/09/why-not-just-use-an-ide-if-you-want-ide-features/
======
mdasen
I think part of it is that a lot of IDEs don't "feel" good. For example,
Eclipse doesn't feel like a Mac app. Dragging tabs around works, but is ugly
compared to Chrome or similar; the icons used are more utilitarian rather than
something someone put thought and care into; often times the advantages it
provides for the Java language just aren't as good with scripting languages
(less mature support for Python and Ruby, less of a need for an IDE for those
languages, and less ability to provide good features since they aren't
statically typed).

Sometimes you want every feature. Other times, you want something that might
have fewer features, but might feel better. When the iPhone came out, it
didn't have a keyboard, it didn't have 3G, etc. Yet, it just felt better - the
size, the icons, the way you interacted with it. I think that editors like
Sublime Text and TextMate really go for that feel.

Users seem to see Sublime Text or TextMate as just missing a feature or two
while looking at Eclipse and finding that it has the features, but lacks the
basic joy of interaction. They also feel that it would be easier to extend
something like Sublime Text than to fix the feel of Eclipse. Personally, I'm
starting to warm to Eclipse as I use it and I appreciate the features it
brings to the table, but I don't ever think I'll see Eclipse as "feeling good"
in the way that TextMate feels right.

~~~
wladimir
_Users seem to see Sublime Text or TextMate as just missing a feature or two
while looking at Eclipse and finding that it has the features, but lacks the
basic joy of interaction_

I somehow have this problem with Eclipse too. I really love its features,
especially for Java/Android development, but it sometimes handles like you're
driving a truck. Even on a fast PC. So its not that much 'fun' to use for me.

Qt Creator is one of the fow IDEs I positively like working with. It is fast,
featureful and somehow doesn't get in my way like Eclipse does. The only
drawback is that it's very Qt and C++-focused, so outside that area usefulness
quickly dwindles.

For the rest I like Sublime Text. ST somehow helps you stay focused on the
text. It is very fast and feels smooth. Like other "simple" editors it opens
very quickly so can be used for editing independent scripts and configuration
as well as source code, and does not impose any kind of framework or project
structure.

~~~
SandB0x
Qt Creator is definitely worth trying out for C++ coding. It has a good Vim
mode and makes building (thanks to qmake) and debugging a breeze.

------
danieldk
It's a trade-off. An IDE will often provide more and better integration, but
is usually focused on a small subset of programming languages and is less
flexible.

Most editors less integration, but are far more flexible. Take Sublime or Vim,
you can customize every bit of the experience with scripts without too much
effort.

Also, I think some languages tend to need an IDE more than others. E.g. Java's
relatively small feature set increases its verbosity. An IDE is almost
required to avoid too much typing and memorizing. Haskell, on the other hand,
is very expressive, making it less fit for smart autocompletion.

~~~
hello_moto
Err, I doubt it takes less effort to customize Vim.

OTOH, I like to use an IDE like NetBeans to navigate Ruby code (go to method
implementation, go to class implementation, etc).

I'd say it depends on what kind of project you're working on. If you're
writing a small one-off script in Haskell, you probably don't need to use an
IDE. The same goes for Java.

Once you integrated 3rd-party libraries (like not just one, but say, 5 of
them), you either have to memorize those libraries or be grateful that IDE can
help you.

------
MrScruff
I've actually just begun the process of switching from an Eclipse + CDT
workflow to Vim in an attempt to understand what attracts people to it. I'm
working nearly exclusively in C++ with some python, developing on Linux. Some
of the features that I'm not sure I can put up with losing are:

\- Reliable code completion. I have to deal with many different third party
libraries and APIs, many of which have their own implementation of basic maths
classes. It's just not possible to remember them all. I've tried clang
complete and it's ok but nowhere near as nice as CDT in Eclipse.

\- Inline popup of definitions on mouseover.

\- Reliable jump to definition or header.

\- Proper refactoring.

\- Local file versioning on save with diffs. Incredibly useful once in a
while.

On the other hand, I'm appreciating having a responsive editor I can run
everywhere and I like having text based configuration and plugins.

I agree with the article that if you want an editor that really understands
your code (and you're working in a statically typed language) then you need an
IDE, not a text editor with plugins.

------
smortaz
At Microsoft we have all types: IDE diehards and those that are happy staying
with vim/emacs. There's also a group that uses a text editor 90% of the time
and fires up the IDE only for the debugger and perhaps GUI builder. Which of
the 3 buckets you fall into seems to be one of those nature/nurture questions.

Re IDE's being slow/bloated - Our group does a Python IDE (free/oss plug-in)
and the performance is pretty decent. If you have SSD's, VS can feel pretty
snappy. Here's a video to give you an idea:
<http://www.youtube.com/watch?v=7CoGsSlrxKk> . For 1.1 we're working toward
becoming more Editor+ like, ie, less Project System overhead - just open a
file & go.

------
weixiyen
Used to be a TextMate lover, bought the license at least 3 times. Then I met
<http://www.jetbrains.com/webstorm/> \- never touched TextMate again, and
don't ever plan to. Just thought I'd share for those who have not tried a
JetBrains IDE before. No other IDE I've tried has lasted more than a week.

~~~
jinushaun
Always wondered who used those things. JetBrains has a good reputation, but
text editors and IDEs are a crowded market. Web development needs an IDE.

------
burgerbrain
I think a proper response to any question of this form is "why use an X if you
can get what you want without an X?"

~~~
vilya
Why use a car for your 100 mile journey when you can get there by bicycle? :-)

~~~
derleth
Try carrying a nontrivial amount of baggage on a bike.

(No, the correct answer to this is not "Don't carry luggage." You can't solve
a problem by chopping its legs off so it fits in your problem-solving grid.)

~~~
div
So extending your analogy, you prefer travelling by truck over travelling by
car ?

------
Swizec
The same reason I don't use a Space Shuttle to travel to my granny that lives
a 100km away.

I don't have to.

But it's got a lot to do with the fact that while IDE's are good for something
like Java or C++ programming, they tend to become really crappy once you get
into web development and have to regularly work with 5+ different languages at
a time.

With most IDE's that would mean I'd have to have 5 of them open to work
comfortably with every language.

~~~
hello_moto
That's because most IDEs don't have good support for web development. (I
wonder what would happen if they are good for web development, would people's
opinion change?)

I used Vim to modify CSS and JS but I struggled to navigate JS code because I
cannot jump to the method implementation with some sort of magical shortcut
key easily. This is pretty tough if I want to know why I don't get my intended
result out of calling the method.

To add injury to that, I found out that I have to redo the implementation and
call the method something else to describe the intent in full. I can't
refactor that easily without going to the path of hell: grep, regex, sed.

~~~
gabebw
Re: jumping to method definitions, have you tried running ctags on your
project directory, then pressing Ctrl-] (go to tag) on the method name? It
should work.

------
laurencer
I distinguish project-oriented IDEs such as Eclipse and IntelliJ from casual
IDEs such as Sublime Text.

If I'm looking at something downloaded from GitHub, I use Sublime Text because
the focus is on browsing the source quickly. I don't want to have to create or
import a project.

Whereas, if I'm actually developing something, I'll use IntelliJ because then
I need all the additional build tools.

I think it's a matter of using the right tool for the right job. Opening
something in IntelliJ _seems_ like a lot of effort because of the extra step
of creating a project, and hence I choose the easier option: Sublime Text.

------
ekidd
If you're using a programmer's text editor (SimpleText, vim, Emacs), you
should be able to touch type your way through committing code. This is a
_basic_ operation.

Here's my workflow using Emacs and magit:

1) Right Alt-G to bring up the magit git interface.

2) Down arrow and tab, repeatedly, to review diffs, with "s" to selectively
stage part of a change.

3) "c", a commit message, and Control-C, Control-C to commit. Then I'm working
on the next feature. This whole process is in muscle memory.

Obviously, the workflow in SimpleText or vim would be different, but there's
no reason it shouldn't be just as fast. Fast commits are not just for IDEs.

------
mhd
Is there really a clear distinction between IDEs and (some) editors? Eclipse
has some language modules that aren't really that great, so would it count as
an IDE for those? And Emacs is most definitely an Elisp IDE, nearly a CL IDE
with slime and quite close with a few other languages, given enough
customization…

And while I haven't looked, I bet you can get enough integration with vim, at
least on the level of Visual Studio 5…

Meanwhile, Smalltalkers know where to draw the line and tell us that we never
used an IDE at all (or an object-oriented language)…

------
skrebbel
The advantages of IDEs over text editors isn't look or feel. It's code
quality.

Especially with statically typed languages, good IDEs make developers
significantly more productive.

Programmers spend most time reading code, navigating code, understanding code.
Much more than writing code. Unless you've only done greenfield solo projects
in your life, you know this is true. IDEs have code navigation features and
tooltips over types and methods. Features like this help a developer
understand code significantly faster.

Additionally, code occasionally needs refactoring. Most common are the real
simple refactorings: A method might grow too hairy and need a split up, maybe
a method's name does not correctly convey its meaning anymore, arguments would
have to be reordered for consistency, and so on. In a text editor, you have to
manually update all references to the changed method. All you can do is
compile (or unit test, in case of dynamically typed languages) until all the
errors are gone. This is cumbersome, error-prone and time consuming.
Search&replace often creates more errors than it fixes. IDEs have direct
support for simple operations like these.

Larger refactorings are mostly compositions of smaller, simpler ones like I
described above. Being able to trust the tool to have made the change
correctly is invaluable in this process; it avoids a full unit test suite run
after each step, and significantly speeds up major refactoring work.

The end result is that a team that uses IDEs and understands its navigation
and refactoring features find it very easy to increase code quality. A room
full of vi users, not so much. A text editor user would prefer to keep things
as they are and add new features instead. The cost of minor refactorings, such
as method renames, does not weigh up to the gain. This gain is small in the
short run, because the developer is actively working with that part of the
code. In the long run, repeatedly skipping these improvements makes code
ununderstandable.

Also, let's not forget the "not invented here" syndrom. IDEs make it easy to
figure out how to use 3rd party libraries and colleague's code with ease. Type
the name of the class/object, press "dot" and you get a nice overview of the
class's capabilities, including tooltip documentation. A text editor user has
to task switch to the browser for docs all the time. If there are docs. Or
read the source code that is being used.

This means that for relatively simple operations (say, a Point class, a string
operation, etcetera), a text editor user will often find it easier to just
write the damn thing right now. Its easier and more fun that scouring the code
base for something that looks like it. The result is low code reuse.

In conclusion, correct usage of a decent IDE increases code quality, makes
maintenance a blaze and keeps developers happy. Except the first week, when
they're not yet used to the slightly odd UI. But if that holds you back,
you're not a professional, you're a whiner.

I admit that IDEs have most value for statically typed languages (which, for
me, is the strongest case for statically typed languages out there).
Dynamically typed languages basically have the problem that they can't get
decent IDE support, ever.

<sad rant>Which is why the web crowd keeps using TextMate and vi, keeps using
Ruby and Python, and keeps writing increasingly unmaintainable code.</sad
rant>

~~~
SwellJoe
The best code I've ever read was written in emacs. The second best code I've
ever read was written in vi. I can't think of code I've seen written in an IDE
that I considered notably _great_ code.

If the doohickeys your IDE does for you to improve code quality actually do
so, I would expect to see evidence of it.

And, regarding your sad rant...The reason the web crowd (and many others) keep
using those tools (though I don't understand the appeal of TextMate, in a
world with vi and emacs), is because they are more productive with them than
alternatives. One of the best Java developers I've known (famously so, he'd
written some Open Source libraries that were in very widespread use), turned
into one of the best Python programmers I've known nearly overnight when he
got hired by a Python shop. And, while he occasionally lamented the loss of
some of Java's tooling (mostly for testing and coverage and instrumentation of
the running code), he used emacs for both languages.

In short, when I meet a developer that relies on an IDE, I have suspicions
that they may be a cargo cult programmer, rather than the kind of programmer I
want to work with. It may not be true, and I'm sure there are excellent coders
working in IDEs. But, I can't really take your pro-Java/pro-IDE rant
seriously, because I know what happens when good developers get the chance to
work in a better language (of which there are many; Python and Ruby are among
them).

~~~
bmj
So your critique of IDEs is as much about the language as it is the IDE?

As far as your Java programmer, how long did it take him to get emacs in a
state with a similar amount of power as an IDE? I'm thinking about compiling,
debugging, source control integration, code completion and API hints, and so
on? I do a fair amount of C# coding at my day job, and I've tried to work
exclusively in vim, and the productivity hit I take trying to get the
conveniences of an IDE in vim pushes me to just Visual Studio and install vim
emulation.

As far as other text editors go (Sublime, TextMate, Notepad++), aren't the
existence of these just proof that programmers like to build things?

~~~
stonemetal
I would say there are two components to it. Language and project size. Java
and C# where designed with IDE use in mind. I am not sure I would want to work
in either without an IDE. For smaller languages like C and Python an IDE
wouldn't be my first choice of tooling, the cost of using the tool just isn't
worth the benefit provided. I could see switching to an IDE if the project got
a little too large.

~~~
arethuza
C# probably was but I suspect it wasn't a factor in the initial design of Java
- I don't even remember there being any IDEs for the first couple of years of
Java being widely available.

~~~
burgerbrain
I would say that Java was designed to be used with committees. Basically a
language to use if you're in a design by committee situation. IDEs were then
introduced to give individuals their own "virtual design committees".

------
usaar333
I have to say I feel like I'm an oddball here for happily using Eclipse. With
an SSD, it's incredibly fast and features like its static analysis (code
completion and error checking), debugger, and even 'open resource' improve
productivity.

That said for quick scripts I'll just use something like kate or vi, but for a
large project, the IDE greatly simplifies things.

~~~
hello_moto
You're not an oddball.

I use Eclipse heavily with a few plugins: m2eclipse, subclipse, EclEmma (code
coverage), FindBugs (static analysis), and CheckStyle (code rule enforcer).

Being able to navigate the codebase blazingly quick (go to method
implementation, class definition, etc) and get a better overall picture of the
class (Outline provides the list of all methods, constructors, member
variables complete with access modifier) is definitely more productive than
anything else.

------
parbo
I use emacs because then I can learn one thing really well that will work
everywhere. Eclipse is a viable option, except it doesn't work in terminals.

P.S. Vim is ok too. D.S.

------
programminggeek
I'm not a huge fan of IDE's in general, but Eclipse w/emacs+ keybindings is
actually a pretty good compromise on larger projects. It gives you the nicer
feel of navigating the code emacs-style, but you still get all the advanced
features like code completion and refactoring that Eclipse provides.

Also, for Java projects Eclipse w/emacs+ is way nicer than vanilla emacs(at
least for me)

------
phatbyte
What about code debugging ? How do you guys debug code on vim or ST ? prints,
echo, var_dumps?...are you kidding me ?

The main reason I'm still using IDE is mostly because of code debugging and
code browsing. If I could debug code on vim or ST and do code browsing I would
switch in no time.

~~~
udp
gdb? ddd?

I don't compile my code inside vim, so why should I expect to be able to debug
it there?

Learning that the tools don't have to be integrated with each other to be
useful was a major eye-opener for me, after using MSVC for many years.

~~~
hackinthebochs
gdb is terrible compared to a good integrated debugger. Honestly, its
laughable that people try to compare the two. /coming from someone who used
gdb for years

------
nirai
Komodo Edit is a really good Open Source editor I recently stumbled into. It
gets all the basic editing functionality right (and I am saying this as a VIM
user).

For any thing else, I believe the OS is the IDE. An OS is in particular an
integrated development environment. It contains all your favorite tools to get
the job done.

To insist having all the functionality you need stuffed into a single unified
plugin-ed application is like insisting to get the entire web into Facebook -
it sucks.

That said, I recently had a surprisingly pleasant experience developing a C#
project with VS 2010.

------
swinkels
As an avid Emacs user, because I like tinkering my development environment. It
may not always be productive, but it sure can be fun!

Please do not underestimate the long term benefits of tinkering and
discovering new things in the process. For me personally, I noticed that those
kind of activities might not seem productive in a short term, but tend to give
me important insights (and productivity gains) in other areas of my
professional life later on.

------
astrobe_
Why not just use an IDE if you want IDE features? Because Emacs is more
general purpose and more flexible.

------
rjurney
IDEs are slow, and bloated to all hell.

I want an editor that is aware of the language I'm using, syntax highlighting,
remote execution, etc. and any other piecemeal features I add.

But I want the editor to be simple. Hello Textmate.

~~~
Flow
That's exactly why I threw away any hopes about Espresso, Coda and perhaps
even TextMate, to have more than basic non-semantic features and syntax
highlighting. Sure they are pretty and Mac native but I want functionality,
not eye candy.

Maybe I'm too used to VS+Resharper and IntelliJ and don't want to waste my
time reformatting code by hand. With those two editors I can reformat HTML
inter-mixed with Javascript and CSS and even get colored curly waves below
spelling errors and calls to functions that do not exist. They are damn good
tools for a pedant. :)

Being a Lisp fan for many years(programmed quite a lot in CL, owns every cool
book about it), I've come to the conclusion that I think I prefer statically
typed languages, especially those with keywords like "var", "val", "def" etc
so I don't have to type out something twice. Limitations can be good, it stops
me from being too clever "in the small".

Some languages, especially those from Microsoft, are designed to be written in
an IDE. That is not a bad thing IMHO. The amount of insight something like
Resharper gives you is sometimes totally awesome. On several occasions
Resharper has claimed parts of an condition is always true/false, and it's
often not obvious but I've never seen Resharper being wrong on those.

I'm now more pedantic than ever with details.

That said, it's very handy to have TextMate in the Dock and in the command
line path. I've used vim and emacs a lot in the past and like them too.

------
actf
A couple of observations and questions:

I find it interesting that a lot of folks in this discussion seem to accept
that an IDE is advantageous for cases involving a large code base or a
statically typed language. Why is an IDE any less appropriate to use with
dynamically typed languages? A lot of the niceties provided by a good IDE for
statically typed languages are still available for dynamically typed
languages. For me, the case in favor of using an IDE is the same regardless of
the language. The "killer features" an IDE provides are: autocompletion (i.e.
intellisense style) and code analysis as you type. I see no reason an IDE
cannot provide these features in a dynamically typed language.

Serious question, to those of you who believe an IDE is not useful for
dynamically typed languages: Without intellisense like capabilities, how do
you remember everything in the language's standard library and for that matter
any non-standard libraries you use? Looking up a method or property in the
documentation everytime you want to use it seems horribly inefficient. That's
the type of job that is perfectly suited for a computer. It seems incredibly
ironic to me that computer programmers are manually performing steps that a
computer could easily be performing for them. As Albert Einstein said: "Why
should I remember anything if I can just look it up?"

As some background I think Vim is a great editor - I use a Vim plugin in
Visual Studio all the time, and I often use Vim for editing simple files. I
think the addition of omnifunc in version 7 brings Vim a lot closer towards
becoming an IDE. Unfortunately Vim's omnifunc capabilities are limited.
Contrary to what you'd be led to believe by a lot of well meaning folks -
Vim's omnifunc capabilities w.r.t python are nowhere near as capable as the
same functionality found in Visual Studio or Eclipse.

I tried an experiment, wondering if I really was more productive in an IDE,
and timed myself coding the solution to a couple of simple problems, using
python in Visual Studio - I waited two weeks, so the solution was no longer
fresh in my mind, and then coded a solution to the same problem again using
Vim (note that I even gave Vim the benefit of the doubt here by using it
second). For every one of the problems I tested I was significantly more
productive in an IDE - sometimes by a factor as high as 2 or 3 times.
Anecdotally I think the two features that make me so much faster are
intellisense, and code inspection. Having errors appear automatically without
the need to run my code is a huge time saver.

I think in the end it's not really about an IDE - it's about the availability
of good intellisense like features, automatic code inspection, good
refactoring tools, and a good debugger (integrated or not). If those features
are available to me when I'm coding then I'll be happy and productive. If
they're not then the tools I'm using are inadequate. As much as I would like
to use Vim exclusively - unfortunately those features are not available (or do
not work well) for the languages I predominately use (C# and python).

------
derleth
Does anyone here consider Emacs an IDE? Because that's my reason: I can give
Emacs all the specific 'IDE features' (whatever those are... probably
'enterprisey' things) I want and it's still Emacs.

~~~
albertzeyer
Sure. As soon as you have all development features _integrated_ in your
_development_ editor _environment_.

~~~
slowpoke
You're arguing definitions while the grandparent argues features. I do believe
that emacs can be considered on par with an IDE in terms of possible features.
I personally prefer vim, but that's a completely different story.

