Aztec Summary
This page contains a high level summary of the Aztec Programming Language, Aztec Class Framework and Aztec Engine software, along with a description of how to navigate through the 165+ separate web pages contained in this site.
Aztec Programming Language Summary
Classes and Data Types
♦ Strongly typed language, but Aztec does offer an "implicit" flag to provide the ability to create local variables automatically based on usage.
♦ Four fundamental primitive data types which are treated as objects
♦ int (8 byte signed integer)
♦ float (8 byte floating point)
♦ string (varying length up to 250 million)
♦ bool (true or false)
♦ Primitive methods exist to slice and dice 8 byte integers into 1, 2 and 4 byte values, as well as bit level manipulation. All Stream I/O classes provide support for reading and writing 1, 2 and 4 byte, signed and unsigned integers. Similar story for 4 byte floating point values.
♦ User defined enumerations
♦ True multiple inheritance and polymorphism
♦ A class can "adopt" one or more classes, which allows adopted class access to all members marked as "family".
♦ Satellite classes allow the definition of a class to be spread across multiple locations and compiled at different times.
♦ Instance methods and shared data can be added to "dynamic" classes.
♦ Allows a class to be extended without deriving a new subclass.
♦ All classes in the Aztec framework are defined as dynamic.
♦ Spreading class definition across modules can also be used to provide controlled access of certain class members.
♦ Flexible model for memory handling including deterministic destructors
Method Definitions
♦ Methods can be defined within a class or at the global/module level.
♦ Methods can also be defined to be executed during the compile phase.
♦ Method arguments can be "pass by value" or "pass by reference", and methods support default arguments.
♦ Arrays references and method references can also be passed as method arguments.
♦ Method references are supported for shared/global methods and instance methods and are completely type safe.
♦ The instance object reference is automatically stored within method reference object, if applicable.
♦ Each method reference type is based on a specific method signature (return type and method arguments).
♦ Method names can be overloaded as long as each implementation has a unique argument list.
♦ Methods can be defined as 'sync' so Virtual Machine automatically synchronizes access across multiple threads.
General Language Elements
♦ Comprehensive model for scope and visibility of identifiers
♦ Six different visibility options for classes, methods and data - most of which can be combined together for maximum flexibility.
♦ Creative and powerful model for performing logic at compile-time using multiple compiler passes
♦ Does not require separate preprocessing language.
♦ Compile-time logic includes conditional execution and full expression evaluation.
♦ Compiler methods support all flow control statements.
♦ Provides library of compiler methods for primitive objects, file I/O, dialogs and system utilities, including loading new source modules.
♦ Powerful exception handling with a high degree of flexibility and consistency with the entire Aztec Event handling methodology
♦ Flexible multi-dimensional dynamic array support with rectangular arrays
♦ Includes a set of methods to operate on arrays, including manual resizing, automatic resizing and sorting.
♦ Parameterized template classes are supported and some templates are provided in the Collection family of classes.
♦ All arrays, lists, ranges and other collections are one based for ease of use and consistency.
♦ Flexible model for specifying the script/application startup class or method (script entry point)
♦ Derive "Main" class from Thread and VM automatically creates object and executes Run method.
♦ Optionally provide a "Main" global method or shared class method for startup.
♦ Name of "Main" class or method can be changed on Aztec Engine command line (-main XXX).
♦ The end-of-statement delimiter (semi-colon) is not required and is typically not used.
♦ The compiler automatically looks across all source modules and libraries to match identifier names, including source modules dynamically loaded by compile-time logic.
Aztec Class Framework Summary
♦ Primitive data types are objects and are thread safe.
♦ Entire library of primitive methods are handled directly as VM instructions.
♦ Makes them as efficient as using operators, and keeps language syntax cleaner.
♦ Applies to instance methods and global methods.
♦ Events and Exceptions
♦ Powerful and consistent event and exception handling across the entire Aztec Class Framework
♦ Three separate options for handling events, including method references and abstract interface classes
♦ An Exception is an Aztec Event, and standard exception handling in the offending thread can occur simultaneously with event handling across multiple threads based on the same exception event.
♦ Multiple thread support with flexible synchronization and thread communication features
♦ Thread to thread and thread to Script messaging features including text, binary and object messages.
♦ Message handlers all conform to the same Aztec Event handling model.
♦ These Same Script level message handers are also used for remote Message .
♦ Variety of utility classes for date/time manipulation, timer alarms and template based collections
♦ Flexible and consistent family of stream I/O classes including file I/O, memory I/O, socket I/O and stream filters
♦ Family of system Metadata objects with real-time information about the running Script. Classes include Metadata, Unit, Module, Class and Method.
♦ Remote messaging feature allows Script to also send messages to remote Aztec Scripts.
♦ The Socket class hierarchy provides separate client and server classes.
♦ ClientSocket provides "socket receive" and "socket close" events to simplify the communication.
♦ ServerSocket provides "socket connect" event to drive connnection process and create client socket for I/O.
♦ ClientSocket uses socket stream I/O for point to point communication with remote application.
♦ The Script class provides several mechanisms to dynamically generate and compile Aztec source code on the fly and immediately make it available to the running program for execution.
♦ Dynamically updates class and virtual method hierarchies for the running program, which can also change the behavior of already existing code.
♦ User interface framework is easy to use, thread safe and provides consistent event handling.
♦ Supports the capability to display the UI on one or more remote machines and process all UI events locally.
♦ Most of the Aztec Class Framework is implemented using proprietary C++ plug-in technology built into the Aztec Engine.
♦ Provides efficiency and helps keep the entire size and compactness of the Aztec Engine where it is.
♦ Where system I/O is part of the class, it solves the whole "chicken and egg" issue about core services provided by a new language such as Aztec.
♦ C++ Plug-in technology can easily be made public. This will allow 3rd party C++ code to be integrated directly into an Aztec system.
Aztec Virtual Machine Summary
♦ The Aztec Virtual Machine provides a completely safe execution environment.
♦ All critical services are monitored and exceptions are fired when necessary. Math operations, file I/O, socket I/O memory and window I/O are handled automatically.
♦ Object memory cleanup is handled automatically by the Virtual Machine, and the system ensures that object references are valid at all times.
♦ The VM manages all Script Thread objects and interaction between them. Each VM Thread is associated with its own underlying OS thread.
♦ The VM also manages the system Metadata associated with the executing script, and dynamically updates it based on dynamic code generation.
♦ Event handling is built right into the Virtual Machine and it can directly and automatically kick off event handlers in multiple threads as directed by the framework.
♦ Many optimizations have been designed into the Compiler and Virtual Machine to provide extremely good run-time performance.
Aztec Engine Summary
♦ The Aztec Engine compiles and executes Aztec source code.
♦ Compile mode builds the Aztec executable bytecode and stores it in a file (.azcode).
♦ Execute mode builds the Aztec executable bytecode and executes it immediately. Supports source file(s) or binary executable file as input.
♦ The Engine provides a "UI Display Server" mode to behave as a remote UI system for a separate Aztec Script.
♦ The Engine also provides an "Ad Hoc Interpret Dialog" which allows the user to dynamically compile Aztec source code, integrate it into the running Script, and execute it.
♦ Standard input and output are supported at the Aztec level, with the option of redirecting standard I/O to the Operating System level if desired.
♦ If OS redirection is not used, Aztec provides a StdIO Console window which can be used for standard output and standard input.
♦ Compiler and Virtual Machine provide log files which can be viewed within the Aztec system UI and they can also be redirected to files.
♦ The Engine provides a System Menu in the Window taskbar that provides access to the Log, Console and Interpret Dialogs.
♦ The size of the entire Aztec Engine is just 1.81 MB, and it consists of a single Windows executable file.
♦ Includes the Aztec Compiler, Aztec Virtual Machine and the entire Aztec Class Framework.
♦ Can also be run in "UI Display Server" mode for use in displaying remote UIs.
♦ Supports Windows 7, 8 and 10, with a Linux version planned for the near future.
♦ The Aztec system is very nimble and easy to move around. No formal installation or setup is required.
♦ Supports C++ plug-in modules with a well defined API.
♦ Aztec classes, data and methods can be created from within the C++ plug-in.
♦ When the VM executes an Aztec method defined in C++ code, it executes the underlying C++ function. The API is used to access and modify the Aztec arguments and to communicate directly with the VM for a variety of services.
♦ The majority of the Aztec Class Framework is implemented using this C++ plug-in technology, with the exception of Template based classes.
Aztec Programming Language Web Site
♦ This web site is the official documentation for the Aztec Programming Language, Aztec Class Framework and Aztec Engine. The Aztec documentation is presented in the form of two separate books titled "Language Definition" and "Class Framework".
♦ Each "book" provides a navigation bar on the left side and it displays each content page in the large frame on the right side of the web site.
♦ A link is provided at the top and the bottom of each navigation bar to switch back and forth between the two.
♦ All available pages for each book are available in the navigation bar.
♦ Each content page contains two sets of up and down arrows for easy navigation through the entire book.
♦ Many Pages are presented in a bulleted format to minimize the complexity and make it easier to read.
♦ Contains the "Why Aztec?" series of pages, Aztec Language Definition and Aztec Engine User Guide.
♦ Class Framework book (119 separate content pages)
♦ Each content page contains an inheritance hierarchy with links to all classes that the class is derived from.
♦ "Derived Classes" and "See Also" sections provide further useful navigation through the framework.
♦ Each page provides a list of methods contained in the class, and each method in the list provides a link to the detailed definition of that method.
♦ There are also three special content pages which are accessible from links in the header of every content page.
♦ The "Download Aztec" page allows the user to download the Aztec Engine software and example Aztec scripts for free.
♦ The "Aztec Search" page allows the user to search for text throughout the web site.
♦ The "Aztec Development Group" page describes a little bit about the company and how to contact us.
♦ HTML Frames are used for separating the navigation bar on the left from the content on the right. Although frames are generally considered old school and may go away in the future, they seem to provide a better simple solution than the newer "iframe" feature for the visual design goals of this website.
♦ There is an issue with this site's frame usage and the Google Chrome browser. When the browser window is resized, the separator bar is not always refreshed properly, and is drawn over the content.
♦ Some content pages contain an example Aztec source code listing. Every source code example contains a complete, working script. They are not just code snippets. The code can be copied directly out of the window and executed using the Aztec Engine. All Aztec source code from examples on this website can be freely used and modified by the user.
♦ Most content pages contain song lyrics from popular musical artists. The lyrics and the artists have no relationship or significance to Aztec Development Group, the Aztec Programming Language or this web site. Aztec Development Group does not endorse or condone any of the phrases or ideas presented in these lyrics. They are provided solely for amusement to help ease the pain of reading technical documentation.
Some Applications for the Aztec Programming Language
♦ Aztec is a great teaching language.
♦ Encourages good OO design and implementation
♦ A small set of operators and clean language syntax
♦ Auto memory management and a well controlled run-time environment
♦ Well designed, consistent and uncluttered class framework
♦ Supports full multiple inheritance, polymorphism and easy to use multi-threading
♦ Very small footprint, easy to install and use, and available for FREE
♦ Provides many cool features to interest budding programmers such as remote UI, multi-threaded event handling, self modifying code and compile-time logic
♦ General purpose application programming – client and server – where the use of a Virtual Machine is reasonable
♦ OS level scripts (directory/file maintenance), product installation scripts and other types of utility scripts
♦ The entire Aztec Engine can operate as a scripting language for a 3rd party application. An existing Aztec Interface object can easily be expanded to support the remote control operation of an Aztec Engine instance, including execution of Aztec Scripts.
♦ The powerful dynamic code generation features make Aztec an interesting choice for artificial intelligence applications
♦ The compact size and efficiency of the VM are a great fit for internet and mobile applications.
♦ 95% of Aztec Compiler, Virtual Machine and Framework source code is written in ANSI C++ to minimize effort to port to other environments.
♦ The entire Aztec Engine will be ported to Linux in the near future, opening the door for the internet, cloud computing and internet of things.
♦ Aztec VM technology could easily be integrated into a web browser.
♦ Linux version of Aztec Virtual Machine could run on small devices such as sensors and send UI windows/alerts to a remote Aztec UI Display Server running on Windows.
♦ Cloud computing and Big Data scripting once database functionality is added to the Aztec Engine.
