IDE's that support ADA

IDE's that support ADA

[nathandsash]

I know that Vi/Vim and Emacs and other programming environments support ADA programming, but how about any modern-day IDE's like Visual Studio for instance?

Re: IDE's that support ADA

[Martyn Pike]

On 26/10/2014 18:34, nathandsash@gmail.com wrote:
> I know that Vi/Vim and Emacs and other programming environments support ADA programming, but how about any modern-day IDE's like Visual Studio for instance?
>

Sure - take a look at

http://libre.adacore.com/tools/gps/
http://libre.adacore.com/tools/gnatbench/

Martyn

Re: IDE's that support ADA

[Niklas Holsti]

On 14-10-26 20:34 , nathandsash@gmail.com wrote:
> I know that Vi/Vim and Emacs and other programming
> environments support ADA programming, but how about any
> modern-day IDE's like Visual Studio for instance?

AdaCore, the company providing the professional and GPL versions of the
GNAT Ada compiler, also provide an IDE called GPS -- comparable to other
"modern" IDEs, IMO, and with several Ada- and GNAT-specific features --
and a plug-in for Eclipse, which I haven't used.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: IDE's that support ADA

[rriehle]

On Sunday, October 26, 2014 12:02:51 PM UTC-7, Niklas Holsti wrote:
> On 14-10-26 20:34 , nathandsash@gmail.com wrote:
> > I know that Vi/Vim and Emacs and other programming
> > environments support ADA programming, but how about any
> > modern-day IDE's like Visual Studio for instance?
> 
> AdaCore, the company providing the professional and GPL versions of the
> GNAT Ada compiler, also provide an IDE called GPS -- comparable to other
> "modern" IDEs, IMO, and with several Ada- and GNAT-specific features --
> and a plug-in for Eclipse, which I haven't used.
> 
> -- 
> Niklas Holsti
> Tidorum Ltd
> niklas holsti tidorum fi
>       .      @       .
For writing Ada code in my classroom, I still use AdaGide.   It is quick and easy, I can enlarge the font on-the-fly with ease, and there is no fooling around with creating projects, etc.  I just write the code, compile it, and execute with no overhead activity.   

BTW, for those who do not know, I retired from my professor-ship at the Naval Postgraduate School (NPS) a couple of years ago, my second attempt at retirement (the first being retirement from AdaWorks).  Right after retiring from NPS (where Ada has become an anathema), I was asked to teach software engineering classes part-time at a small private school in San Jose, Ca.  I am also teaching a class called Programming Paradigms, and I make it a point to include Ada as one of the programming languages in that course.  

The students are usually amazed to see such things as Design by Contract in a language, along with some of the other unique features of the language.  We only have six hours out of the total of 45 hours of classroom discussion for Ada, but at least they get a taste of it.  

In addition, Ed Colbert is now charged with updating Ada Distilled.  I hope he will be able to complete the updates.  I am making some contributions to the new edition, and hope to include a software engineering chapter for it.

Richard Riehle, PhD, International Technological University, San Jose, CA.

Re: IDE's that support ADA

[David Botton]

> For writing Ada code in my classroom, I still use AdaGide.

I used it to develop most of my early Ada software when I was still using Windows. Was great.

> In addition, Ed Colbert is now charged with updating Ada Distilled.  I hope he will be able to complete the updates.  I am making some contributions to the new edition, and hope to include a software engineering chapter for it.

It was great news when I heard. I am a huge fan of your work and using it in the course work I am putting together for an introduction to Ada for Business systems to promote with Ada and Gnoga.

David Botton

Re: IDE's that support ADA

[David Botton]

On Sunday, October 26, 2014 2:34:06 PM UTC-4,   wrote:
> I know that Vi/Vim and Emacs and other programming environments support ADA programming, but how about any modern-day IDE's like Visual Studio for instance?

Just about any environment that supports TextMate extensions (TextMate, Atom, Ace) or on Mac SubEthaedit's extensions (like SubEthaEdit, Code, etc) will support Ada and offer a number of support features.

GPS (available in all the GNAT-GPL packages) is currently the only environment that offers code completion based on semantics that I know of.

David Botton

Re: IDE's that support ADA

[Robert Love]

On 2014-10-26 21:33:50 +0000, David Botton said:

> On Sunday, October 26, 2014 2:34:06 PM UTC-4,   wrote:
>> I know that Vi/Vim and Emacs and other programming environments support 
>> ADA programming, but how about any modern-day IDE's like Visual Studio 
>> for instance?
> 
> Just about any environment that supports TextMate extensions (TextMate, 
> Atom, Ace) or on Mac SubEthaedit's extensions (like SubEthaEdit, Code, 
> etc) will support Ada and offer a number of support features.
> 
> GPS (available in all the GNAT-GPL packages) is currently the only 
> environment that offers code completion based on semantics that I know 
> of.
> 
> David Botton

You mean  more than just syntax highlighting?  What extension 
specifically do you refer to?  Thanks in advance.

Re: IDE's that support ADA

[David Botton]

> You mean  more than just syntax highlighting?  What extension 
> specifically do you refer to?  Thanks in advance.

As mentioned, semantically aware code completion, in particular for tagged types.

David Botton

Re: IDE's that support ADA

[Wesley Pan]

On Tuesday, October 28, 2014 6:58:23 PM UTC-7, David Botton wrote:
> > You mean  more than just syntax highlighting?  What extension 
> > specifically do you refer to?  Thanks in advance.
> 
> As mentioned, semantically aware code completion, in particular for tagged types.
> 
> David Botton

These Emacs extensions might help:
- Auto-Complete: https://github.com/auto-complete/auto-complete
- YASnippet: https://github.com/capitaomorte/yasnippet 

Re: IDE's that support ADA

[Stephen Leake]

nathandsash@gmail.com writes:

> I know that Vi/Vim and Emacs and other programming environments
> support ADA programming, but how about any modern-day IDE's like
> Visual Studio for instance?

Interesting. The latest version of Emacs was released 20 Oct 2014. In
what sense is it not "modern"?

What does Visual Studio have that you believe Emacs doesn't have, that
you find useful? It is often somewhat difficult to find and turn on
various features in Emacs.

I maintain Ada mode for Emacs; I'm looking ideas about for what needs
improving. 

The main thing I like about Emacs is you can customize it to do
_exactly_ what you want; no compromises :).

-- 
-- Stephe

Re: IDE's that support ADA

[Peter Chapin]

On Tue, 28 Oct 2014, Stephen Leake wrote:

> Interesting. The latest version of Emacs was released 20 Oct 2014. In 
> what sense is it not "modern"?
>
> What does Visual Studio have that you believe Emacs doesn't have, that 
> you find useful? It is often somewhat difficult to find and turn on 
> various features in Emacs.

Typical features of modern IDEs include: displaying semantic errors (type 
errors, etc) as you type, refactoring support, integrated debugging, and 
code completion along with display of associated documentation. Many IDEs 
also facilitate test case generation and profiling. In the Ada world there 
is integration with SPARK (for example as GPS does).

Emacs is powerful and may well be able to do some or all of these things. 
Indeed, there is a Scala extension for Emacs that goes a long way in this 
direction. I believe it works by interacting directly with the Scala 
compiler behind the scenes.

