Ada for 1st year students

Ada for 1st year students

[amado.alves]

Dear Fellow Adaists:

I have been blessed with the oportunity to teach Ada to 1st year
students of a licenciate programme of informatics engineering at
Universidade Lusófona do Porto.

I seek advice from the vast wisdom in this forum, on:

(1) Textbooks. In Portuguese (Brazilian translation fine) or English.
Must be introductory, i.e. for students sans prior knowledge of
programming in any language. Should be small or cheap (or both). The
vendor should be prompt.

(2) Compilers. Must be free (as in free beer) or very low cost
(perhaps an educational license) and install out-of-the box on Windows
or Linux (or both, preferably). Must support Latin-1, preferably
Unicode. The vendor should be prompt.

(3) IDE or text editor. Same requirements as above.

(4) Graphic or GUI library. (I want to be able to produce graphical
output, not just the same old text output on a teletype-like window.)
Same requirements as above, plus: a simple or small API, eventually at
the cost of possibilities (e.g. may be limited to a single window, of
a single fixed size, limited number of colors). Should have some
support for input, e.g. textboxes, buttons, mouse input. Should use a
simple fragment of Ada, viz. excluding OOP. Should support printing,
or exporting to PDF or some such, or clipboard copying onto a "office"
document, or any combination of the above. Support for a picture
format would be a plus (PNG, JPEG...)

I have knowledge, in various degrees, of various items in each
category, but I will not name any at this moment, to avert
prejudice ;-)

Many thanks.

Re: Ada for 1st year students

[Vadim Godunko]

On Oct 9, 8:06 pm, amado.al...@gmail.com wrote:
>
> (2) Compilers. Must be free (as in free beer) or very low cost
> (perhaps an educational license) and install out-of-the box on Windows
> or Linux (or both, preferably). Must support Latin-1, preferably
> Unicode. The vendor should be prompt.
>
Both GNAT GPL and GNAT GAP (Academic) are free of charge, support
Linux 32/64 and Windows, easy for install.

> (3) IDE or text editor. Same requirements as above.
>
GPS is a part of the GNAT GPL/GAP.

> (4) Graphic or GUI library. (I want to be able to produce graphical
> output, not just the same old text output on a teletype-like window.)
> Same requirements as above, plus: a simple or small API, eventually at
> the cost of possibilities (e.g. may be limited to a single window, of
> a single fixed size, limited number of colors). Should have some
> support for input, e.g. textboxes, buttons, mouse input. Should use a
> simple fragment of Ada, viz. excluding OOP. Should support printing,
> or exporting to PDF or some such, or clipboard copying onto a "office"
> document, or any combination of the above. Support for a picture
> format would be a plus (PNG, JPEG...)
>
GtkAda and QtAda. But both has large and powerful API and use OOP.
QtAda has binary package for Windows.

Re: Ada for 1st year students

[mockturtle]

On Oct 9, 6:06 pm, amado.al...@gmail.com wrote:
> Dear Fellow Adaists:
>
> I have been blessed with the oportunity to teach Ada to 1st year
> students of a licenciate programme of informatics engineering at
> Universidade Lusófona do Porto.
>
> I seek advice from the vast wisdom in this forum, on:
>
> (1) Textbooks. In Portuguese (Brazilian translation fine) or English.
> Must be introductory, i.e. for students sans prior knowledge of
> programming in any language. Should be small or cheap (or both). The
> vendor should be prompt.
>
> (2) Compilers. Must be free (as in free beer) or very low cost
> (perhaps an educational license) and install out-of-the box on Windows
> or Linux (or both, preferably). Must support Latin-1, preferably
> Unicode. The vendor should be prompt.
>
> (3) IDE or text editor. Same requirements as above.
>
> (4) Graphic or GUI library. (I want to be able to produce graphical
> output, not just the same old text output on a teletype-like window.)
> Same requirements as above, plus: a simple or small API, eventually at
> the cost of possibilities (e.g. may be limited to a single window, of
> a single fixed size, limited number of colors). Should have some
> support for input, e.g. textboxes, buttons, mouse input. Should use a
> simple fragment of Ada, viz. excluding OOP. Should support printing,
> or exporting to PDF or some such, or clipboard copying onto a "office"
> document, or any combination of the above. Support for a picture
> format would be a plus (PNG, JPEG...)
>
> I have knowledge, in various degrees, of various items in each
> category, but I will not name any at this moment, to avert
> prejudice ;-)
>
> Many thanks.

Well, an easy answer to your 2..4 questions is the GNAT solution
with the GPS IDE and GtkAda.  I'm sure that it works both with
Linux and Windows, since I work on Linux and my students on
Windows.  I never used GtkAda, so I do not know if it suits
your needs.  No idea about the book...

Re: Ada for 1st year students

[Georg Bauhaus]

Vadim Godunko schrieb:

> GtkAda and QtAda. But both has large and powerful API and use OOP.
> QtAda has binary package for Windows.

With all due respect to the creators, both GtkAda and
QtAda are anything but a beginner's item.
JEWL seems more to the point, and tested in the desired
environment.

Re: Ada for 1st year students

[Ludovic Brenta]

Amado writes:
> Dear Fellow Adaists:
>
> I have been blessed with the oportunity to teach Ada to 1st year
> students of a licenciate programme of informatics engineering at
> Universidade Lusófona do Porto.

Great news.  Congratulations and I hope you enjoy it.

> I seek advice from the vast wisdom in this forum, on:
>
> (1) Textbooks. In Portuguese (Brazilian translation fine) or English.
> Must be introductory, i.e. for students sans prior knowledge of
> programming in any language. Should be small or cheap (or both). The
> vendor should be prompt.

John English, "Ada 95: The Craft of Object-Oriented Programming",
1997; available free of charge at http://www.it.bton.ac.uk/staff/je/adacraft/

The wikibook at http://en.wikibooks.org/wiki/Ada_Programming/; this is
not really a textbook but can be a good complement to the above.

> (2) Compilers. Must be free (as in free beer) or very low cost
> (perhaps an educational license) and install out-of-the box on Windows
> or Linux (or both, preferably). Must support Latin-1, preferably
> Unicode. The vendor should be prompt.

GNAT GPL Edition from http://libre.adacore.com, or call for tenders
from the vendors listed at http://en.wikibooks.org/wiki/Ada_Programming/Installing

Most GNU/Linux distributions already contain GNAT from the Free
Software Foundation.

> (3) IDE or text editor. Same requirements as above.

GNAT GPL Edition and Debian both come with the GNAT Programming
Studio.

> (4) Graphic or GUI library. (I want to be able to produce graphical
> output, not just the same old text output on a teletype-like window.)
> Same requirements as above, plus: a simple or small API, eventually at
> the cost of possibilities (e.g. may be limited to a single window, of
> a single fixed size, limited number of colors). Should have some
> support for input, e.g. textboxes, buttons, mouse input. Should use a
> simple fragment of Ada, viz. excluding OOP. Should support printing,
> or exporting to PDF or some such, or clipboard copying onto a "office"
> document, or any combination of the above. Support for a picture
> format would be a plus (PNG, JPEG...)

For the GUI I would rule out both GtkAda and QtAda; not because they
are "bad" but because there are simpler alternatives for simple
programs. These alternatives are:

JEWL (John English's Window Library), comes with the aforementioned
text book; see http://www.cmis.brighton.ac.uk/staff/je/jewl/.
Unfortunately, does not support X11.

TextTools, a text-mode library for doing windows, buttons, scroll bars
etc; portable on multiple operating systems, and incidentally
available as part of Debian. See http://www.pegasoft.ca/tt.html

> I have knowledge, in various degrees, of various items in each
> category, but I will not name any at this moment, to avert
> prejudice ;-)

I have a prejudice against proprietary software, so I don't name
names, but there is a vendor in Madison, Wisconsin, who might be able
to help if you don't need compatibility with POSIX :)

--
Ludovic Brenta.

Re: Ada for 1st year students

[Robert A Duff]

amado.alves@gmail.com writes:

> I have been blessed with the oportunity to teach Ada to 1st year
> students of a licenciate programme of informatics engineering at
> Universidade Lus�fona do Porto.

You should check out the GAP program at AdaCore.

- Bob

Re: Ada for 1st year students

[amado.alves]

> GtkAda and QtAda. But both has large and powerful API and use OOP.
> QtAda has binary package for Windows.

From the info on websites it seems QtAda uses the "native look and
feel" of each platform whereas GtkAda uses... what? X on unixes and
what on Windows?
Thanks.

Re: Ada for 1st year students

[amado.alves]

On 9 Out, 18:00, Georg Bauhaus <rm.dash-bauh...@futureapps.de> wrote:
> Vadim Godunko schrieb:
>
> > GtkAda and QtAda. But both has large and powerful API and use OOP.
> > QtAda has binary package for Windows.
>
> With all due respect to the creators, both GtkAda and
> QtAda are anything but a beginner's item.
> JEWL seems more to the point, and tested in the desired
> environment.

If I choose one of the big systems then I'll make a non-OOP binding to
it for my students to use. Like John English did a few years ago.
Maybe I'll choose JEWL. Problem is it only supports Microsoft Windows.
I wanted to support Linux too. Using JEWL and then telling my students
"if you want graphics you have to use Windows" will send the wrong
message I'm afraid... Not pedagogical at all.

Re: Ada for 1st year students

[Jeffrey R. Carter]

amado.alves@gmail.com wrote:
> 
> (4) Graphic or GUI library. (I want to be able to produce graphical
> output, not just the same old text output on a teletype-like window.)
> Same requirements as above, plus: a simple or small API, eventually at
> the cost of possibilities (e.g. may be limited to a single window, of
> a single fixed size, limited number of colors). Should have some
> support for input, e.g. textboxes, buttons, mouse input. Should use a
> simple fragment of Ada, viz. excluding OOP. Should support printing,
> or exporting to PDF or some such, or clipboard copying onto a "office"
> document, or any combination of the above. Support for a picture
> format would be a plus (PNG, JPEG...)

This is probably going to drive your platform selection. The only thing I'm 
aware of that comes close to meeting your requirements for this is JEWL, which 
is Windows only. JEWL is implemented using type extension, but does not require 
it from the client. It doesn't support printing, but should support clipboard 
copying. It can display BMP images.

