On 05/12/2012 08:53 AM, SomeDude wrote:
On Saturday, 12 May 2012 at 06:19:37 UTC, Jonathan M Davis wrote:
I do have to say that I find it somewhat funny that this is your set of
requirements for an IDEA and yet "integrated debugger" is in the "some
'nice
to have' features" section. Doesn't an IDE _have_ to have an integrated
debugger or it's only a code editor (since it lacks the whole
integrated part
of Integrated Development Environment).
- Jonathan M Davis
Indeed, and Timon forgot the best feature of IDEs for bytecode compilers
imho: they compile in the background, so that errors are detected while
you type.
Probably I didn't express myself properly, but this was meant to be
included at the
' - visualization of compilation errors (but please don't nag me)'
point.
There is no annoying "write-correct" cycle as compile-time
errors are shown in real time. That's a *huge* productivity boost.
* When I fail to write code that actually compiles, a few seconds of
additional waiting time seem to be deserved. (it might be a longer time
for eg. C++ though, so there this argument might not apply). If a
programmer usually cannot write code that compiles, what are the chances
that his code will be correct when it is run?
* The write-correct cycle is still there (actually it is a
write-run-correct cycle), because current IDEs only catch trivial errors.
It's actually better than with interpreted or scripted languages,
because once you've finished writing code, it will run !
Basically, with modern IDEs, the productivity with languages like Java/C# is
comparable
to Python.
If I have to develop in Java, emacs or even gedit usually do just fine.
Background compiling shouldn't be too hard to implement for an editor, I
guess: run the compiler in background on the current module every other
second (or only when a set of simple syntaxic conditions like
parentheses/accolades matching are matched, conditions which can easily
be checked by the editor itself), and display the error messages in semi
real time on screen where they appear.
This is too simplistic and very wasteful. The same data will be
processed all over again. I don't know how IDEs manage to make modern
>2GHZ quad-core systems appear slow, but it might well be that kind of
coding.