Peter

Re: IDE's that support ADA

[Stephen Leake]

Peter Chapin <PChapin@vtc.vsc.edu> writes:

> On Tue, 28 Oct 2014, Stephen Leake wrote:
>
>> Interesting. The latest version of Emacs was released 20 Oct 2014.
>> In what sense is it not "modern"?
>>
>> What does Visual Studio have that you believe Emacs doesn't have,
>> that you find useful? It is often somewhat difficult to find and
>> turn on various features in Emacs.
>
> Typical features of modern IDEs include: displaying semantic errors
> (type errors, etc) as you type, 

Meaning it attempts to parse the syntax after typing every character? So
if you start typing 'if ... then ... else .. end if', you get errors
until you type 'endif'? Yuck.

The current Emacs Ada mode indentation engine fails in that scenario
because the parse fails, and I'm working to make the parser tolerant of
errors so the indentation works.

On the other hand, Emacs Ada mode will tell you of the first current
syntax error if you ask it (which I do when indentation fails). And it
has a mode where you get that report each time you attempt to indent.

So I'll count that as "does that".

Hmm. You said "semantic", not "syntactic". So this means a full compile
with name and type resolution, not just a syntax parse. That makes sense
for simpler languages; I don't think it makes much sense for Ada.

> refactoring support, 

I've never been clear what this means, exactly. It could be:

- Rename all occurences of this identifier

    Emacs Ada mode has "show all references", which would walk thru all
    occurrences and let you rename each one; that could be enhanced
    fairly easily.

- Change the parameter list for this subprogram

    I don't see how you can automate that; you have to consider exactly
    what that means at each use. So the "walk thru all occurences" is
    useful.


- something else?

> integrated debugging, 

Has that.

> and code completion along with display of associated documentation.

There are various completion modes in Emacs; they will search open
buffers, history lists, etc.

If by this you mean "show me only possible completions that would
_compile_ here", that requires a successful semantic compile in the face of
errors. I'm working on allowing a syntax parse; that will get part way
there. 

In some simple cases you don't need a parse; if I type
"Ada.Text_IO.Put", it could offer "" and "_Line" as completions by
parsing the Ada.Text_IO spec, without parsing the current file.

More useful would be all the operations on type "Bar_Type" for object
"Foo". The GNAT cross-reference info can build that list given
"Bar_Type", so I might be able to get there.

I haven't tried completion in GPS in a while.

If the "associated documentation" for a subprogram is the comments at
the declaration, then that just requires navigating to the current
completion choice in another window. Although one editor I saw put that
in a help balloon; cute, but probably not enough space for useful info.

> Many IDEs also facilitate test case generation and profiling. 

Emacs can easily run the GNAT command line tool that does this, and
navgate thru the reports.

> In the Ada world there is integration with SPARK (for example as GPS
> does).

Not clear what "integration" means here. Again, Emacs can run the
command line tools that SPARK uses.

> Emacs is powerful and may well be able to do some or all of these
> things. Indeed, there is a Scala extension for Emacs that goes a long
> way in this direction. I believe it works by interacting directly with
> the Scala compiler behind the scenes.

Emacs Ada mode uses a mix of the GNAT compiler (for cross reference
info) and a separate parser (for indentation and lower-level navigation).

-- 
-- Stephe

Re: IDE's that support ADA

[Peter Chapin]

On Wed, 29 Oct 2014, Stephen Leake wrote:

>> Typical features of modern IDEs include: displaying semantic errors
>> (type errors, etc) as you type,
>
> Meaning it attempts to parse the syntax after typing every character? So
> if you start typing 'if ... then ... else .. end if', you get errors
> until you type 'endif'? Yuck.

Yes, exactly. However, the Java IDEs I've used tend to complete each 
structure for you immediately. In Ada terms that would mean automatically 
adding the 'end if,' for example, as soon as 'then' is typed. However, it 
is true that the IDEs will show spurious errors due to incomplete 
structures while you are typing them. Often they only do this after a 
short (and configurable) time delay to ease the pain somewhat. Actually I 
find I get used to it fairly quickly. I only pay attention to the red 
squiggly lines if I'm at a place where I believe everything should be 
okay. One gets a feeling of satisfaction when all the red squiggly lines 
go away. :)

> Hmm. You said "semantic", not "syntactic". So this means a full compile 
> with name and type resolution, not just a syntax parse. That makes sense 
> for simpler languages; I don't think it makes much sense for Ada.

I guess I would disagree here. It's more useful for complex languages than 
for simple languages because the programmer (meaning me) is more likely to 
be unaware of all the rules. Ada has a lot of rules so help from the IDE 
would be welcome.

With the Java IDEs I've used (Eclipse, IntelliJ), if the IDE "signs off" 
on the code, it will compile. I can't recall a time when that hasn't been 
true. Thus the IDE does full name resolution across packages, libraries, 
and considers inheritance, etc, etc.

The same is nearly true of the Scala plug-in for IntelliJ (I haven't used 
the Scala plug-in for Eclipse). Scala's type system is complex so to have 
the IDE faithfully do the type checking as you type your code is no small 
feat, I'm sure. Yet it is the expected thing from a "modern" IDE these 
days.

JetBrains, the makers of IntelliJ is currently building an IDE for C/C++ 
programming. I don't doubt for a minute that they intend to do the same 
thing for those languages. In fact, the preliminary version even deals 
with the preprocessor on the fly (it expands preprocessor macros, analyzes 
the code generated, and produces messages related to what it finds).

>> refactoring support,
>
> I've never been clear what this means, exactly. It could be:
>
> - Rename all occurences of this identifier
>
>    Emacs Ada mode has "show all references", which would walk thru all
>    occurrences and let you rename each one; that could be enhanced
>    fairly easily.

Yes, that's a good start. Does it work for references in comments too?

> - Change the parameter list for this subprogram
>
>    I don't see how you can automate that; you have to consider exactly
>    what that means at each use. So the "walk thru all occurences" is
>    useful.

Well Eclipse has a 'change method signature' refactoring option. It 
changes the signature of a method and all its overrides. It can also keep 
the original method and have it delegate to the new method (and mark the 
original as depreciated).

> - something else?

I'm looking at the refactor menu in Eclipse... there is an option to 
convert a local variable of a method into a field of the class. So in Ada 
terms that would be promoting a local variable of a primitive subprogram 
to a component of the tagged type.

Eclipse also has refactorings to move methods from super classes to 
subclasses (or vice-versa). In Ada terms we are talking about moving 
subprograms from one package to another, with suitable renamings I guess.

There is also an extract interface refactoring that examines a class and 
generates an interface based on the methods it finds there.

There are other refactorings too, but you get the idea. Of course we are 
talking about Java here so the ones I mentioned are all OOP specific. One 
might be able to come up with other, Ada specific, possibilities.

>> integrated debugging,
>
> Has that.

Cool.

> More useful would be all the operations on type "Bar_Type" for object 
> "Foo". The GNAT cross-reference info can build that list given 
> "Bar_Type", so I might be able to get there.

