Ada as a beginning language

Ada as a beginning language

[David Smith (GE)]

I am a Computer Science student at the University of South Florida in
Tampa.  We now use Ada as the intro programming language for the program.

I have been formally taught Pascal, C, adn Assembly and do most of my
programming in Think Pascal, in which I am most comfortable.  From 
what I have used Ada for (remember it IS and intro class) it seem very
similar to Pascal other than the extremly tight type checking.

I would like anyones option on Ada as the first/intro language for Computer
Science.  My option is that the strong types, and other structures frustates
new programers, as many of my classmates have been.  (and why is 0/=0.0?)

Thanks to all.

--
/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\
| David A. Smith - dasmith@suntan.ec.usf.edu  | Remember this, "Users only |
|  "Why me??!!"  - smith@cfrrisc1.cfr.usf.edu | know what they don't want. |
\__________________________________________________________________________/

Re: Ada as a beginning language

[cis.ohio-state.edu!zaphod.mps.ohio-state.edu!howland.reston.ans.net!agate]

In article <1993Mar18.033431.12194@ariel.ec.usf.edu> dasmith@sunburn.ec.usf.edu
. (David Smith (GE)) writes:
>I am a Computer Science student at the University of South Florida in
>Tampa.  We now use Ada as the intro programming language for the program.
>
>I have been formally taught Pascal, C, adn Assembly and do most of my
>programming in Think Pascal, in which I am most comfortable.  From 
>what I have used Ada for (remember it IS and intro class) it seem very
>similar to Pascal other than the extremly tight type checking.
>
>I would like anyones option on Ada as the first/intro language for Computer
>Science.  My option is that the strong types, and other structures frustates
>new programers, as many of my classmates have been.  (and why is 0/=0.0?)

  It is probably better to be frustrated and have to take the time to
figure things out then to not be informed of serious flaws in one's view
of programming.  In the example 0 /= 0.0 apart from the types not
matching there is an issue about comparing (and expecting) floating
point numbers to be exactly equal to some integer value. For instance
if these were not contants but were something of the form
   if Some_Real_Type /= 0 then  ..   you are saying that if
Some_Real_Type = 1e-38 that it is still not good enough (ie still not
zero) in some cases this is what is intended but you have issues
such as .Should the compiler truncate the floating point number, round
it or do something else.

As far as the overall suitability of Ada as in introductory language
...In my opinion, its better than most other choices. It is difficult
to get away from the bad habits that even good C code teaches. I still
have problems with peole who have used Ada for a few years yearning to
pass system.addresses around in Ada code to get around having to learn
generics or becuase its more efficient :( 

There are other languages that have strong points for an introductory
language (Mod-2, even pascal) but there is little "wrong" with Ada for
an intro course (as a side note, no matter what language you use,    
beginners will be frustrated and sure that they have found a bug in
the compiler..At least with Ada they have a chance of being correct :)

Jeff Creem

Re: Ada as a beginning language

[David Emery]

In a discussion on this with a college professor, I asserted Ada's
greatest strength is its well-defined error handling.  As much stuff
as possible is checked at compile-time.  Stuff that isn't checked at
compile-time (unless erroneous) is caught at run-time with predictable
behavior (i.e. an exception).  Contract this to C, FORTRAN and Pascal,
and try to explain to a student what happens when s/he accidentally
divides by zero...
				dave

Re: Ada as a beginning language

[Michael Feldman]

In article <EMERY.93Mar18203251@dr_no.mitre.org> emery@dr_no.mitre.org (David Emery) writes:
>In a discussion on this with a college professor, I asserted Ada's
>greatest strength is its well-defined error handling.  As much stuff
>as possible is checked at compile-time.  Stuff that isn't checked at
>compile-time (unless erroneous) is caught at run-time with predictable
>behavior (i.e. an exception).  Contract this to C, FORTRAN and Pascal,
>and try to explain to a student what happens when s/he accidentally
>divides by zero...
>				dave

...or tries to write into the 25th element of a 20-element array.

As an exercise, try this with your favorite C compiler. As for Pascal,
we always have to ask "which Pascal?" because the standard for Pascal
does not specify the behavior of such an operation (or much of anything
else). At least with Ada, you are _guaranteed_ that any of the 500-odd
validated compilers will cause your program to raise constraint_error.

This professor agrees with Dave.

Mike Feldman
------------------------------------------------------------------------
Michael B. Feldman
co-chair, SIGAda Education Committee

Professor, Dept. of Electrical Engineering and Computer Science
School of Engineering and Applied Science
The George Washington University
Washington, DC 20052 USA
(202) 994-5253 (voice)
(202) 994-5296 (fax)
mfeldman@seas.gwu.edu (Internet)

"The most important thing is to be sincere, 
and once you've learned how to fake that, you've got it made." 
-- old show-business adage
------------------------------------------------------------------------

Re: Ada as a beginning language

[Jack Beidler]

I have found the several postings regarding Ada as a beginning
language to be quite interesting.  Let's take a more careful look
at this issue.  My favorite statement regarding the use of 
programming languages in computing courses has been to the effect
that the choice of the programming language should be secondary.
The primary issues in the various courses should be conceptual issues.
The programming language should serve a supporting role.  At best
the programming language should provide direct support to the 
concepts.  At worse, the programming language should not get in the
way (with contrived syntax and parens all over the place and use the
word "void" in weird places because you have to and ...).

But I've been told that we all think in languages, therefore, the
choice of programming language in the first course is very critical
because it will biase the way students think about algorithm
development.  There first programming language becomes the way they
think about representing algorithms.  If the first programming
language does not have a good safe syntax, the result is a less
disciplined programmer.  I'd prefer a meaningful syntax error at
compile time to spending my life hacking away with a debugger as
a method of developing software.

The issue is discipline.  A well disciplined programmer can work 
safely with almost any language.  But in the beginning courses the
programming language and the support environment must be such that
disciplined is encouraged.  The best choice for a beginning language
is (1) a language that encourages discipline to hacking, (2) a 
language with a safe meaningful syntax, and (3) a language that 
provides direct support to a broad variety of software development
concepts.  That language use to be Pascal, it is now Ada.
-- 
+------------------------------------------------------------------+
|  John (Jack) Beidler				                   |
|  Prof. of Computer Science Internet: BEIDLER@JAGUAR.UOFS.EDU     |
|  University of Scranton              beidler@guinness.cs.uofs.edu|
|  Scranton, PA 18510	      Bitnet : BEIDLER@SCRANTON            |
|                                                                  |
|          Phone: (717) 941-7446	 FAX:   (717) 941-4250     |
+------------------------------------------------------------------+

Re: Ada as a beginning language

[Neal Rigney]

> Tampa.  We now use Ada as the intro programming language for the program.
So do we.
> I would like anyones option on Ada as the first/intro language for Computer
> Science.  My option is that the strong types, and other structures frustates
> new programers, as many of my classmates have been.  (and why is 0/=0.0?)

Personaly, I kinda like Ada.  I don't know if it's really a good language to
start computer science on, but I've already started, so what the Heck.
I'm  into my second semester of CS,  and I've pretty much gotten used to
Ada.  I like some of its structuring, and once  you get used to it, it is
pretty nice(personal  opinion.)  However, We have had something like 50% of
the class drop because it's rather difficult...

-Neal