
IDE WTF - omaranto
http://lukepalmer.wordpress.com/2010/10/18/idewtf/
======
alextgordon
There is certainly room for IDEs to improve. But there's no way we can ever
have the level of automation and abstraction that photographers, video editors
and other creatives enjoy.

Take the photo clone tool mentioned. Why does that work? Because human vision
is lossy and forgiving - the difference between 95% correct and 100% correct
is around 5%, depending on how closely the person is looking at it.

Programming on the other hand... code is either 0% correct or 100% correct.
Anything less than 100% correct is _broken_.

Media is also far less complex. How do I know if my video is correct? I simply
play it. If there any errors, they are all possible to detect in the minutes
it takes to play the video.

There will never be an equivalent for code. You can't visualize an arbitrary
algorithm over all its inputs - that's undecidable. It's hard enough to see
what a function in three variables does, let alone quicksort.

The best we can do is have editors for specific tasks. GUI editors, markup
editors, etc. For everything else, code is the only option. We can patch the
awkwardness with better languages and better IDEs, but it will never, ever, go
away.

~~~
seldo
This would be fine if it were obvious to all of us that GUIs have advanced as
far as they can, and the remainder of the problems we see in them were
inherent to the complexity and nondeterministic nature of the systems they
manage.

But it's not like that. My IDE occasionally gets confused and forgets how to
rename a file. Eclipse takes 3 minutes to refresh a source-file tree. People
still use vim and emacs for things! There could be no clearer sign to me that
IDEs are rubbish pieces of software than the fact that people keep falling
back on tools that have barely evolved in 30 years.

~~~
ekiru
vim was released in 1991. emacs did exist 30 years ago, but it's certainly
evolved quite a bit since then.

My personal emacs installation evolves regularly, although I will admit that
it hasn't evolved at all today.

~~~
leot
vi was released in, apparently, 1976. <http://www.linfo.org/vi/history.html>

------
primigenus
We attempted to solve a lot of these problems in our online HTML/CSS/JS
editor/prototyping tool, <http://quplo.com>. We also wrote about our
frustrations with IDEs earlier this year: <http://blog.quplo.com/2010/04/the-
modern-ide-sucks/>

Some things we tried to fix:

\- The file system; you don't need one when you're building an HTML prototype.
Instead you have sheets, where you can organise multiple "files" (URIs,
basically) based around how you want to organise, not how some arbitrary
hierarchy of nested folders wants you to.

\- Code completion; intellisense and other completion usually pops up an
alphabetic list of everything available in the namespace. In the case of CSS,
typing "a" presents you with autocomplete starting with "azimuth". When do you
ever need azimuth? So instead, we built "common sense code completion", where
the likely most-used properties are surfaced at the top of the list. Now,
writing HTML and CSS is mostly a case of pressing tab a lot, and up or down
when you don't want the auto-suggested default.

\- Browser-based; why even write code in a desktop IDE, especially HTML/CSS?
Doing in the browser has so many advantages, such as web browsers' awesome tab
features or, since it's a web app, everything you write being instantly
available online.

\- Collaboration; as a web app, no more checking in and updating. We handle
version management and you just work on your code with your team (long term:
Google-style realtime collaboration?)

There's a lot to improve about today's IDEs. We got started on one specific
for simple HTML development. Someone else should solve this problem for
programming languages.

~~~
nailer
If you change your mind and consider doing Python or Ruby as well as HTML,
count me in as a customer.

------
sofuture
Visual Studio with Resharper does half of the things mentioned in the article.

Some of .Net, LINQ for example, was built _with the IDE in mind_ hence LINQ's
'backward' seeming query syntax (you say what you're querying over up front,
so the IDE can provide typed autocomplete/information).

Even with VS and Resharper, there's still so much that could be done. It's a
massive problem though, I think.

~~~
rayvega
Agreed. With ReSharper, I don't recall a time where syntax was incorrect at
compile time. It immediately indicates any syntax errors at coding time.

However, the inline method/function definition that the OP mentions is
something I have also wanted. The two closest features are:

