Re: Ada policy enforcement

[eachus@spectre.mitre.org (Robert I. Eachus)]

     The original goal of the HOLWG was to cut the number of languages
that the DoD was paying to maintain compilers, tools, and classes for.
The numbers ranged from about 800 to over 1000 depending on how you
counted...

     The reality now is that many of those languages and tools have
gone away, and C++ is one of the few languages added.  I'd like to say
that the number is below 50 today, but it is probably closer to 100.
This is great progress, but some of the languages will only go away
when the programs that use them do, and others, even though worth the
cost of displacing, will take years of recoding and upgrades to get
there.

     Now taking this larger view, trying to eliminate C totally is a
waste of the government's time.  (And is in no sense a goal.  I've
been involved in many C exception requests, some I recommended
against, others I was the one to recommend.) There are still times and
places, even on projects where the majority of the the code is in Ada,
where C is much better for the purpose, or the only reasonable tool.
If the DoD could get to the point where a programmer who knew Ada, C,
and SQL could do 70% of the maintenance work, we would be in great
shape.  As it is there are still many large complex systems where the
software is in FORTRAN, CMS2, JOVIAL, or worse.  (And I even had to
work with 3 dialects of JOVIAL and two of CMS2 in the recent past.)

     Just to give you a clue, there is one program I am aware of that
requires over 50 compilers, assemblers, etc. to compile the source
code, and most of the tools are maintained at government expense.
There are many other systems where we would love to junk the existing
hardware and replace it with COTS hardware costing less than the
monthly maintenance costs of the existing hardware.  But doing that
requires porting the software, and in some cases there are no
programmers around who even know the languages used in the existing
systems, so reverse engineering may be out of the question.

     Using C instead of Ada might make a program more likely to fail.
Or using Fortran instead of Ada may cause later porting problems.  But
these problems pale into insignificance next to obsolete hardware
programmed in language no longer taught, where the government even has
trouble finding people willing to teach a course--if students can be
found.

    Now having said all that, C++ is a very different animal from C.
With C we know that--if the code is written and works--it may be
harder to port than Ada, but the costs are comparable.  With C++ it
turns out that the trick is porting the class libraries, and that this
means that often two C++ applications compiled with the same compiler
cannot be merged later because the class libraries are incompatible.
Figuring out how to make reuse work in that environment is difficult.
On the other hand C++ does seem to be good for small one-off
applications that won't require much maintenance.  It may have it's
place, but it is a very different place from C.

--

					Robert I. Eachus

with Standard_Disclaimer;
use  Standard_Disclaimer;
function Message (Text: in Clever_Ideas) return Better_Ideas is...