At first I found the code completion stuff irritating but it's actually 
quite useful when you get used to it. Often I don't remember exactly how 
to spell something and it's nice to have the IDE produce a list of 
possibilities that are relevant at that point in the program. The Scala 
plug-in for IntelliJ will actually help you complete "naked" names. For 
example if I'm typing an expression like

x = somethingLong + someOth...

IntelliJ will show me the names in scope that start with "someOth" and 
let me pick from that list:

x = somethingLong + someOtherLongName

It really reduces the pain of typing long names a lot (especially since it 
reorders the list based on names I've used recently to put the commonly 
needed ones at the top). Considering that using long names is encouraged 
in the Ada community a feature like that would nice for an Ada IDE.

> If the "associated documentation" for a subprogram is the comments at 
> the declaration, then that just requires navigating to the current 
> completion choice in another window. Although one editor I saw put that 
> in a help balloon; cute, but probably not enough space for useful info.

It helps that in the Java world there is a standard for how comments are 
supposed to look (Javadoc). The IDE knows this standard and can help with 
formatting and display of the information. For example it is normal for 
the IDE to check that the spelling of parameter names in the comments 
agrees with the way they are spelled in the actual method (not to mention 
the number of parameters, etc).

>> In the Ada world there is integration with SPARK (for example as GPS
>> does).
>
> Not clear what "integration" means here. Again, Emacs can run the
> command line tools that SPARK uses.

Well, GPS can display the path associated with an unproved verification 
condition so you get a visual display of the path where the failure might 
occur.

I think it's great that you are working to improve Ada mode in Emacs. I 
actually use Emacs a lot and find myself going to it when I want to get 
real work done (funny about that). I'm not suggesting that all of the 
things above are necessary or desirable for Ada mode, but it gives you 
some idea of where Java IDEs are currently at, and of the expections users 
of those IDEs bring to the table.

Peter

Re: IDE's that support ADA

[Adam Beneschan]

On Wednesday, October 29, 2014 4:28:59 PM UTC-7, Peter Chapin wrote:

> Well Eclipse has a 'change method signature' refactoring option. It 
> changes the signature of a method and all its overrides. It can also keep 
> the original method and have it delegate to the new method (and mark the 
> original as depreciated).
> 
> > - something else?
> 
> I'm looking at the refactor menu in Eclipse... there is an option to 
> convert a local variable of a method into a field of the class. So in Ada 
> terms that would be promoting a local variable of a primitive subprogram 
> to a component of the tagged type.
> 
> Eclipse also has refactorings to move methods from super classes to 
> subclasses (or vice-versa). In Ada terms we are talking about moving 
> subprograms from one package to another, with suitable renamings I guess.
> 
> There is also an extract interface refactoring that examines a class and 
> generates an interface based on the methods it finds there.
> 
> There are other refactorings too, but you get the idea. Of course we are 
> talking about Java here so the ones I mentioned are all OOP specific. One 
> might be able to come up with other, Ada specific, possibilities.

One thing I've sometimes found useful in Eclipse is Extract Method, where I can highlight a part of a method (function) and it will figure out how to take the highlighted part and turn it into a separate method with a name it prompts me for.  It does a reasonable job of guessing what parameters I'd like to pass to it, and what function result I want, if any.  Something like this is very difficult to get right all the time, and I wish it gave me more options to customize when it guesses wrong.  At that point, all I can do is cancel the operation and then do the refactoring by hand.  But even if it works, say, 60% of the time, it really does help in those 60% of cases and it's not much of an extra burden to try it in the other 40%.

                                 -- Adam

Re: IDE's that support ADA

[Stephen Leake]

Adam Beneschan <adambeneschan@gmail.com> writes:

> One thing I've sometimes found useful in Eclipse is Extract Method,
> where I can highlight a part of a method (function) and it will figure
> out how to take the highlighted part and turn it into a separate
> method with a name it prompts me for. It does a reasonable job of
> guessing what parameters I'd like to pass to it, and what function
> result I want, if any. Something like this is very difficult to get
> right all the time, and I wish it gave me more options to customize
> when it guesses wrong. At that point, all I can do is cancel the
> operation and then do the refactoring by hand. 

Do you sometimes let it complete, then change it?

I'll have to see if I can find that code in the Eclipse source, to see
what algorithms it is using.

-- 
-- Stephe

Re: IDE's that support ADA

[Adam Beneschan]

On Saturday, November 1, 2014 2:58:36 PM UTC-7, Stephen Leake wrote:
> Adam Beneschan writes:
> 
> > One thing I've sometimes found useful in Eclipse is Extract Method,
> > where I can highlight a part of a method (function) and it will figure
> > out how to take the highlighted part and turn it into a separate
> > method with a name it prompts me for. It does a reasonable job of
> > guessing what parameters I'd like to pass to it, and what function
> > result I want, if any. Something like this is very difficult to get
> > right all the time, and I wish it gave me more options to customize
> > when it guesses wrong. At that point, all I can do is cancel the
> > operation and then do the refactoring by hand. 
> 
> Do you sometimes let it complete, then change it?

That's certainly an option.  Maybe I've done that at times.  But in the cases I've encountered, it has usually seemed to be easiest just to do things manually (using the usual cut-and-paste functions).  Probably that's because the new argument list it proposes for the extracted method is just too far different from what I need, and changing it later doesn't seem worth the effort.

                               -- Adam

Re: IDE's that support ADA

[Dmitry A. Kazakov]

On Wed, 29 Oct 2014 19:28:56 -0400, Peter Chapin wrote:

> On Wed, 29 Oct 2014, Stephen Leake wrote:
> 
>> Meaning it attempts to parse the syntax after typing every character? So
>> if you start typing 'if ... then ... else .. end if', you get errors
>> until you type 'endif'? Yuck.
> 
> Yes, exactly. However, the Java IDEs I've used tend to complete each 
> structure for you immediately.

And you cannot turn this mess out? Ooch.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: IDE's that support ADA

[Adam Beneschan]

On Thursday, October 30, 2014 1:19:15 AM UTC-7, Dmitry A. Kazakov wrote:
> On Wed, 29 Oct 2014 19:28:56 -0400, Peter Chapin wrote:
> 
> > On Wed, 29 Oct 2014, Stephen Leake wrote:
> > 
> >> Meaning it attempts to parse the syntax after typing every character? So
> >> if you start typing 'if ... then ... else .. end if', you get errors
> >> until you type 'endif'? Yuck.
> > 
> > Yes, exactly. However, the Java IDEs I've used tend to complete each 
> > structure for you immediately.
> 
> And you cannot turn this mess out? Ooch.

If you mean "turn this mess off", I believe you can (at least in Eclipse); there are places to configure things like this.  I think that all their different rules for different syntactical structures can be configured individually, which means there are a lot of them on the menu, which means I haven't gone through them all, so I'm not totally sure it can be disabled.  But I think it can.

                                  -- Adam

Re: IDE's that support ADA

[Peter Chapin]

On Thu, 30 Oct 2014, Adam Beneschan wrote:

> If you mean "turn this mess off", I believe you can (at least in 
> Eclipse); there are places to configure things like this.  I think that 
> all their different rules for different syntactical structures can be 
> configured individually, which means there are a lot of them on the 
> menu, which means I haven't gone through them all, so I'm not totally 
> sure it can be disabled.  But I think it can.