1) Visual Studio has a 'Code Definition Window'
([http://msdn.microsoft.com/en-
us/library/f5yx24a6%28v=VS.100%...](http://msdn.microsoft.com/en-
us/library/f5yx24a6%28v=VS.100%29.aspx)) that dynamically displays the
contents of a method in a separate window pane. Although it is not inline, at
least you can visually see the code without navigating away from the current
source file.

2) In ReSharper, you can sort of fake it by calling the command 'Inline
Method' and unchecking 'Inline all usages' and then Undo when done inspecting
the code. However, that is a hack with its share of problems. I'd prefer a
feature to toggle the inline method content in a preview mode without actually
modifying any existing code.

~~~
vilya
> However, the inline method/function definition that the OP mentions is
> something I have also wanted.

Eclipse actually does this. If you hover your mouse over a function name, it
will pop up a tooltip showing you the code for the function. I find it
extremely handy - it's one of the things I think I'm really going to miss,
having just given up on Eclipse because of its frustratingly bad performance.

------
lee
It seems like the author forgets that the medium of code IS text. Not
graphics, or sound, or a 3D model... but code is text, and for now text is the
most concise representation of code.

But actually, a textual representation means that you need to rely less on
fancy GUI's to write code. There are also added benefits like ease of search.
If you're using a nice editor like Emacs or Vim, the medium is very easy to
manipulate.

~~~
narag
_It seems like the author forgets that the medium of code IS text._

In fact, it isn't. Code is better defined as a tree. The "impedance mismatch"
of writting a tree using sequential text strings is what makes fragile the
tools that IDEs feature.

That code is seen as text is just a historical accident. I believe most
serious programmers have been beaten by some incomplete implementation of
graphical interfaces and accepted to fall back to good old plain text.

But we are in 2010. This acceptance of this state of matters is very
unfortunate. Specially sad is when the author says that IDEs are no more than
text editors with some extended capabilities. They shouldn't! They should load
the code in all its glorious shape... that by no means is a chunk of text.

~~~
lee
I did say "medium". The form with which we interact with.

Text is the best medium right now. No one's discovered a better method of
representation.

Are you saying we should represent code in a more graphical tree-like way?
Even in that case, you still need text to fill in the tree.

Or are you saying we should program in visio-style diagrams?

~~~
lukev
> Or are you saying we should program in visio-style diagrams?

Yes. It _should_ be possible to develop an interface that is actually faster
and cleaner to program in than text. I'd love to see what touch interfaces can
do in this regard.

It's never been done, granted. But it should be possible. I hope developers
aren't dissuaded from attempting graphical programming interfaces just because
everything that has existed up to now has sucked.

~~~
jerf
Syntax highlighting is pretty much it. Adding much more would blow out our
ability to handle complexity and just be too busy on the screen for anything
to make sense.

Go look at a language parser sometime; we've actually put a _lot_ of work in
any production-ready language into that "low tech" text interface. The tree
approach is useful for macro writing, and if you don't know Lisp maybe you
should go check one out, but I'm very unconvinced there's a better way to
actually interact with the code even in theory. It may be visually
unimpressive but it's actually incredibly, incredibly sophisticated under the
hood. If it's good enough for human speech, it's more than good enough for
programming.

~~~
lukev
Yes, I love lisp - I'm a huge Clojure buff. And that's exactly what makes me
think a graphical programming interface _could_ be done well. As languages get
more lisp-like, it seems as if they would become _more_ conducive to a
graphical programming environment.

I imagine looking at something that looks a lot like lisp - it shows the high-
level structure of the code as a tree. But it could allows me to change the
level of abstraction I'm viewing on the fly. Also, it could reveal (or hide,
at my preference) lots of metadata about the code... is it pure, is it
stateful, is it parallel, etc.

In essence, it allows you to look at your code as an n-dimensional entity
instead of a 2 dimensional file.

Basically, I'd like to see what happens when you decouple the code from its
presentation. Then, you can choose alternate presentations (including plain
text!) depending on the task at hand.

------
seldo
I could not agree more.

Given that IDEs are the primary tools of programmers, and unlike Photoshop
users our primary skill is to build software itself, why are IDEs not the most
advanced pieces of software that exist? It seems logical. They have the most
advanced users; they don't need to worry about scaring the kids at home. They
should be constantly adopting the latest and greatest in performance and UX.

