Adagé is a 64-bit general-purpose programming language optimized for high-performance numeric processing and sophisticated string manipulation. Created as a multiparadigm programming language, Adagé 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, Adagé employs a highly consistent core syntax designed to enhance program readability and user productivity.
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!
Adagé 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.
Adagé 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.
Adagé 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.
Adagé is focused primarily on program readability, program flexibility, and program reliability. These criteria will always exist for modern, well-designed programming languages.
Adagé 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, Adagé relies on ample quantities of memory space for key language structures to ensure accuracy, contextual compliance, and program security.
Adagé 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.
Adagé allows variables with a given name to take many forms. Subprograms have no type constraints and do not require braces or semicolons.
Adagé strives for correctness through simplified syntax, static and dynamic checks, restricted use of aliasing and overloading, and aspect assertions.
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.
The expressive power of a language concerns the breadth of ideas that can be represented and communicated in that language. Adagé contributes to expressiveness by providing exceptional functionality, first-class functions, garbage collection, minimal syntactic sugar, and both static and inferential type checking.
Imperative programming uses procedural-based programming constructs. Adagé is memory safe, meaning it prevents memory leaks and buffer overflows through bounds checking. Adagé 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.
Adagé 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.
Adagé 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, Adagé 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.
Adagé's bi-level structure offers two levels of program development. At the high level, Adagé's expressive syntax is specifically designed to free users from the intricate details of the underlying system architecture. At the low level, Adagé provides extensive features explicitly designed to allow direct access to system hardware and external libraries using native inline assembly language instructions.
Adagé 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 Adagé is no exception. Adagé doesn't attempt to incorporate every possible language or library feature ever dreamed up just because they exist.
Adagé 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, Adagé provides a rich set of abstract constructs that insulates programmers from the underlying machine architecture. To accomplish this, Adagé borrows conceptual features found in languages like Ada 2012, VB6, C99, Modula-3, Pascal, and SPARK 2014.
At the low-level, Adagé accepts inline assembly language instructions in order to extend the language's capabilities beyond what high-level languages typically are capable of offering. Adagé uses the Netwide assembler to translate program instructions into machine-readable code.
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 Adagé, 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 Adagé programming language. This straightforward guide covers the many detailed features of the Adagé 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.
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 Adagé should be easily read, simple to write, and highly reliable.
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.
Adagé 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. Adagé achieves an optimal balance in orthogonal design.
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.
Adagé also makes its computations convenient to use rather than cumbersome; there are no short-circuit constructs as found in other high-level programming languages. Adagé 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.
Adagé achieves reliability through strict type checking; bounds checking; exception handling; and restricted use of anonymous types, aliasing, and operator overloading.
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.