From: val@news.ccutah.edu (Val Kartchner)
Subject: Re: Ada Mandate (was Re: Open Systems closed to Ada?)
Organization: University of Utah Computer Center
Date: Fri, 11 Dec 92 20:32:26 GMT

dugal@wotan.austin.ibm.com (Douglas Gray) writes:
: In article <1992Nov30.215944.17819@fcom.cc.utah.edu> val@news.ccutah.edu (Val Kartchner) writes:
: >... In our current project, we were prohibited from using
: >a 4GL because it isn't Ada.  We used a cost justification that included
: >estimates that the required ratio of Ada code to 4GL code would be 5:1.
: >This would translate into equivalent savings in development and maintenance
: >times.  Our four requests were refused, and we did the project in Ada.  We
: >found out that the actual ratio was 50:1 or more.  Since cost is directly
: >related to SLOC, this is the "cost savings" that was generated by the
: >mandate.
: 
:      Hmmm...how was the 50:1 ration determined?  Was there a parallel 
: project in the 4GL written to the same functionality as was eventually
: required of the Ada code?  If not, we can't know what the "actual ratio" is.

As a matter of fact, our "prototype" (quoted because this became the actual
"production" system) was working, and our contract actually specified that
our project would be done in that 4GL.  However, the government had not
actually bothered to get the necessary waiver.  We attempted to get the
waiver 5 times, but it was turned down.  We were prepared to attempt a
sixth waiver when the decision was made to go with Ada.

I was in the meeting when the decision was made.  It was a political decision
by management to look good for management farther up (at the Pentagon level).
The decision was then made to scrap the initial development (which had taken
at least the 4 months that I had been there and several months before that),
slip the schedule by six months, and change the contract.  (The contract still
hasn't been changed.)  The schedule ended up being slipped another 3 months
because the government had not actually bothered to order the Ada compiler
by the necessary deadline.  (Procurement is another topic for discussion.)

: ...  More importantly, though, the cost of development (ESPECIALLY in DOD 
: systems) is absolutely miniscule in comparison to the complete life-cycle 
: cost of a system.  Defense systems will be around for many years; moved 
: from one hardware platform to another; the cost to maintain that sucker is 
: enormous!  That's the big reason for Ada.  
:      
:      Consider this project over the entire life-cycle.  What about 
: training costs, for example?  Can we be sure this 4GL will still be 
: supported 15 years from now?  If not, think of the expense!  As a US 
: taxpayer, I think that using a "compelling cost justifiable reason" as
: the litmus test for Ada is the best news I've heard in quite some time!

The 4GL is provided by the same company that provides the COTS database.  If
the 4GL goes away, then the database will have gone away.  Either way, the
entire system will need to be rewritten.  (I've worked with four different
databases, and they were all very different; different enough to cause
major rewrites if not total restructuring.)

Besides that, there were several things that needed to be done, this system
is not portable.  (No non-Ada 3GL or below code was written.)  We needed
function pointers (provided in some other 3GLs).  We would have used
generics if they could take a variable number of parameters with variable
types.  I understand that Ada 9X will be adding function pointers (Oops!
Forgot something.), but we need to complete our contract now not in 1995.

Administrators are making decisions on the tools to be used by programmers.
What I see in the DoD and this group is that "Ada is the right tool for every
job."  Would you like to be given a mechanics toolkit and told to use it to
fix a watch?  As a taxpayer, I'm concerned with what I have seen in the DoD. 

So, despite the FACT that these statistics will be refused by the majority
of this group, I will present them for those who haven't determined the
outcome before reading the data.


					Ratio Ada to 4GL
			Ada	4GL	Raw	Corrected for # of forms
Number of forms:	 40	 71	 .56	  n/a
Number of chars:    3809420  391718	9.72	17.26
Number of lines:     114504   17176	6.66	11.83
Number of blocks:      8041    1075	7.48	13.48


However, these raw numbers do not show the functionality of the systems.  When
we went from the 4GL and forms generator (they are highly bound), we lost
functionallity.  One of the abilities that we lost was the ability to do
multi-table joins.  I've made my estimate on how much it would take to bring
the Ada code (still not fully debugged) up to the capabilities of our
"prototype".  (Hey!  Aren't prototypes supposed to have less capabilities than
the actual working model?)  Which of you knows this system better to make
make your estimate?

I will be glad to show anyone who is willing to come how I got these values
and that these are the true values.  (Anyone close enough to take me up on
this offer should contact me at the address given in the signature below.)

			-=:[ VAL ]:=-
--
|================== #include <disclaimer.h> ==================///=============|
| "AMIGA: The computer for the creative mind" (tm) Commodore /// Weber State  |
| "Macintosh: The computer for the rest of us"(tm) Apple \\\///   University  |
|== "I think, therefore I AMiga" -- val@csulx.weber.edu ==\///= Ogden UT USA =|
Newsgroups: comp.lang.ada