PMzone logo

Introducing Ada

A Unique Core Programming Language

Language specification and design, theory and practice!

Ada - Our Flagship Programming Language

Ada is a 64-bit general-purpose programming language optimized for high-performance numeric processing and sophisticated string manipulation. Created as a multiparadigm programming language, Ada combines procedural (statement-based) operations with object-oriented (class-based) functionality. It's key features include mutable typing, program encapsulation, data abstraction, polymorphic functions, and low-level machine access. To facilitate these fundamental design imperatives, Ada employs a highly consistent core syntax designed to enhance program readability and user productivity.

Why Another Programming Language

Since there are many excellent languages available to programmers, why would someone want to spend the time and energy creating another programming language? We believe there are a number of very good reasons. Among them are the following:

Incorporate the best aspects of currently available programming languages

Make the syntax more consistent and less complicated

Focus on numeric processing and string manipulation

Enhance compiler development and maintainability

Incorporate native inline assembly language support

Improve programmer skill level and software design knowledge

Experience a whole lot of fun designing something complex

An outstanding programming language gives users what they want; a language they can enjoy using. It is just as easy to design a good language as it is a bad one!

Ada Design Philosophy

Ada is a bi-level programming language. It employs high-level syntax that insulates programmers from the underlying machine architecture while allowing low-level inline assembly language statements to be inserted into the source code to provide access at the system level when necessary.

Ada uses a highly standardized, syntactically simple grammar designed to facilitate program and compiler development. The language is expressly designed for business and scientific application domains.

Preliminary Design Considerations

Ada is deliberately scaled in size and scope. The development of complex, commercially viable software applications generally involves large project teams with seemingly unlimited resources. We naturally assume most non-commercial programmers like us are constrained by limited resources.

Ada is focused primarily on program readability, program flexibility, and program reliability. These criteria will always exist for modern, well-designed programming languages.

Ada is a programming language concerned with producing correct, error-free code containing no user surprises. It embraces assembly language—not replaces it. For this reason, Ada relies on ample quantities of memory space for key language structures to ensure accuracy, contextual compliance, and program security.

Ada is Readable

Ada avoids terse and cryptic syntax so that program code is easy to read. The use of plain language provides a grammar devoid of ill-defined technical jargon.

Ada is Flexible

Ada allows variables with a given name to take many forms. Subprograms have no type constraints and do not require braces or semicolons.

Ada is Reliable

Ada strives for correctness through simplified syntax, static and dynamic checks, restricted use of aliasing and overloading, and aspect assertions.

Programming Language User Manual

Adagé for Programmers is the essential guide to building safe and reliable software applications. This website is intended for novice programmers and computer science students desiring an introductory foundation to an imperative programming language that combines inline assembly language instructions with high-level procedural-based programming code.

An outstanding programming language gives users what they want; a language they will love. It is just as easy to design a good language as it is a bad one. The fundamental language itself should be concise, but include adequate library functions to expand its power. The manual should be short as well. A well-designed language does not need lengthy clarifications, numerous warnings, or lots of special case examples.

Expressive Programming Language

The expressive power of a language concerns the breadth of ideas that can be represented and communicated in that language. Ada contributes to expressiveness by providing exceptional functionality, first-class functions, garbage collection, minimal syntactic sugar, and both static and inferential type checking.

Secure Programming Language

Imperative programming uses procedural-based programming constructs. Ada is memory safe, meaning it prevents memory leaks and buffer overflows through bounds checking. Ada is type safe, meaning it prevents type errors through strong typing, enforced declarations, and improper casting.

Imperative languages are based on the von Neumann microprocessor architecture. In a von Neumann machine, both data and programs are stored in the same memory. The CPU, which executes instructions, is a separate block of circuitry from memory. The central constructs of imperative languages are variables.

Reliable Programming Language

Ada is reliable because it performs to its specifications under all programming conditions and is highly readable and writeable. The easier a program is to write, the more likely it is to be correct. Programs that are difficult to read are often hard to write and modify. Reliability also comes about through strict type checking, exception handling, non-support for aliasing, and many other built-in syntax designs.