Note: in English, "eventually" doesn't mean what its cognate in romance 
languages means (I'm familiar with "eventuel" in French).

-- 
Jeff Carter
"How'd you like to hide the egg and gurgitate
a few saucers of mocha java?"
Never Give a Sucker an Even Break
101

Re: Ada for 1st year students

[Vadim Godunko]

On Oct 9, 10:25 pm, amado.al...@gmail.com wrote:
>
> From the info on websites it seems QtAda uses the "native look and
> feel" of each platform whereas GtkAda uses... what? X on unixes and
> what on Windows?
"native look and feel" means what you can't distinguish native and
QtAda applications usually. QtAda application uses user's preferences
from the Control Panel for drawing and user input handling. It uses
native dialogs, for printing and file operations for example, and so
on. GtkAda application sometimes force its own style. :-(

Re: Ada for 1st year students

[amado.alves]

> This is probably going to drive your platform selection. The only thing I'm
> aware of that comes close to meeting your requirements for this is JEWL...

So it seems. It meets all the "musts." :-)

The ideal (meet all "shoulds" too) would probably require a tailor
made binding to Qt but I don't have the time :-(

> Note: in English, "eventually" doesn't mean what its cognate in romance
> languages means...

Oops... you're right, it slipped, I meant "possibly"

Re: Ada for 1st year students

[Simon Wright]

Ludovic Brenta <ludovic@ludovic-brenta.org> writes:

> TextTools, a text-mode library for doing windows, buttons, scroll bars
> etc; portable on multiple operating systems, and incidentally
> available as part of Debian. See http://www.pegasoft.ca/tt.html

Hmm! A couple of minor glitches in the C code, then works (well, almost
all the demos do something!) on Mac OS X/GCC 4.3.0. Worth remembering,
thanks.

Re: Ada for 1st year students

[amado.alves]

On 9 Out, 20:09, Vadim Godunko <vgodu...@gmail.com> wrote:
> On Oct 9, 10:25 pm, amado.al...@gmail.com wrote:
>
> > From the info on websites it seems QtAda uses the "native look and
> > feel" of each platform whereas GtkAda uses... what? X on unixes and
> > what on Windows?
>
> "native look and feel" means what you can't distinguish native and
> QtAda applications usually. QtAda application uses user's preferences
> from the Control Panel for drawing and user input handling. It uses
> native dialogs, for printing and file operations for example, and so
> on. GtkAda application sometimes force its own style. :-(

Yeah. Qt sounds superior. But I will probably stick with JEWL and
Windows. Maybe next year...

Re: Ada for 1st year students

[amado.alves]

Thanks a very great lot to all.
At 12 posts and counting it is clear that the contestants for the GUI
are Qt and JEWL, the compiler is GNAT GAP, JE's book online is a fine
option, only the IDE... I have reservations about GPS, it's too much,
and in my experience slow and unreliable, I think I'll give Eclise a
try, as it's already installed in the lab for another course.

Re: Ada for 1st year students

[ahab]

On Oct 9, 2:42 pm, amado.al...@gmail.com wrote:
> only the IDE...

I would reccomend Ada Guide for first year students. (
http://sourceforge.net/projects/adagide/ ) It is not nearly as
heavyweight as GPS or eclipse, but a step up from notepad.

other suggestions are listed here: http://stackoverflow.com/questions/119227/good-ada-ide

I am currently doing a project with TextTools. Its working great for
what I want, but I don't think I'd be happy if it were put on me in my
first two semesters.

Re: Ada for 1st year students

[Pascal Obry]

amado.alves@gmail.com a �crit :
> Thanks a very great lot to all.
> At 12 posts and counting it is clear that the contestants for the GUI
> are Qt and JEWL, the compiler is GNAT GAP, JE's book online is a fine

For the online reference I'll add:

   Ada Distilled from Richard Riehle
   http://www.adaic.org/learn/index.html

> option, only the IDE... I have reservations about GPS, it's too much,
> and in my experience slow and unreliable, I think I'll give Eclise a

GPS slow and unreliable... Well I'm using it all days...

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|              http://www.obry.net
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada for 1st year students

[Ed Falis]

On Thu, 09 Oct 2008 17:01:01 -0400, Pascal Obry <pascal@obry.net> wrote:

> amado.alves@gmail.com a ï¿œcrit :
>> Thanks a very great lot to all.
>> At 12 posts and counting it is clear that the contestants for the GUI
>> are Qt and JEWL, the compiler is GNAT GAP, JE's book online is a fine
>
> For the online reference I'll add:
>
>    Ada Distilled from Richard Riehle
>    http://www.adaic.org/learn/index.html

Only problem there is that it's oriented to people who know how to program.
>
>> option, only the IDE... I have reservations about GPS, it's too much,
>> and in my experience slow and unreliable, I think I'll give Eclise a
>
> GPS slow and unreliable... Well I'm using it all days...

Relatively speaking, I consider Eclipse a big fat pig.  I can't believe it  
claims the wonderful and elegant IBM VisualAge in its parentage.  My own  
opinion, of course.

Re: Ada for 1st year students

[amado.alves]

So it seems it's JE stuff all the way (AdaGuide is his work too, no?)

So we probably should nominate this guy for the next Ada prize
(AdaCore, Ada-Europe, SIGAda?)

Thanks.

Re: Ada for 1st year students

[Gene]

On Oct 9, 12:06 pm, amado.al...@gmail.com wrote:
> Dear Fellow Adaists:
>
> I have been blessed with the oportunity to teach Ada to 1st year
> students of a licenciate programme of informatics engineering at
> Universidade Lusófona do Porto.
>
> (4) Graphic or GUI library. (I want to be able to produce graphical
> output, not just the same old text output on a teletype-like window.)
> Same requirements as above, plus: a simple or small API, eventually at
> the cost of possibilities (e.g. may be limited to a single window, of
> a single fixed size, limited number of colors). Should have some
> support for input, e.g. textboxes, buttons, mouse input. Should use a
> simple fragment of Ada, viz. excluding OOP. Should support printing,
> or exporting to PDF or some such, or clipboard copying onto a "office"
> document, or any combination of the above. Support for a picture
> format would be a plus (PNG, JPEG...)

We have been using a "Turtle Graphics" implementation that hides the
complexity of GtkAda for beginning programmers.  It works pretty
well.  By the end of a semester, nearly all students are able to
design and implement a fairly elaborate game, graphical simulation, or
similar program. We couldn't get there with bare GtkAda. The TG
package runs without modification under Linux, Solaris, and Windows.
Only the build command is different.  See http://www.eecs.usma.edu/research/
.  If you decide to use it, I'd be happy to answer any questions.

Re: Ada for 1st year students

[Jeffrey R. Carter]

amado.alves@gmail.com wrote:
> So it seems it's JE stuff all the way (AdaGuide is his work too, no?)

No. AdaGIDE is by Martin Carlisle of the US Air Force Academy.

http://adagide.martincarlisle.com/

-- 
Jeff Carter
"How'd you like to hide the egg and gurgitate
a few saucers of mocha java?"
Never Give a Sucker an Even Break
101

Re: Ada for 1st year students

[Jeffrey Creem]

amado.alves@gmail.com wrote:
> Dear Fellow Adaists:
> 
> I have been blessed with the oportunity to teach Ada to 1st year
> students of a licenciate programme of informatics engineering at
> Universidade Lus�fona do Porto.
> 
> I seek advice from the vast wisdom in this forum, on:
> 
> (1) Textbooks. In Portuguese (Brazilian translation fine) or English.
> Must be introductory, i.e. for students sans prior knowledge of
> programming in any language. Should be small or cheap (or both). The
> vendor should be prompt.
> 

Try looking at this book

http://www.amazon.com/PLUS-DATA-STRUCTURES-Nell-Dale/dp/0763737941

It tends to be geared more toward a beginner student than some of the 
other books that were suggested.

Re: Ada for 1st year students

[amado.alves]

On 10 Out, 01:40, Dennis Lee Bieber <wlfr...@ix.netcom.com> wrote:
> On Thu, 9 Oct 2008 16:14:49 -0700 (PDT), amado.al...@gmail.com declaimed
> the following in comp.lang.ada:
>
> > So it seems it's JE stuff all the way (AdaGuide is his work too, no?)
>
>         Presuming you really mean AdaGIDE, then /no/.  AdaGIDE is Martin
> Carlisle, USAF Academy, and goes back to the days of GNAT3.14 I think.

Oops, sorry Martin, I'll nominate both you and JE :-)

I remember using AdaGIDE some years back. Yeah, 3.14p. I remember a
button to compile for Mindstorms :-)

So it seems the most pedagogical tools are Microsoft Windows only
still today.

Re: Ada for 1st year students

[amado.alves]

On 10 Out, 02:15, Jeffrey Creem <j...@thecreems.com> wrote:
> http://www.amazon.com/PLUS-DATA-STRUCTURES-Nell-Dale/dp/0763737941
>
> It tends to be geared more toward a beginner student than some of the
> other books that were suggested.

Thanks, but too off the mark, viz. too expensive (100US$) and too OO.

Re: Ada for 1st year students

[Georg Bauhaus]

amado.alves@gmail.com schrieb:

> So it seems the most pedagogical tools are Microsoft Windows only
> still today.

These windows based tools may meet your goals best.
However, other criteria for tools being *pedagogical*
have been put forward. For example, see the recent
complaints about IDE-students not knowing at all what a
compiler is. And/or how to operate programs other
than through pressing function keys or clicking
menu items and buttons.

The alternative implicit in this criticism may not
be fashionable at first sight: just shiny magic
text characters, no disney framings.
As a minor compensation, the text alternative
is as inexpensive as the load of MS software that
MS Select is offering to universities as lure.

And fore sure, defending text in a Windows world
requires risk taking on the part of the teacher
who needs to make old style programming an attraction.
Might not be a good idea, as it associates the teacher
and course with text only computers, an old language,
nah, go away.

--
Georg Bauhaus
Y A Time Drain  http://www.9toX.de

Re: Ada for 1st year students

[Jeffrey Creem]

amado.alves@gmail.com wrote:
> On 10 Out, 02:15, Jeffrey Creem <j...@thecreems.com> wrote:
>> http://www.amazon.com/PLUS-DATA-STRUCTURES-Nell-Dale/dp/0763737941
>>
>> It tends to be geared more toward a beginner student than some of the
>> other books that were suggested.
> 
> Thanks, but too off the mark, viz. too expensive (100US$) and too OO.

Expensive yes. Of course on the plus side, wait a week and perhaps the 
dollar will collapse so low that $100 won't mean anything ;)

Too OO is an interesting topic. There are some schools that are going 
with an objects first approach to introduction to programming 
(University of New Hampshire for example -- though with Java).

They are certainly not the first college to go with this approach but I 
think it is still too soon to tell how approaches like this will work out.

Re: Ada for 1st year students

[John McCormick]

On Oct 10, 5:04 am, amado.al...@gmail.com wrote:
> On 10 Out, 02:15, Jeffrey Creem <j...@thecreems.com> wrote:
>
> >http://www.amazon.com/PLUS-DATA-STRUCTURES-Nell-Dale/dp/0763737941
>
> > It tends to be geared more toward a beginner student than some of the
> > other books that were suggested.
>
> Thanks, but too off the mark, viz. too expensive (100US$) and too OO.

I've been teaching the first year courses since 1978 and have been
using Ada in them since 1990.  I've written Ada textbooks for these
courses.  I have some strong opinions in these matters.

I'm surprised you find Ada Plus Data Structures too Object-Oriented.
I feel that the John English book is far more Object-Oriented.  I
recommend the English book to those who want to teach a beginning
course with the objects early approach.  Ada Plus Data Structures
takes the traditional abstract data type approach but uses the OO
terminology.  The only use of inheritance in the book is with
controlled types in the prevention of memory leaks in pointer based
collection classes.  However, Ada Plus Data Structures was not written
for beginners.  It is meant for the second course (CS2).

For the first course (CS1), I feel strongly that the textbook should
emphasize top down design through procedural abstraction.  Beginners
need to learn the fundamental control structures (decision, iteration,
and subprogram) and fundamental data structures (the Ada type
system).  I feel that it is important that they see sizable examples
in the form of case studies.

I am VERY wary of teaching GUI programming to beginners.  They put
enormous amounts of time into playing with fonts, colors, etc at the
expense of learning basic programming.  Too many students come out of
GUI based CS1 courses with no ability to write decent if and loop
statements.  But they sure can draw pretty windows. :-) I prefer to
keep the I/O as basic as possible and concentrate on the fundamentals
of algorithm design and implementation.  Two textbooks that embrace
this philosophy are

Programming and Problem Solving with Ada 95
by Dale, Weems, and McCormick  (I am obviously highly biased toward
this book)

Ada 95: Problem Solving and Program Design
by Feldman and Koffman

Note the emphasis on problem solving in each of these titles.  Don't
go by the US Amazon for the prices.  I know that my publisher prices
my books lower in Spain, so they probably do the same in Portugal.
Check with your book store.  There is also a decent supply of used
copies available.

I like to schedule what CS educators call "closed labs".  These are
like the labs you had in your chemistry and physics courses.  In the
lab, students get practice with the concepts discussed in lecture.
They solve small problems with an instructor nearby to assist.
Research at the University of Texas at Austin indicates positive
results with closed labs.  I give my students a Pre-Lab exercise to
complete before the lab session, the In-Lab exercise, and then a Post-
Lab exercise (programming assignment) that gives them a more
challenging problem to solve.  I would be happy to share these
laboratory materials.  Of course, they are closely tied to my textbook

In terms of tools, you are on the right track with GNAT through the
GAP program.  I agree with others that GPS is too much for beginners.
My favorite IDE, AdaGIDE, has been mentioned.  It is about as basic as
you can get.  No one has mentioned my second favorite simple IDE,
jGRASP which is available for multiple platforms.  jGRASP's control
structure diagrams are viewed favorably by many educators.  Find it at
http://www.jgrasp.org/

Re: Ada for 1st year students

[amado.alves]

On 11 Out, 13:54, John McCormick <mccorm...@cs.uni.edu> wrote:
> I'm surprised you find Ada Plus Data Structures too Object-Oriented.
> I feel that the John English book is far more Object-Oriented.

I think first chapters of JE's book are not OO and are fine for me but
I'll check again. I'll check your books too.
I didn't inspect Ada Plus Data Structures rigourously. No time. Too
expensive, and *seemingly* too OO.

Let me clarify that the course is Algoritmia (algorithmics), with
pseudocode for design and analysis and Ada for implementation. The
primary textbook is Cormen et al., with Ziviani (C/Pascal) and a lot
others as secundary bibliography. However this is not engraved in
stone yet. But will have to be soon.

I share your stance on the usual GUIs being too distracting. Note I
require simplicity, even limitedness, to avoid that. Like turtle
graphics. But I want a couple input gadgets. Actually I was thinking
of a fixed panel with a couple buttons, textboxes, and an output
frame, and the studends only change the names of these components, and
the API is totally imperative. Maybe next year... In the meanwhile, I
think I'll go with AdaGIDE and JEWL.

Yes, jGRASP I am thinking to use also (it's great that development has
restarted of this great tool) but maybe only later.

The course programme has a lot of lab work, including two Projects
counting 50% for the grade. However I am trying to do it all in
classes. I don't like to burden the students with home work, or out-of-
classes labwork. There will be some, but very little.

Thank you very much for your extremely valuable information. I'd sure
love to have a look at your materials, but please at your entire
convenience, and just a single example handout or slide is fine.

I need to hang out on GAP more. Probably we'll meet there. I just sent
the fax resubscribing.

Re: Ada for 1st year students

[amado.alves]

On 11 Out, 01:15, Jeffrey Creem <j...@thecreems.com> wrote:
> Too OO is an interesting topic.

It is a fascinating topic :-)

I've ruled out Java immediatly when I saw that a nice imperative
algorithm must start with

package public class ... or whatever

---nothing to do with the logic of the algorithm.

By the same token I exclude full OO with Ada

type What_Type is abstract tagged null record with private... or
whatever.

OO is many things. Information hiding I teach soon in the course. But
that existed before OO. Like reuse.

OO maybe the right idiom for full fledge event driven GUIs, Gtk, Qt,
all seem to be highly OO. For this first course I envisage limited
imperative things like Get_Text_1 --- waits for text input on textbox
1 (waits that user presses Commit).

Re: Ada for 1st year students

[amado.alves]

Bookshops in Porto are a disgrace for CS textbooks. Even the classics,
TAOCP, K&R, we have to buy in Amazon. Even Brazilian Portuguese
translations we have to buy in Amazon or Brazil. Lisbon, or Spain may
be a little better, but just a little.

BTW Amazon now has links to used copy deals. Feldman & Koffman costs
1.22 $US used + 12 $US international shipping. The problems is the
time it takes to arrive, and sometimes custom taxes (it seems to be
random).

Re: Ada for 1st year students

[amado.alves]

McCormick, your book I had already requested an evaluation copy a few
days back, but got no reply yet.

Re: Ada for 1st year students

[Dmitry A. Kazakov]

On Sat, 11 Oct 2008 06:46:36 -0700 (PDT), amado.alves@gmail.com wrote:

> On 11 Out, 01:15, Jeffrey Creem <j...@thecreems.com> wrote:
>> Too OO is an interesting topic.
> 
> It is a fascinating topic :-)

I strongly disagree.
 
> I've ruled out Java immediatly when I saw that a nice imperative
> algorithm must start with

The opposite to "imperative" is "declarative." Typing is an independent
issue.

In my view students should be exposed to typing together with algorithms.

> package public class ... or whatever
> 
> ---nothing to do with the logic of the algorithm.

