|
 |
 |
New Features in XactScript:
(in comparison with the previous version - LeXml 1.0)
- LeXml can only directly interface with Java objects called "Interface Modules" that implement a specific type of object interface
- XactScript can interface with any Java object, legacy LeXml interface modules, and in the future objects in other languages and over remote connectors such as CORBA, XML-RPC, and RMI.
- You could think of it like this: XactScript dynamically generates the "Interface module" with it's object profiling architecture
- The XactScript Object Profiling Architecture allows the complex and type-specific interfaces of Java and other objects to be used from a page without requiring that the page author be conscious of the types of parameters or other special language-specific considerations.
- XactScript automatically finds the "best fit" for a set of arguments to a function in an object if multiple functions exist with the same name
- The XactScript object profiler uses a learning mechanism to learn and remember object profiles and best fit type profiles for added speed
- In the end, what all this means is that native objects can be controlled from a simple, easy to use language without requiring that the page author be concerned with the details of object argument types and complex calling semantics
- Very fast-XactScript compiles it's documents into an internal object model and caches these compiled documents in memory and on disk. LeXml on the other hand parses the actual XML of a document each time the document is accessed. This, combined with XactScript's other learning and self-optimization algorithms, provides up to a 2000% speed improvement over LeXml.
- Cross platform-like LeXml, XactScript is written in 100% Java and can run on many different platforms and machine architectures
- XactScript has the capacity to be used for more than just a web page rendering language
- The fact that XactScript is a universal object control language means that it could be used as a "glue" language for building distributed applications, similar to the Microsoft .NET concept but much simpler. (Some of this is potential future functionality, but not that far off from a development cycle point of view.)
- XactScript supports multiple tag renderer plugins, allowing it to be used to render things like PDF reports using special tag structures instead of just HTML output. HTML is merely one possible output type from an XactScript document. It is even concievable that in the future XactScript could be extended via a new tag renderer plugin to control graphical user interfaces! (Imagine being able to write a Java applet inline within a web page in a simple and easy language!)
- XactScript contains features enabling it to be used to "crunch" data for things such as a database imports. It turns out that writing a simple XactScript page is an excellent way to define the way a file should be processed for data import.
- It continues LeXml's concept of seperating page design from code-real "nuts and bolts" code is written as native Java objects that are generalized and not site specific. Site specific interface design, data importing, reporting, and other tasks can be defined in XactScript.
- Like LeXml, it is designed to be able to be written and maintained by someone with only limited programming ability such as a web site designer or system administrator. The XactScript tag structure is simple and easy to understand, and the object profiling and calling algorithms hide the details of object use from the document author (as discussed above).
- Since XactScript is a universal object control language, it can be integrated with existing object-oriented applications already developed or used to control legacy code.
- XactScript is able to load and call old-style LeXml interface modules, enabling LeXml sites to be ported to the new technology easily and in stages.
- XactScript is modular and can be embedded into other applications, enabling it to also potentially be used as an embedded control language like TCL (Tool Control Language) or JavaScript.
- There are two very powerful new tags in XactScript: _stepthrough and _stepinto. These control tags enable hierarchical lists of data to be visualized and manipulated very easily with only a few lines of code. Normally, visualizing hierarchical data is cumbersome and requires that new recursive "tree walker" functions be written for every instance where such visualization is needed. XactScript automates this process and at the same time makes it very easy for the document author.
- There is much better error handling in XactScript vs. LeXml, including the ability to catch errors within a page, redirect to special error output if necessary, and have e-mails sent in fatal error conditions to notify administrators that there is a problem.
|
|
|
 |