Programming Language Design Goals

Ada emphasizes program readability over program writeability, provides efficient and straightforward compilation, has built-in extensibility and modularity, and is highly orthogonal and safe.

As with any imperative programming language, Ada is focused on storing program instructions, declaring typed objects, elaborating and storing the objects as data, and then manipulating those data using type-specific operations. Adagé operations are further strengthened by the use of packages that separate interfaces from the implementation code and by employing contracts between software components to verify code correctness.

Ada's bi-level structure offers two levels of program development. At the high level, Ada's expressive syntax is specifically designed to free users from the intricate details of the underlying system architecture. At the low level, Ada provides extensive features explicitly designed to allow direct access to system hardware and external libraries using native inline assembly language instructions.

Programming Language Features

Ada is an imperative general-purpose, structurally expressive programming language with static type checking, intuitively readable constructs, and built-in concurrency, encapsulation, exception handling, object-oriented structures, modularity, and extensibility.

Be aware that no software programming language can be all things to all programmers and Ada is no exception. Ada doesn't attempt to incorporate every possible language or library feature ever dreamed up just because they exist.

Ada is implemented as a bi-level, procedurally imperative language for general purpose systems programming where variable length string processing, extended precision arithmetic operations, and machine-level hardware access are primary requirements. As a high-level programming language, Ada provides a rich set of abstract constructs that insulates programmers from the underlying machine architecture. To accomplish this, Ada borrows conceptual features found in languages like Ada 2012, VB6, C99, Modula-3, Pascal, and SPARK 2014.

At the low-level, Ada accepts inline assembly language instructions in order to extend the language's capabilities beyond what high-level languages typically are capable of offering. Ada uses the Netwide assembler to translate program instructions into machine-readable code.

Programming Language Reference Manual

There are many excellent compilers built using C/C++ or even Java. This website focuses on designing and writing a 64-bit compiler using BASIC as the bootstrap compiler, and eventually Ada, which will be used to write its own compiler.

One hallmark of a cogent programming language is its user's manual. Adagé for Programmers is designed to assist users in learning how to build practical applications using the Ada programming language. This straightforward guide covers the many detailed features of the Ada programming language. It incorporates example programs accompanied by programming tips, recommended practices, and learning exercises to ensure a complete understanding of Adagé's range of features.

Readable, Writable, and Reliable Software

Programmers who develop software are often constrained by the limits placed on the kinds of control structures, data structures, and abstractions they can use. The author decided that Ada should be easily read, simple to write, and highly reliable.

Readability

One of the most important criteria for a programming language is the ease with which source code can be read and understood. Readability goes to the heart of overall syntactic simplicity, orthogonality, and data types.

Ada is designed with a fundamentally small number of syntax constructs and reserved words, reduced ways to accomplish particular operations using legal syntax combinations, and restricted operator overloading and aliasing. Ada achieves an optimal balance in orthogonal design.

Writability

Writability is a characteristic that measures how easy it is to write and create program code for a specified software domain. It is a well-known fact that the easier a program is to write, the more likely it is to be correct. Although Adagé's smaller number of constructs can be combined in many ways, they are consistently employed with a standard set of rules. Adagé is expressive.

Ada also makes its computations convenient to use rather than cumbersome; there are no short-circuit constructs as found in other high-level programming languages. Ada supports abstraction, which means it has the ability to define and use complicated structures and operators in ways that allow many of the details to be ignored.

Reliability

Ada achieves reliability through strict type checking; bounds checking; exception handling; and restricted use of anonymous types, aliasing, and operator overloading.

About PMzone

At PMzone.org, we author software programming books, tutorials, and user manuals for all programmer interest levels. As you read our publications and tutorials, if you have questions or comments, you are welcome to contact us via email or regular mail. See our contacts web page.


© 1997-2017 Transtar Management Services, Inc. All rights reserved. Terms of Use