The logic of any algorithm, except for primitive state machines, has no
meaning without the types of things being computed. A good course should
show this first. After all, using predefined types is bad taste in Ada.

Generations of students become programmers incapable to understand
difference between real, floating-point and fixed-point numbers. Didn't
they start with "nice imperative algorithm," before learning what the
number is?

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

Re: Ada for 1st year students

[(see below)]

On 11/10/2008 13:54, in article
bc9af86b-de74-4ee8-bbd8-942154036def@34g2000hsh.googlegroups.com, "John
McCormick" <mccormick@cs.uni.edu> wrote:

> I've been teaching the first year courses since 1978 and have been
> using Ada in them since 1990.  I've written Ada textbooks for these
> courses.  I have some strong opinions in these matters.
> 
...
> 
> For the first course (CS1), I feel strongly that the textbook should
> emphasize top down design through procedural abstraction.  Beginners
> need to learn the fundamental control structures (decision, iteration,
> and subprogram) and fundamental data structures (the Ada type
> system).  I feel that it is important that they see sizable examples
> in the form of case studies.
> 
> I am VERY wary of teaching GUI programming to beginners.  They put
> enormous amounts of time into playing with fonts, colors, etc at the
> expense of learning basic programming.  Too many students come out of
> GUI based CS1 courses with no ability to write decent if and loop
> statements.  But they sure can draw pretty windows. :-) I prefer to
> keep the I/O as basic as possible and concentrate on the fundamentals
> of algorithm design and implementation.
 ...
> 
> Note the emphasis on problem solving in each of these titles.  Don't
> go by the US Amazon for the prices.  I know that my publisher prices
> my books lower in Spain, so they probably do the same in Portugal.
> Check with your book store.  There is also a decent supply of used
> copies available.
> 
> I like to schedule what CS educators call "closed labs".  These are
> like the labs you had in your chemistry and physics courses.  In the
> lab, students get practice with the concepts discussed in lecture.
> They solve small problems with an instructor nearby to assist.
> Research at the University of Texas at Austin indicates positive
> results with closed labs.  I give my students a Pre-Lab exercise to
> complete before the lab session, the In-Lab exercise, and then a Post-
> Lab exercise (programming assignment) that gives them a more
> challenging problem to solve.  I would be happy to share these
> laboratory materials.  Of course, they are closely tied to my textbook
> 
> In terms of tools, you are on the right track with GNAT through the
> GAP program.  I agree with others that GPS is too much for beginners.
> My favorite IDE, AdaGIDE, has been mentioned.  It is about as basic as
> you can get.  
...

I headed a team that introduced Ada 95 as the 1st- and 2nd-years' foundation
language at Glasgow University CS Department in 1996. That ran very well
indeed for 10 years. In fact, it was by far the most successful course I had
anything to do with, in nearly 30 years of teaching programming.

The course we delivered followed the recommendations above very closely
indeed, and I strongly agree with virtually everything John has said.

(Ada has now been replaced by Python "because it is more fun".  I'm glad I
retired before that happened, as I would not be able to disguise my contempt
for the guilty parties.)

-- 
Bill Findlay
<surname><forename> chez blueyonder.co.uk

Re: Ada for 1st year students

[Simon Wright]

John McCormick <mccormick@cs.uni.edu> writes:

> I am VERY wary of teaching GUI programming to beginners.  They put
> enormous amounts of time into playing with fonts, colors, etc at the
> expense of learning basic programming.

This is rather like my wife's experience of teaching 10-year-old girls
Lego Mindstorms -- she has to hide the wings, eyes, & other decorative
objects until the last moment or nothing gets done.

Even so, they turn the control program's screen background Barbie pink
at the first opportnity!

Re: Ada for 1st year students

[amado.alves]

> > package public class ... or whatever
>
> > ---nothing to do with the logic of the algorithm.
>
> The logic of any algorithm, except for primitive state machines, has no
> meaning without the types of things being computed. A good course should
> show this first. After all, using predefined types is bad taste in Ada.

Sure, but 2 things:

(1) the main focus of the course is indeed the logic

(2) types are fundamental and are addressed, only not full fledge OOP
(I cannot use full fledged OOP for the algorithms, way too
distracting, "package public class ...", "abstract tagged null record
with private...", whatever, totally unnecessary and a turn of)

Re: Ada for 1st year students

[amado.alves]

And for starting they will even use a package that predeclares
variables I, J, K, L, M as integers, X, Y, Z as reals, etc. That's my
approach anyway, logic first, types later. They just include the
package and voila, by magic, all the variables in the pseudocode are
there for usage in the same way. Later I will explain this magic, by
looking inside the package, and then they will redo their programs
sans that package.

Re: Ada for 1st year students

[Mike H]

In message 
<9955de2c-f74a-4c2b-b513-56c130a5f1ee@k16g2000hsf.googlegroups.com>, 
amado.alves@gmail.com writes
>And for starting they will even use a package that predeclares
>variables I, J, K, L, M as integers, X, Y, Z as reals, etc. That's my
>approach anyway, logic first, types later. They just include the
>package and voila, by magic, all the variables in the pseudocode are
>there for usage in the same way. Later I will explain this magic, by
>looking inside the package, and then they will redo their programs
>sans that package.

I really do think that types are fundamental to good Ada code. When I 
taught Ada I started with types. Before they even saw a line of Ada code 
I would get class groups discussing 'time' and 'duration'.
- are time and duration interchangeable?
- if you subtract a time from a time, what do you get?
- what about other operations on a pair of time variables?
- what about operations on duration variables
- are there any sensible multiplication or division operations

Usually the discussions got quite heated and that was the object of the 
exercise! By the time they were called to order, their minds were much 
more open to the concept of strict typing (especially those who had had 
other programming experience such as C).

I then gave some simple examples and exercises using a package 
declaration containing pre-declared integers, minutes and time (time as 
minutes since some arbitrary event) to demonstrate how errors at compile 
can be 'friendly'! My 'magic' was to follow that up by showing them the 
package body code.
-- 
Mike Hopkins

Re: Ada for 1st year students

[(see below)]

On 12/10/2008 00:37, in article YKhi7cZjiT8IFwIr@ada-augusta.demon.co.uk,
"Mike H" <newsreader@ada-augusta.demon.co.uk.INVALID> wrote:

> In message 
> <9955de2c-f74a-4c2b-b513-56c130a5f1ee@k16g2000hsf.googlegroups.com>,
> amado.alves@gmail.com writes
>> And for starting they will even use a package that predeclares
>> variables I, J, K, L, M as integers, X, Y, Z as reals, etc. That's my
>> approach anyway, logic first, types later. They just include the
>> package and voila, by magic, all the variables in the pseudocode are
>> there for usage in the same way. Later I will explain this magic, by
>> looking inside the package, and then they will redo their programs
>> sans that package.

Amado, to remove spam I filter out all messages from gmail (etc), so I do
not see your original posts, but I have to say that I think this is daft.

Apart from anything else, they should be declaring variables with suitable
subranges, right from day 1.

-- 
Bill Findlay
<surname><forename> chez blueyonder.co.uk

Re: Ada for 1st year students

[Gary Scott]

Dennis Lee Bieber wrote:
> On Sat, 11 Oct 2008 13:57:52 -0700 (PDT), amado.alves@gmail.com
> declaimed the following in comp.lang.ada:
> 
> 
>>And for starting they will even use a package that predeclares
>>variables I, J, K, L, M as integers, X, Y, Z as reals, etc. That's my
> 
> 
> 	Egad... The return of FORTRAN...
Fortran never went anywhere, its alive and well and outsells Ada 1000 to 
1.  Implicit typing is not used/is discouraged, but yes it remains the 
default (the standard committee made a serious mistake when the new 
source form was defined)

-- 

Gary Scott
mailto:garylscott@sbcglobal dot net

Fortran Library:  http://www.fortranlib.com

Support the Original G95 Project:  http://www.g95.org
-OR-
Support the GNU GFortran Project:  http://gcc.gnu.org/fortran/index.html

If you want to do the impossible, don't hire an expert because he knows 
it can't be done.

-- Henry Ford

Re: Ada for 1st year students

[John McCormick]

On Oct 11, 11:20 am, "(see below)" <yaldni...@blueyonder.co.uk> wrote:
>
> I headed a team that introduced Ada 95 as the 1st- and 2nd-years' foundation
> language at Glasgow University CS Department in 1996. That ran very well
> indeed for 10 years. In fact, it was by far the most successful course I had
> anything to do with, in nearly 30 years of teaching programming.
>
> The course we delivered followed the recommendations above very closely
> indeed, and I strongly agree with virtually everything John has said.
>
> (Ada has now been replaced by Python "because it is more fun".  I'm glad I
> retired before that happened, as I would not be able to disguise my contempt
> for the guilty parties.)
>
> --
> Bill Findlay

Your story is one I hear often when I work the ACM SIGAda booth at the
exhibit hall at SIGCSE conferences.

It never ceases to amaze me how computer science educators want to use
bleeding edge technology in the beginning courses.  These are the
students who require the most stabilty in a programming language.
When Java first burst upon the educational scene, my Department voted
to replace our successful Ada based course with a Java one.  If I had
been old enough to retire, I might be golfing with you today.  After 5
years, the faculty teaching the upper level courses staged a revolt.
Their students' ability to write code (mostly in C) for their projects
had fallen tremendously from the days when we used Ada in the
beginning courses.  We switched back to Ada!  I think we are the only
school to switch from Java to Ada.  But I still can't rest.  Last
Spring there was an experimental section of the first course that was
Python based.  I imagine that the mantra at SIGCSE 2009 will be "Java
is dead, long live Python."

John

Re: Ada for 1st year students

[amado.alves]

I've slept on it and I'll retract from magic variables. Students will
declare the variables from day 1. Thanks for your warnings, they
confirm this. But please remind that my main focus is not teaching
Ada, but algorithms, and Ada is being use for implementing the
algorithms. I need a fragment of Ada that together with some packages
provide a non distracting environment, language, for the
implementation of the algorithms. Of course I'll teach Ada basics.
I'll teach packages. Packages are the heart of Ada, more than types. I
don't think I'll teach types much. I'll teach how to *use* types i.e.
how to declare variables. Thanks.

Re: Ada for 1st year students

[Dmitry A. Kazakov]

On Sun, 12 Oct 2008 06:00:51 -0700 (PDT), John McCormick wrote:

> It never ceases to amaze me how computer science educators want to use
> bleeding edge technology in the beginning courses.

I don't see anything bad in that. It is the question what is considered as
a bleeding edge. Ada is certainly one in large, high-integrity, concurrent
systems design. It also has a very innovative OO types system. (However,
there are problems with irregularity, MI, MD). It is a question of how do
you sell it.

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

Re: Ada for 1st year students

[Gary Scott]

amado.alves@gmail.com wrote:
> I've slept on it and I'll retract from magic variables. Students will
> declare the variables from day 1. Thanks for your warnings, they
> confirm this. But please remind that my main focus is not teaching
> Ada, but algorithms, and Ada is being use for implementing the
> algorithms. I need a fragment of Ada that together with some packages
> provide a non distracting environment, language, for the
> implementation of the algorithms. Of course I'll teach Ada basics.
> I'll teach packages. Packages are the heart of Ada, more than types. I
> don't think I'll teach types much. I'll teach how to *use* types i.e.
> how to declare variables. Thanks.
For the stated purpose, Fortran 95/2003 would be just about perfect.  It 
also has modules, and the syntax is generally more math-like and intuitive.

-- 

Gary Scott
mailto:garylscott@sbcglobal dot net

Fortran Library:  http://www.fortranlib.com

Support the Original G95 Project:  http://www.g95.org
-OR-
Support the GNU GFortran Project:  http://gcc.gnu.org/fortran/index.html

If you want to do the impossible, don't hire an expert because he knows 
it can't be done.

-- Henry Ford

Re: Ada for 1st year students

[Georg Bauhaus]

Gary Scott wrote:

> For the stated purpose, Fortran 95/2003 would be just about perfect.  It
> also has modules, and the syntax is generally more math-like and intuitive.

Unfortunately, math intuition can be deceptive when
it comes to those naughty computers. They just don't want to
behave like you would expect, being guided by mathematical
preconceptions. They behave like computers.
They require each and every step to be modeled in terms of
these restricted computer thingies.

Why not start with computers, then learn about the mathematics
of programs and then see how the knowledge can be employed to solve
other mathematical problems. Or even to just solve problems.
If an exercise should lead the student to an understanding
of computers, where does mathematical intuition lead?
Does mathematical intuition help with how to control a computer
with the help of a programs?

Is mathematical high school knowledge helpful at all?
I remember exercises being taken from math. Easy ones requiring
only that students know the meaning of the word that the instructor
had chosen for "calculating the sum of line lengths" of some
geometrical figure. If you had taken math at school, you will
probably remember. Other exercises, later, involved concepts
from 3rd semester math. Too bad if this math concept hadn't
been taught as part of 3rd semester physics education.
"Engineers, you are interested in mathematics, so I'll just
explain it in mathematical terms..." [noise level increasing
due to higher participation in murmur that the remark had caused.]

There is a preoccupation with the parts of mathematics that
math-trained CS instructors happen to know. That's education by
assumption! Suppose that in early computer education the
math-centric problems were replaced with equally programmable
formal problems taken from neurobiology, 3rd semester. What is
going to happen? Outrage! Because obviously mathematicians can't
be supposed to know about neurobiology. By any educational
logic. But CS students know mathematics, because, you know,
it's the same thing, basically.  Or take problems from chemistry,
3rd semester? Or from econometry, 3rd course?  I guess this then
will be the first time that the CS mathematicians start seeing the
harm that their intuition is doing to computer programming...


-- 
Georg Bauhaus
Y A Time Drain  http://www.9toX.de

Re: Ada for 1st year students

[Colin Paul Gloster]

Amado Alves submitted:

|-----------------------------------------------------------------------|
|"Bookshops in Porto are a disgrace for CS textbooks. Even the classics,|
|TAOCP, K&R, we have to buy in Amazon. Even Brazilian Portuguese        |
|translations we have to buy in Amazon or Brazil. Lisbon, or Spain may  |
|be a little better, but just a little.                                 |
|                                                                       |
|[..]"                                                                  |
|-----------------------------------------------------------------------|

Used they be better before people began importing specialist books
from foreign booksellers? In this theme, if you can use a credit card
to buy books from a vendor connected to the Internet then perhaps you
would be willing to import books stocked on the same continent as
Portugal from
WWW.Eason.Ie
though not all of the books mentioned in this thread are stocked by
Eason.

With kind regards from Coimbra (elsewhere in Portugal),
Colin Paul Gloster

Re: Ada for 1st year students

[Colin Paul Gloster]

On Sun, 12 Oct 2008, Georg Bauhaus wrote:

|------------------------------------------------------------------|
|"[..]                                                             |
|                                                                  |
|                                                                  |
|Is mathematical high school knowledge helpful at all?             |
|[..]"                                                             |
|------------------------------------------------------------------|

Yes.

|------------------------------------------------------------------|
|"                                                                 |
|[..]  I guess this then                                           |
|will be the first time that the CS mathematicians start seeing the|
|harm that their intuition is doing to computer programming..."    |
|------------------------------------------------------------------|

What harm is being done? It is true that some adjustments are needed
or are at least appropriate to overcome difficulties with traditional
high school formulations of algorithms when ported to tricky inorganic
computers, but I do not agree that using a limited base of high school
mathematics for programming examples is harmful.

Yours sincerely,
Colin Paul

Re: Ada for 1st year students

[Colin Paul Gloster]

On Sun, 12 Oct 2008, Dmitry A. Kazakov wrote:

|--------------------------------------------------------------------------|
|"On Sun, 12 Oct 2008 06:00:51 -0700 (PDT), John McCormick wrote:          |
|                                                                          |
|> It never ceases to amaze me how computer science educators want to use  |
|> bleeding edge technology in the beginning courses.                      |
|                                                                          |
|I don't see anything bad in that. It is the question what is considered as|
|a bleeding edge. Ada is certainly one in large, high-integrity, concurrent|
|systems design. It also has a very innovative OO types system. (However,  |
|there are problems with irregularity, MI, MD). It is a question of how do |
|you sell it."                                                             |
|--------------------------------------------------------------------------|

What is bleeding edge in Ada?

How can bleeding edge technology be risked in high-integrity systems?

Regards,
Colin Paul

Re: Ada for 1st year students

[Dmitry A. Kazakov]

On Mon, 13 Oct 2008 14:10:28 +0100, Colin Paul Gloster wrote:

> On Sun, 12 Oct 2008, Dmitry A. Kazakov wrote:
> 
>|--------------------------------------------------------------------------|
>|"On Sun, 12 Oct 2008 06:00:51 -0700 (PDT), John McCormick wrote:          |
>|                                                                          |
>|> It never ceases to amaze me how computer science educators want to use  |
>|> bleeding edge technology in the beginning courses.                      |
>|                                                                          |
>|I don't see anything bad in that. It is the question what is considered as|
>|a bleeding edge. Ada is certainly one in large, high-integrity, concurrent|
>|systems design. It also has a very innovative OO types system. (However,  |
>|there are problems with irregularity, MI, MD). It is a question of how do |
>|you sell it."                                                             |
>|--------------------------------------------------------------------------|
> 
> What is bleeding edge in Ada?
> 
> How can bleeding edge technology be risked in high-integrity systems?

Very simple, because the complexity of high-integrity systems grows fast,
as they *necessarily* become networking, distributed and multi-tasking. We
need new technologies of software design in order to keep such systems
integral and affordable. So the risk is here, anyway. Use of traditional
MISRA C only increases the risk, after a certain grade of complexity has
been reached.

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

Re: Ada for 1st year students

[Colin Paul Gloster]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: TEXT/PLAIN; CHARSET=UTF-8; format=flowed, Size: 6234 bytes --]

Amado Alves started this thread with a post which appeared on October
9th, 2008:

|----------------------------------------------------------------------|
|"Dear Fellow Adaists:                                                 |
|                                                                      |
|I have been blessed with the oportunity to teach Ada to 1st year      |
|students of a licenciate programme of informatics engineering at      |
|Universidade Lusófona do Porto.                                       |
|                                                                      |
|I seek advice from the vast wisdom in this forum, on:                 |
|                                                                      |
|(1) Textbooks. In Portuguese (Brazilian translation fine) or English. |
|Must be introductory, i.e. for students sans prior knowledge of       |
|programming in any language. Should be small or cheap (or both). The  |
|vendor should be prompt."                                             |
|----------------------------------------------------------------------|

Greetings,

I work in the original University of Coimbra, though not as a
lecturer. I have not noticed many Ada books in Portuguese. It may be
beneficial to have a list of such books (even if they are out of print
(it might be possible to borrow them from a library of another
university) or not the best (though warnings of bad parts of books
would be useful)) when I am asked for advice on how to learn Ada.

As for whether vendors are prompt or not, some are but in cases where
vendors were slow, they were slowed down by me (as many suggested that
I could try to run benchmarks but I must still write a significantly
meaningful representative body of code with which to conduct such
benchmarks).

|----------------------------------------------------------------------|
|"(2) Compilers. Must be free (as in free beer) or very low cost"      |
|----------------------------------------------------------------------|

Is this to teach the students that they shall live in poverty if they
shall not be self-sufficient by means of a discipline other than
informatics engineering?

|-----------------------------------------------------------------------|
|"(perhaps an educational license) and install out-of-the box on Windows|
|or Linux (or both, preferably)."                                       |
|-----------------------------------------------------------------------|

Aside from GNAT which had already been mentioned in this thread, I
suspect that one licensing option of an Aonix compiler might be
suitable. It used to be possible to get a cheap Aonix compiler many
years ago and I do not know whether that is still true.
Compilers are available affordably for universities from OC Systems (
WWW.OCSystems.com
) though not for Windows. Depending on the platform, Motif or
OpenMotif bindings are provided.
Janus/Ada and Claw are definitely available for a small amount of
money though possible graphical development for a project I am
involved in would not be expected to start for a long time and so I
have not used Janus/Ada yet.
An academic license from Sofcheck is affordable, though I do not know
what you would use for graphics.
You can telephone Mr. Lima of International Business Machines on 218
927 455 or 915 601 760 or fax him on 218 927 280 or Nuno Marques also
of I.B.M. on 218927380 or 917226179 re a teaching license but I do not
remember how much of a discount it would entail (it would be a bigger
discount than for collegiate research and I have not yet taken
advantage of an invitation to try a copy without committing in advance
to paying for it and keeping it, so I do not know whether a graphical
library is supplied). I.B.M. Ada compilers for Windows are no longer
supplied.
I do not know whether Irvine offers a graphical library.

|----------------------------------------------------------------------|
|" Must support Latin-1, preferably                                    |
|Unicode. The vendor should be prompt.                                 |
|                                                                      |
|[..]                                                                  |
|                                                                      |
|(4) Graphic or GUI library. (I want to be able to produce graphical   |
|output, not just the same old text output on a teletype-like window.) |
|Same requirements as above, plus: a simple or small API, eventually at|
|the cost of possibilities (e.g. may be limited to a single window, of |
|a single fixed size, limited number of colors). Should have some      |
|support for input, e.g. textboxes, buttons, mouse input. Should use a |
|simple fragment of Ada, viz. excluding OOP. Should support printing,  |
|or exporting to PDF or some such, or clipboard copying onto a "office"|
|document, or any combination of the above. Support for a picture      |
|format would be a plus (PNG, JPEG...)                                 |
|[..]"                                                                 |
|----------------------------------------------------------------------|

Furthermore, Amado Alves later emphasized in
news:1fe7f0a7-498c-4fd2-833f-ff223220dfc1@b38g2000prf.googlegroups.com
on the same day:
|------------------------------------------------------------------|
|"[..]                                                             |
|                                                                  |
|[..] Using JEWL and then telling my students                      |
|"if you want graphics you have to use Windows" will send the wrong|
|message I'm afraid... Not pedagogical at all."                    |
|------------------------------------------------------------------|

Support for character sets and graphics are not important for the
current parts of my work, so I do not confirm nor deny their
presence.

I have never used it, but you may determine for yourself whether Steve
Sangwine's PNG binding at
HTTP://PNG-IO.Sourceforge.net
is suitable.

Regards from Coimbra,
Colin Paul Gloster

Re: Ada for 1st year students

[Colin Paul Gloster]

On Mon, 13 Oct 2008, Dmitry A. Kazakov wrote:

|-----------------------------------------------------------------------------|
|"[..]                                                                        |
|>                                                                            |
|> How can bleeding edge technology be risked in high-integrity systems?      |
|                                                                             |
|Very simple, because the complexity of high-integrity systems grows fast,    |
|as they *necessarily* become networking, distributed and multi-tasking. [..]"|
|-----------------------------------------------------------------------------|

Networks; distributed systems; and multi-tasking have existed for
centuries. How are these bleeding edge?

Re: Ada for 1st year students

[Dmitry A. Kazakov]

On Mon, 13 Oct 2008 15:26:32 +0100, Colin Paul Gloster wrote:

> On Mon, 13 Oct 2008, Dmitry A. Kazakov wrote:
> 
>|-----------------------------------------------------------------------------|
>|"[..]                                                                        |
>|>                                                                            |
>|> How can bleeding edge technology be risked in high-integrity systems?      |
>|                                                                             |
>|Very simple, because the complexity of high-integrity systems grows fast,    |
>|as they *necessarily* become networking, distributed and multi-tasking. [..]"|
>|-----------------------------------------------------------------------------|
> 
> Networks; distributed systems; and multi-tasking have existed for
> centuries. How are these bleeding edge?

1. In high-integrity systems?

2. Even without that at the level of engineering, for centuries there is no
any industrial technology to design such systems.

3. Silicon exits almost since the Big Bang, nevertheless computer design is
a bleeding edge.

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

Re: Ada for 1st year students

[Georg Bauhaus]

Colin Paul Gloster wrote:
> On Sun, 12 Oct 2008, Georg Bauhaus wrote:

> |------------------------------------------------------------------|
> |"                                                                 |
> |[..]  I guess this then                                           |
> |will be the first time that the CS mathematicians start seeing the|
> |harm that their intuition is doing to computer programming..."    |
> |------------------------------------------------------------------|
> 
> What harm is being done?

Distraction from the topics of computer science (knowledge
of the computer).  Try to minimize things that (a) are not
about computers and (b) need additional knowledge of largely
unrelated detail.  IOW, CS should not be made a math review
course.
  CS needs to put limits on mathematical high school intuition.
E.g., if you want to study computers, and only computers,
then knowing sets is probably more to the point than knowing
integrals.

Example:
A type is a *set* together with a set of operations.

   type Colors_of_the_Rainbow is
    (Rot, Orange, Gelb, Gr�n, Blau, Indigo, Violett).

This is a set.  In

   Colors_of_the_Rainbow'Succ (Indigo),

Succ is an operation associated with the type
Colors_of_the_Rainbow. It takes a value from the set and
produces another value of the set, if there is one.
For Indigo, it produces Violett.

You can express Type + Operations as a tuple,

  ({Rot, Orange, Gelb, Gr�n, Blau, Indigo, Violett},
           -- the values
   {Succ, Pred, ...}).
           -- the operations

Is this, I guess algebraic style, typical of high school
mathematics?

Re: Ada for 1st year students

[John McCormick]

On Oct 12, 9:56 am, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
wrote:
> On Sun, 12 Oct 2008 06:00:51 -0700 (PDT), John McCormick wrote:
> > It never ceases to amaze me how computer science educators want to use
> > bleeding edge technology in the beginning courses.
>
> I don't see anything bad in that. It is the question what is considered as
> a bleeding edge. Ada is certainly one in large, high-integrity, concurrent
> systems design. It also has a very innovative OO types system. (However,
> there are problems with irregularity, MI, MD). It is a question of how do
> you sell it.

Your points about Ada's complexity are appropriate for upper level
courses.  But not for the first course.  Here students are struggling
with the basic control structures and the basic scalar and composite
types.

It is common that the latest fad language is undergoing rapid change.
Often the textbooks are a version or two behind the tools the students
are using.  While more advanced students can deal with these
differences, it is VERY frustrating to beginners. This was the point I
was trying to make with my comment.

John

Re: Ada for 1st year students

[Colin Paul Gloster]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: TEXT/PLAIN; charset=UTF-8, Size: 3535 bytes --]

On Mon, 13 Oct 2008, Georg Bauhaus wrote:

|----------------------------------------------------------------------|
|"Colin Paul Gloster wrote:                                            |
|> On Sun, 12 Oct 2008, Georg Bauhaus wrote:                           |
|                                                                      |
|> |------------------------------------------------------------------||
|> |"                                                                 ||
|> |[..]  I guess this then                                           ||
|> |will be the first time that the CS mathematicians start seeing the||
|> |harm that their intuition is doing to computer programming..."    ||
|> |------------------------------------------------------------------||
|>                                                                     |
|> What harm is being done?                                            |
|                                                                      |
|Distraction from the topics of computer science (knowledge            |
|of the computer).  Try to minimize things that (a) are not            |
|about computers and (b) need additional knowledge of largely          |
|unrelated detail.  [..]"                                              |
|----------------------------------------------------------------------|

Perhaps it is possible to concentrate excessively on mathematics, but
would you disapprove of the following exercise from a textbook because
it requires a basic familiarity with things which are not computers?
"Suppose every student except student b passes their electronics
exam. Write the relevant Pascal program text for representing the set
of students who fail electronics." Those things being for example any
of a student; electronics; failure; and calling a student "b".

