Section 15.1 - Ada Program Structure

Packages are the principle structuring facility in Ada. Packages are intended to be used to directly support abstraction, information hiding, and modularization. For example, packages are useful for encapsulating machine dependencies.

It isn't easy to describe program structuring issues, because that's really a program design question, not just a language question. Some recommendations are given in Chapter 4 ("Program Structure") of Ada Quality and Style: Guidelines for Professional Programmers. Here are some of those guidelines:

• Packages should serve a single purpose. You should avoid creating packages that are simply collections of unrelated objects and subprograms.
• You should use a package to group together closely related types. For example, you might have a "vector" type (a one-dimensional list of numbers) and "matrix" type (a two-dimensional list of numbers). In this case, you could have a single package called Matrix_Manipulation with both types defined in it.
• Put only what is needed for the use of a package into its specification; hide the implementation details from the users.
• In general, avoid defining a variable in a package specification, since that creates a global variable visible to anyone who withs the package.
• Minimize the number of declarations in a package specification.
• Only use with clauses where they are needed. In particular, if you can move a with clause so that it's used by the package body instead of the package specification, you should do so.

Note that Ada is different from some other languages. Ada separates the concept of type from the concept of module (package); some other languages merge the two concepts (particularly Eiffel, and to a lessor degree C++). Each approach has its advantages and disadvantages, which we won't delve into here.

There is no quiz question for this section.

You may go to the next section.

Go back to the previous section

Go up to the outline of lesson 15