Goals

As you may have already guessed, the XPS is targeted at addressing some important issues in software development. To clarify the intent of XPS, we list its main goals:

• Raise the level of language abstraction to make program writing easier by providing a fundamental core programming language (XPL) and supporting extensions in the form of new XML-based programming languages that are translated to XPL and then reduced to executable code.
• Allow programmers to specify programs using a language that is specific to the field or domain to which the program is applied. For example, chemists should be able to write programs in a language that intrinsically understands their primary information source: Chemical Markup Language (CML). The chemistry programming language would support processing of CML documents and provide operations on them that are of interest to chemists (e.g. Reactions between molecules). XPS should support the creation of such programming languages in any knowledge domain or field. Allow one programming language to be derived from another so that the cost of new language development is only an increment over what is currently specified in existing language extensions or the core language, XPL.
• Support multiple styles and semantics of programming such as functional, object-oriented, declarative logical, fuzzy logic, etc.
• Ensure XPS programs can be executed on a wide variety of platforms by making a clear distinction between the program specification, an abstract virtual machine upon which it can run, and the implementation(s) of that virtual machine.
• Ensure that programs conform to a variety of international standards so that they can be freely exchanged and processed by systems other than XPS. Specifically, this involves the use of Unicode, XML, and related XML standards (XML Schema, XML Namespaces, XPath, XSL for Transformations, etc.).
• Liberate the software through the use of open source licenses.
• Base the implementation of the XPS on existing, freely available components.
• Provide a comprehensive programming language, XPL, that is based on XML standards so that programs can be easily: executed, transformed, processed as documents, etc.
• Provide a machine independent software layer that will allow XPL programs to run on any hardware or operating system.
• Ensure that XPS is highly extensible and supports the tenets of domain engineering and meta-programming. XPS must provide everything a domain engineer would need so that XPL can be used as the basis for higher-order languages that professionals in the given doomain could successfully build high-quality, robust applications without being experts in software or computer science.
  For example, a chemist armed with knowledge of CML (for describing molecular structures) and with a suitable extension for programming CML based on XPL, should be able to easily construct programs to visualize, reason about, or otherwise process molecular structures.
• Abstract away the details of memory management, input/output, synchronization, parallel programming, machine limitations, transactions, databases, distributed messaging, high quality user interfaces, and other fundamental services by endowing the programming language with declarative features for each of these (i.e. you state what, not how).
• Support internationalized software development. While the core XPL tags will be based in english for uniformity and faster translation, the fact that XPL is based on XML means that XSLT could be used to write XPL in foreign languages and that any UniCode character can be used for program identifiers. The goal is to provide the first programming language that is open to all natural languages.
• Utilize existing high-quality Open Source software in the core of XPS. This will significantly reduce the effort required to build XPS and avoid re-inventing things already satisfactorily developed. For example, it has already been determined that Unicode processing will be handled by ICU, communications and machine abstraction will be handled by ACE, XML processing will behandled by Xerces, 3d graphics will be handled by CrystalSpace, etc. Other packages will be used as required.
• Provide a comprehensive platform for software development and deployment. Services for managing and building software (for example, those provided by ant, gmake, and CVS) will be incorporated directly into XPS. The system must also support multiple users and multiple workspaces, promotion of software from development to staging to production environments, runtime monitoring and configuration, etc.

Additionally, XPS seeks to resolve the following issues in programming sysems:

• New programming languages will continue to be developed because the needs keep changing.
• The growing diversity of languages will continue to breed incompatibilities between languages and their runtime environments.
• There appears to be a need to specify programs at higher and higher levels of abstraction so that complex programs can be specified succinctly and tersely and in a language suitable for the domain from which the need for the program arose.
• A variety of incompatible language syntactic styles, programming semantics, and runtime environments diminish our ability to integrate, combine, and reuse programs efficiently.
• Much of the nuts and bolts of programming languages is redundant.
• To combine languages in one program you must either physically separate them (e.g. In separate processes) or deal with the complexity of supporting multiple compilers, linkers, and runtime conventions.
• Learning multiple languages with significantly different syntactical styles is difficult.
• Runtime incompatibility (e.g. accessing FORTRAN common block from Smalltalk) may make some integrations impossible.