|----------------------------------------------------------------------|
|"  CS needs to put limits on mathematical high school intuition.      |
|E.g., if you want to study computers, and only computers,             |
|then knowing sets is probably more to the point than knowing          |
|integrals.                                                            |
|                                                                      |
|[..]"                                                                 |
|----------------------------------------------------------------------|

One should know about integration if one is designing a computer which
performs integration (which is a computational chore).

I agree that sets (or things like sets) are almost always important.

|----------------------------------------------------------------------|
|"You can express Type + Operations as a tuple,                        |
|                                                                      |
|  ({Rot, Orange, Gelb, Grün, Blau, Indigo, Violett},                  |
|           -- the values                                              |
|   {Succ, Pred, ...}).                                                |
|           -- the operations                                          |
|                                                                      |
|Is this, I guess algebraic style, typical of high school              |
|mathematics?"                                                         |
|----------------------------------------------------------------------|

I suspect that it is not.

Regards,
Colin Paul Gloster

Re: Ada for 1st year students

[amado.alves]

> would be willing to import books stocked on the same continent as
> Portugal from
> WWW.Eason.Ie
(Colin)

Thanks, I'll check. I try a bunch of vendors but usually I end up with
Amazon.UK, the things arrive in a couple of days.

(Principal software shop in Coimbra is Critical, is that where you're
at? I did a gig there.)

Re: Ada for 1st year students

[amado.alves]

> > Is mathematical high school knowledge helpful at all?             >
> Yes.

I second that yes. I find it very useful that CS students know
algebraic structures, discrete mathematics (summations), boolean
algebra, induction, set theory, first order logic (usually not in high
school curricula unfortunately)...

Re: Ada for 1st year students

[amado.alves]

Colin, thanks for the extensive references. I'll check.

At Universidade Nova de Lisboa I had a colleague named Nuno Marques.
I'm curious to see if he's the IBM guy.

PNG-IO I know well. It works fine. Only problem is the infectious
license (GPL). They won't supply another.

Re: Ada for 1st year students

[Gene]

On Oct 11, 9:35 am, amado.al...@gmail.com wrote:

> I share your stance on the usual GUIs being too distracting. Note I
> require simplicity, even limitedness, to avoid that. Like turtle
> graphics. But I want a couple input gadgets. Actually I was thinking
> of a fixed panel with a couple buttons, textboxes, and an output
> frame, and the studends only change the names of these components, and
> the API is totally imperative. Maybe next year... In the meanwhile, I
> think I'll go with AdaGIDE and JEWL.

We publish a very simple Ada turtle graphics written over GtkAda that
has a split window with graphics on the left and a console on the
right hand side.  There is a replacement interface for Ada.Text_IO
that writes and reads text strings in the right hand panel.  Mouse
input works in the left hand window.  There are a couple of sample
programs.  If you want buttons, you can easily implement simple ones
yourself, which has value of its own.

We have used this in a CS1-type course for a few years with good
results.  It runs equally well over Windows or Unix.

IMO the most valuable thing about this package is that the programmer
does Get/Put style I/O (even for the mouse) rather than handling
events.  Event-handing is too much for many beginning programmers to
understand because the handlers can be called in arbitrary orders.
They need to figure out what sequential execution is before they
should have to deal with that extra complexity.

See http://www.eecs.usma.edu/research/ .

Incidentally, we will move away from Ada in CS1 over my dead, cold
body.

Re: Ada for 1st year students

[Randy Brukardt]

"Ludovic Brenta" <ludovic@ludovic-brenta.org> wrote in message 
news:8905e0da-08c8-4cfd-9731-9eaa21d43fcd@e38g2000prn.googlegroups.com...
>Amado writes:
...
>> I have knowledge, in various degrees, of various items in each
>> category, but I will not name any at this moment, to avert
>> prejudice ;-)
>
>I have a prejudice against proprietary software, so I don't name
>names, but there is a vendor in Madison, Wisconsin, who might be able
>to help if you don't need compatibility with POSIX :)

I assume you are talking about Claw. Keep in mind that the Claw Introductory 
Version bindings are licensed under the GMGPL (although the files don't show 
that), so it can be used in Open Source software. For the OP's purposes, I 
think it would be enough. But no Linux version (yet).

                             Randy.

Re: Ada for 1st year students

[amado.alves]

> ... the Claw Introductory
> Version bindings are licensed under the GMGPL (although the files don't show
> that), so it can be used in Open Source software. For the OP's purposes, I
> think it would be enough. But no Linux version (yet).
>
>                              Randy.

Yes, good old Claw, the Introductory Version would do fine, thanks for
the reminder.

Re: Ada for 1st year students

[Colin Paul Gloster]

On Mon, 13 Oct 2008, Amado Alves submitted:

|---------------------------------------------------------------------|
|"[..]                                                                |
|                                                                     |
|(Principal software shop in Coimbra is Critical, is that where you're|
|at? I did a gig there.)"                                             |
|---------------------------------------------------------------------|

No, I do not work in a software shop. I am a computer scientist
employed as a physicist in the Department of Physics of one of the
universites of Coimbra. If you happen to visit the locality, you would
be welcome to visit me (though I am not always in the country).

Critical Sofware drafted an impressive list of flaws of the bug-ridden
Open RAVENSCAR Kernel which though it did not list one of the most
important bugs (whih I think might not had been in the version which
Critical Software had inspected but which has been in a version which
I used shortly thereafter), was an impressively longer list than the
problems I had detected myself. I asked for a final report which still
has not been delivered to me after some five years.

I unsuccessfully applied to work for Critical Software once.

Regards,
Paul Colin

Re: Ada for 1st year students

[Colin Paul Gloster]

On Mon, 13 Oct 2008, Dmitry A. Kazakov wrote:

|--------------------------------------------------------------------------------|
|"On Mon, 13 Oct 2008 15:26:32 +0100, Colin Paul Gloster wrote:                  |
|                                                                                |
|> On Mon, 13 Oct 2008, Dmitry A. Kazakov wrote:                                 |
|>                                                                               |
|>|-----------------------------------------------------------------------------||
|>|"[..]                                                                        ||
|>|>                                                                            ||
|>|> How can bleeding edge technology be risked in high-integrity systems?      ||
|>|                                                                             ||
|>|Very simple, because the complexity of high-integrity systems grows fast,    ||
|>|as they *necessarily* become networking, distributed and multi-tasking. [..]"||
|>|-----------------------------------------------------------------------------||
|>                                                                               |
|> Networks; distributed systems; and multi-tasking have existed for             |
|> centuries. How are these bleeding edge?                                       |
|                                                                                |
|1. In high-integrity systems?                                                   |
|                                                                                |
|[..]"                                                                           |
|--------------------------------------------------------------------------------|

Probably yes.

A hospital probably existed centuries ago, such that that hospital was
networked to a distributed system of gatherers of medicines. A plural
number of patients probably used to be treated when the multi-tasking
load was significant.

Regards,
Colin Paul Gloster

Re: Ada for 1st year students

[Dmitry A. Kazakov]

On Tue, 14 Oct 2008 13:03:53 +0100, Colin Paul Gloster wrote:

> A hospital probably existed centuries ago, such that that hospital was
> networked to a distributed system of gatherers of medicines. A plural
> number of patients probably used to be treated when the multi-tasking
> load was significant.

It is not a software system. So far even networking the devices within one
operating room is impossible at the safety and reliability level required.
There is no any technology to do this at the hospital level. This is not
even a bleeding edge, it is a very remote future.

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

Re: Ada for 1st year students

[Georg Bauhaus]

Colin Paul Gloster schrieb:

> Perhaps it is possible to concentrate excessively on mathematics, but
> would you disapprove of the following exercise from a textbook because
> it requires a basic familiarity with things which are not computers?
> "Suppose every student except student b passes their electronics
> exam. Write the relevant Pascal program text for representing the set
> of students who fail electronics." Those things being for example any
> of a student; electronics; failure; and calling a student "b".

This example shows two processes involved in problem
solving:  (1) Transporting the problem from its own domain to
the computer abstraction. (2) Solving the programming problem.

I'd suggest, then, that first the transport destination (computer)
must become a familiar item. Can't expect anyone to operate
unfamiliar, complex machinery... That is, students must know
what a computer is in order to write programs.

So instead of starting with algorithms involving students,
examinations, eventualities, and other deceptively familiar
things, introduce an array as an addressable sequence of memory
cells. Have them contain bit patterns.  Propose to solve the
follosing problem: Find a particular pattern "b" in the array.

I think there is a lot to learn from array searching.
You need the very basics of programming.  The advantage of
starting with the computer and nothing else is that you do not
loose focus.
I think there is a famous paper entitled "An algorithm, Find."
or similar.

Of course, you can't find a programming solution to some real
world problem without also knowing how to find abstractions.
Later.

Re: Ada for 1st year students

[amado.alves]

> > option, only the IDE... I have reservations aboutGPS, it's too much,
> > and in my experience slow andunreliable, I think I'll give Eclise a
> (Marius)
> GPSslow andunreliable... Well I'm using it all days...
(Pascal)

I was just painfully reminded of what I really dislike about GPS and
these sort of IDEs in general. You cannot build a program! You have to
create a "project", then configure here, configure there. Total BS. It
completely ruined my class yesterday, about building and executing
Hello world! I will ditch GPS and call gnatmake upon Ada directly.
It's easier to learn and control and use. Unfortunately we loose the
baby (the editor) with the bath water (the "IDE"). I'll probably use
AdaGIDE. Thanks.

Re: Ada for 1st year students

[christoph.grein]

> I was just painfully reminded of what I really dislike about GPS and
> these sort of IDEs in general. You cannot build a program! You have to
> create a "project", then configure here, configure there. Total BS. It
> completely ruined my class yesterday, about building and executing
> Hello world! I will ditch GPS and call gnatmake upon Ada directly.
> It's easier to learn and control and use. Unfortunately we loose the
> baby (the editor) with the bath water (the "IDE"). I'll probably use
> AdaGIDE. Thanks.

I don't understand this. If you have a more complex system (files
distributed over many directories), use of a GNAT project file eases
building the program. This has nothing to do with GPS:

gnatmake -P project_file ...

GPS helps you in creating the project file and when you press Build,
it calls gnatmake resp. gprmake as you would do it from the command
line. So where is the problem?

Of course, AdaGIDE is much simpler, so it's good for beginners, but
use of it for my daily work - only over my dead body... (I use a set
of about 20 project files, all being imported by the "main" project,
to build the system. And replacing Ada units for experimental changes
without changing the original units is really easy with extension
projects, even in parallel by different developers/testers - and you
have all changed units together in one place, irrespective of where
the originals are located.)

Re: Ada for 1st year students

[Jean-Pierre Rosen]

amado.alves@gmail.com a �crit :
>>> option, only the IDE... I have reservations aboutGPS, it's too much,
>>> and in my experience slow andunreliable, I think I'll give Eclise a
>> (Marius)
>> GPSslow andunreliable... Well I'm using it all days...
> (Pascal)
> 
> I was just painfully reminded of what I really dislike about GPS and
> these sort of IDEs in general. You cannot build a program! You have to
> create a "project", then configure here, configure there. Total BS. It
> completely ruined my class yesterday, about building and executing
> Hello world! I will ditch GPS and call gnatmake upon Ada directly.
> It's easier to learn and control and use. Unfortunately we loose the
> baby (the editor) with the bath water (the "IDE"). I'll probably use
> AdaGIDE. Thanks.
Two things about GPS:
1) Make sure you use a recent version. Yes, first versions were buggy, 
but this has changed.

2) It is easy to prepare a project for your students. I'm giving a full 
Ada training in 6 days - obviously no time to waste with setting up an 
environment. I provide a directory which already contains a .gpr file, 
and students don't have to care about the details
-- 
---------------------------------------------------------
            J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: Ada for 1st year students

[amado.alves]

> I don't understand this. If you have a more complex system (files
> distributed over many directories), use of a GNAT project file eases
> building the program. This has nothing to do withGPS:
>
> gnatmake -P project_file ...
>
> GPShelps you in creating the project file and when you press Build,
> it calls gnatmake resp. gprmake as you would do it from the command
> line. So where is the problem?

The problem is it ruins my classes!

And project files are completely unecessary and inconvient. As you
know Ada is designed in such a way that all the dependencies are
described in the program text. Fortunately gnatmake understands this
and works fine sans project file.

I also find the outline window uncessary and inconvenient. It is
doubling what is already there in the program text.

In my opinion this new trend of IDEs ruined program text editing and
viewing.

Now jGRASP is another story. I thing they got it right.

Re: Ada for 1st year students

[christoph.grein]

> And project files are completely unecessary and inconvient. As you
> know Ada is designed in such a way that all the dependencies are
> described in the program text.

Ada describes only the dependences among Ada units. It has nothing to
say about where these units are. gnatmake has switches to tell it
where to look. Projects are just another means (and IMO with much
better readability) to tell where to find the units.

> Fortunately gnatmake understands this
> and works fine sans project file.

Yeah, with a lot of -I switches...

> I also find the outline window uncessary and inconvenient. It is
> doubling what is already there in the program text.

I have to deal with a lot of units not written by me with sometimes
about 20 or more subprograms in them. The outline view enables quick
navigation among them.

> In my opinion this new trend of IDEs ruined program text editing and
> viewing.

Hm, that's just your opinion, that's OK.

But do not confound this with e.g. the Java-like documentation. There
a people doing the same for Ada - an IMHO absolutely silly
undertaking. Ada has (contrary to Java) separate specs and bodies, so
I prefer reading the specs directly instead of some generated junk
documentation files.

> Now jGRASP is another story. I thing they got it right.

They indeed have a nice way to present code :-)

Re: Ada for 1st year students

[Dmitry A. Kazakov]

On Wed, 15 Oct 2008 04:00:37 -0700 (PDT), christoph.grein@eurocopter.com
wrote:

> I don't understand this. If you have a more complex system (files
> distributed over many directories), use of a GNAT project file eases
> building the program.