Both Eclipse and IntelliJ also have extensively customizable formatting 
rules so you can generally get it to do what you want rather than what 
someone else wants. The formatting rules can be project specific so you 
can abide by project requirements and still use your preferred formatting 
for your own projects. Maybe this is what Adam is talking about.

The rules are used when you try to format an entire file (which I almost 
never do because it munges the places where I make exceptions to the 
formatting rules) and also when it completes structures that you type.

Overall I find the behavior more useful than annoying once

a) It's configured the way I like, and
b) I got used to it.

Peter

Re: IDE's that support ADA

[Stephen Leake]

Peter Chapin <PChapin@vtc.vsc.edu> writes:

> On Thu, 30 Oct 2014, Adam Beneschan wrote:
>
> Both Eclipse and IntelliJ also have extensively customizable
> formatting rules so you can generally get it to do what you want
> rather than what someone else wants. The formatting rules can be
> project specific so you can abide by project requirements and still
> use your preferred formatting for your own projects. Maybe this is
> what Adam is talking about.
>
> The rules are used when you try to format an entire file (which I
> almost never do because it munges the places where I make exceptions
> to the formatting rules) and also when it completes structures that
> you type.
>
> Overall I find the behavior more useful than annoying once
>
> a) It's configured the way I like, and
> b) I got used to it.
>
> Peter

How does compare to Emacs Ada mode indentation?

There are not many config options for this, so I'm wondering if people
are happy with the result, or just live with it.

-- 
-- Stephe

Re: IDE's that support ADA

[Peter Chapin]

On Sat, 1 Nov 2014, Stephen Leake wrote:

>> The rules are used when you try to format an entire file (which I
>> almost never do because it munges the places where I make exceptions
>> to the formatting rules) and also when it completes structures that
>> you type.
>>
>> Overall I find the behavior more useful than annoying once
>>
>> a) It's configured the way I like, and
>> b) I got used to it.
>>
>
> How does compare to Emacs Ada mode indentation?
>
> There are not many config options for this, so I'm wondering if people
> are happy with the result, or just live with it.

To be honest the indentation features in ada-mode were flaking out on me 
recently... but I'm not sure it's ada-mode's fault. I have reason to 
believe it might be something else.

Anyway I just updated my ada-mode to the 5.1.6 version. If I can reproduce 
any of the flakey stuff I'll let you know (off list I guess).

Peter

Re: IDE's that support ADA

[Stephen Leake]

Peter Chapin <PChapin@vtc.vsc.edu> writes:

> To be honest the indentation features in ada-mode were flaking out on
> me recently... but I'm not sure it's ada-mode's fault. I have reason
> to believe it might be something else.
>
> Anyway I just updated my ada-mode to the 5.1.6 version. If I can
> reproduce any of the flakey stuff I'll let you know (off list I
> guess).

Best place for Emacs Ada mode problems is the Ada mode mailing list:

http://host114.hostmonster.com/mailman/listinfo/emacs-ada-mode_stephe-leake.org

-- 
-- Stephe

Re: IDE's that support Ada

[Jacob Sparre Andersen]

Stephen Leake wrote:

> How does compare to Emacs Ada mode indentation?
>
> There are not many config options for this, so I'm wondering if people
> are happy with the result, or just live with it.

I'm not completely happy with the Emacs Ada mode indentation, but I
mostly just live with it (and have a fix for the inserted TAB characters
in my makefiles).

When I'm unhappy with the indentation, it is mostly when I have the
impression that it doesn't follow the Ada 95 Style Guide.

Greetings,

Jacob
-- 
"Can we feel bad for the universe later?"

Re: IDE's that support Ada

[Simon Wright]

Jacob Sparre Andersen <jacob@jacob-sparre.dk> writes:

> I'm not completely happy with the Emacs Ada mode indentation, but I
> mostly just live with it (and have a fix for the inserted TAB
> characters in my makefiles).

Inserted TABs?

ada-mode 4.01 used, I think, to convert tabs to spaces automatically. My
.emacs now has

(add-hook 'before-save-hook 'delete-trailing-whitespace)
(setq-default indent-tabs-mode nil)

The first of these makes it hard to program in Whitespace,
http://en.wikipedia.org/wiki/Whitespace_(programming_language).

Re: IDE's that support Ada

[Stephen Leake]

Jacob Sparre Andersen <jacob@jacob-sparre.dk> writes:

> Stephen Leake wrote:
>
>> How does compare to Emacs Ada mode indentation?
>>
>> There are not many config options for this, so I'm wondering if people
>> are happy with the result, or just live with it.
>
> I'm not completely happy with the Emacs Ada mode indentation, but I
> mostly just live with it (and have a fix for the inserted TAB characters
> in my makefiles).

ada-mode has nothing to do with makefiles, so I'm confused.

Perhaps you have turned off literal tab characters in files globally (as
I do):

(setq-default indent-tabs-mode nil)

then you need to reenable them in makefiles:

