Jon said:
One difficulty is that some of the nice things sound *really* picky and
small until you actually use them. Being able to really easily navigate
to a type just by typing in the first few characters of its name (or
the initials, like HWR for HttpWebRequest) doesn't sound terribly
useful - but I do it all the time.
In a very long age ago, I used to write code in the Brief editor. A
co-worker had written some macros and supporting indexer that allowed
quick and easy jumping through the code. References, declarations, etc.
were all indexed, and there was even a macro that would refer to the
source management database and show you the exact check-in and diff
where the line was added or changed.
Of course, compiling was all done via command prompt interface.
"Integrated" was completely off my radar.
The VS browser of earlier versions did something very similar, but not
in nearly so transparent a way as those macros did.
For a variety of reasons, my use of Brief and the related macros fell by
the wayside. At first, I missed those features. But I have to
admit...between having online documentation (unheard of back then) and
things like Intellisense (I see you point about overloads being
displayed in a pop-up versus spinner, but really...just having that
information present is, for me, at least 80% of the battle), I don't
miss them nearly so much today.
So yeah, I can see how the features you're talking about would be
useful. But even VS (which may in fact be one of the less-capable IDEs
out there) comes pretty close, and in some ways is much better than what
I have been used to.
Likewise compile-on-save with a really fast incremental compiler
encourages a different mentality - the difference between a 2 second
build and "it's so quick you don't notice it" is much bigger than it
sounds.
I guess that's one of those "you just have to be there" things, or
something. The other day, I revisited a VS Solution to which I had
added a Setup project. Compiles were taking "forever", but it took me
awhile to figure out that the disk-crunching going on was the Setup
project being built and copying all this data from one place to another
(and of course packaging up the setup.exe file).
By "forever", I'm talking about 10-15 seconds. I used to work on
projects that required hours for a clean build, and oftentimes even
several minutes for an incremental build. Yet, I complain about a build
that takes 10-15 seconds now.
For my smaller projects (and these days, basically everything I do is a
"smaller project"...I've pretty much abandoned my large-team days, for
better or worse), I've got ones that can compile is less than a second,
especially if just doing an incremental build. That _is_ "so quick you
don't notice it".
Even the stuff that can be measured in seconds, I'm just not compiling
often enough for it to be a big deal. Once in awhile I'm in a situation
where I manage to mess something up two or three times in quick
succession, requiring a rapid sequence of recompiles. But most of the
time, I'm spending minutes, if not tens of minutes (or in some cases,
even hours) on design and coding. Spending a few seconds to compile the
latest changes is, for all intents and purposes in my life "so quick you
don't notice it". It's a tiny fraction of the actual time spent writing
software now.
Now, that said...I did download Eclipse, and I will check it out. I'll
be happily surprised if I find that even the things that don't seem like
a big deal to me turn out to be.
One thing which wasn't on the list but I've been missing recently:
local history. Eclipse keeps track of all your changes to a file (for a
limited time, of course). Every time you save, it keeps a snapshot (as
a diff, IIRC). This is much more useful than *just* having version
control in the SCM - there's no need to check in code you're not happy
with, just to make sure that in the process of "fixing" it you don't
break it completely and lose what you have.
Now that I can see as being very useful, especially if Eclipse allows
some control over the lifetime of the diffs. Or at the very least,
preserves the diffs at least as long as the project is open and being
worked on.
Right now, I do a lot of #ifdef-ing for this purpose, so that I can
easily go back to previous version of code if a new idea doesn't work
out, etc. Having the IDE handle this completely for me would be great.
Eclipse concentrates heavily (at least on the Java side) on making the
text editor really, really producive - it doesn't tend to do nearly as
much on the wizard/designer side.
I admit, one of my biggest reasons for loving .NET so much is the
designer features. I've always hated doing UI stuff in Windows, because
it's always so time-intensive and tedious. .NET has greatly reduced the
amount of time I have to spend tweaking UI to get it just right, and has
allowed me to spend relatively more time focused on the underlying
features of the software I'm writing.
Now, obviously this is as much about .NET as it is about a specific IDE.
But inasmuch as VS provides the designer features that really make
this work, I would really miss the lack of those features in another
IDE, at least for .NET stuff.
Anyway, guess I'll see the specifics soon enough. Assuming, of course,
that the Mac version is equivalent to the Windows version.
Pete