It is not only a GPS problem. Visual Studio, GPS tries to imitate, has it,
Workbench as well (and totally unusable in addition). You need to create a
project up front. But typically people start a project with one or two
files and want to work on incrementally. Ada as a language allows this. GPR
project files do not.

> Of course, AdaGIDE is much simpler, so it's good for beginners, but
> use of it for my daily work - only over my dead body.

I like AdaGIDE's approach that a source file can be compiled immediately
and the "project" (I mean the *.ago file) is created in the background.
Later, as the project grows you can modify the project file.

BTW, I don't consider visual editing of project files as a strength. It
does not work in GPS, it also does not in Visual Studio. In both I edit
project files manually using a text editor. It would be much better if Ada
Core would scrap that MS stuff and invest freed resources into editing
project files as texts with on-the-fly checks, auto-completion support,
elaborated context help, getting rid of Phyton scripts. Also the language
of project files is far from being satisfactory (yes, it is not XML, but
not yet Ada! (:-))

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

Re: Ada for 1st year students

[Pascal Obry]

amado.alves@gmail.com a �crit :
> And project files are completely unecessary and inconvient.

For small projects maybe but for large projects spread across multi
directories and aggregating multiple modules or other projects it is
really really convenient. I do not feel like adding thousand of -I and -L!

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|              http://www.obry.net
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada for 1st year students

[amado.alves]

> 2) It is easy to prepare a project for your students. I'm giving a full
> Ada training in 6 days - obviously no time to waste with setting up an
> environment. I provide a directory which already contains a .gpr file,
> and students don't have to care about the details (Rosen)

Thanks for the tip. But it doesn't work for me. I have a lot of
projects (real projects, not GPS notion). I don't have time to write
all gpr files. (Which are unecessary anyway.)

Re: Ada for 1st year students

[amado.alves]

> For small projects maybe but for large projects spread across multi
> directories and aggregating multiple modules or other projects it is
> really really convenient. I do not feel like adding thousand of -I and -L!
(Obry)

Agreed, but aren't there environment variables for that?

Re: Ada for 1st year students

[amado.alves]

> It is not only a GPS problem. Visual Studio, GPS tries to imitate, has it,
> Workbench as well (and totally unusable in addition). You need to create a
> project up front. But typically people start a project with one or two
> files and want to work on incrementally. Ada as a language allows this. GPR
> project files do not. (Kasakov)

Exactly! Greatly put.

> I like AdaGIDE's approach that a source file can be compiled immediately
> and the "project" (I mean the *.ago file) is created in the background.
> Later, as the project grows you can modify the project file.

Yes, that makes a world of difference (if these drafted projects file
are needed at all, or convenient, or better than environmental
variables, which I still don't think they are).

> BTW, I don't consider visual editing of project files as a strength. It
> does not work in GPS, it also does not in Visual Studio....

Yeah, visual programming only introduces a new form of spaggetti. I've
seen this happen. Visual "programmers" writing the (possibly) right
code on the wrong textbox of the wrong popdown menu of the wrong
window... WIMP programmers indeed. Visual spaggetti, the worse kind
there is. Bugs extremely hard to find. Takes months. That's the
bleeding edge technology of programming tools :-(

I am not teaching IDEs, or project management, or configuration
management. I am teaching algorithmics, and Ada. The visual noise and
extra work introduced by these Visual IDEs is simply unacceptable for
this purpose.

Re: Ada for 1st year students

[Georg Bauhaus]

christoph.grein@eurocopter.com schrieb:
>> And project files are completely unecessary and inconvient. As you
>> know Ada is designed in such a way that all the dependencies are
>> described in the program text.

(I think it _is_ possible to compile a simple one
file main unit in GPS without setting up a project first.)

> Ada describes only the dependences among Ada units. It has nothing to
> say about where these units are. gnatmake has switches to tell it
> where to look. Projects are just another means (and IMO with much
> better readability) to tell where to find the units.

This is about a class for beginners.  Configuration
management will keep them busy learing things that
have little to do with writing your first programs for
a well defined execution environment.

The concept of feeding the source to the compiler
is obviously easier to understand when all that is
needed is

$ gnatmake main.ads

or


$  adacomp  my_turtles.ada

or some such.

The first programs might need to with other units,
at some point. To avoid -I-ing etc., I'd rather dump
included directories and instead put all the needed
source files in one working directory.  It will be
obvious, then, where the files are, how to look at
them, and so on.
Arranging larger projects is another subject.

The GNAT User's Manual has always had a section on
translation using gnatmake.  I think it was written after
years of experience in teaching how to use a compiler.

Re: Ada for 1st year students

[amado.alves]

> (I think it _is_ possible to compile a simple one
> file main unit in GPS without setting up a project first.)

Occasionally, but only after a lot of nob turning, and by then the
class is ruined.

> This is about a class for beginners.  Configuration
> management will keep them busy learing things that
> have little to do with writing your first programs for
> a well defined execution environment.

Exactly! Thanks a lot, I don't feel lonely anymore :-)

Re: Ada for 1st year students

[christoph.grein]

On 16 Okt., 00:30, amado.al...@gmail.com wrote:
> > (I think it _is_ possible to compile a simple one
> > file main unit in GPS without setting up a project first.)
>
> Occasionally, but only after a lot of nob turning, and by then the
> class is ruined.
>
> > This is about a class for beginners.  Configuration
> > management will keep them busy learing things that
> > have little to do with writing your first programs for
> > a well defined execution environment.
>
> Exactly! Thanks a lot, I don't feel lonely anymore :-)

I think you misunderstood what I said. For beginners, AdaGIDE or
command line is OK, why bother them with config mgmt.

But as soon as you start a "real" project, you cannot do without some
config managmnt. Rational (now IBM) APEX uses subsytems for this,
AdaCore GNAT uses project files - I know both of them and both have
their pros and cons - , Aonix (now who, I forget) ObjectAda some other
means, RR and who else sells compilers have still other means.

Alas, Ada stopped at the code level, the APSE idea (the standard for
the development environment) did not get anywhere (wasn't it the
woodenman document?).

And I gather GNAT project files were introduced exactly because using
hundreds of -I switches was felt inconvenient, to say the least. So
how come they are useless?

Re: Ada for 1st year students

[amado.alves]

> And I gather GNAT project files were introduced exactly because using
> hundreds of -I switches was felt inconvenient, to say the least. So
> how come they are useless?

Second time someone counts *hundreds* of -I switches. I'd love to see
that list :-)
Largest count of -I switches I've ever seen is around ten.
Even so I think I prefer a single gnatmake command.
Even if it's like those two-page long SQL queries kept religiously in
banks, insurance companies (and now telecoms I guess :-)
Usually I include the build command as a comment in the main program.
A stored command, a project file, I see no difference, except the
latter is yet another tool.
But I accept project files hapilly for large lists.
The hard part is finding out the paths anyway.

Common Configuration Settings (was: Ada for 1st year students)

[Georg Bauhaus]

christoph.grein schrieb:

> Alas, Ada stopped at the code level, the APSE idea (the standard for
> the development environment) did not get anywhere (wasn't it the
> woodenman document?).
> 
> And I gather GNAT project files were introduced exactly because using
> hundreds of -I switches was felt inconvenient, to say the least.

How about a set of rules covering common settings
for configuration management in a compiler independent
fashion?

For example, the set could cover the Cartesian product of
the usual suspects, such as directories to be included,
the target platform, debugging, assertions and checks, ...
Once a few basic rules are there, it should be easy to

(a) transform the rules into compiler specific syntax

(b) have rule transformation use host OS conventions

(c) allow for compiler specific additions


We would not have to learn yet another ad hoc language.

Re: Ada for 1st year students

[christoph.grein]

On 16 Okt., 11:12, amado.al...@gmail.com wrote:
> Second time someone counts *hundreds* of -I switches. I'd love to see
> that list :-)

I doubt you would like to see it.

We have source distributed in about 20 main directories, so-called
subsystems. Each of these is organized in a hierarchy of deeply nested
subdirectories. Path names get awfully long. All in all, there are
several 1000 Ada units.

I really did not feel like trying to write the set of -aI switches.
Instead I have a set of about 20 project files corresponding to the
above mentioned main directories. In a project file, I can say "take
all units in directory x and its subdirectories". As far as I know,
there is no way to do this with -aI; I have to name each single
directory where there are some units. This surely would amount to
100s.

I could use environment variables, but I can't put them under
configuration control as I can do with project files. And they are not
so easily maintainable.

I'm sure there would be a way to go without project files, I just find
they present the most convenient one.

Re: Common Configuration Settings (was: Ada for 1st year students)

[christoph.grein]

On 16 Okt., 11:42, Georg Bauhaus <rm.dash-bauh...@futureapps.de>
wrote:
> How about a set of rules covering common settings
> for configuration management in a compiler independent
> fashion?
>
> For example, the set could cover the Cartesian product of
> the usual suspects, such as directories to be included,
> the target platform, debugging, assertions and checks, ...
> Once a few basic rules are there, it should be easy to
>
> (a) transform the rules into compiler specific syntax
>
> (b) have rule transformation use host OS conventions
>
> (c) allow for compiler specific additions
>
> We would not have to learn yet another ad hoc language.

Aha, wouldn't we need some language for this? Python, Perl, Ruby, ...
This looks like another ad hoc language for me. There was some reason
why APSE did not evolve.

Re: Ada for 1st year students

[Niklas Holsti]

christoph.grein@eurocopter.com wrote:

> We have source distributed in about 20 main directories, so-called
> subsystems. Each of these is organized in a hierarchy of deeply nested
> subdirectories. Path names get awfully long. All in all, there are
> several 1000 Ada units.
> 
> I really did not feel like trying to write the set of -aI switches.
> ...
> 
> I could use environment variables, but I can't put them under
> configuration control as I can do with project files. And they are not
> so easily maintainable.

I use shell-scripts that define the environment variables 
(ADA_INCLUDE_PATH), then do "gnatmake" without -I options. There 
are different scripts for different versions and configurations of 
the Ada programs. These script files are under configuration control.

I don't have as many directories and subdirectories as Christoph, 
so I don't (yet) need to write recursive directory traversal 
algorithms in these scripts, but it would be possible to do so and 
get the equivalent of the project-file construct "take all units in 
directory x and its subdirectories".

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

Re: Common Configuration Settings

[Georg Bauhaus]

christoph.grein@eurocopter.com schrieb:

>> Once a few basic rules are there, it should be easy to
>>
>> (a) transform the rules into compiler specific syntax
>>
>> (b) have rule transformation use host OS conventions
>>
>> (c) allow for compiler specific additions
>>
>> We would not have to learn yet another ad hoc language.
> 
> Aha, wouldn't we need some language for this? Python, Perl, Ruby, ...

No no no...!  Common configuration language just needs a simple
stupid abstract CFG based on existing language.

GNAT project files, or AdaMagic's ADA.LIB and UNIT.MAP are
heading in this direction.  There is overlap in what the
GNAT files and AdaMagic files contain, such as paths.
It is at this overlap of settings where I would start defining
simple common configuration.

The current situation for portable Ada projects is that even
when configuration settings are the same, you still need
to specify and maintain them in differnt ways. Why?

Obviously, configuration is important, and is adressed
in any case, by each vendor.
In order to reduce the amount of duplicated configuration
information, a common core would need to be formalized.
Now that Ada.Directories and Ada.Environment_Variables
are part of the Ada language implementers have algorithms
ready.

Re: Ada for 1st year students

[amado.alves]

> I use shell-scripts that define the environment variables...
> These script files are under configuration control.

I use Ada scripts :-)

Re: Common Configuration Settings

[amado.alves]

> Now that Ada.Directories and Ada.Environment_Variables
> are part of the Ada language implementers have algorithms
> ready.

Sounds like my Ada scripts that set up paths etc. :-)

Re: Ada for 1st year students

[Pascal Obry]

amado.alves@gmail.com a �crit :
> Largest count of -I switches I've ever seen is around ten.

I can count a single one if I put all the sources into the same
directory. This is just bad design. If you have modules for subsystems
then you'll have very soon lot of -I and -L... And you'll also have to
manage the linker library order (not that trivial)...

> Even so I think I prefer a single gnatmake command.

Me too:

   $ gnatmake -P myapp

Don't tell me that:

   $ gnatmake -Ithis -Ithat/there/whatever -Iand/again/here main.adb \
      -largs -llibfoo -llibbar -llibwhatever -bargs -E

is easier to read, maintain and understand :)

> The hard part is finding out the paths anyway.

That no hard path. The project file does this for you. I think you do
not understand the project facility at all.

Let's have a simple example:

   application/
      appli.gpr
      src
      obj

      module1/
         module1.gpr
         src
         obj
         lib

      module2/
         module2.gpr
         src1
         src2
         obj

file: module1.gpr

   project Module1 is
      for Source_Dirs use ("src");
      for Object_Dir use "obj";
      for Library_Name use "mod1";
      for Library_Kind use "relocatable";
   end Module1;

file: module2.gpr

   project Module1 is
      for Source_Dirs use ("src1", "src2");
      for Object_Dir use "obj";
   end Module1;

file: appli.gpr

   with "module1/module1";
   with "module2/module2";
   with "gtkada";
   with "aws";

   project Appli is
      for Source_Dirs use ("src");
      for Object_Dir use "obj";
      for Main use ("runme.adb");
   end Appli;

Then to build appli:

   $ gnatmake -Pappli

It will build a relocatable library (and yes this is portable to Win32
or UNIXes) named libmod1.so, a set of sources from module2, a set of
sources from main application and will then link your executable with is
based on module1, module1 and GtkAda plus AWS. All the linker arguments
will be passed correctly and in the proper order, this just by calling:

   $ gnatmake -Pappli

So what?

So, except for anything simple with 2 or 3 sources I do create a project
file.

BTW, GPS has the notion of default project created automatically to
handle sources in the the run directory.

I hope this will dismiss all misconception about project file :)

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|              http://www.obry.net
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada for 1st year students

[amado.alves]