(add-hook 'makefile-mode-hook (lambda () (setq indent-tabs-mode t)))

So far, makefiles is the only mode I've encountered that requires
literal tabs.

> When I'm unhappy with the indentation, it is mostly when I have the
> impression that it doesn't follow the Ada 95 Style Guide.

That was never suggested as a goal for Emacs ada-mode.

But if you can post specific differences, I can consider how to
accomodate them with the current or new options.

ada-mode 5.x is _much_ easier to customize this way than 4.0.

-- 
-- Stephe

Re: IDE's that support Ada

[Simon Wright]

Stephen Leake <stephen_leake@stephe-leake.org> writes:

> Perhaps you have turned off literal tab characters in files globally (as
> I do):
>
> (setq-default indent-tabs-mode nil)
>
> then you need to reenable them in makefiles:
>
> (add-hook 'makefile-mode-hook (lambda () (setq indent-tabs-mode t)))

I don't have to do that.

Emacs 24.3.1 (i386-apple-darwin13.0.0, NS apple-appkit-1265.00)

Re: IDE's that support Ada

[Jacob Sparre Andersen]

Stephen Leake wrote:
> Jacob Sparre Andersen <jacob@jacob-sparre.dk> writes:

>> I'm not completely happy with the Emacs Ada mode indentation, but I
>> mostly just live with it (and have a fix for the inserted TAB
>> characters in my makefiles).
>
> ada-mode has nothing to do with makefiles, so I'm confused.

My English isn't perfect: What I mean is that I have a "standard" rule
in my makefiles for substituting TAB characters in Ada source files with
spaces.

>> When I'm unhappy with the indentation, it is mostly when I have the
>> impression that it doesn't follow the Ada 95 Style Guide.
>
> That was never suggested as a goal for Emacs ada-mode.
>
> But if you can post specific differences, I can consider how to
> accomodate them with the current or new options.
>
> ada-mode 5.x is _much_ easier to customize this way than 4.0.

I'll give you proper feedback once I've switched to ada-mode 5.x.

Greetings,

Jacob
-- 
"Universities are not part of the nation's security organisation,
 they are not the nation's research laboratory either: they are
 the nation's universities."                     -- E.W. Dijkstra

Re: IDE's that support Ada

[Stephen Leake]

Jacob Sparre Andersen <jacob@jacob-sparre.dk> writes:

> Stephen Leake wrote:
>> Jacob Sparre Andersen <jacob@jacob-sparre.dk> writes:
>
>>> I'm not completely happy with the Emacs Ada mode indentation, but I
>>> mostly just live with it (and have a fix for the inserted TAB
>>> characters in my makefiles).
>>
>> ada-mode has nothing to do with makefiles, so I'm confused.
>
> My English isn't perfect: What I mean is that I have a "standard" rule
> in my makefiles for substituting TAB characters in Ada source files with
> spaces.

Ah, that makes sense. I do that in Emacs with:

      (add-hook 'before-save-hook
		(lambda () (untabify (point-min) (point-max)))
		nil t))

That's in ada-mode-hook (and in other modes where I want it); the full
code is:

(defun sal-ada-mode-setup ()
  (set (make-local-variable 'hippie-expand-try-functions-list)
	(list 'ada-skel-hippie-try
	      'try-expand-dabbrev
	      'try-expand-dabbrev-all-buffers
	      'try-expand-dabbrev-from-kill))

  (let ((case-fold-search t))
    (cond

     ((string-match "arm_info" default-directory)
      ;; Randy keeps tabs in files, indents 'case'
      (add-hook 'before-save-hook 'delete-trailing-whitespace nil t)
      (add-hook 'before-save-hook 'copyright-update nil t)
      )

     ((string-match "org.emacs.ada-mode.*/test" default-directory)
      ;; use default ada-mode options for tests
      (add-hook 'before-save-hook 'delete-trailing-whitespace nil t)
      (add-hook 'before-save-hook 'copyright-update nil t)
      )

     (t
      ;; my projects
      (setq ada-indent-when 0)
      (setq ada-indent-label 0)
      (setq ada-indent-record-rel-type 0)
      (setq ada-fill-comment-prefix "--  ");; match gnat style
      (add-hook 'before-save-hook 'delete-trailing-whitespace nil t)
      (add-hook 'before-save-hook 'copyright-update nil t)
      (add-hook 'before-save-hook
		(lambda () (untabify (point-min) (point-max)))
		nil t))
      )))

(setq ada-skel-initial-string "{header}")
(add-to-list 'ada-prj-parser-alist (cons "prj" 'ada-prj-parse-file-1))
(add-hook 'ada-mode-hook 'sal-ada-mode-setup)

-- 
-- Stephe

Re: IDE's that support ADA

[Stephen Leake]

Peter Chapin <PChapin@vtc.vsc.edu> writes:

> On Wed, 29 Oct 2014, Stephen Leake wrote:
>
>>> Typical features of modern IDEs include: displaying semantic errors
>>> (type errors, etc) as you type,
>>
>> Meaning it attempts to parse the syntax after typing every character? So
>> if you start typing 'if ... then ... else .. end if', you get errors
>> until you type 'endif'? Yuck.
>
> Yes, exactly. However, the Java IDEs I've used tend to complete each
> structure for you immediately. In Ada terms that would mean
> automatically adding the 'end if,' for example, as soon as 'then' is
> typed. However, it is true that the IDEs will show spurious errors due
> to incomplete structures while you are typing them. Often they only do
> this after a short (and configurable) time delay to ease the pain
> somewhat. Actually I find I get used to it fairly quickly. I only pay
> attention to the red squiggly lines if I'm at a place where I believe
> everything should be okay. 

Ah, so it's not an obtrusive error display; it doesn't beep and open
another buffer with error messages. That makes sense.

I did see that in the Eclipse environment for Java used on FIRST
Robotics last year.

One problem with this approach is that editing file A can easily cause
problems in file B, so you still need some sort of global error list.
How do the IDE's you've used handle that?

The Eclipse FIRST environment was not good at that, as I recall; you had
to explicitly check each possible file.

>> Hmm. You said "semantic", not "syntactic". So this means a full
>> compile with name and type resolution, not just a syntax parse. That
>> makes sense for simpler languages; I don't think it makes much sense
>> for Ada.
>
> I guess I would disagree here. It's more useful for complex languages
> than for simple languages because the programmer (meaning me) is more
> likely to be unaware of all the rules. Ada has a lot of rules so help
> from the IDE would be welcome.
>
> With the Java IDEs I've used (Eclipse, IntelliJ), if the IDE "signs
> off" on the code, it will compile. I can't recall a time when that
> hasn't been true. Thus the IDE does full name resolution across
> packages, libraries, and considers inheritance, etc, etc.

I suspect it actually invokes the compiler, and processes the error
messages. That's easy to do, but the compile can be pretty slow if the
project is big enough, so you don't want to do it for every edit. GNAT
does have a "semantic check only mode", which is faster.

The problem I'm getting at is the cross-file interactions mentioned
above. 

>>> refactoring support,
>>
>> I've never been clear what this means, exactly. It could be:
>>
>> - Rename all occurences of this identifier
>>
>>    Emacs Ada mode has "show all references", which would walk thru all
>>    occurrences and let you rename each one; that could be enhanced
>>    fairly easily.
>
> Yes, that's a good start. Does it work for references in comments too?

No, those are not listed in the compiler cross references. Does any
other tool do that? How would it handle overloaded names?

>> - Change the parameter list for this subprogram
>>
>>    I don't see how you can automate that; you have to consider exactly
>>    what that means at each use. So the "walk thru all occurences" is
>>    useful.
>
> Well Eclipse has a 'change method signature' refactoring option. It
> changes the signature of a method and all its overrides. 

Ok. So it does _not_ change all of the references, which is what I was
talking about.

Emacs Ada mode can show the list of overrides, so it could do the
operation you describe.

>> - something else?
>
> I'm looking at the refactor menu in Eclipse... there is an option to
> convert a local variable of a method into a field of the class. So in
> Ada terms that would be promoting a local variable of a primitive
> subprogram to a component of the tagged type.

I gather you have not actually used that?

I have done that on occasion, when I realize I need to split a primitive
operation into two parts, and save some state in between the two calls.

But I usually change the variable name, and sometimes the type; I don't
see how having an editor do a small part of that job is useful.

Having lots of screen space, with lots of windows on lots of source
files, and an easy way to navigate among them, makes editing specs and
bodies simultaneously easy.

> Eclipse also has refactorings to move methods from super classes to
> subclasses (or vice-versa). In Ada terms we are talking about moving
> subprograms from one package to another, with suitable renamings I
> guess.

I've done that as well, as the constraints on the type hierarchy design
change.

I'm not at all sure I want the editor doing that level of editing for
me. It's certainly not hard to cut and paste the appropriate lines from
one buffer to another; then I get it in the right place, and can search
thru comments to make sure they are updated.

> There is also an extract interface refactoring that examines a class
> and generates an interface based on the methods it finds there.

That's trivial in Ada; just change the type declaration to "interface".
Unless there are components in the type; then you have work to do that
the editor can't do for you.

> There are other refactorings too, but you get the idea. 

The only idea I get here is "not worth having the editor do this".

Since I hack on Emacs all the time, I am usually very willing to spend
an hour adding a feature that will save me 10 minutes of work today, on
the theory that I'll make back the time in the future (or other people
will). But I've never been tempted to implement these refactoring
features; I just don't see how they can be worth it.

Maybe I'm just a lot pickier about how my source code is arranged, so I
don't want the editor messing with it (even when I'm writing the editor
:).

Which is why I'm asking for feedback on refactoring features that
people actually find _useful_.

>>> In the Ada world there is integration with SPARK (for example as GPS
>>> does).
>>
>> Not clear what "integration" means here. Again, Emacs can run the
>> command line tools that SPARK uses.
>
> Well, GPS can display the path associated with an unproved
> verification condition so you get a visual display of the path where
> the failure might occur.

I gather that's displaying the information in a SPARK tool error
message. Is it really better than just seeing the text of the message?
Can you click on something to navigate to the appropriate source code?

I'll have to try SPARK one of these days.

> I think it's great that you are working to improve Ada mode in Emacs.

Thanks.

> I actually use Emacs a lot and find myself going to it when I want to
> get real work done (funny about that). 

That's good to hear!

> I'm not suggesting that all of the things above are necessary or
> desirable for Ada mode, but it gives you some idea of where Java IDEs
> are currently at, and of the expections users of those IDEs bring to
> the table.

Ok, thanks for the input.

-- 
-- Stephe

Re: IDE's that support ADA

[Dmitry A. Kazakov]

On Sat, 01 Nov 2014 16:53:50 -0500, Stephen Leake wrote:

> Peter Chapin <PChapin@vtc.vsc.edu> writes:
> 
>> On Wed, 29 Oct 2014, Stephen Leake wrote:
>>
>>> Hmm. You said "semantic", not "syntactic". So this means a full
>>> compile with name and type resolution, not just a syntax parse. That
>>> makes sense for simpler languages; I don't think it makes much sense
>>> for Ada.
>>
>> I guess I would disagree here. It's more useful for complex languages
>> than for simple languages because the programmer (meaning me) is more
>> likely to be unaware of all the rules. Ada has a lot of rules so help
>> from the IDE would be welcome.
>>
>> With the Java IDEs I've used (Eclipse, IntelliJ), if the IDE "signs
>> off" on the code, it will compile. I can't recall a time when that
>> hasn't been true. Thus the IDE does full name resolution across
>> packages, libraries, and considers inheritance, etc, etc.
> 
> I suspect it actually invokes the compiler, and processes the error
> messages. That's easy to do, but the compile can be pretty slow if the
> project is big enough, so you don't want to do it for every edit. GNAT
> does have a "semantic check only mode", which is faster.

Unless you do autocompletion, there is no need to run compiler
synchronously to the editor. E.g. Visual Studio compiles sources
asynchronously to typing and underlines errors it finds seconds later. It
is still a bit annoying and sometimes blocks input nevertheless.

> The problem I'm getting at is the cross-file interactions mentioned
> above. 

True, especially for separate units GNAT's partial compilation is not much
better than simple syntax checks.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: IDE's that support ADA

[Peter Chapin]

On Sat, 1 Nov 2014, Stephen Leake wrote:

> Ah, so it's not an obtrusive error display; it doesn't beep and open 
> another buffer with error messages. That makes sense.

Yes, you just see "red squiggles" about things the IDE doesn't like. If 
you hover over the squiggle a message pops up that tries to explain the 
problem.

> One problem with this approach is that editing file A can easily cause 
> problems in file B, so you still need some sort of global error list. 
> How do the IDE's you've used handle that?
>
> The Eclipse FIRST environment was not good at that, as I recall; you had
> to explicitly check each possible file.

The IDEs I've used have some kind of project view that shows, usually in a 
tree structure, all the files of my project. The view typically isn't 
exactly a representation of the files themselves. For example in the Java 
world packages are usually collapsed into a single node if there are no 
intermediate entities whereas in the file system you have to drill down 
through several subdirectories. For example the class

 	edu.vtc.myproject.Buffer

would be stored in the file

 	edu/vtc/myproject/Buffer.java

but the IDE project view wouldn't make you navigate all levels of the 
package hierarchy and just display the package "edu.vtc.myproject" as an 
individual node.

Anyway, files with errors are often shown with red squiggly lines under 
their names or with some other indication of a problem. That said, I'm 
actually not 100% sure if you have to visit the file first to see the 
error indication. It might depend on the nature of the error. I never 
really paid attention to that.

>> With the Java IDEs I've used (Eclipse, IntelliJ), if the IDE "signs
>> off" on the code, it will compile. I can't recall a time when that
>> hasn't been true. Thus the IDE does full name resolution across
>> packages, libraries, and considers inheritance, etc, etc.
>
> I suspect it actually invokes the compiler, and processes the error
> messages. That's easy to do, but the compile can be pretty slow if the
> project is big enough, so you don't want to do it for every edit. GNAT
> does have a "semantic check only mode", which is faster.

I can tell you more precisely how it works with the Scala plug-ins for 
Eclipse and IntelliJ. I'm a much bigger Scala user than a Java user.

The Scala compiler (there is really only one) has a special interface 
designed to assist IDEs. When used via that interface it's called the 
"presentation compiler." The Scala plug-in for Eclipse loads the 
presentation compiler as a library and holds it in memory all the time. It 
interacts with the compiler via the interface I mentioned which allows, 
apparently, incremental syntax and semantic checks. I'm not sure about the 
technical details.

As a result you see errors as you type them provided the code you are 
editing is not exceptionally long or complex. If it is, there is a 
significant delay. One file in the Scala compiler source code itself is 
almost 6,000 lines and the presentation compiler lags pretty well when you 
try to edit that file. However for normal sized files the delay is 
perfectly acceptable. The main disadvantage to this approach is it uses a 
LOT of memory.

I believe the Emacs extension ENSIME also uses the presentation compiler 
to do what it does (code completion, type checking, etc, etc). See: 
https://github.com/ensime. I set ENSIME up once but it was a bit flakey at 
the time (this was years ago). It's probably worth another look.

In contrast the IntelliJ plug-in for Scala completely re-implements the 
Scala compiler front-end from scratch. This includes semantic analysis 
(type checking). They did this for two reasons

1. The presentation compiler wasn't available when they started their 
project.

2. They claim they can integrate more tightly with the rest of their IDE 
this way. It is certainly true that the Scala plug-in for IntelliJ takes 
less memory and feels faster.

The down side of their approach is that the IDE sometimes gets it wrong 
and occasionally claims something is wrong that isn't or vice-versa. As 
the plug-in has matured this doesn't happen much anymore. Martin Odersky, 
the prime mover of Scala, has applauded IntelliJ because they have "helped 
debug the Scala Language Specification." In effect, their plug-in is a 
second implementation of the language.

>> Yes, that's a good start. Does it work for references in comments too?
>
> No, those are not listed in the compiler cross references. Does any
> other tool do that? How would it handle overloaded names?

Well, I was thinking about Javadoc comments. For example:

/**
  * Blah, blah, blah
  *
  * @param size The size of the thingy.
  */
void someMethod(int size) { .. }

If you rename the parameter the IDE knows enough to rename it in the 
Javadoc too. I've seen IDEs offer to rename things in comments throughout 
but usually that's an option that's off by default. Typically you can 
preview a refactoring and I would definitely preview something like that 
for sure! I'm not sure what it does, exactly; maybe it's just search and 
replace.

>> I'm looking at the refactor menu in Eclipse... there is an option to
>> convert a local variable of a method into a field of the class. So in
>> Ada terms that would be promoting a local variable of a primitive
>> subprogram to a component of the tagged type.
>
> I gather you have not actually used that?

I haven't! To be honest the refactoring I use the most, by far, is 
renaming. I'm nervous about letting the IDE modify my code at will 
because, frankly, I don't entirely trust it. Anything with far reaching 
consequences I tend to preview carefully.

Even after renaming I worry about the IDE messing up my formatting. 
Despite having the formatting configured a certain way there are always 
exceptions.

> I have done that on occasion, when I realize I need to split a primitive
> operation into two parts, and save some state in between the two calls.
>
> But I usually change the variable name, and sometimes the type; I don't
> see how having an editor do a small part of that job is useful.
>
> Having lots of screen space, with lots of windows on lots of source
> files, and an easy way to navigate among them, makes editing specs and
> bodies simultaneously easy.

Using a static language with strong typing is more useful than fancy IDE 
features in this regard. That's my feeling.

>> There are other refactorings too, but you get the idea.
>
> The only idea I get here is "not worth having the editor do this".

I would tend to agree. Still... people coming from the Java world have 
ideas about what a "modern" IDE is supposed to be able to do. I'm not sure 
how much the refactorings get used in real life. I suppose someone has 
studied that question, maybe?

>> Well, GPS can display the path associated with an unproved
>> verification condition so you get a visual display of the path where
>> the failure might occur.
>
> I gather that's displaying the information in a SPARK tool error
> message. Is it really better than just seeing the text of the message?
> Can you click on something to navigate to the appropriate source code?

Yes. In GPS there is an icon next to the message that when clicked will 
highlight the path. I'm not sure where the information is coming from; 
it's not in the error message itself. I suppose GPS is reading some log 
file or report file generated by gnatprove.

>> I actually use Emacs a lot and find myself going to it when I want to
>> get real work done (funny about that).
>
> That's good to hear!

I think I keep coming back to Emacs because it is the ultimate generalist. 
For a while I tried using OneNote to keep notes but I decided, for me, a 
collection of text files was suitable and I edit those files with... Emacs 
of course!

It doesn't matter what programming language I'm using, what configuration 
files I'm editing, what document preparation system I'm writing in... 
Emacs works. Thus I find myself sitting in Emacs a lot of the time.

Peter

Re: IDE's that support ADA

[Stephen Leake]

Peter Chapin <PChapin@vtc.vsc.edu> writes:

> I believe the Emacs extension ENSIME also uses the presentation
> compiler to do what it does (code completion, type checking, etc,
> etc). See: https://github.com/ensime. 

Thanks for the tip; I'll look at it for ideas.

> In contrast the IntelliJ plug-in for Scala completely re-implements
> the Scala compiler front-end from scratch. This includes semantic
> analysis (type checking). They did this for two reasons

I'm taking this approach with Emacs Ada mode, because I want it to be
based on a BNF grammar, so it is easy to implement other languages using
the same infrastructure.

That may mean it's too slow :).

> The down side of their approach is that the IDE sometimes gets it
> wrong and occasionally claims something is wrong that isn't or
> vice-versa. 

Since the grammar I'm using is from the LRM, this is easy to avoid.
Well, except when the LRM changes behind my back, as with 'or else raise
<exception>' in aspects :).

Other languages don't have as well-defined or well-structured grammars,
so it may be harder.

>>> I'm looking at the refactor menu in Eclipse... there is an option to
>>> convert a local variable of a method into a field of the class. So in
>>> Ada terms that would be promoting a local variable of a primitive
>>> subprogram to a component of the tagged type.
>>
>> I gather you have not actually used that?
>
> I haven't! To be honest the refactoring I use the most, by far, is
> renaming. I'm nervous about letting the IDE modify my code at will
> because, frankly, I don't entirely trust it. Anything with far
> reaching consequences I tend to preview carefully.

This is the problem for me, as well. The Ada compiler will probably
catch any problems, but it's hard to be sure.

>>> Well, GPS can display the path associated with an unproved
>>> verification condition so you get a visual display of the path where
>>> the failure might occur.
>>
>> I gather that's displaying the information in a SPARK tool error
>> message. Is it really better than just seeing the text of the message?
>> Can you click on something to navigate to the appropriate source code?
>
> Yes. In GPS there is an icon next to the message that when clicked
> will highlight the path. I'm not sure where the information is coming
> from; it's not in the error message itself. I suppose GPS is reading
> some log file or report file generated by gnatprove.

Ok. The default display of such things in Emacs includes the file name;
it should be possible to hide it, but that's not "the Emacs way" :).

-- 
-- Stephe

Re: IDE's that support ADA

[Luke A. Guest]

Due to Java and VisualStudio, people expect certain things from an IDE,
including automatic completion of identifiers across library boundaries,
advanced editing of spec/body at the same time, and the other things
mentioned already.

Without an IDE that can do this I don't think people will ever take Ada
seriously.

When new languages come out there are advanced IDE's created or existing
ones extended very quickly. Whereas Ada one dare started but not completed
most probably due to the scale of the language involved.

Luke

Re: IDE's that support ADA

[David Botton]

On Monday, November 3, 2014 12:00:44 PM UTC-5, Luke A. Guest wrote:

> Without an IDE that can do this I don't think people will ever take Ada
> seriously.

GPS does offer this now. Perhaps possible to adapt code from it for Emacs modes since also GPL.

David Botton

Re: IDE's that support ADA

[Luke A. Guest]

David Botton <david@botton.com> wrote:
> On Monday, November 3, 2014 12:00:44 PM UTC-5, Luke A. Guest wrote:
> 
>> Without an IDE that can do this I don't think people will ever take Ada
>> seriously.
> 
> GPS does offer this now. Perhaps possible to adapt code from it for Emacs
> modes since also GPL.


God doesn't do this across libraries.

Enacts was s bitch to get a basic form of autocomplete to work and even
then it doesn't work every time, only for open buffers and again only
sometimes.

Luke

Re: IDE's that support ADA

[David Botton]

> God doesn't do this across libraries.

I am sure God could if he put out an IDE, but it seems to work for me with any library I with on GPS so not sure I understand.

David Botton

Re: IDE's that support ADA

[Luke A. Guest]

David Botton <david@botton.com> wrote:
>> God doesn't do this across libraries.
> 
> I am sure God could if he put out an IDE, but it seems to work for me
> with any library I with on GPS so not sure I understand.
> 
> David Botton

Ah funny typo! But last I tried gps didn't do it. Is there something you
have to do to get it to work?

Re: IDE's that support ADA

[Stephen Leake]

Luke A. Guest <laguest@archeia.com> writes:

> David Botton <david@botton.com> wrote:
>>> God doesn't do this across libraries.
>> 
>> I am sure God could if he put out an IDE, but it seems to work for me
>> with any library I with on GPS so not sure I understand.
>> 
>> David Botton
>
> Ah funny typo! 

What typo are you talking about?

> But last I tried gps didn't do it. Is there something you
> have to do to get it to work?

What is "it" here?


-- 
-- Stephe

Re: IDE's that support ADA

[Dennis Lee Bieber]

On Mon, 3 Nov 2014 19:50:49 +0000 (UTC), Luke A. Guest
<laguest@archeia.com> declaimed the following:


>
>God doesn't do this across libraries.
>

http://www.songworm.com/lyrics/songworm-parody/EternalFlame.html
-- 
	Wulfraed                 Dennis Lee Bieber         AF6VN
    wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/

Re: IDE's that support ADA

[Stephen Leake]

Luke A. Guest <laguest@archeia.com> writes:

> David Botton <david@botton.com> wrote:
>> On Monday, November 3, 2014 12:00:44 PM UTC-5, Luke A. Guest wrote:
>> 
>>> Without an IDE that can do this I don't think people will ever take Ada
>>> seriously.
>> 
>> GPS does offer this now. Perhaps possible to adapt code from it for Emacs
>> modes since also GPL.
>
>
> God doesn't do this across libraries.

Hmm. Guess I'm better than God :).

The current Emacs ada-mode does use some code from gnatcoll for
cross-referencing. The same code is also used in GPS.

I also have an experimental implementation that uses the core GPS
indentation engine for ada-mode; it works pretty well, but needs some
work to provide full functionality.

I will certainly consider using the GPS code for completion, when I get
around to that.

Right now I'm focusing on speeding up the parser; there are people who
have files that take 10 seconds to parse with the current
implementation.

> Enacts was s bitch to get a basic form of autocomplete to work and even
> then it doesn't work every time, only for open buffers and again only
> sometimes.

What is "Enacts"? A google search for "enacts emacs" didn't find
anything useful.

ada-mode does need name completion.

-- 
-- Stephe

Re: IDE's that support ADA

[Stephen Leake]

Luke A. Guest <laguest@archeia.com> writes:

> Due to Java and VisualStudio, people expect certain things from an
> IDE,

This would be better phrased as:

    People who are used to some Java IDEs and VisualStudio expect
    certain things from an IDE

I'm a member of the set "people who have used Java", and _I_ don't
expect the things being discussed here :). I used Emacs, of course.