Instead we have vim and emacs which, beloved as they are, still have as their
primary interface a grid of characters -- not just the code itself, but the
_user interface_. It's like nothing has changed in terms of the graphical
output capabilities of computers since the late 1970s. (And yes, there are
WIMP versions, which add drop-down menus. But the primary interface mechanism
is still keyboard shortcuts.)

Then there is the beast called Eclipse. It certainly _seems_ like it should be
able to do everything in the world, certainly the download takes long enough
and there are enough configuration options. Yet it is buggy, its plugin
architecture is a conflicting mess, and its performance is so abysmal that
frustrated coders return to vim and emacs so they can get something done.

Version control -- a _critical_ function for all modern programmers -- is
still largely handled on the command line. Maybe, if you're lucky, you get a
side-by-side comparison in Eclipse (but not for git, yet!), but as far as
tagging and branching goes, graphical representations are out. WTF?

I'm so glad to see this article, because I have spent so long in the company
of programmers who hear me ranting about IDEs and just tell me to "use vim",
as if that were the problem.

~~~
miloshh
> Then there is the beast called Eclipse. It certainly seems like it should be
> able to do everything in the world... Yet it is buggy, its plugin
> architecture is a conflicting mess, and its performance is so abysmal...

I have used Eclipse for many years with multiple languages, and none of this
is quite true. There is a bit of a learning curve, where you have to learn not
to do some things that break it. :) But that just takes a few hours, and a bit
of patience - after that you have many months of happy coding, where it just
works...

~~~
tjr
I used Eclipse daily for about two years, along with an internal C code
plugin. I'm not sure which I can attribute to Eclipse and which I can
attribute to the plugin, but my Eclipse workspaces were frequently getting
randomly corrupted, global search-and-replace was not trustworthy, and for a
while it was running so unstable overall that there were times I could launch
Eclipse, load my workspace, and within a few minutes of just sitting there it
would crash. This was running on Windows XP.

So I tried Eclipse at home on my Mac. I saw that it came with a utility for
auto-packaging Java programs into OS X bundles. I made a simple Java Swing
"Hello World" program and tried the bundle utility. It didn't work. I tried a
few more times, and it never worked, but in fact got progressively worse in
its output. Uninstall.

Some months later I thought I'd try Eclipse on the Mac again; surely it had
improved. So I downloaded it again, created a new project, clicked through to
add a new source code file and I got an error, that it could not create a new
file.

I'm guessing that my experiences must be abnormal, since Eclipse is so hugely
popular, but I now avoid it whenever I possibly can.

~~~
jsvaughan
Yes, your experiences are extremely abnormal. I've used Eclipse extensively (I
think since 2002 or so) and apart from the very early days I have never had a
corrupted workspace, I have never ever had a problem with inconsistent search
results and I can't remember an occurrence of it crashing (unless you count an
out of memory, which is just from bad config).

------
ynniv
Adobe has probably made billions of dollars on Photoshop, and has thousands of
people working on improving interaction with a regular grid of color values.
This is a high profit, low complexity situation. Most developers are not
willing to spend $700 on an editor, and the gamut of programming language
source code syntaxes is too broad for a single editor to work uniformly across
them. But really, comparing anything to Photoshop is silly.

Some music sequencing programs will in fact allow you to create measures with
the wrong number of beats, and have annoying, unproductive interfaces.
Premiere is actually really annoying to work with, which sent a lot of people
over to Final Cut. Even extremely similar programs like Adobe Illustrator are
fraught with miserable design and crappy storage formats.

The OP has valid points, but these apply to most software, and not just IDE's.

~~~
jasonkester
I'd spend $700 on a truly good IDE, and so should any programmer capable of
doing simple arithmetic. Calculate how much more productive you can be using
the best tools available, then figure out how many hours at your bill rate it
will take to make back that investment.

For something like IntelliJ ($$$, but awesome) versus Eclipse (free, but
crap), most people will find that they break even in less than a week.
Assuming you expect your programming career to be longer than that, it's not a
tough decision to make.

