Central to Argot is the concept of carrying the meta data with the actual data being transfered. At the very heart of Argot is a meta dictionary. The meta dictionary contains the data types for describing the enclosed meta dictionary data types. The meta dictionary has similarities to the "Rossetta stone", it creates the key from which other data can be defined. A single Argot file or message can contain data, the data dictionary, which describes the format of the data, and a meta dictionary which describes the format of the data dictionary. This creates a purely self-referencing and self-describing data file with no external dependencies.
By removing these external dependencies, Argot allows systems and devices to communicate data in evolving formats. Data formats may be as complex or as simple as an application requires, and may be extended without removing meaning for other applications that share the data. These features make Argot an ideal match for distributed systems, data storage, embedded applications, and proprietary web applications.
Argot provides the strong typing you receive from a system like XML Schema, but without the constraints of an external static schema. Because all definitions are local to a file, an application is able to confirm whether a file's data format description conforms to its own. This completely localizes the interaction between application and data, removing the need for systems and files to refer to an external static schema. Embedding the meta data with the data is an important and powerful feature of Argot. It makes it easier to modify and grow large distirbuted systems organically, something a single versioned XML schema can not do.
An Argot designer uses the concept of a common dictionary to choose the required data types for an application. The common dictionary is able to grow over time and can contain information from a variety of domains. Each concept in the dictionary is defined within the context of other types in the dictionary. After the data types have been chosen from the common dictionary, an application dictionary is created. The application dictionary is a subset of the common dictionary and only includes the data types the application needs to communicate.
When the application creates an Argot enabled file, the file itself contains the complete description of the data being sent. The file's dictionary is a subset of the data types of the application dictionary. In this way each application and file in a system contains all the knowledge about the information it is able to process or data it contains.
The receiver of an Argot enabled file is able to read the dictionary and compare the data types of its own dictionary with that of the files. Once the types of the file dictionary have been matched with that of the application reading the file, the data can be read. This completely removes the need for a static common domain schema. Each application and file in effect contains its own schema.
This can be re-illustrated using the following set theory:
The ability to compare dictionaries and ensure that the formats are compatible gives Argot its flexibility. The use of a common dictionary allows concepts to be updated and changed without the versioning consequences found with XML or ASN.1.
When a new concept is introduced into a system, the programmer adds the additional new code into the applications that must process the new concept. The Argot library allows the new marshaling code to be added without disrupting other parts of the application.
Argot and its dictionary format are binary. This ensures the most flexibility and only a small overhead for dictionary information during communications. The binary nature of the dictionary and data also allows the Argot library reading the data to be small, making the library and format appropriate for embedded applications.
Argot allows a file or application to contain its own specification. This removes the need for a file to directly adhere to external schemas. As a direct result, two systems, which have previously had no contact, are able to discover dynamically if they have common data types to allow communications between them. This has a number of implications in the way we build future software and communications systems.
The Argot dictionary and mapping system opens a world of possibilities that have not been previously possible. Specifically it allows:
- Ability to better integrate heterogenous systems from multiple vendors in large infrastructure environments. A data serialization method which is totally language and system independant.
- Reflective binary data, allowing software to confirm the format of the data before attempting to read it.
- Argot Network Resolution, which allows client and server to negotiate the specific data structures before attempting to send/recieve them.
- Abstract data types which allow multiple representations for a single data type to be defined.
- Using abstract data types, data dictionaries can be extended without modifying existing definitions.
- Definitions from multiple dictionaries to be combined and intersected to provide a single dictionary source of data types.
- Heterogeneous systems to change and grow over time: changing to the needs of business requirements.
- Compact binary data to be used anywhere well formed data structure is required. This is in contrast to the current trend of using text in XML.
- Fully reflective file formats to be generated, which describe their own file format.
- Data formats to change and grow as required by business applications.
- Ability to define binary programming languages, which allow the constructs of the language to be extended by the user.
To learn more about Argot in detail, read the Argot White Paper or the Programmer's guide provided with the downloads. You can also continue on to the Features, or read our getting started Tutorial which develops a basic bookstore application.