> including automatic completion of identifiers across library
> boundaries, 

This is on my list of things to do.

> advanced editing of spec/body at the same time, 

What does this mean, exactly?

I guess it could mean:

    If I make changes to the spec of a function, make the same changes
    for me in the body.

    and vice-versa
    
That would be nice.

One approach to this is to provide a function "ada-resync-spec-body"
which would find the spec/body corresponding to the one at point, and
change it to match.

Anything else?

> Without an IDE that can do this I don't think people will ever take Ada
> seriously.

There's that mysterious "people" again :).

Clearly lots of people do take Ada seriously - AdaCore makes money. I
think you mean "Ada will never be as popular as Java etc". That's fine;
I don't care about that metric.

On the other hand, if you mean "some people who would otherwise use Ada
will never try it", that's an important point.

My impression is GPS has most of the features discussed so far
(except "advanced spec/body edit"), so I really only care about adding
things to Emacs.

> When new languages come out there are advanced IDE's created or existing
> ones extended very quickly. 

ok.

> Whereas Ada one dare started but not completed most probably due to
> the scale of the language involved.

I don't follow; we have:

- GPS

    not available "quickly" after Ada 83, but updated regularly since it
    was released

- Emacs ada-mode

    available soon after Ada 83, and updated regularly since then, but
    lacking in some advanced features.