~~~
ynniv
A few programmers will pay a lot of money, but most programmers seem to be
uninterested in paying more than $70. Compared this to photographers, who will
almost universally pay $700. The market is much larger.

~~~
adbachman
I worked for a large manufacturing / consumer product company as a .NET
developer and the four people on my team all had top level MSDN subscriptions.
( <http://msdn.microsoft.com/en-us/subscriptions/buy.aspx> )

I think the number I heard for our team, just MSDN subscriptions, was around
$25000 a year.

~~~
ynniv
That's only like 35 copies of Photoshop. Not to downplay the money you spent,
but the market for Visual Studio is smaller than Photoshop. Also, the customer
of Visual Studio is team leads and management, not actual users. This might
explain why more expensive VS packages emphasize collaboration and team
features.

~~~
jasonkester
VS.NET is something of a special case, since Microsoft would like nothing more
than to give it away for free. They don't, because if they did it would make
toolmakers like ReSharper and CodeSmith seem unjustifiably expensive.

If you're a small shop, you can get in thru BizSpark and get a pack of MSDN
licenses big enough for your whole team for something like $400, all in.

So sure, you can pay $2500/copy retail if you're big enough to do so. Or if
you're small, you can pay peanuts. Say what you want about Microsoft, but they
go out of their way to take care of their developers.

~~~
ynniv
Another great reason why selling a premium IDE is difficult.

------
dstorrs
====QUOTE

How come I can still have syntax errors? How come it is ever possible to have
a syntax error in a program? Shouldn’t the IDE at least be helping me to have
a valid program all the time? Finale doesn’t let you write a measure with the
wrong number of beats and then complain when you push play. It just fixes it
for you — “oh look, you need a rest there.”

====/QUOTE

Oh Luke Palmer, no.

NO. The absolute last thing I want from my editor is for it to be modifying
the code without my explicit request. Then if something breaks, I need to
worry about whether I broke it or whether the editor broke it. (And yes, yes,
I know, the compiler "modifies my code", blah blah.)

------
charlief
I think it is a case of apples and oranges here. Yes we need to make progress
on IDEs, and of course we can borrow inspiration from many sources. I've used
every application the author has mentioned: Photoshop, Premiere, Maya,
AutoCAD, ProTools, Finale, Reason, PageMaker, and the reasons the tools
succeed have more to do with the necessities dictated by the media you are
editing rather than some kind of profound innovation.

------
gosub
If I remember correctly, in one of the SICP video lecture, Hal Abelson says
that s-exprs are equivalent to the the syntax tree of the program and, given a
graphical interface, we would be manipulating this tree directly. AppInventor
for Android is the most similar thing we have today, and not surprisingly it's
based on Kawa scheme. It would be a very powerful mode of code editing, if it
wasn't centered around click and drag operations (and limited to android). I
think that a modal editor ala VIM, paired with a graphical code-block
environment and fuzzy text autocompletion, would be a nearly perfect IDE.

------
gurraman
I'm perfectly happy with the tools I use when programming.

The tools I use to manipulate images and photos on the other hand... they're
big and clunky, force me to use constipated shortcuts, are tedious to install,
cannot be run remotely (well, effectively), they crash and aren't that easy
for me to extend.

I'm, sort of, working on the opposite problem: I'm tossing a few hours towards
a way to manipulate images without the "IDE".

~~~
Tyr42
How about things like ImageMagick?[1] Command line or from a programming
language. No IDE at all. I've used it in the past, and it's useful for batch
operations.

[1]<http://www.imagemagick.org/>

------
JesseAldridge
My first guess was that the programming market was just too small for
commercial tools to make a profit. But that doesn't seem to be the case.

"Graphic designers held about 286,100 jobs in 2008."

<http://www.bls.gov/oco/ocos090.htm>

"Computer software engineers and computer programmers held about 1.3 million
jobs in 2008."

<http://www.bls.gov/oco/ocos303.htm>

So now I'm thinking the main problem is that it's hard to compete with open
source. There are just so many good-enough open source programming tools out
there. Commercial tools not only have to better than the open source stuff,
they have to be _way_ better. This is because of all the costs involved with
adopting a new IDE: Not just the price of the software, but the time spent
learning a new environment and getting it configured right are significant
time investments.

So open source eats away at the margins of commercial tools, which leads to
less people working on commercial tools, which drives more people to the open
source incumbents, etc.

I believe pg says open source is bad at design. That seems right to me. Open
source is good at copying existing tools, but not so good at innovating. So we
end up at a local maxima where all programming tools are decent, but not
great.

------
agscala
The author really is understating the power of things we already have, Visual
Studio and Emacs in particular (and I suppose he would clump Vim in as well).
While they aren't the holy grail of syntax checkers, they are still extremely
well tuned tools for creating software.

~~~
jlongster
Agreed. I'll throw in my vote for Emacs; you can get very far with
autocompletion (M-/) and tags. Autocompletion will complete the word you are
typing with other words from all your open buffers, and it works 95% of the
time. Tags allow you to jump to definitions easily.

The way Emacs implements these are so dumb but in reality they work great, and
it's all really fast. The problem with large IDEs is they can be really slow
if they are having to constantly analyze large codebases.

------
br1
The author overestimates the quality of designer tools.

~~~
torme
Agreed, as an occasional user of After Effects, I can state with certainty
that buggy software in media editing definitely exists.

------
sedachv
Haha, only yesterday I mentioned Interlisp sedit on HN. Welcome to the world
of the 1970s: <http://en.wikipedia.org/wiki/Structure_editor>

There's a reason these things weren't all that popular.

~~~
sedachv
Oh boy, and who could forget DWIM. I'm sure if the concept of refactoring
existed back then (it didn't; apparently L Peter Deutsch would just throw out
your code and start again if he didn't like it) there would be some really
cool tools for that too.

~~~
sedachv
Classic:
[http://docs.google.com/viewer?a=v&q=cache:o4niyIQ6_O8J:w...](http://docs.google.com/viewer?a=v&q=cache:o4niyIQ6_O8J:www.softwarepreservation.org/projects/LISP/interlisp/Teitelman-
FCJJ1972.pdf+programmers+assistant&hl=en&gl=ca&pid=bl&srcid=ADGEEShJgKd9Srkt1d1ks_l5JJIQe7Hf4KtT_GVHoHPhmL3MShAYgqrRCr1t1WXoOhg2wa65I7aN244UFvbWAhvJL2IKv0lVTEjSCNGKhWoPVxvniC-
gc3go5S7uduKgcMNQrFSGvxYH&sig=AHIEtbT8xcDYio5z9BYceJ7o0c5FXsds4A)

For all the hating, automating programming is an obvious thing to do (the idea
is both trivial and quite profound:
<http://news.ycombinator.com/item?id=645338>), and there are some really cool
ideas there (reversible debugging being one).

------
st3fan
"At least I’ve heard IntelliJ IDEA is great, I’ve never used it." & "How come
I can still have syntax errors?"

Well, I think you answered your own question dude.

------
dtf
Some creative apps are dataflow systems. Dataflow maps very well to GUIs and
intelligent tools. For the parts which aren't dataflow, you end up with the
same manual labour that you have in code editing.

Video editing, for instance, is quite similar to code editing. Juggling large
libraries of assets, trying to make things fit together on the level of
details and taste while maintaining an intelligible and manageable whole and
keeping to a deadline. You have tools to help you keep track of things, but
you're still mostly on your own.

------
ghempton
It's funny, when I use the programs he mentions, I always wish I had some code
to manipulate rather than use some esoteric GUI.

------
aufreak3
My personal IDE wish list below (some simple, some not so, and necessarily
incomplete) -

1\. Copy-paste abstraction - When you copy a snippet from one part to another,
automatically lift it out as a function first. If it can't be abstracted for
some reason, alert!

2\. Path finder - I have A,B,C and I want to get X,Y,Z. Find me a path through
the libraries please. We created Prolog. Can we use it for this? Even guesses
are useful. Hoogle is a start (thanks Curry and Howard!). The ABCXYZ can be
abstract descriptions like type, or example data.

3\. Debugger time travel - move back and forth in time freely, allowing code
modification. Me got tons of RAM+disk for history and branching. .. and why
can't something get unwritten from a file?

4\. Breaking news - when I modify a function that could break something else,
tell me now.

5\. Link function arguments to in-source example data for testing and
exploration. I love to start with data first _before_ writing anything.

6\. Embed images and live code snippets as documentation. Ever drew ascii
diagrams in source code? Mathematica notebooks have solved this and more
already.

7\. Function grapher - select an expression and show as graph. At least what
"Grapher" on MacOSX provides. The IDE should know basic mathematics - like
mathematica.

8\. (extension of 7) Design at least simple functions graphically.

9\. Spell check myIdentifierNames dammit!

~~~
stevejohnson
Currently working on (4) from the SCM angle. My buddy and I have been lazy
bloggers, but we're still coding.

<http://timunionsteve.posterous.com/>

------
fish2000
Ah, the grass is always greener.

The adobe tools mentioned are excellent for what they do, but they are never
without interface quirks that can range from mildly irritating to bizarre -- I
have consistently found the Edit Styles box in InDesign to work
counterintuitively in small ways, like forgetting that I checked 'preview' or
overwriting my edits if a dropdown has been incorrectly fiddled with.

Adobe stuff also completely lacks decent version control. "Version Cue" is
pretty clunky and has no conception of diff-ing. If I make edits to the story
in an InDesign file and replace 3 FPO images with real ones, why can't I have
a repository I can browse, in which I can see an awesome and self-explanatory
visualization of these changes? Maybe you need InCopy servers for something
like that but I don't think that's a feature they have.

Contrastingly, with the latest XCode preview, versioning was almost seamless
and very nice to work with. After installing the XCode preview, I was able to
check out a project from GitHub, run it, edit it, and commit the changes, with
a lovely two-pane view of the diff in question when committing, showing
additions and deletions. I didn't have to think about it at all -- it was only
"almost" seamless as I had to manually do 'git push', which I'm sure they'll
fix that in the final release.

You can do scripting with JavaScript inside the Adobe apps, but it's slow and
the API takes some considerable getting-used-to. Some things most programmers
would consider scriptable are not: I'd love to be able to bust out a regex or
some conditional logic when building a Photoshop automation, for example; the
current interface for that feels condescending and ridiculous if you're coming
from TextMate or emacs.

Always greener. I'm just sayin.

------
akkartik
He's focusing on tool support (for manipulating representations of code), but
languages (representations) could do with improvement as well.

Or perhaps you could think about both together. How would you coevolve a
language with tools? If you could make assumptions about the tools people
have, how would that change the language?

Ah, that's just smalltalk. Done.

------
apl
I'd rather spend my working life in Emacs than in Photoshop, but I guess just
as anything else, UI preferences differ.

------
brudgers
Oddly, I have been thinking exactly the opposite - what aspects of IDE's are
missing from graphics programs.

Among the features of IDE's that programs like AutoCAD and Photoshop lack are
continuous error checking and validation. They provide little feedback
regarding proper document organization or standards and specifications
compliance as part of a typical work flow.

In addition, some IDE's offer direct visual feedback regarding user interface
design along the same lines (though not necessarily to the same degree) as
graphics software.

edit: I'm not saying that these features are impossible to implement, rather
that implementing them is not feasible for the typical user(victim).

------
jasonkester
Any other VS.NET/ReSharper folks get halfway through his list of things that
IDEs don't do, quietly noting that our IDE does in fact do them, then quit
reading?

That's one of the big benefits of a compiled language like C#. The IDE can be
continuously background-compiling, making things like Refactor/Rename work
like the author wishes it would instead of replacing strings. Same with Find
Usages, Find Declaration, and Automatically Import the Stuff I Need.

Every time I wander off into Ruby or Python, I end up coming back a little bit
sad. Such nice languages, but the tools just can't hang.

~~~
someone_here
Which brings up a good point: Where are the Javascript IDEs?

~~~
sireat
This might sound heretical, but I find that current Eclipse 3.6 for Javascript
is not bad at all. [http://www.eclipse.org/downloads/packages/eclipse-ide-
javasc...](http://www.eclipse.org/downloads/packages/eclipse-ide-javascript-
web-developers/heliossr1)

Since hard drive space is cheap, I have different Eclipse installations for
each language I use. This seems to cut down on plugin hell and slowdowns that
people often complain about.

I can't comment on how good Eclipse is actually for web development, but for
embedded Javascript scripting it works splendidly. Most precisely, it lets me
zoom in and out of abstractions in a large project with multiple files with
ease.

~~~
someone_here
Does it have properties and method autocomplete?

------
skoni
The Code Bubbles Project is an attempt to rethink the UI of IDEs:

<http://www.cs.brown.edu/people/acb/codebubbles_site.htm>

------
msmith
I really wonder how much time the author has spent with a modern IDE like
Eclipse. For Java development, it really does have all of the features on his
wish list, or something equivalent.

~~~
gb
That was my thought too, Eclipse JDT at least is pretty impressive, some of
the other plugins not so much. I was surprised to see IntelliJ mentioned as
supposedly good too, I wouldn't say it's terrible, but I find it somewhat
lacking in comparison to JDT.

------
lelele
Why do you complain about IDEs when most popular languages are Java, C, C++,
ecc.? (see
[http://www.tiobe.com/index.php/content/paperinfo/tpci/index....](http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html))

IDEs can't be better than languages they deal with, because languages shape
the way programmers think. Clunky languages call for clunky IDEs.

------
stcredzero
_but languages are written in text and IDEs are basically text editors with a
few extra features._

Not necessarily. The text editor features of most Smalltalk IDEs were pretty
gimpy, but the text editing was _never_ the exciting part! It's the whole
environment being like iPython on steroids everywhere and all the time.

------
dgallagher
Per Apple, Xcode 4 will have a feature that auto-fixes certain coding
mistakes, like missing semi-colons:

[http://developer.apple.com/technologies/tools/whats-
new.html...](http://developer.apple.com/technologies/tools/whats-new.html#fix-
it)

------
doki_pen
I've worked on java projects in both vi and eclipse. While ramp up on larger
projects generally takes longer in vi, I feel like the payoff is worth it.
What eclipse does for you in suggesting classes become memory muscle pretty
quickly in vi. At which point, eclipses slowness is just crippling. If someone
could make an IDE that was fast, and could figure out the project completely
from my build tool without nudging, I might enjoy it. I just don't see how a
more feature rich IDE is going to be faster and less buggy.

~~~
jsvaughan
How do you do refactoring in vi? Do you really search and replace?

~~~
doki_pen
Yes. It depends on the case, but sed, awk and grep are also useful.

------
jeffffff
a lot of it has to do with programmers bitching about bad programs way more
than users of those other programs. he has obviously never used protools or
any audio editing program. protools is one of the best out there, but it is
still awful, as are the rest of them. it took digidesign almost a year to add
support for leopard and then they charged $150 for the update.

------
shelfu
"At least I’ve heard IntelliJ IDEA is great, I’ve never used it."

That's like complaining about image manipulation software when all you've used
is GIMP.

I'm a vim guy from way back, I always avoided big IDEs because of the bloat.
IDEA is the first I've tried where the IDE doesn't feel like it's getting in
the way, and actually makes the job easier.

~~~
bokchoi
And the IdeaVIM plugin isn't half bad either.

------
twymer
_"click a little [+] next to predict(p) and see it right there inline, with
its argument replaced by p? Oh, that’s how that works, cool, [-]."_

While I like this idea, I fail to see how having to use my mouse to navigate
to and click the +/- would be more useful than using a keyboard shortcut to
jump to definition..

~~~
crc32
I also think I would find this "inlining" quite confusing in an OOP language,
where the "predict" method was a member of an object instance, containing code
that referenced this/self.

------
spektom
> How come I can still have syntax errors?

Google's App Inventor prevents you from making syntax errors, since you use
code blocks instead of writing source code. Actually, if you use code
templates that any modern IDE has, it helps you to avoid most syntax errors as
well...

------
mindcreek
just learn to use a good text editor like emacs or vim, I use emacs and it
fits me like glow whatever text based activity I am currently engaging at that
moment.

And yes there can be better IDEs but I wont be using them.

------
points
I don't think it's a good comparison. And the author just comes across as
"wah! programming is hard! _sob_ ".

