Editorial

Software tools: the role of modern high-level languages

Software engineering: the term was introduced at a NATO conference in 1968. However, since that time progress has been rather slow. During the past 15 years or so a number of software engineering techniques have been introduced. These include stepwise refinement, structured programming, data abstraction, modularization, etc.

The question which may then be asked is: with all these improvements why are so many programs still written in assembly language? Why have the anticipated gains in software productivity and quality not been achieved? These are issues, particularly in the area of realtime embedded computers. Design methodologies, programming methodologies and software engineering concepts have been slow to catch on. There are two main reasons. The first is the lack of suitable software tools, the foremost of which is the implementation language. Structured programming is not easy in assembly language, FORTRAN or BASIC. The second reason is that the habits and attitudes of programmers are difficult to change.

The new high-level languages, particularly ADA and MODULA-2, have provided not only the necessary tools to support modern software engineering practice but also the impetus to change habits. People are more willing to make a commitment to a new technology than to change techniques whilst still using the same technology. The final obstacle is the programmer's viewpoint on reusable software. Many programmers regard software reuse as the lowest form of the art. This viewpoint must change to be more appropriate to today's problems. What is wanted is not unique individual pieces of creative genius but rather reusable, maintainable and understandable engi- neered products which are functional and supportive parts of a total adaptable system. Hence the importance of modularization.

The best way to push new techniques is to support them with suitable tools. Making these tools widely available will speed the spread of advanced software engineering techniques. This is the reason for the emphasis on software tools which include compilers, operating systems, syntax-directed editors and version control systems as well as the implementation language. Although a detailed treatment is beyond this discussion, it should not be forgotten that the quality of the compiler, as a tool to support the use of the language, has an important influence.

So, the theme of the series of papers on modern high- level languages which this editorial introduces is that

• The increasing size and complexity of microcomputer software systems requires the widespread adoption of good software engineering practices.

• Good software engineering practices require software tools, the foremost of which are the implementation languages.

The series opens with the paper opposite on high-level language features by Professor Tony Davies of The City University, London, UK. This includes discussion of the control structures required to support structured pro- gramming, the compiler detection of errors by strong typing and the declaration before use of user-defined types and operators, and abstraction.

PASCAL as a teaching language has taught good habits to many students. Pat Samwell's paper on PASCAL includes discussion of data structuring; types and their operations; user definition of types; program structuring; sequential, repetitive and conditional constructs.

PASCAL had shortcomings which made it difficult to use in industrial applications, because it was designed as a teaching language. MODULA-2 was designed to overcome these shortcomings and in his paper Joe Gallacher discusses the module concept and the export/import mechanism and how these support not only data abstraction but also data hiding, and facilitate the creation of libraries of reusable software modules. Also discussed are the low-level features of MODULA-2 which support direct memory addressing, bit manipulation, concurrency and I/O and interrupt handling.

John Barnes of Alsys was closely involved in the development of ADA and is in a unique position to discuss the features of this important language which was designed for, and promulgated by, the US Department of Defense. It is a large and powerful language designed with the aim of producing viable and reliable software. ADA was designed to support all stages in the software life cycle. The construction of the language is intended to make ADA programs easy to read, but not necessarily easy to write. It of course supports the features already discussed, e.g. separate compilation, data abstraction, low-level mani- pulation, etc. The language is intended to promote software reliability by a combination of program structuring methods, extensive compile-time checks and runtime checks.

Having dealt with the major modern procedural languages the series will extend to cover OCCAM, a language specially developed by UK company Inmos for parallel processing, and the declarative language PROLOG.

Joe Gallacher Series Coordinating Editor

76 Microprocessors and Microsystems