- Eclipse ada-mode

    not clear when this was first available, still supported by AdaCore,
    not clear on advanced features

What is "not completed"?

-- 
-- Stephe

Re: IDE's that support ADA

[Florian Weimer]

* Stephen Leake:

> Meaning it attempts to parse the syntax after typing every character? So
> if you start typing 'if ... then ... else .. end if', you get errors
> until you type 'endif'? Yuck.

You get red squiggly lines under the code, much like in a word
processor with on-the-fly spell checking.  I find that completely
non-intrusive.  It does not even take up valuable screen real estate.

> Hmm. You said "semantic", not "syntactic". So this means a full compile
> with name and type resolution, not just a syntax parse. That makes sense
> for simpler languages; I don't think it makes much sense for Ada.

I don't think semantic analysis on partial programs is more difficult
for Ada than for C++ (in fact, it's probably easier in many common
cases because there is less ambiguity between expressions and types).
Semantic completion has been implemented for C++, I don't see why it
would be technically infeasible for Ada.  There are areas which are
rather difficult, like ambigous overloads which are only resolved once
more program text is available, but so are lambda expressions in Java
8, and IDE will manage somehow.

Actually, I would consider it rather useful.  It's not just the
auto-completion, you'd also bee able to see docstrings of referenced
entities while typing (this functionality is reasonably easy to add
once you now where those entities are defined).  That I would find
rather useful.

