Emacs vs GPS vs Eclipse, Ada vs Lisp vs Lua vs Java

[Stephen Leake <stephen_leake@stephe-leake.org>]

Per Sandberg <per.sandberg@bredband.net> writes:

> I dropped emacs and "emacs Ada-mode" several years ago  and the main
> reason was that that environment where only toys compared to the power
> of the .gpr-files in combination with GPS.

Perhaps you should try again; Emacs Ada-mode now parses .gpr files to get
the required info.

On the other hand, perhaps I should try GPS again; it's been a few
years. My last impression was that it was a toy compared to Emacs :).

.gpr files are more important to the compiler than to the IDE.

> However on win32 I count:
>  "notepad" as a great editor to write 2 line batch scripts in
> and
>  ".bat" as a great language as long as the file is less then 5 lines.

and doesn't do anything useful.

> I think emacs is great in a much larger scope and it is a very
> powerful tool.

Ok.

> But when the task is to produce larger systems in Ada, I haven't seen
> anything that is even comparable with the combination .gpr-files and
> GPS, and it works fine for "hello_world" as well.

Since Emacs does .gpr, what is left in GPS that is so much better?

Last I checked, GPS doesn't do VHDL, LaTeX, Maxima, Matlab, bash mode,
make mode, monotone, read/send mail; all tools I need in my integrated
development environment. I even need C++ for monotone, but I assume GPS
does that.

I understand the Ada navigation is slightly better in GPS. I haven't
tried it, so I don't miss it.

I haven't tried customizing GPS. I have customized Emacs extensively;
for example, I've significantly improved the monotone front-end.

Hmm. I assume it would not be too hard to teach GPS to colorize VHDL;
adding intelligent indentation is probably harder (is it possible
without writing Ada for GPS? maybe it has been done). To be fair, the
intelligent indentation for Ada in Emacs is the hairiest code I have
every seen.

It might even be possible to build a vhdl.xml for gprbuild to run the
VHDL toolchain. Is there another way to teach GPS to run a toolchain?

If GPS could integrate the gtkwave viewer for VHDL debugging, that would
be great; it's run as a separate process from Emacs.

My understanding is that to add something like the monotone front-end in
GPS requires writing Ada code, which requires compiling, linking, and
restarting GPS for each modification.

In Emacs, the monotone front-end is in elisp, where each subroutine can
be edited and loaded without restarting Emacs, and each variable can be
set on the fly. There is an interactive debugger for stepping thru the
elisp. Once it is debugged, it can be batch compiled for faster
execution.

For most applications, I pick Ada hands down over Lisp. But for user
interface GUIs, a dynamically loaded interpreted/debugged environment is
_much_ better. So I stick with elisp for that.

If GPS can do dynamically loaded Ada with source-code debugging, that
would be a huge selling point. But I suspect the technical requirements
of such an environment require a much simpler language like Lisp.

Lua might work in such an environment; it's better than Lisp, not as
good as Ada. monotone uses Lua as a user customization language.

Apparently Java is used this way in Eclipse; does that have source-code
debugging for dynamically loaded subprograms?

-- 
-- Stephe