Re: new programmer wondering what to learn

Re: new programmer wondering what to learn

[Samuel A. Mize]

Peter Hermann wrote:
> 
> [ Article crossposted from comp.lang.misc ]
> [ Author was John LAMBORN ]
> [ Posted on Fri, 23 May 1997 07:41:05 GMT ]
> 
> I am a new programmer (just starting a few months ago).
> I am also a computer science major.
> I have a couple of questions :
> 1. which languages would be best for general real world use (other than         c++)?

Virtually any language other than C++  :-)

> 2. is it worth my while to learn ada?

Very much.  If you never use it in your work, what you learn
about programming while learning Ada will help you.  (I'm
assuming you have a decent teacher, or use one of the online
tutorials at http://www.adahome.com).

> 3. which languages would be best to learn for database building?

This is done in SQL or a similar special-purpose query language.
These are generally interfaced to a programming language; Ada
has some of these.  I don't know what's most common in the DB world.

I believe I recently saw a comment that some major vendor (Oracle?)
was using a query language that was based on Ada.

> 4. which languages would be best for graphical application (video game          programming)?

Best is probably Ada, with its built-in multitasking and other
real-time support features.

Most common is probably C, or C compiled with a C++ compiler
(genuine C++ -- code that depends on the "++" features -- is
much rarer than C compiled as C++).

> thank you ahead of time
> 
> please reply by email if you would
> 
> jonathan lamborn
> 
> --
> Peter Hermann  Tel:+49-711-685-3611 Fax:3758 ph@csv.ica.uni-stuttgart.de
> Pfaffenwaldring 27, 70569 Stuttgart Uni Computeranwendungen
> Team Ada: "C'mon people let the world begin" (Paul McCartney)

--
-- Samuel Mize           (817) 619-8622               "Team Ada"
-- Hughes Training Inc.  PO Box 6171 m/s 400, Arlington TX 76005

new programmer wondering what to learn

[Peter Hermann]

[ Article crossposted from comp.lang.misc ]
[ Author was John LAMBORN ]
[ Posted on Fri, 23 May 1997 07:41:05 GMT ]

I am a new programmer (just starting a few months ago).
I am also a computer science major. 
I have a couple of questions :
1. which languages would be best for general real world use (other than 	c++)?
2. is it worth my while to learn ada?
3. which languages would be best to learn for database building?
4. which languages would be best for graphical application (video game 		programming)? 

thank you ahead of time 

please reply by email if you would

jonathan lamborn


--
Peter Hermann  Tel:+49-711-685-3611 Fax:3758 ph@csv.ica.uni-stuttgart.de
Pfaffenwaldring 27, 70569 Stuttgart Uni Computeranwendungen
Team Ada: "C'mon people let the world begin" (Paul McCartney)

Re: new programmer wondering what to learn

[Michael F Brenner]

Replying to the four Peter Hermann questions

1. Which languages would be best for general real world use?
   If you are going to program in languages, we must recognize that the
   current traditional religions of computer science are the languages
   beginning with the letter C, like C, C++, Cobol, and the C++ derivative
   Java. However, the languages that are most useful for solving problems
   in descending order of usefulness are SQL, Ada-95, awk, perl, htlm,
   cgi, and rtf.

   You will be a heritic if you solve database problems in SQL instead of
   Cobol and C++, but you will cost your customer less money, both
   up front and over the life cycle of the project. You will similarly
   be a heretic if you do your probablistic pattern recognition, data
   mining, and intelligent applications in Ada-95 instead of C++ and Java,
   but your code will have fewer bugs, be easier to maintain, and will be
   easier to connect to existing C, C++, Java, Ada-95, CORBA, Net, and 
   extremely complex data structures, resulting in a life-cycle cost
   reduction over the dominant religions.

   However, your question is predicated on an assumption that it takes
   a long time to learn to be basically useful in a new language, which
   is not true. Try to do an extremely complex data structure in each
   of the languages before specializing in any of them.

2. Is it worth my while to learn Ada?
   Since Ada-95 includes configuration management, life-cycle maintenance
   reduction, bug-catching, parallel processing, and software reliability
   features not present in other languages, and since it is relatively
   easy to connect Ada-95 code to existing code in many other languages,
   YES, it is worth your while to learn Ada.

3. Which langauges would be best to learn for database building?
   SQL.

4. Which languages would be best for graphics, i.e. video game programming.
   All programs that ever will be written have already been written, except
   for video games. The language which makes it easiest to integrate
   together efficient code in the language itself, downloaded Free code,
   and pieces of code in many other languages is Ada-95. Combined with
   the code reliability of finding more bugs at compile time than the
   other commonly used languages, there is a significant advantage for
   writing a video game in Ada-95. There is free code available for the
   commonly used device drivers, and tasking and protected records give
   you a reliable, interesting method of controlling concurrency. Advice
   on the most efficient way to implement various video game features is
   a speciality of this list. For example, have you tried to implement
   sprite graphics on a VGA 16-color mode by using each of the 4 planes
   as a sprite plane, in a color determined by the palette? How fast can
   you scroll a VGA screen? How can you uncook the keyboard so keystrokes
   are recognized immediately? How can you make the keyboard into an 
   organ so you can play multiple keys at the same time? This list will
   either answer your questions or point you to people who can. If your
   video game is going to be Free software, there are people on this
   list who may be willing to contribute time to helping develop it.

Re: new programmer wondering what to learn

[Marin David Condic, 561.796.8997, M/S 731-93]

Undetermined origin c/o LISTSERV administrator writes:
>2. Is it worth my while to learn Ada?
>   Since Ada-95 includes configuration management, life-cycle maintenance
>   reduction, bug-catching, parallel processing, and software reliability
>   features not present in other languages, and since it is relatively
>   easy to connect Ada-95 code to existing code in many other languages,
>   YES, it is worth your while to learn Ada.
>
    Here I'd like to get a little clarification: How exactly does
    Ada95 include "configuration management"? CM in the usual sense of
    the term means some method of tracking what set of sources goes
    into a given software build, what changes were made between
    version N and version N+1 and related librarian kinds of issues.
    DEC CMS and SCCS under Unix would be examples of tools used for
    this purpose. (Although neither tool would encompass the
    *entirety* of the domain of CM)

    I don't see how Ada95 contributes to this in any direct way since
    it is beyond the scope of a programming language definition.
    Unless, you perhaps had something else in mind when writing
    "configuration management"?

    The rest of what you wrote makes good sense and I'd agree that it
    is worth any programmer's time to learn Ada95.

    MDC

Marin David Condic, Senior Computer Engineer    ATT:        561.796.8997
Pratt & Whitney, GESP                           Fax:        561.796.4669
West Palm Beach, FL                             Internet:   CONDICMA@PWFL.COM
===============================================================================
    "The race is not always to the swift, nor the battle to the
    strong - but that's the way to bet."

        --  Damon Runyon
===============================================================================

Re: new programmer wondering what to learn

[Michael F Brenner]

The mail reader has asked me why I said that Ada includes 
configuration management. THank you for asking. Let me make
up a good one. No, I mean ....

The definition of CM is having control over your baseline, 
including three particular aspects of the baseline: the parts
themselves, the changes to those parts, and the change requests
that induced those changes. Ada is a standard for generating code
in accordance with a time controlled configuration management
scheme that prevents mismatches in the changed parts, using a
particular method of packaging those parts which is superior
to the packaging in most other computer languages. Thus it
contributes to the first two aspects of CM control: control of the
parts themselves and the changes to those parts. It does not
contribute much to control over change requests. In addition,
since it includes within the language many solutions to problems
which before Ada often were solved by octal patches, Ada reduces
the number of patches, which reduces the number of bugs, the
number of parts, and the number of mismatches between patched
code and actual object code. Finally, in a totally source code
system there will be no requirement to store the object code
files at all, reducing the number of configured files by about
half. Prior to the gnat age (PTTGA), Ada had a very great
contribution toconfiguration management which gnat eliminated,
which was a built-in method of delivering an entire system in
a single text file, in the correct compilation order, ready to
compile and link. With gnat, we must use and external tool to
configure the parts list, which takes more tool money and labor
money. Luckilly, tools which work most of the time are included
with gnat, namely gnatchop and gnatmake. The configuration
nightmare introduced by gnat/gnatchop/gnatmake is not the
startling increase in manual labor required to externally 
control the source code in different external files, nor the
infamous k8-name-overlap problems (try compiling the interrupt
handler provided by Alsys), nor the bugs in gnatmake which 
are always to be fixed in the next release, but rather the
loss of the ability to configure multiple bodies for a single
package. Before gnat we did this by strategically placing the
alternate bodies mixed in with linkage pragmas in that single
file. Now, we trade the advantages of gnat for a reduction
in configuration management, and the inability to control
within the compiler, the multiple package bodies needed for
a single package. Tradeoffs like this are common in certain
areas.

Re: new programmer wondering what to learn

[Robert Dewar]

Marin asks

<<    I don't see how Ada95 contributes to this in any direct way since
    it is beyond the scope of a programming language definition.
    Unless, you perhaps had something else in mind when writing
    "configuration management"?>>

What is meant by this mention is simply that one (of may) tasks of CM
is ensuring that builds are consistent. Ada assists in this process as
a kind of after the fact checker in that the Ada system will check that
a consistent system has been built.

No one would (or should) claim that Ada encompasses all of CM (or desire
that it be the case :-)

Re: new programmer wondering what to learn

[Robert Dewar]

Michael says

<<Prior to the gnat age (PTTGA), Ada had a very great
contribution toconfiguration management which gnat eliminated,
which was a built-in method of delivering an entire system in
a single text file, in the correct compilation order, ready to
compile and link. With gnat, we must use and external tool to
configure the parts list, which takes more tool money and labor
money. Luckilly, tools which work most of the time are included
with gnat, namely gnatchop and gnatmake. The configuration
nightmare introduced by gnat/gnatchop/gnatmake is not the
startling increase in manual labor required to externally
control the source code in different external files, nor the
infamous k8-name-overlap problems (try compiling the interrupt
handler provided by Alsys), nor the bugs in gnatmake which
are always to be fixed in the next release, but rather the
loss of the ability to configure multiple bodies for a single
package. Before gnat we did this by strategically placing the
alternate bodies mixed in with linkage pragmas in that single
file. Now, we trade the advantages of gnat for a reduction
in configuration management, and the inability to control
within the compiler, the multiple package bodies needed for
a single package. Tradeoffs like this are common in certain
areas.
>>

My guess from reading this is that Michael does not use GNAT much,
or if he does, he has missed a lot in how to deal with things.
First, and most notably, the reference to "correct compilation
order" is quite bizarre, seeing as GNAT does not require any
particular compilation order.

The reference to a single text file is also a bit curious. Perhaps
he is speaking here of the ability to put multiple units in a single
file that is presented to the compiler? This of course is not something
that is required in either Ada 83 or Ada 95. It is of course a facility
that is provided in GNAT, precisely by the transparent use of gnatchop.

Remember that is it is quite trivial to entirely duplicate the behavior
of a classical Ada 83 library based system in GNAT, so anything you could
do with such a system can be trivially done with GNAT.

The reference to multiple package bodies again is most odd. This is preciesly
something that GNAT can handle far more conveniently than most classical
library based systems. This is because a single library cannot contain
multiple units of the same name. This means that you have to handle this
in Ada 83 using implementation dependent techniques such as the Alsys
multi-lib facility. In GNAT, it is trivial to handle multiple bodies.

Two obvious techniques are to use different file names, and then use
a configuration file that chooses the appropriate files to be used,
or to use the same file name in different directories and then control
the selection by the path name. GNAT itself uses both techniques to
provide multiple bodies for the tasking runtime for different targets,
and we find GNAT particularly convenient for this purpose.

Next, the reference to the "infamous k8-name-overlap problem" also shows
some ignorance of capabilities here. Of course the problem with limited
file names shows up only on DOS. We do not recommend that people use
the DOS version for any serious work, but GNAT is the only full language
Ada 95 compiler for DOS, so if you must use DOS, you will have to use
GNAT, and you certainly will have to address the file name problem.

Here is an important point: GNAT places NO RESTRICTIONS on the names that
can be used for Ada source files. You can call an Ada source file
printf.c if you like. There is a convenient default naming convention,
that many people find quite satisfactory, but certainly if you compile
other than trivial programs for DOS, you will not find the default
satisfactory. You must choose your own appropriate file names, just as
you would for any other system in DOS, and then use the standard GNAT
features for specifying the file names to the compiler (the -x switch
for gcc, and the Source_File_Name configuration pragma).

If you are finding a "startling increase in manual labor", you are
probably not using the system right. Last time I enquired, you said
you were not really using GNAT. I somewhat guess that this is still
the case!

Anyway, I suggest that you try to be more specific, rather than just
generally rambling. You may then well be able to get more specific
help -- try in particular sending specific questions about usage
to chat@gnat.com, where there are definitely people who can help,
if indeed you are genuinely interested in using GNAT!

Robert Dewar
Ada Core Technologies

Re: new programmer wondering what to learn

[Marin David Condic, 561.796.8997, M/S 731-93]

Robert Dewar <dewar@MERV.CS.NYU.EDU> writes:
>What is meant by this mention is simply that one (of may) tasks of CM
>is ensuring that builds are consistent. Ada assists in this process as
>a kind of after the fact checker in that the Ada system will check that
>a consistent system has been built.
>
    O.K. I see the point. If two versions of a file differ in
    specification, Ada is going to warn you about it. The compilation
    system by design has to do some sort of time stamping or version
    checking to know what's out of date. I can see how that can be
    construed as "Configuration Management".

    It's just that most of us who have to deal with industrial
    strength Configuration Management (it gets really important to
    know that the software you're loading in someone's jet is the
    exact same identical software that you ran all those verification
    tests on!) don't usually consider the "developmental" build
    process to fall under "CM". A developmental build - perhaps made
    to satisfy yourself that everything still compiles as you are
    stirring around in the files - doesn't need to be repeatably
    re-built, so it doesn't need to fall under what we usually call
    "Configuration Management".

    If, on the other hand, you want to make a build which actually
    goes into the lab for any sort of "formal" testing, then you need
    to know the differences between vsn N and vsn N+1 and you need to
    be able to reproduce through some means the exact same image you
    gave to the lab. That involves "Configuration Management" and in
    that area I don't see Ada (or any language, theoretical or actual)
    having much to do with that sort of issue.

    I guess it's another one of those "Lets go to the S-OED or
    Webster's" issues which is tough to resolve when well meaning and
    intelligent people can easily say "around here when we say X we
    mean...."

    MDC

Marin David Condic, Senior Computer Engineer    ATT:        561.796.8997
Pratt & Whitney, GESP                           Fax:        561.796.4669
West Palm Beach, FL                             Internet:   CONDICMA@PWFL.COM
===============================================================================
    "The chief problem of lower-income farmers is poverty."

        --  Nelson Rockefeller
===============================================================================

Re: new programmer wondering what to learn

[Marin David Condic, 561.796.8997, M/S 731-93]

Undetermined origin c/o LISTSERV administrator writes:
>
>The definition of CM is having control over your baseline,
>including three particular aspects of the baseline: the parts
>themselves, the changes to those parts, and the change requests
>that induced those changes. Ada is a standard for generating code
>in accordance with a time controlled configuration management
>scheme that prevents mismatches in the changed parts, using a
>particular method of packaging those parts which is superior
>to the packaging in most other computer languages. Thus it
>contributes to the first two aspects of CM control: control of the
>parts themselves and the changes to those parts. It does not
>contribute much to control over change requests. In addition,
><snip>

    Sounds a little more like what we call "Change Control" - which
    certainly dovetails with CM, but is not quite the same thing. (See
    my earlier post - I think we're just talking problems of
    definition.)

    Around here, we use one or two different "Librarian" systems
    (home-grown) in which a developer has to check out/check in source
    code in connection with a change request. (Mostly to lock out
    inadvertent race conditions between developers, but also for
    tracking the changes, etc.) Certainly, Ada adds assistance if some
    developer wants to push the compile button and make a build for
    some informal test purpose. "CM" comes into play when you push the
    compile button "for real" and make something you need to be able
    to reproduce.

>code and actual object code. Finally, in a totally source code
>system there will be no requirement to store the object code
>files at all, reducing the number of configured files by about
>half. Prior to the gnat age (PTTGA), Ada had a very great
><snip>

    Beg to differ. There is a real nightmare issue for CM in this day
    of modern compiler and OS technology which makes it even more
    important to put the image itself under CM. (Our CM weenie is
    right about now plugging her ears and yelling "I can't hear you,
    Marin! Ya! Ya! Ya!..." They *hate* hearing about this problem!) It
    works like this: You can take the exact, same source code file and
    the exact, same version of the compiler and put the two together
    on the same computer on two different days and get a different set
    of bits out the back end. You can argue all day long that they may
    be semantically equivalent sets of bits, but it won't get you
    anywhere. You can't *prove* that the new set of bits didn't
    introduce an error - which means re-running the verification
    tests.

    Hence, we still do configuration manage images from a formal build
    process and will probably continue to do so for a long time to
    come.

>half. Prior to the gnat age (PTTGA), Ada had a very great
>contribution toconfiguration management which gnat eliminated,
>which was a built-in method of delivering an entire system in
>a single text file, in the correct compilation order, ready to
>compile and link. With gnat, we must use and external tool to
>configure the parts list, which takes more tool money and labor
>money. Luckilly, tools which work most of the time are included
>
    Never had a problem maintaining separate module files. As a matter
    of fact, I've never worked on a job where the final "Configuration
    Managed" product was a single source file containing all the Ada
    (or Fortran, or C, or ____) code. Typically, you may have all the
    final source files locked up under a single directory - or use
    some tool like DEC CMS to manage the source files, but I've never
    seen it done where you take the separate source files and combine
    them into a single one for the final build process. I can't think
    of a good reason to do so since you can accomplish the same thing
    while maintaining separate files. For developmental reasons, you
    want them in separate files - probably with some kind of command
    procedure or shell script or whatever to accomplish the
    compilation in the proper order. when you reach a stopping point,
    you just park all the artifacts into someplace where they can't be
    modified and call the job done. Why would you want to do all the
    work of sucking up all the sources into a single file (in
    compilation order) just for CM?

    MDC

Marin David Condic, Senior Computer Engineer    ATT:        561.796.8997
Pratt & Whitney, GESP                           Fax:        561.796.4669
West Palm Beach, FL                             Internet:   CONDICMA@PWFL.COM
===============================================================================
    "The chief problem of lower-income farmers is poverty."

        --  Nelson Rockefeller
===============================================================================

Re: new programmer wondering what to learn

[Robert Dewar]

Marin said

<<    O.K. I see the point. If two versions of a file differ in
    specification, Ada is going to warn you about it. The compilation
    system by design has to do some sort of time stamping or version
    checking to know what's out of date. I can see how that can be
    construed as "Configuration Management".>>

Well I think ensuring consistent builds is indeed *one* of the functions
of a CM system (let's put it this way, any CM system that cannot provide
this assurance, say when working with C++ programs, is missing a critical
capability). But no one would say that this is all CM is about!