|
TECHNICAL
TRACK
THURSDAY, MARCH 2
8:30 am
Morning
Keynote
Dave Winer, UserLand.com
Dave
Winer, 42, is president of UserLand Software, a web
tools developer based in Palo Alto, CA. UserLand makes
Frontier, a powerful scripting and database environment
for the Mac OS and Windows. In late 1994, Winer started
DaveNet, a popular commentary channel, distributed
via electronic mail and thru the worldwide web. A
software industry veteran, Winer also produced award-winning
commercial software hits at Living Videotext, including
ThinkTank, Ready and MORE. Living Videotext merged
with Symantec in 1987. In 1997 he was chosen as a
Seybold Fellow for his pioneering work in web-based
publishing systems.
Session #9: Client Software
9:00 am
Creating
XML: the forthcoming XMetaL 2.0
Lauren Wood, Director of
Product Technology, SoftQuad Software Inc.
lauren@softquad.com
Biography:
Lauren
Wood is Director of Product Technology at SoftQuad
Software Inc. She is a co-designer of SoftQuad Software's
HTML and XML authoring tools, as well as taking part
in various technical committees. She chairs the W3C
Document Object Model Working Group and is on the
Steering Committee for XML.org.
Abstract:
This
is a preview of the forthcoming version of SoftQuad
Software's award-winning XML editor, XMetaL. XMetaL
2.0 contains significant new features which will be
of interest to anyone who needs to create, check,
or edit XML content.
9:30 am
SVG Technical Overview
(presentation
coming soon)
Michael Bierman, Advanced
Technology Group, Adobe
mbierman@adobe.com
Abstract:
Scalable
Vector Graphic (SVG) is the emerging W3C language
for expressing rich 2D graphics in XML. W3C member
organizations defining SVG include Adobe, Apple, Autodesk,
BitFlash, Corel, Hewlett-Packard, IBM, ILOG, INSO,
Macromedia, Microsoft, Netscape, Oasis, OpenText,
Opera, RAL/CCLRC, Quark, Sun Microsystems, Visio and
Xerox. SVG has been designed to be compatible with
and leverage other W3C technologies (e.g., XML, HTML/XHTML,
CSS, XSL, DOM, SMIL-Animation) and techologies defined
by other organizations (e.g., Java, ECMAScript). SVG
content can be expressed either as stand-alone XML
documents or embedded inline within other XML documents
such as XHTML.
This
talk will provide a technical overview of the features
and capabilities of SVG and will show how it integrates
with and leverages other web technologies. Topics
will include SVG's rich graphics features set, including
filter effects, along with a description of its features
that support interactivity and animation. Demonstrations
will showcase various implementations of SVG and will
provide a hint of how SVG will change the landscape
of the future of the web.
10:00 am
The
Object Content Explorer (OCE): An XML based tool for
Component Based Software Development Teams
Erik Ostermueller, Senior
Developer/Analyst, Alltel Information Services erik.ostermueller@alltel.com
Biography:
Erik
Ostermueller is a senior developer/analyst for Alltel
Information Services in Little Rock, Arkansas. He
has seven years experience in the computer industry.
Born in St. Louis, Missouri, Erik Ostermueller received
his bachelors degree in Computer Science from the
University of Kansas, Lawrence, in 1991. Immediately
out of school, Erik provided computer consulting for
ABC News in Moscow, Russia. After several months abroad,
Erik settled down in Little Rock, AR. with a job in
the retail industry.
He
designed, developed and supported NT and DOS mission
critical retail systems for approximately 35,000 users.
Hard work schedules and a six-month old boy convinced
Erik to leave the retail environment for a now-defunct
start-up company. There, he wrote healthcare software
for prisons (go figure) in Visual Basic.
Currently,
Erik is a lead developer on a Java/XML real-time banking
system and has participated in the DNAfs Working Group.
Erik relies on his young family to continually remind
him that death marches are a bad thing.
Abstract:
Consider
the vast number of software tools available on the
market today that graphically present and communicate
the makeup of a given set of software components.
There are UML tools, object browsers/repositories,
programmer's text editors, debuggers and standard
documentation resources. None of these tools, however,
allow you to graphically drill down into an object
and actually invoke all the methods and assign data
to all the attributes of the components.
The
Object Content Explorer (OCE) is a graphical, XML
based tool that allows you to do precisely that. Such
a tool be provide invaluable to a team developing
component based software, especially components without
a graphical user interface (GUI).
Here
are a few things that the OCE can do for a development
team:
*
Help the Quality Assurance team to
-
Enlist non-technical staff in building test cases
-
Determine whether a programmer new to the system (the
customer) can easily understand the components
*
Provide Sales and Marketing personnel with a tool
to
-
Successfully present a complex product
-
Provide live, meaningful demonstrations of the product
*
Help a training staff to integrate the components'
documentation with program operation and error messages.
*
Facilitate re-use of components. The ability to
easily view and 'test drive' a component will bring
to life a component repository.
What
is the OCE?
The
OCE is a graphical tool. It can be used to invoke
methods and assign data to attributes of components
that do have a GUI.
Elements
of the User Interface
+
Universe of Components and Structures
We
should be able to instantiate any component or use
any XML structure in the system. This 'universe'
will provide us with a unique list of all possible
components and structures. Some builds of the OCE
may include just a subset of this universe.
+
Stack
This
will be a list of all components that are currently
instantiated at a given point in time. When the
program starts, no components (or perhaps only a
few architecture components) will be instantiated.
We should be able to freely add to and delete from
this list. To add to the list, we should pick a
component or structure type from the 'universe'
described above. The OCE will then instantiate the
entity.
+
Component TreeView
There
should be one tree for each element listed in the
stack. Each tree should be presented in its own
window (probably an MDI/InternalFrame child window).
The tree should do the following things:
-
Present a hierarchical view of the component's structure,
including all attributes and methods.
-
Allow us to set the attributes of the components
and for parameters of the method signatures. The
GUI should display the current values of the attributes.
-
Allow us to save the status of the current attribute
values to a file. We should also be able to select
any child node on a tree, and save all 'downstream'
attributes to a file. The file system extension
for that file should be the name of the component
type (from the universe list) for the selected child
node.
-
Provide 'drill down' functionality by collapsing
and displaying different parts of the tree.
-
Allow us to invoke any method of the object using
the attribute values currently set.
-
Represent the parameter signature for all methods
as a 'minitree.' This mini-tree should be a child
of the method.
-
Ensure that the mini-trees that represent values
for parameters on a method signature behave just
like any other child node. For instance, we must
be able to save the values of a mini tree to a
file. The extension of this file should be something
like ComponentType-MethodName. We must be able
to set and reset the values of the parameters.
This
portion of the tool could leverage the following
XML-component based work:
-
XMOP and SODL (http://jabr.ne.mediaone.net/documents/sodl10.dtd)
-
MBXML (Marshall By XML) (http://www.develop.com/dbox/msj/0397.htm)
+
Log
The
log should provide a list of all operations that
take place. Which operations?
Component
Instantiations
Component
Deletions
Method
Invocations
Append
Operations (discussed later)
Optionally,
the log should specify the file name of the attributes/values
used for a given method invocation.
Perhaps
we could have a parameter that specified the dialect
that the OCE uses to write the log. The dialect
could be any one of these:
Perl,
C++, Java, VBScript, PowerBuilder, Delphi, Ada,
etc.
Perhaps
the log would provide the code for a program that
used the components. Certainly some important
tasks will be tough for the OCE:
How
do we iterate through a list of items? How do
we branch on a conditional statement? Perhaps
these items will have to be hand coded, perhaps
not.
+Status
The
status portion of the GUI will provide feedback
from all method invocations. Specifically, this
feedback will include the return codes (and corresponding
descriptions). Perhaps the OCE could weave the
Log facility and the Status facility together
into one control.
+Documentation
Unfortunately,
it is not likely that someone unfamiliar with
the System will be able to use the OCE without
some documentation. The OCE should provide
context-sensitive help. If method foo() of
class X is currently selected, then F1 (or
some other key) should display help for X::foo().
Documentation should also provide some pseudo-code
that shows how to use a given component.
Session #10: Information Management
11:00 am
Using
XML to send Compressed data objects across
networks
Alagappan Meyyappan,
Engineer, Siemens
meyy6@hotmail.com
Jaganathan Jeyapaul,
Engineer, Electron Economy
Biographies:
Alagappan
Meyyappan works as a Software Architect with Siemens
(ICP) for designing internet based management softwares.
Has provided Software Consulting for Cisco Systems
, Bank of Nova Scotia, Fujitsu in developing varieties
of Network Management System products. Has a M.S in
Information technology from University of Birmingham,
United Kingdom and B.Eng. in Electrical Engineering
from Regional Engineering College at Tiruchirappalli,
India.
Jaganathan
Jeyapaul works as a Software consultant and has provided
consulting work for leading clients like Oracle Corporation,
Fujitsu and etc in developing B2B and E-Commerce Projects.
Has a M.S. in Aerospace Engineering from Indian Institute
of Science, Bangalore, India and B.Eng from Madras
Institute of Technology, Chennai, India
Abstract:
The
entire process starts by collecting all the similar
objects, which have the same attributes but different
values, and compressing them using delta compression
technique. Then using a simple algorithm an XML document
is formed for this compressed object packet for sending
it across the network. The XML document is downloaded
at the other end and a corresponding reverse algorithm
is used to uncompress and retrieve these objects back.
This
implementation will provide with a mechanism to
send compressed objects in a standardized manner
so that all entities in the network understands
it.
The
further part of this presentation will include the
following
1.
How to collect the similar object and compress them
using the simple delta compression
2.
An Algorithm to produce the XML document for these
compressed objects
3.
An Algorithm to recover the objects form the XML
document
11:30 am
An
XML-Based Approach to the Control of XML Document
Indexing
Jacek Ambroziak, Staff Engineer,
XML Techology Center, Sun Microsystems, Inc.
jacek.ambroziak@east.sun.com
Biography:
Jacek
Ambroziak joined Sun Microsystems' XML Technology
Center in 1999, where he's been applying his extensive
background in natural language technologies, Java,
Jini, and XML to the problems of XML document search
and retrieval. Jacek has been with Sun Microsystems
since 1992, when he became a Research Scientist
in the Knowledge Technology Group of Sun Laboratories.
While in this position, Jacek worked on an approach
to text search called "conceptual indexing," which
combines techniques from knowledge representation
and natural language processing to enable a computer
to systematically organize relationships among concepts.
Jacek architected and implemented modular semantic
lexicons, co-developed a modular text processing
pipeline, and built a highly efficient conceptual
database and search engine. Subsequent to this work
he designed and implemented in Java a full-text
search engine that became part of Sun's JavaHelp
facility. Jacek received his Ph.D. in Computer Sciences
in 1990 from the Polish Academy of Sciences in Warsaw.
He worked as a Research Associate in the Academy's
Institute of Fundamental Technological Research
and, before joining Sun, was a Visting Scientist
in the College of Engineering at Cornell University.
Jacek's recent publications include a 1998 SunLabs
Report with William Woods on "Natural Language Technology
in Precision Content Retrieval" and a presentation
on "Conceptually Assisted Web Browsing" given at
the WWW6 Conference in 1997.
1:30 pm
Afternoon
Keynote: Taxi to the Future
Tim Bray, Textuality, conference co-chair
Tim Bray works in the areas of system design, performance
optimization, programming, lecturing, writing, and
editing. He has experience in the workings of software,
the Internet, documents, management, and financing.
Tim serves as a member of the World Wide Web Consortium's
XML Working Group and has co-edited the XML 1.0
and XML Hyperlinking specifications through their
first several drafts. He has served as editor of
The Gilbane Report, Technical Editor of XML.com,
and is a Seybold Fellow.
Session #11: XML and Windows
2:00 pm
XML
at Microsoft: Today and Tomorrow
David
Turner, XML Product Manager, Microsoft Corporation
dturner@microsoft.com
Abstract:
This
presentation will be a broad review of Microsoft's
current and planned support for XML in its operating
systems, development tools and products.
2:30 pm
Designing
XML based applications for Windows
Frank Boumphrey, VP. HTML
Writers guild
frank@hwg.org
Biography:
Frank
Boumphrey has spoken extensively on XML, VB and
ASP. He teaches classes on these subjects for the
HTML Writers Guild. He is the author and co-author
of several books on XML, including Style sheets
for HTML and XML, XML applications, Beginning XHTML
(Nov) and XML Unleashed (Dec). He is co-editor of
the latest XHTML spec. and is working on the new
XML forms working group for W3C.
Abstract:
In
spite of the Universality of Java, VB remains the
most common programming language in commercial enterprises.
Not only is there a large base of programmers trained
in VB, but also VB is certainly the language that
is in widest use for fronting Data engines.
This
paper discusses the use of Visual Basic as a front
to XML data stores; discusses the pros and cons
of using XML (v. RADBMS) as a Data store; and looks
at the pros and con's of using the MSXML COM object
as a tool for accessing and manipulating XML data.
Points
are illustrated by a VB application that uses the
MSXML COM object as a front for a set of medical
records.
Preamble
As
a language Java spearheaded the development of XML
applications. However as XML moves from being a
'fringe' document markup language to being a 'mainstream'
language for the development of enterprise applications,
it is inevitable that 'enterprise' programmers will
seek to employ XML with the tools that they are
already familiar with. This tool in many instances
is the VB programming language. The MSXML.DLL allows
VB, VC++, FoxPro programmers to easily develop XML
applications.
RAD
applications VB basic
Visual
Basic first became popular as a 'Rapid Application
Development' tool. Less than a few years back once
the 'proof of concept' of an application was established
by VB it was usual to migrate the application to
a 'real' programming language such as C++. With
each issue of VB this has become less true, and
now VB is a powerful language in it's own right.
It is usual nowadays for applications that are developed
in VB to be compiled directly from the VBX files.
When benchmarked applications that have been compiled
directly from VB are in most cases as fast and as
miserly of resources as those compiled as C.
Using
MSXML
The
Microsoft XMLDOM ActiveX Object is made available
in the MSXML.DLL. This is easily incorporated
into VB or VC++ applications using either early
or late binding techniques. MSXML is 99% compliant
with both the XML 1.0 recommendation and the W3C
level 1 DOM. It's '1%' short-comings are discussed
in some detail in this paper.
Early
v. late bindings of the MSXML COM object
In
a Windows application the MSXML object can be
bound to the application with either a 'late'
binding or an 'early' binding. the pros and cons
of each are discussed. (bottom line: it doesn't
really matter!)
XML
v. RADBMS
Databases
have several disadvantages for the storage of
complex hierarchical data. Most of these are well
known to an audience conversant with XML. XML
is ideal for the storage of complex, chunky, hierarchically
driven data. Such a situation arises in the routine
recording of medical records.
There
are numerous other situations where a database
driven system is inadequate to describe the data
adequately (legal and scientific records are two
such examples). The situations when a RADBMS and
when an XML based system should be used are examined
in some detail.
Example:
Using MSXML as a front for a medical record application.
The
mechanics of creating an instance of an MSXML
object are presented, as well as the specifics
of using the 'Microsoft.XMLDOM' object to search
and manage a medical record marked up in XML are
examined. The MSXML object is C++ based, fast
an accurate.
Summary
The
MSXML DLL gives Windows programmers the opportunity
to incorporate the full power of XML into Windows
applications. The rational and methodology for
doing this is discussed in this paper.
3:00 pm
MSXML2:
Technology Preview
Charlie Heinemann, Program
Manager, Microsoft
chein@microsoft.com
Abstract:
This
session will be a detailed, technical presentation
of the new features in the recently released technology
preview of the Microsoft XML parser. The presentation
will highlight the parser's updated support for
XSLT and XPath as well as other new features that
will enhance server side processing. These include:
*
Advanced XSLT and XPath features:
*
Passing parameters to stylesheets
*
Passing objects to stylesheets
*
Caching stylesheets
*
Querying the DOM using XPath
*
Setting the Mode at run-time
*
XPath caching
*
Schema caching and the ability to validate data
against an in-memory schema
Session #12: Distributed XML
4:00 pm
Xbean
Distributed Applications
Bruce Martin, Software
Guru, jGuru.com (formerly known as MageLang Institute)
martin@jguru.com
Biography:
Bruce
is one of the pioneers of distributed object computing.
At Hewlett Packard Laboratories in the early 90s,
he designed and implemented an interface definition
language that became the basis for HP's original
CORBA submission. At Sun Microsystems, he was one
of Sun's CORBA architects and was the primary author
of five of the OMG's CORBA Services specifications.
At Inprise Corporation, Bruce was an architect and
developer of Inprise's first CORBA-based Java Application
Server. Bruce has extensive practical experience
with Java, XML and the DOM. Bruce is now a software
guru at MageLang Institute. He is championing xbeans.org,
an open-source project to create a repository of
Java Beans that process XML and can be easily composed
into distributed applications. Bruce has an excellent
ability to convey both the conceptual basis of a
technology and the practical nuts and bolts use
of it. He has given talks around the world on distributed
systems, advanced transaction models, object oriented
programming, and distributed object technologies
at both academic conferences and industrial events.
Bruce has written many papers for conferences, journals,
and books. He received Ph.D. and Masters degrees
in Computer Science from the University of California
at San Diego, and a Bachelors degree in Computer
Science from the University of California at Berkeley.
Abstract:
An
Xbean is a software component that takes XML as
input, processes it in some fashion and then passes
XML on to the next Xbean. Xbeans are Java Beans.
Java
Bean technology supports the packaging, reuse,
connection and customization of Java code. With
the appropriate set of Xbeans and a Java Bean
design tool, it is possible to build useful distributed
applications with little or no programming.
In
this talk, I will illustrate how Xbeans can be
easily composed into distributed applications,
including data exchange, business to business,
work flow and web channel applications. I will
provide performance results for communicating
XML across process boundaries in Java. The results
compare time and space performance of textual
XML to Java serialization of the DOM. I will describe
Xbeans.org, an open-source project to build a
freely available repository of Xbeans.
4:30 pm
XML/RDF
as a solution for interoperability in Agent Systems
Gerard Maas, Research Engineer
at the Corporate Research Center of Alcatel Bell
gerard.maas@alcatel.be
Biography:
Gerard
Maas received a Master Degree in Computer Engineering
with Mention of Honour from his thesis work at the
Universidad SimÛn Bolivar (USB) in May 1997.
August in the same year he joined the services group
at the Custormer Services Department of Alcatel
Bell (Belgium) as intra/inter-net application developer
and web designer. Early in 1999 he joins the on-line
services group at the Alcatel Research Center. His
current activities mainly relate to the development
of Java prototypes in the investigation of new Internet
technologies.
Abstract:
The
evolution of the Internet is bringing together a
mixture of different terminal types, users and their
preferences and a heterogeneous network made of
otherwise isolated islands of particular systems.
Those systems can communicate in a very rudimentary
way but the lack of semantics and universal solutions
is a major issue.
In
this context, software agents promise to bring
seamless interoperability among those systems
in the form of local interaction or remote communication.
The
lack of data semantics restrains the development
of agent based solutions, given the low capacity
of the software to understand the meaning of the
data they encounter in several forms (documents,
direct interactions, communications) with other
entities. XML is a major player in this field,
structuring the data to a level where it is still
human readable as well as machine understandable.
Alongside XML, the Resource Description Framework
(RDF) defines a mechanism for modelling resources.
By using RDF Schema a meta-model of the RDF data
model can be defined.
In
a software agent context, we can identify critical
points where understanding of data is the path
for success:
*
In the agent: The data forms a knowledge base,
providing the agent with information. It has to
be able to adapt to the complexity level that
the agent requires. Next to this, it must still
be manageable, adaptable to the sort of information
collected and transportable (in the case of mobile
agents).
*
Between agents: Communication. The data takes
the form of a message to correspond to the communication
needs of the agents. Agents typically pursue a
goal and the socialization with other agents could
be crucial in this task. The definition of ontologies
and standardized languages play a major role here.
*
Between agents and their environment: To interact
with available resources, users and services the
agents must have means to recognize and use available
interfaces in a regular way.
The
use of XML/RDF in software agents addresses all
these situations.
Knowledge
representation within an agent is possible using
a RDF model implementation. The application at
the high level communication is direct: messaging
between entities in (agents, applications, platforms)
x (agents, applications, platforms) is performed
using RDF descriptions. Given the object oriented
flavor of RDF Schemas, we see object serialization
in XML/RDF as a direct application of the paradigm.
We could even think further, in a context of mobile
agents where the representation of the underlying
behavior is encoded in RDF and provided to another
system where a functionally equivalent software
piece will re-take the already started task in
the new environment. In the rest of the document,
we will focus on XML/RDF as a data model for knowledge
representation and agent communication.
Here
at Alcatel we have developed 3AP: Advanced Alcatel
Agent Platform. An agent platform based on Java(TM)2
technology and compliant with FIPA97[1] and MASIF[2]
. It is able to host communicative and mobile
agents. On top of 3AP, we have implemented
a security negotiation service, which allows mobile
agents wanting to migrate to another host, to
request first a grant for a set of security-sensible
task to avoid undesirable or potentially dangerous
hoops. This request is prepared locally and sent
to the addressed host, where a qualified agent
will query the platform in order to determine
the acceptance or denial of the request.
In
the side of the communication, the permissions
required by the agent wanting to migrate are
encoded in RDF. These permissions can be implemented
in several ways by each host, while the encoding
in RDF keeps the semantics of the message, ruled
by the underlying schema.
The
task at platform level is to provide an interpretation
of the RDF message, making local objects from
the RDF description and working with them to
determine an answer. Back at the originating
agent, it receives the RDF answer and links
it back with its knowledge base, being now able
to decide whether to go or not.
RDF
gives us more than a simple message encoding.
The agent's internal RDF representation gives
it the ability to incorporate a portable knowledge,
allowing mobile agents (which are typically
lightweight) to carry a bunch of meaningful
and manageable information that can grow during
the course of its life, as needed.
In
the course of our study we have seen the seamless
integration of XML/RDF with agent technology,
bringing added value for the effort invested
in the implementation of the bridges to/from
the RDF model.
We
achieve a higher level of interaction at the
communication stage at the same time that the
agent is able to incorporate filtered pieces
of this exchanged information into its knowledge.
Together
with RDF data, the RDF schema brings a powerful
model to build up a common ontology necessary
in the creation and standardization of agent
languages. The object- oriented approach of
the RDF Schemas makes them the bond of the programmatic
agent world with the more data driven Web of
today's Internet. We envisage that together
with Java technology, agents could bring a new
level of distributed inter-working into the
now much reactive world of the Internet.
5:00 pm
The
PIA, a platform for XML-based Web Applications
Stephen Savitzky, Chief
Software Scientist, Ricoh Silicon Valley, Inc. Calif.
Research Center
steve@rsv.ricoh.com
Biography:
Stephen
Savitzky is Chief Software Scientist at Ricoh Silicon
Valley in Menlo Park, CA. He has been working in
the computer field for over thirty years; his current
work involves the PIA, an open-source, XML-based
platform for web applications. Previous projects
include two C++ application frameworks, a real-time
kernel for the Zilog Z8000, and several assemblers
and linkers. Some of his web pages (Interesting
Places for Kids; Notes, Advice and Warnings for
Kids on the Web) were among the earliest such sites
on the Web; Interesting Places for Kids was listed
in the April 11, 1995 issue of PC Magazine as part
of A Guided Tour of 100 Hot Sites. He has an MS
degree in computer science from Stanford (1971).
Abstract:
This
paper describes a design and development style well-suited
to creating customizable Web applications using
server-side processing of XML documents. The fundamental
assumption underlying this style is that "Web application
maintenance is mostly a matter of document management
and should not require specialized programming skills
or tools." The examples and technical details given
will focus on our particular platform, the PIA,
but the general principles apply generally to other
web application platforms.
The
"Platform for Information Applications" (PIA) is
an open-source, XML-based system in which both documents
(information) and application behavior (processing)
are combined in XML "active documents." This approach
is particularly appropriate for applications deployed
by smaller organizations without significant IT
support; applications are easily customized and
extended without the need for programming.
PIA-based
Web applications consist primarily of XML documents
written using a set of domain specific tags; our
parser also supports legacy HTML documents extended
with custom XML tags. The PIA server engine serves
pages in response to client requests by dynamically
processing these documents in accordance with developer-defined
semantics. This processing may include simple tag
substitution, page transformation, database lookup
and insertions, or any other functions appropriate
to the application domain. In essence, the tags
provide a specialized vocabulary available to use
in customizing the application.
The
PIA's processing is all done on the server side;
the client sees only standard HTML, or XML in
standard DTD's. The document-processing engine
implements a Turing-complete language with pure
XML syntax and LISP-like semantics. Processing
requires only a single pass through the input
document, and never builds a complete parse tree;
a subset of the DOM is used for intermediate storage
where required. Tag definitions, including the
binding of primitive operations to tags, come
from an XML ``tagset'' document separate from
the document being processed; the result is a
blended system with aspects of both style sheets
and embedded languages. In addition, explicitly
binding operations to tags provides an extremely
flexible security model, with different documents
getting different levels of trust.
In
the PIA, semantics for the small set of primitive
operations are defined in Java, along with the
web server and an off-line command-line processor.
Unusual aspects of the web engine include event-driven
``agents'' implemented in XML, and an XML configuration-file
language.
A
C version of the document-processing engine is
in progress, and will eventually be available
as an Apache module.
This
approach promises platform independent, easily
customizable Web applications. XML support in
the form of editors and other tools already exists
on essentially all platforms and continues to
grow.
Specifying
the processing in XML not only makes the logic
more accessible to non-programmers but restricts
the dependence on a particular computing environment
to the implementation of a few tags.
Open
standards are used throughout the PIA: it supports
both SAX and DOM interfaces for XML applications,
and the Servlet interface on the web server
side. WebDAV support is planned, as is support
for XML namespaces. The entire system is available
as open source from http://RiSource.org/PIA.
MANAGEMENT
TRACK --
TECHNICAL
TRACK (Feb
29, March
1)
|