Re: IDE's that support ADA

[David Botton]

Is there a way to do code completion that takes into account semantics like GPS does with Emacs?

I used to use Emacs all the time and generally prefer it to GPS, but being able to code compete on inherited sub programs, has been enough to keep me in GPS lately.

David Botton

Re: IDE's that support ADA

[Stephen Leake]

David Botton <david@botton.com> writes:

> Is there a way to do code completion that takes into account semantics
> like GPS does with Emacs?

Not currently, but since Emacs can use the same back-end tools that GPS
uses, it is possible, and it's on my list of things to do.

-- 
-- Stephe

Re: IDE's that support ADA

[Hubert]

On 10/26/2014 11:34 AM, nathandsash@gmail.com wrote:
> I know that Vi/Vim and Emacs and other programming environments support ADA programming, but how about any modern-day IDE's like Visual Studio for instance?
>
I am wondering, why hasn't anybody mentioned Slickedit i this thread? I 
used to work with it in C++ until a few years ago when  switched to 
Visual Studio for that. I know it used to have problems with the Ada 
beautifier but they seem to have caught up with that. they are currently 
working on a new version and I follow their progress loosely in their 
forum, even reported a bug with Ada which they promised to fix for the 
final release.
 From my tests with the 2013 version it seems that it is already pretty 
good. the main thing that interests me there is the hierarchy tree (in 
C++ it would be a class browser) that shows all the packages hieraries 
for an Ada program and which provides a nice browsing feature.
It misses stuff that GPS has, for instance it does not provide the 
parameter names for a subprogram call but for me that is worth less than 
a good browser. My main problem with GPS is that I quickly loose 
overview over my program because from my work in C++ I am not used to 
looking at it in terms of source file hierarchies but class hierarchy.



---
This email is free from viruses and malware because avast! Antivirus protection is active.
http://www.avast.com

Re: IDE's that support ADA

[David Botton]

> I am not used to 
> looking at it in terms of source file hierarchies but class hierarchy.

That is certainly GPS's weakest point and it seems to be unable to do code completion for ancestor methods more than one parent level up.

I just assume their customer base does not make much use of Ada's OO abilities.

David Botton