Missaka Wijekoon skrev:
Hi, Missaka,
This sort of question always sounds contentious, but I'm just
interested: do you have a documentation to this effect?
I'd be keen to see some real-world figures of using one IDE over
another (or none at all).
I can't actually give hard numbers, but I can list a few features I
would have liked back in University.
* Continuous compilation: At best, when you clicked "go", your IDE or
ANT task would recompile the whole project then and there, forcing you to
wait a bit. At worst, you were compiling manually from the command line (or
using ANT), and when your program behaved erratically, you asked yourself
"Did I remember to recompile?"
* Source code navigation: You see a method call, and you'd really like
to peer inside it's code. In the old days, you essentially search through
the entire class hierarchy, 'cause you never know where a method might have
been defined, or when it might have gotten overloaded.
* Error highlighting: In the old days, you'd try to compile and see some
error messages. You'd read the first one, and fix it, and then recompile.
Why? Because the other messages might have been spurrious errors caused by
the first one (especially if the first one was a syntax error). Now, errors
are underlined, and as soon as you fix one and save, the file is
automatically recompiled, and the new errors are shown.
* Refactoring: This is a very general one. Refactoring used to be
tedious and error prone (especially if you didn't have error highlighting).
It was difficult to remember all the small changes you had to make. Now it's
two or three clicks, and it's done.
There are many others, but these are the ones I'm sure most Eclipse
users use every day.
Then there's stuff that's probably relatively specific to my company. We
exploit the fact that Eclipse is highly extensible a lot, and have some very
powerful plugins. I wrote the front end to a COBOL 85 compiler "manually" (I
used generators like JavaCC and JTB, but not our homebrewed Eclipse plugin,
'cause it wasn't developped enough yet), and it took me about 2 months to
finish. It was just a lot of tedious coding involving dealing with every
keyword in COBOL (of which there are a lot). The "difficult" part could be
isolated into a few small modules. Because I developped it over 2 months,
the style and API is inconsistent: over time, I found better ways to do
something, or found out that I needed some methods to be more general, etc.
When our plugin was ready, I spent about a week writing code in our
proprietary language, clicked a button, and another COBOL 85 compiler front
end was generated, having all the same features of the original one, except
now the API and style was completely consistent (since it was all described
over the course of a few days instead of months).
Now less than 3% of our Java code (measured by filesize) is written by
humans.
We've got several compiler front-ends right now; for Java 1.4 (i.e. no
generics support yet), C, C# 1.0, COBOL 85, SQL, etc. and we will
occasionally want to make architectural changes to all of them. For example,
we were using the (vanilla) Visitor pattern to go through the ASTs and
perform computations on them. We decided to scrapped the visitors, and go
with a hybrid of the "Guide" pattern and the "Visitor Combinator" pattern.
Normally this would be a monstrous task. We're essentially rewriting the
core components of every compiler for every language we support! But with
our plugin, it's just a matter of changing a handful of Java classes (20 at
the most), perhaps change our templating language a bit, click the "go"
button, and all the compilers will be regenerated using the new design
pattern.
The Eclipse team describes Eclipse not only as an IDE, but as a
platform. We've taken that idea and ran with it. We don't just code using
Eclipse; we write tools custom-tailed and specifically designed to solve the
problems that WE are facing. In that sense, Eclipse is a meta-tool that
allows us to create the tools that bring us about a 8x savings in time, and
a 33x savings in codebase size (which reduces maintenance costs).
- Oliver
