Terminology seems to be a big problem with people learning Ada.  The Ada
language uses different terminology than others (aka C, C++, Java).  The
latest example is with "tag type" vs "class", but a much older difference
is with Ada's use of the word "task" vs "thread" in C.  Ada's terminology
is older, I believe (I have a 1974 text "Operating Systems" by Madnick and
Donovan that uses "task"; it does not mention "thread").

I personally like Ada's terminology because it agrees with A) my text book;
B) many other real-time operating systems throughout my experience
(starting with the Space Shuttle language HAL/S in the 1970s, continuing to
real-time operating systems and Ada in the 1980s).  The only reference to
"thread" in my experience is with the POSIX standard.

I have seen some discussions about Ada tasks vs POSIX threads, and was
surprised to see someone suggesting that they are not synonymous.  The
argument went something like this: Since tasks are built in to the
language, the compiler knows about them.  Since the compiler knows about
them, there are times that the compiler can optimize them such that a new
thread is not needed.  Therefore there is a difference in terminology.

This looks like an interesting attempt at re-writing history, since I would
be surprised to find any references to "thread" prior to Ada's first usage
of the term "task".  And the Rationale for Ada83 uses the same definition
as was in my text book ("a computation that may be done concurrently with
other computations").  While it is true that if one uses the POSIX services
to create a thread, then a thread is really created, it would be difficult
to say there is really an Ada task if the compiler optimizes it away (it
might be in the source code, but the debugger would not think it existed).

There are at least two good ways to proceed within the Ada community.

1) Change the Ada terminology to agree with the POSIX (and C) terminology.
This has the benefits of easier communication, accepting standard
terminology, and (slightly) easier learning of Ada.  Allow "thread" to be
used in any place where "task" is now allowed (add one more reserved word).

2) Use the Ada terminology consistently.  This separates us from the C
world (this is a good thing).  It agrees with history.  It does not create
a new reserved word.

By the way, it is interesting that Linux uses the word "task" in its
implementation of process functionality (including threads), and at least
one Ada vendor uses "thread" in runtime system routines implementing tasks.

Roger Racine
Draper Laboratory, MS 31
555 Technology Sq.
Cambridge, MA 02139, USA
617-258-2489