Thanks for the wonderful tutorial.
For my algorithmics classes mostly I do have simple programs with 2 or
3 sources.
I don't want the extra noise.
I will use AdaGIDE for beginners.
Advanced users may use GNAT projects.
(I have various types of students.)

This is a fascinating topic on its own, configuration languages and
technology. For one, GNAT projects is the same approach of Make. (And
therefore hard to swallow.)

Re: Ada for 1st year students

[sjw]

On Oct 16, 7:15 pm, amado.al...@gmail.com wrote:
> Thanks for the wonderful tutorial.
> For my algorithmics classes mostly I do have simple programs with 2 or
> 3 sources.
> I don't want the extra noise.
> I will use AdaGIDE for beginners.
> Advanced users may use GNAT projects.
> (I have various types of students.)

For a startup project, where you can keep all the source in one
directory (say, ~/Project_1) there's not going to be a lot of
difference between AdaGIDE with a canned environment and GPS with a
canned GNAT project, I'd have thought. All the discussion so far seems
to be about complicated environments; if the course is about learning
to walk, let's avoid teaching 3-day eventing instead!

Re: Ada for 1st year students

[sjw]

On Oct 16, 12:17 pm, Niklas Holsti <niklas.hol...@tidorum.invalid>
wrote:

> I use shell-scripts that define the environment variables
> (ADA_INCLUDE_PATH), then do "gnatmake" without -I options. There
> are different scripts for different versions and configurations of
> the Ada programs. These script files are under configuration control.

