What Is A Programming System?

When you see the term programming system, you probably think about a language, its compiler, and the runtime libraries and support it needs. In traditional languages, this is everything you need to get a program running. However, XPS defines it a little differently as the sections below describe.

Toolkit Oriented

XPS doesn't pretend that its tools are the only way its libraries can be used. Each tool provided by XPS is simply an interface between the command line and the XPS libraries. You are completely free to build your own tools from the libraries provided. Monolithic tools don't exist here.

This design feature permits extensibility of XPS at a very fundamental level

Language Agnostic

XPS offers only a very simple and low level fundamental programming language, XPL. From there additional languages can be created by supplying a schema for the language in Relax NG and a plug-in to the compiler to assist in code generation.

Full Lifecycle

XPS manages your source code through its full lifecycle: development, testing, production use, and retirement. XPS provide full Services for promoting applications through the various stages of its life.

Lifetime Optimization

Because XPS manages a program or application through its entire lifespan, it can perform optimization based on its knowledge of the use of the program. The size of the program, frequency of use, length of execution, the kind of workspace it is deployed to, and many other factors are combined to determine which programs in a workspace should be optimized most aggressively. When optimizing a program, it can move a program through various forms: bytecode interpretation, just-in-time compilation, statically compiled. Programs that graduate to static compilation can be profiled at runtime to collect performance data that will be used to further optimize the program based on its typical workload.

Integrated Runtime

At runtime, the virtual machine (XVM), offers an integrated runtime. Because all XPS languages have a common foundation (XPL and LLVM), they can share the runtime environment as well. This means that data created in one language can be just as easily manipulated in another language. This integration of data and runtime services makes it possible to use the right language for the job, without compromising performance or code clarity.

Extensible Semantics

Most programming systems can be broken down into three basic components:

• the syntactic, structural, and compositional rules of the language (syntax checker)
• the semantics of what the language means and how it should be interpreted for execution (compiler), and
• the mechanisms to execute the language on a machine (runtime).

But, the essence of the programming system lies only in the second category, the semantics of the language. The programmer thinks and works at the semantic level to specify what s/he wants the computer to do. The syntax checker is merely the enforcement of a convention used to allow humans to tell the computer what to do in a syntax this is suitable for both humans to write and for computers to correctly interpret. The runtime component is merely the plumbing needed to make the program actually execute. That is, after the semantics have been correctly interpreted by the compiler, the runtime simply takes care of executing the program on a given machine. Thus, the particular syntax used to express the semantic ideas to the computer and the details of the runtime mechanism of those semantics are uninteresting (as long as they both work correctly).

While none of this is surprising to programming language implementers, it is mentioned here because the focus of XPS is on integrating the semantics of multiple languages and allowing for the extension of the system to support additional semantics. What we need is a diversity of language semantics supported by an extensible programming system. In XPS, syntactical, structural and compositional rules have been relegated to XML, XSLT and Relax NG. Compilation (interpretation of the semantics) is handled by a combination of a core language definition (XPL), a low level virtual machine (LLVM), and pluggable compiler modules. A portable and extensible virtual machine specification provides a runtime for the system that can be implemented on any platform. Together, these components make up the XPS. What makes XPS unique is its ability to allow new semantic programming models to be developed, have them easily turned into executable programs, and address some of the issues in the integration of programming languages.