Starting in the 1960s, the U.S. Department of Defense
(DOD) began to confront the growing unmanageability of
its software development efforts. Whenever a new applica-
tion such as a communications controller as developed, it typically had its own special-
ized programming language. With more than 2,000 such
languages in use, it had become increasingly costly and
difficult to maintain and upgrade such a wide variety of
incompatible systems. In 1977, a DOD working group began
to formally solicit proposals for a new general-purpose pro-
gramming language that could be used for all applications
ranging from weapons control and guidance systems to bar-
code scanners for inventory management. The winning lan-
guage proposal eventually became known as Ada, named
for 19th-century computer pioneer Ada Lovelace .After a series of reviews and revisions
of specifications, the American National Standards Institute
officially standardized Ada in 1983, and this first version of
the language is sometimes called Ada-83.
Language Features
In designing Ada, the developers adopted basic language
elements based on emerging principles hat had been implemented in languages
developed during the 1960s and 1970s .hese elements include well-defined control
structures and
the avoidance of the haphazard jump or “goto” directive.
Ada combines standard structured language features
(including control structures and the use of subprograms)
with user-definable data type “packages” similar to the
classes used later in C++ and other languages.As shown in this
simple example, an Ada program has a general form similar
to that used in Pascal. (Note that words in boldface type are
language keywords.)
with Ada.Text_IO; use Ada.Text_IO;
procedure Get_Name is
Name : String (1..80);
Length : Integer;
begin
Put (“What is your first name?”);
Get_Line (Name, Length);
New_Line;
Put (“Nice to meet you,”);
Put (Name (1..Length));
end Get_Name;
The first line of the program specifies what “packages”
will be used. Packages are structures that combine data
types and associated functions, such as those needed for
getting and displaying text. The Ada.Text.IO package, for
example, has a specification that includes the following:
package Text_IO is
type File_Type is limited private;
type File_Mode is (In_File, Out_File, Append_File);
procedure Create (File : in out File_Type;
Mode : in File_Mode := Out_File;
Name : in String := “”);
procedure Close (File : in out File_Type);
procedure Put_Line (File : in File_Type;
Item : in String);
procedure Put_Line (Item : in String);
end Text_IO;
The package specification begins by setting up a data
type for files, and then defines functions for creating and
closing a file and for putting text in files. As with C++
classes, more specialized packages can be derived from
more general ones.
In the main program Begin starts the actual data pro-
cessing, which in this case involves displaying a message
using the Put function from the Ada.Text.IO function and
getting the user response with Get_Line, then using Put
again to display the text just entered.
Ada is particularly well suited to large, complex software
projects because the use of packages hides and protects the
details of implementing and working with a data type. A
programmer whose program uses a package is restricted to
using the visible interface, which specifies what parameters
are to be used with each function. Ada compilers are care-
fully validated to ensure that they meet the exact specifica-
tions for the processing of various types of data , and the language is “strongly typed,” meaning that
types must be explicitly declared, unlike the case with C,
where subtle bugs can be introduced when types are auto-
matically converted to make them compatible.
Because of its application to embedded systems and real-
time operations, Ada includes a number of features designed
to create efficient object (machine) code, and the language
also makes provision for easy incorporation of routines writ-
ten in assembly or other high-level languages. The latest offi-
cial version, Ada 95, also emphasizes support for parallel
programming. The future of Ada is
unclear, however, because the Department of Defense no lon-
ger requires use of the language in government contracts.
Ada development has continued, particularly in areas
including expanded object-oriented features (including
support for interfaces with multiple inheritance); improved
handling of strings, other data types, and files; and refine-
ments in real-time processing and numeric processing.
0 comments:
Post a Comment