I used to use gnatpmake (http://www.pogner.demon.co.uk/gnatpmake/)
until I discovered GNAT Projects. It relies on .adapath files in each
source directory which specify the paths to any other source
directories on which this one depends.

Re: Ada for 1st year students

[amado.alves]

> For a startup project, where you can keep all the source in one
> directory (say, ~/Project_1) there's not going to be a lot of
> difference between AdaGIDE with a canned environment and GPS with a
> canned GNAT project, I'd have thought.

I thought so too, but something's wrong, in most installations, GPS
will get in the way, e.g. complain about the unit under construction
not in the (default) project file. Noise. AdaGIDE is smarter.

Re: Ada for 1st year students

[amado.alves]

> I used to use gnatpmake (http://www.pogner.demon.co.uk/gnatpmake/)
> until I discovered GNAT Projects. It relies on .adapath files in each
> source directory which specify the paths to any other source
> directories on which this one depends.

This is interesting, might come in handy, thanks a lot for the
reference.

Re: Ada for 1st year students

[Michael Feldman]

amado.alves@gmail.com wrote:

Regarding Ada for *first-year students*.

I taught first- and second-year university courses for over 30 years, 
before retiring in 2006. From 1982 to 2002, Ada was the language of our 
2nd-level or CS2 (data structures and algorithms) course. In 1992, we 
switched the first or CS1 course from Pascal to Ada.

Through all these years, the one thing the students had in common was 
that *some* of them had prior programming experience (in secondary 
school), but *most* (well over 50%) had none at all.

> (1) Textbooks. In Portuguese (Brazilian translation fine) or English.
Must be introductory, i.e. for students sans prior knowledge of
programming in any language. Should be small or cheap (or both). The
vendor should be prompt.

Believe it or not, there exists a (Brazilian) Portuguese-language one, 
for which I wrote a brief review a while back:

Introdu��o � Programa��o com Ada 95 (in Portuguese)
(Introduction to Programming with Ada 95)
Arthur Vargas Lopes
Editora da Ulbra, 1997 (ISBN 85-85692-38-3)

This 400-page book is a very nice, if relatively brief, introduction to 
most of Ada 95, suitable for Portuguese-speaking students at first 
level. The examples are complete and compilable, moving from the very 
simple to more interesting ones using packages,  tagged types, and tasks 
(the last a subject in which the author is especially interested). 
Included with the book is a set of diskettes containing the book 
examples and a copy of AVLAda95, the author's Windows 95/98/NT student 
development environment. While some English-language Ada texts have been 
translated into other languages, this is one of the few original texts 
not written in English, and one of the very few such books intended for 
first-year students. The author is using it in Brazil, and it ought to 
be useful for other Ada-related courses in Brazil and Portugal. It can 
serve as a good example to encourage others to write non-English Ada 
textbooks. (M.B.F.)

I don't know whether it's still in print, but it's worth checking out. I 
did find a Brazilian listing for it at

http://www.traca.com.br/?mod=LV82359&origem=resultadodetalhada

The author got his Ph.D. from the university I taught in, and I was on 
his doctoral committee, so I knew him pretty well at the time. If you 
can't find the book, let me know and I'll try to put you in touch with 
him. I think he may be living here in the US now.

 > (2) Compilers. Must be free (as in free beer) or very low cost 
(perhaps an educational license) and install out-of-the box on Windows 
or Linux (or both, preferably). Must support Latin-1, preferably 
Unicode. The vendor should be prompt.

GNAT is definitely the way to go. https://libre.adacore.com/

 > (3) IDE or text editor. Same requirements as above.

Let's summarize the pro's and con's of IDE's for *beginners*.

AdaGIDE is student-oriented but Windows-only, and designed to handle 
only Ada programs.

GPS is multiplatform (Windows and Linux) but a bit overcomplicated for 
beginners. I haven't tried using it for other languages.

My favorite student IDE hasn't been mentioned here: jGRASP. It's been 
developed and refined over a number of years by James Cross' (pretty 
well-funded) group at Auburn University (in Alabama).

jGRASP exists - and is actively developed and supported - for Windows, 
Linux, and Mac OS X, and will handle source files in Ada, C, C++, 
Objective C, Java, and VHDL. Using option screens, you can tailor it to 
use your favorite compiler; GNAT is the default Ada one.

jGRASP will do the usual editor stuff like syntax coloring, but also has 
a bunch of other pedagogical tools (which you can cick on and off), like 
graphically annotating your source file to show the syntax. (This is 
much more interesting to look at than to describe.)

There's no complicated project setup - just tell it where your source 
files are.

jGRASP is not (as far as I know) open-source; I think the group doesn't 
want to lose control of it. It is, however, distributed free - just 
download it from www.jgrasp.org.

I have no connection to the jGRASP project. That said, I've met Jim 
Cross for many years at Ada and SIGCSE conferences, and I like the work 
he and his group have done with this system over the years. Give it a 
try - it's not a big investment to download and install.

Mike Feldman
Professor Emeritus of Computer Science
The George Washington University
Washington, DC

Re: Ada for 1st year students

[amado.alves]

Professor Feldman, thanks a very great lot for this extremely useful
information and advice.

I will certainly check the book by Lopes. (And write one myself
someday :-)

(I recall you dearly as the reviewer of my first published Ada
paper:-)

I know jGRASP well and I will probably use it. (It was mentioned
briefly in the thread before, now lost somewhere in the 100 messages)

/*
AdaGIDE has a few quirks, cannot handle paths containing spaces, and I
cannot find how to pass options to the compiler (I need the -gnatW8
switch to write in Unicode, I don't understand why this is not the
default behaviour of GNAT, of all tools actually, but that's another
story)
*/

Re: Ada for 1st year students

[amado.alves]

My bug is the 'j' in "jGRASP" :-(

Re: Ada for 1st year students

[Peter Hermann]

amado.alves@gmail.com wrote:
> My bug is the 'j' in "jGRASP" :-(

grasp has degraded to a java company since before November 2003

maybe they still offer their nice graphic decorator of Ada source code
called Control Structure Diagram CSD   ?

Re: Ada for 1st year students

[amado.alves]

On 21 Out, 13:34, Peter Hermann <s...@spam.de> wrote:
> amado.al...@gmail.com wrote:
> > My bug is the 'j' in "jGRASP" :-(
>
> grasp has degraded to a java company since before November 2003
>
> maybe they still offer their nice graphic decorator of Ada source code
> called Control Structure Diagram CSD   ?

I tried the new jGRASP.
CSD and Ada yes, but no support for Unicode or Latin_1 :-(
I want identifiers and text in Portuguese.
I have the same problem with AdaGIDE.
Also jGRASP has gone the modern IDE way with its left side menu,
leaving little space for the program :-(

Re: Ada for 1st year students

[John McCormick]

On Oct 21, 6:16 am, amado.al...@gmail.com wrote:
> /*
> AdaGIDE has a few quirks, cannot handle paths containing spaces, and I
> cannot find how to pass options to the compiler (I need the -gnatW8
> switch to write in Unicode, I don't understand why this is not the
> default behaviour of GNAT, of all tools actually, but that's another
> story)
> */

You can add all the compiler options you like through the Tools-
>Global Settings.  This creates a file called gnat.ago that you can
copy to any directory to reuse those settings.  You can have one set
of switches for debug development and another for release (production
programs).  The choice between the modes is made from the tool bar.  I
use a lot of style switches in my beginning classes.  Here are my
AdaGIDE settings:

-gnaty3aAeiklM110rtx -gnatwcdfgkmruw

I don't have problems with spaces in path names with AdaGIDE.  I did
have that problem before.  But I'm not sure whether it was an upgrade
to a later version of AdaGIDE or an later version of GNAT that solved
the problem.

John

Re: Ada for 1st year students

[amado.alves]

> You can add all the compiler options you like through the Tools->Global Settings.  This creates a file called gnat.ago that you can
>
> copy to any directory to reuse those settings.  You can have one set
> of switches for debug development and another for release (production
> programs).  The choice between the modes is made from the tool bar.  I
> use a lot of style switches in my beginning classes.  Here are my
> AdaGIDE settings:
>
> -gnaty3aAeiklM110rtx -gnatwcdfgkmruw

Wonderful. Thanks a lot.

> I don't have problems with spaces in path names with AdaGIDE.  I did
> have that problem before.  But I'm not sure whether it was an upgrade
> to a later version of AdaGIDE or an later version of GNAT that solved
> the problem.

Yes they solved that problem. I was wrong. The problem is different.
It's not the spaces, it's non-ASCII characters in file names. Still a
problem thou :-( For example I have a procedure called Função_H. The
file name appears like "funo.adb" on the file manager, and AdaGIDE
cannot build an executable. May be a problem of the OS, or of the
combination AdaGIDE-OS.

Re: Ada for 1st year students

[Georg Bauhaus]

amado.alves@gmail.com schrieb:

> Yes they solved that problem. I was wrong. The problem is different.
> It's not the spaces, it's non-ASCII characters in file names. Still a
> problem thou :-( For example I have a procedure called Fun��o_H. The
> file name appears like "funo.adb" on the file manager, and AdaGIDE
> cannot build an executable. May be a problem of the OS, or of the
> combination AdaGIDE-OS.


I guess that the Rumpelstilskins of engineering will tell
you that those Portuguese characters are unnecessary. They
are not found on international keyboards anyway, right?
Or maybe they will refer you to a "solution" such as
pragma Source_File_Name.

Of course, Windows PC OS is the culprit, extending its technical
lead into Ada programming tools! Let's see what an "It Just Works"
Scottish computer has to say:

$ file fun��o_h.adb
fun��o_h.adb: UTF-8 Unicode text

$ gnatmake -gnatW8 -gnati8 fun��o_h.adb
gcc -c -gnatW8 -gnati8 fun��o_h.adb
gnat1(98261) malloc: *** mmap(size=1638400000) failed (error code=12)
*** error: can't allocate region
*** set a breakpoint in malloc_error_break to debug
fun��o_h.adb:1:13: missing "("
compilation abandoned due to previous error
gnatmake: "fun��o_h.adb" compilation error

$ # The above is a process running out of memory in just a few secods

$ cat fun��o_h.adb
function Fun��o_H return Natural is
begin
   return 1;
end Fun��o_H;


$ uname -v |cut -f 1 -d ';'
Darwin Kernel Version 9.5.0: Wed Sep  3 11:29:43 PDT 2008

Quite possibly you can inject a DOS into a source code
build system this way ;-)

Retro rulez.

Re: Ada for 1st year students

[amado.alves]

> ... Retro rulez.

:-)

On Mac OS X almost all is well. Only issue is the Terminal. It lists
the file as "func??a??o_h.adb", and commands must be like

14\203o_h -gnatW8 -fLusófona/Programas marius$ gnatmake testar_func
\314\247a\31
gcc -c -gnatW8 testar_função_h.adb
testar_função_h.adb:4:11: warning: file name does not match unit name,
should be "testar_função_h.adb"
gcc -c -gnatW8 algoritmia.adb
gcc -c -gnatW8 função_h.adb
gnatbind -x testar_função_h.ali
gnatlink testar_função_h.ali
_h 6:~/Universidade_Lusófona/Programas marius$ ./testar_func\314\247a
\314\203o_

the line does not move and so the echo gets garbled as shown, and
gnatmake has the nerve to complain about the unit name. But it builds
the right executable named... "testar_func??a??o_h" on the listing,
"testar_func\314\247a\314\203o_h" if I want to invoke it, and
(correctly) "testar_função_h" on Finder.

Editor = XCode (shipped with Mac), compiler = GNAT, visual file
manager = Finder (shipped), text terminal = Terminal (shipped).

Re: Ada for 1st year students

[Larry A Barowski]

"Peter Hermann" <spam@spam.de> wrote in message 
news:gdki93$hvc$1@infosun2.rus.uni-stuttgart.de...
> amado.alves@gmail.com wrote:
>> My bug is the 'j' in "jGRASP" :-(
>
> grasp has degraded to a java company since before November 2003

We are a university research group, not a company. Our "market" is
mainly education. If another language comes to dominate education
(or if someone will fund development for another language), then we
will change our focus.

But the "j" was added when jGRASP came to be written in Java
(previously it was C/C++), and before the focus on Java-related
features.

> maybe they still offer their nice graphic decorator of Ada source code
> called Control Structure Diagram CSD   ?

Yes, and for C, C++, Objective-C, VHDL, and Java.

Re: Ada for 1st year students

[mcollado]

amado.alves@gmail.com escribi�:
> ... The problem is different.
> It's not the spaces, it's non-ASCII characters in file names. Still a
> problem thou :-( For example I have a procedure called Fun��o_H. The
> file name appears like "funo.adb" on the file manager, and AdaGIDE
> cannot build an executable. May be a problem of the OS, or of the
> combination AdaGIDE-OS.

The following works OK in my spanish WinXP SP3:

------------------
E:\pruebas\ada>type espa�a.adb
with Text_IO; use Text_Io;

procedure Espa�a is
begin
    put_line( "Espa�a" );
end Espa�a;


E:\pruebas\ada>gnatmake espa�a
gcc -c espa�a.adb
gnatbind -x espa�a.ali
gnatlink espa�a.ali

E:\pruebas\ada>espa�a
Espa�a

E:\pruebas\ada>
------------------

The above is a console capture. It also works Ok in AdaGIDE.

-- 
Manuel Collado - http://lml.ls.fi.upm.es/~mcollado

Re: Ada for 1st year students

[Larry A Barowski]

> I tried the new jGRASP.
> CSD and Ada yes, but no support for Unicode or Latin_1 :-(
> I want identifiers and text in Portuguese.

No Unicode yet, but you can choose any 8-bit encoding (including
Latin_1) using "Settings" / "Font" / "Encoding". Eventually we
will go to Unicode.

> I have the same problem with AdaGIDE.
> Also jGRASP has gone the modern IDE way with its left side menu,
> leaving little space for the program :-(

You can close the left side stuff. For Ada, you would only
need it open when doing a "Find". You can also pull editing
windows out of the virtual desktop or operate in the
old-school way, with separate windows (no virtual desktop).

Re: Ada for 1st year students

[Britt Snodgrass]

On Oct 22, 8:33 am, "Larry A Barowski" .
>
> > maybe they still offer their nice graphic decorator of Ada source code
> > called Control Structure Diagram CSD   ?
>
> Yes, and for C, C++, Objective-C, VHDL, and Java.

The Control Structure Diagrams are, for me, the most interesting
feature of jGRASP.  At work I use Eclipse with the GNATbench plug-in.
I've often wished that jGRASP were available as an Eclipse plug-in,
just so I could have the CSDs.

I generally like Eclipse.  Its slow to launch but fast enough
afterwards.  Tha main drawback to Eclipse is its occasional tendency
to suddenly leave the room (crash on unhandled Java exception).

- Britt

Re: Ada for 1st year students

[Jeffrey R. Carter]

Georg Bauhaus wrote:
> Of course, Windows PC OS is the culprit, extending its technical
> lead into Ada programming tools! Let's see what an "It Just Works"
> Scottish computer has to say:

Ada allows such identifiers, but that doesn't mean they're accepted by the OS or 
tools that run on it. One could argue that, once again, Ada is ahead of its time.

Just because Ada allows such identifiers doesn't mean one should use them. 
Certainly if they prevent the compilation of the unit and one cannot find an OS 
and tools that change that, one should not use them.

I would argue that one should not use such identifiers, even if the the 
language, tools, and OS work perfectly with them. Ada reserved words (with the 
lamentable exception of "elsif") are English words, and the intention is that, 
with properly chosen identifiers, Ada source code reads (sorta/kinda) like 
English text, which can be a big help in understanding the code. Using 
non-English identifiers negates this, and therefore should be avoided.

if Chooidooigoo then

is gobbledygook whether you speak both languages or not.

I'd suggest creating Portu-Ada, which uses Portuguese equivalents of the 
reserved words. A preprocessor translates the reserved words into English, and 
mangles identifiers to eliminate characters that interfere with compilation. The 
resulting generated Ada is not intended for human consumption, and is discarded 
once it is no longer needed. This should make programming more accessible to 
Portuguese beginning students than using straight Ada with its English reserved 
words.

Writing the preprocessor in Portu-Ada might be a suitable project for the 
students, and would help expose them to straight Ada (and the limitations of the 
tools and OS).

Just Rumpelstiltskin's 2 cent's worth.

-- 
Jeff Carter
"People called Romanes, they go the house?"
Monty Python's Life of Brian
79

Re: Ada for 1st year students

[Jeffrey R. Carter]

Georg Bauhaus wrote:
> $ gnatmake -gnatW8 -gnati8 fun��o_h.adb

gnatmake -gnatif fun��o_h.adb

should work.

-- 
Jeff Carter
"People called Romanes, they go the house?"
Monty Python's Life of Brian
79

Re: Ada for 1st year students

[Adam Beneschan]

On Oct 22, 11:02 am, "Jeffrey R. Carter"
<spam.jrcarter....@spam.acm.org> wrote:
> Ada reserved words (with the
> lamentable exception of "elsif") are English words

And except for "xor".  Also, I don't think "abs" is an English word,
although it does have a slang meaning that has nothing whatsoever with
its Ada usage.  "mod" and "rem" do appear to be English words
(according to m-w.com), but the meanings of those words again have
nothing to do with their usage in Ada.

                               -- Adam

Re: Ada for 1st year students

[Jeffrey R. Carter]

Adam Beneschan wrote:
> 
> And except for "xor".  Also, I don't think "abs" is an English word,
> although it does have a slang meaning that has nothing whatsoever with
> its Ada usage.  "mod" and "rem" do appear to be English words
> (according to m-w.com), but the meanings of those words again have
> nothing to do with their usage in Ada.

True. I meant the reserved words that aren't operators, and should have said so. 
I'm not sure if there's a term for them.

-- 
Jeff Carter
"People called Romanes, they go the house?"
Monty Python's Life of Brian
79

Re: Ada for 1st year students

[Larry A Barowski]

"Britt Snodgrass" <britt.snodgrass@gmail.com> wrote in message 
news:052e521b-2024-471f-b980-8f442bb5cfc2@q9g2000hsb.googlegroups.com...
> The Control Structure Diagrams are, for me, the most interesting
> feature of jGRASP.  At work I use Eclipse with the GNATbench plug-in.
> I 've often wished that jGRASP were available as an Eclipse plug-in,
> just so I could have the CSDs.

We have several proposals that focus on or include a jGRASP
plugin for Eclipse in the works (and a couple have already failed).

Re: Ada for 1st year students

[Marco]

> I am not teaching IDEs, or project management, or configuration
> management. I am teaching algorithmics, and Ada. The visual noise and
> extra work introduced by these Visual IDEs is simply unacceptable for
> this purpose.

  How about Notepad++ ?

   http://notepad-plus.sourceforge.net/uk/site.htm

   No unnecessary registry crap it can run as a pure Win32 executable.

   For Linux you would need to use WINE to run it.

Re: Ada for 1st year students

[Marco]

On Oct 22, 6:33 am, "Larry A Barowski"
<ThisisLarrybarAtEngDotAuburnDotLearninginstitution> wrote:
> "Peter Hermann" <s...@spam.de> wrote in message
>
> news:gdki93$hvc$1@infosun2.rus.uni-stuttgart.de...
>
> > amado.al...@gmail.com wrote:
> >> My bug is the 'j' in "jGRASP" :-(
>
> > grasp has degraded to a java company since before November 2003
>
> We are a university research group, not a company. Our "market" is
> mainly education. If another language comes to dominate education
> (or if someone will fund development for another language), then we
> will change our focus.
>
> But the "j" was added when jGRASP came to be written in Java
> (previously it was C/C++), and before the focus on Java-related
> features.

  We used to use the older GRASP version on Solaris boxes back in the
mid to late 90's with our VADS compilers. It was nice to have a Ada
"visual" editor without resorting to expensive APEX.
The new hires couldn't deal with vi or emacs :)
thanks in retrospect

But I do think adding the "j" to the name was a mistake, most folks
don't care what a program is written in (unless it is too slow). At
the time, it seemed like Ada was being abandoned for the upstart Java.
We never really liked the Java based version, because at the time, it
seemed a little slow.

Re: Ada for 1st year students

[lbarowski]

On Oct 25, 3:36 pm, Marco <prenom_no...@yahoo.com> wrote:

>
> But I do think adding the "j" to the name was a mistake, most folks
> don't care what a program is written in (unless it is too slow).

The fortunate thing for us was that Java did take off,
especially for education. So although it may have turned
some people off, the "j" probably did us more good than
harm.

> At
> the time, it seemed like Ada was being abandoned for the upstart Java.
> We never really liked the Java based version, because at the time, it
> seemed a little slow.

It was slow at that time, but we had faith in Moore's Law.
The time needed to maintain, develop, and test two very
different versions with a dozen different builds was
killing our progress and stability. Having a more-or-less
single codebase was well worth creating a new version and
having it be a bit slow for a few years.

ThisisLarrybarAtEngDotAuburnDotLearninginstitution
[Posting from GG because Comcast no longer provides
usenet access :( :( :( :( .]

Re: Ada for 1st year students

[lbarowski]

On Oct 25, 3:36 pm, Marco <prenom_no...@yahoo.com> wrote:
> But I do think adding the "j" to the name was a mistake, most folks
> don't care what a program is written in (unless it is too slow).

Since Java did take off, especially for education, the "j"
probably did us more good than harm.

> At the time, it seemed like Ada was being abandoned for the
> upstart Java. We never really liked the Java based version,
> because at the time, it seemed a little slow.

It was slow at first, but we had confidence in Moore's Law.
Having a more-or-less single codebase with only two installer
builds has saved us tons of development and testing time in
the long run.

Re: Ada for 1st year students

[Mike H]

In message 
<9955de2c-f74a-4c2b-b513-56c130a5f1ee@k16g2000hsf.googlegroups.com>, 
amado.alves@gmail.com writes
>And for starting they will even use a package that predeclares
>variables I, J, K, L, M as integers, X, Y, Z as reals, etc. That's my
>approach anyway, logic first, types later.

Then why use Ada?

Having just come back to Ada after ten years in retirement what was one 
of the first howlers I committed? I used the same natural type to count 
both bytes and words. Do I have to spell out what happened next?

-- 
Mike
"Why," said Ford squatting down beside him and shivering, "are you lying face
down in the dust?" "It's a very effective way of being wretched," said Marvin.

Re: Ada for 1st year students

[Mike H]

In message 
<1fe7f0a7-498c-4fd2-833f-ff223220dfc1@b38g2000prf.googlegroups.com>, 
amado.alves@gmail.com writes

[snip]

>Using JEWL and then telling my students
>"if you want graphics you have to use Windows" will send the wrong
>message I'm afraid... Not pedagogical at all.
If the students take their Ada out into the real world then they will 
find themselves deep in the world of mixed language projects.

Having taught Ada at undergraduate level and then moved out of Academia, 
I would suggest that one of the things they must learn is not to 
re-invent a wheel when a perfectly good one can be bought off the shelf. 
One of the projects that I worked on was the kernel of an air defence 
system, written in Ada, of course. But the GUIs, including the simulated 
radar displays, where not.
-- 
Time flies like an arrow. Fruit flies like a banana.
Mike

Re: Ada for 1st year students

[amado.alves]

> if Chooidooigoo then
>
> is gobbledygook whether you speak both languages or not.

Convincing power high.

> I'd suggest creating Portu-Ada, which uses Portuguese equivalents of the
> reserved words.

Good idea. Lusoada. A couple problems thou:

English syntax: Positive range is ...
Portuguese syntax: intervalo Positivo é ...

Accents (e.g. é)

Lots of other stuff to translate, viz. attribute names and standard
identifiers (not only reserved words).

But it's a interesting concept and I'll try to push it around here at
Univ. *Lusófona* (maybe we'll get support from the rector who is the
inventor of the word no less).

Re: Ada for 1st year students

[Colin Paul Gloster]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: TEXT/PLAIN; charset=UTF-8, Size: 2091 bytes --]

On Tue, 4 Nov 2008, amado.alves@gmail.com wrote:

|--------------------------------------------------------------------------|
|"> if Chooidooigoo then                                                   |
|>                                                                         |
|> is gobbledygook whether you speak both languages or not.                |
|                                                                          |
|Convincing power high.                                                    |
|                                                                          |
|> I'd suggest creating Portu-Ada, which uses Portuguese equivalents of the|
|> reserved words.                                                         |
|                                                                          |
|Good idea. Lusoada. A couple problems thou:                               |
|                                                                          |
|English syntax: Positive range is ...                                     |
|Portuguese syntax: intervalo Positivo é ...                               |
|                                                                          |
|Accents (e.g. é)                                                          |
|                                                                          |
|Lots of other stuff to translate, viz. attribute names and standard       |
|identifiers (not only reserved words).                                    |
|                                                                          |
|But it's a interesting concept and I'll try to push it around here at     |
|Univ. *Lusófona* (maybe we'll get support from the rector who is the      |
|inventor of the word no less)."                                           |
|--------------------------------------------------------------------------|

This apparently had been tried with French for an old version of
FORTRAN which is no longer being used, unlike French and Anglophonic
FORTRAN used by Francophones.

Re: Ada for 1st year students

[John McCormick]

I believe that Mike Feldman's former student, Arthur Vargas Lopes,
created an Ada 83 compiler or preprocessor with Portuguese keywords.

John

On Nov 4, 9:31 am, amado.al...@gmail.com wrote:
>
> > I'd suggest creating Portu-Ada, which uses Portuguese equivalents of the
> > reserved words.
>
> Good idea. Lusoada. A couple problems thou:
>
> English syntax: Positive range is ...
> Portuguese syntax: intervalo Positivo é ...
>
> Accents (e.g. é)
>
> Lots of other stuff to translate, viz. attribute names and standard
> identifiers (not only reserved words).
>
> But it's a interesting concept and I'll try to push it around here at
> Univ. *Lusófona* (maybe we'll get support from the rector who is the
> inventor of the word no less).

Re: Ada for 1st year students

[amado.alves]

On 5 Nov, 15:30, John McCormick <mccorm...@cs.uni.edu> wrote:
> I believe that Mike Feldman's former student, Arthur Vargas Lopes,
> created an Ada 83 compiler or preprocessor with Portuguese keywords.
>
> John

This is great news, thanks. I'll check (via Mike Feldman).