First Ada software patent issued to Air Force

[srctran@world.std.com (Gregory Aharonian)]

 
     As if the DoD doesn't have enough ways to undermine Ada acceptance and
to waste money on promoting Ada software reuse (and coming up with such ways
faster than I can find out about them and critique them), it seems that the
DoD has found a new way to screw things up:  patent Ada technology.
 
     Yes, this month the first software patent specifically dealing with
Ada was issued (given that there are about 9000 software patents issued since
1970, most in the past few years, this is one more measure the Mosemann
contractors ignored about the lack of acceptance of Ada).  Patent number
5,187,788 is for a graphical user interface CASE tool that generates Ada
source code from diagrams.  Assigned to the Air Force, the inventor is on
Robert Marmelstein of Ohio (I assume he works at Wright Patterson, anyone
know him and his tool?).
 
     There are a variety of reasons why it is a waste of money for the DoD
to patent Ada technology.  First, patents are usually sought for to allow
a business to commercial exploit a new idea, and as I thought it was quite
obvious, the DoD is neither a business, nor very successful at commercially
exploiting anything.  As an example of this, consider that once the patent
application was submitted to the Patent Office in June 1991, the Air Force was
free to publicly mention the technology in the patent, which I assume exists
in the form of a working computer program.  Yet not once since June of 1991
has there been an announcement on comp.lang.ada about the availability, or
even existence, of this program (which qualifies Marmelstein to run one of
the DoD software reuse centers).
 
     Second, given that the technology in the patent is not very original
(there are many commercial and university systems doing the same thing), I
doubt any business would want to license and commercialize the technology,
assuming that the patent could survive a reexamination (which I doubt given
the extensive prior art).  In fact, illustrating how screwed up communications
are inside the DoD, the Air Force itself in another part of the country has
an older effort that qualifies as prior art to undermine this patent (of
course if someone inside the DoD ever showed interest in my reuse database
of all of the DoD's software, they could have found this out, assuming save
tax dollars is a patriotic goal worth pursuing).
 
    Third, given the poor acceptance of Ada in the non-Mandated world, you
would think that if the DoD was able to come up with something that makes
Ada more productive to use, and better illustrates Ada's capabilities, you
would think that the DoD would flood the universities and private sectors
with copies of the program to foster Ada acceptance.  The DoD won't profit
from sales of the program, but would profit from the multiplier effect of
having Ada more accepted.
 
    So the $10,000 to $20,000 that it cost to acquire the patents, plus the
$10,000 for maintenance fees over the next seventeen years seems to me like
a waste of tax dollars, does little to help Ada become more accepted, and
more chillingly, starts a trend to patent Ada technology and components, which
for those few experienced in software reuse, is the one sure way to destroy
a software reuse effort - having to worry about licensing components while
waiting for everyone's lawyers to process all of the agreements.
 
    Anyways, attached is the abstract to the patent.  It sounds like a neat
computer program.  How about posting it to comp.lang.ada, comp.archives, or
just mentioning its existence?  And why does everyone tolerate this waste?
 
Gregory Aharonian
Source Translation & Optimization
 
 
==============================================================================
 
             GRAPHICS SYSTEM FOR AUTOMATIC COMPUTER CODE GENERATION
 
                          U.S. Patent Number 5,187,788
		               Robert Marmelstein
		                 U.S. Air Force
		               February 16,  1993
 
 
    A method of code generation for the Ada programming language, which
provides a user with the ability to quickly create a graphical representation
of an initial program design, the graphical representation being in a form
from which the Ada code is generated and then compiled;
 
    wherein the representation provides a user with a plurality of different
but consistent views of an Ada program, with graphic symbols representing
objects defined as entities including constants and variables having values,
wherein the objects include packages, operations, data types, states, slots,
events and connections as defined for the Ada language, and wherein operations
comprise tasks, procedures and functions;
 
    wherein said method comprises the steps:
 
    using a first editor for providing a first view wherein the user defines
an initial Ada package specification, using a combination of graphical means
and text, using a second editor for providing a second view with which the
user creates and manipulates complex data structures and defines local
variables, data structures and local variables used in the Ada program, and 
using a third editor for providing a third view with which the User defines
the control flow of a specific subprogram; and using first, second and third
event handlers for the first, second and third editors respectively;
 
    using the first editor and first event handler to create, select, edit
and delete graphic symbols, including graphic symbols representing packages,
and to create connections between graphic symbols which correspond to Ada
with and use statements, and to create package operations and data structures,
inserting graphic symbols into the data of the common data base, and updating
data in a common data base for objects which have been edited and not
deleted;
 
    using the third editor and third event handler to create, select, edit
and delete graphic symbols representing states, events, slots and transitions,
wherein states represent actions or sequence of actions including procedure
calls, function calls, code blocks, raise exception statements, and
rendezvous statements, wherein events represent Ada select or accept
statements, wherein slots represent paths of communication between tasks,
and wherein transitions describe conditions whereby control is passed to
another sate, wherein transitions between states include while statements,
for/in statements, loops and unconditional flow of control, and updating data
in the common data base for objects which have been edited and not deleted;
 
    using the second editor and second event handler to create, select, edit
and delete graphic symbols representing the data structure, and updating data
in the common data base for objects which have been edited and not deleted;
 
    entering a "generate Ada" command with the first editor to initiate Ada
source code generation for the Ada packages defined for the Ada program,
using templates which are generic structure types having a plurality of data
members, there being a template for each type of object, Ada code being
generated in the system by declaring specific data structures of the template
types with allocation of memory, traversing said common database, extracting
relevant information needed to produce the Ada code from each object in the
common database and inserting the relevant information into members of the
specific data structures, and executing a print function with the data members
of the templates as parameters.
-- 
**************************************************************************
Greg Aharonian
Source Translation & Optimiztion
P.O. Box 404, Belmont, MA 02178