1111111111111111 IIIIII IIIII 11111 1111111111 11111 lllll lllll 111111111111111 1111111111 11111111
`US 20020069192Al
`
`(19) United States
`(12) Patent Application Publication
`Aegerter
`
`(10) Pub. No.: US 2002/0069192 Al
`Jun. 6, 2002
`( 43) Pub. Date:
`
`(54) MODULAR DISTRIBUTED MOBILE DATA
`APPLICATIONS
`
`(76)
`
`Inventor: William Charles Aegerter, Portland,
`OR (US)
`
`Publication Classification
`
`Int. Cl.7 ....................................................... G06F 7/00
`(51)
`(52) U.S. Cl. .................................................................. 707/1
`
`Correspondence Address:
`Micah D. Stolowitz
`Stoel Rives LLP
`Suite 2600
`900 SW Fifth
`Portland, OR 97204 (US)
`
`(21)
`
`Appl. No.:
`
`10/006,200
`
`(22)
`
`Filed:
`
`Dec. 4, 2001
`
`Related U.S. Application Data
`
`(63)
`
`Non-provisional of provisional application No.
`60/251,285, filed on Dec. 4, 2000.
`
`Servo
`
`(57)
`
`ABSTRACT
`
`Computer-implemented system and methods for deploying a
`distributed client-server system, enabling developers to rap(cid:173)
`idly create and deploy read-write distributed data interfaces
`for host database systems. The disclosed system is especially
`advantageous for mobile clients as connection to the server
`environment can be intermittent without unduly impeding
`local ( disconnected) operations. One important aspect of the
`invention is an incremental process for executing an appli(cid:173)
`cation servo in a client device. This process includes build(cid:173)
`ing and incrementally maintaining a logical context tree in
`which each node expresses a complete current state of the
`execution process.
`
`XML
`Database
`
`Servo
`Processor
`
`User
`Interface
`
`Instacart, Ex. 1038
`
`1
`
`

`

`Patent Application Publication
`
`Jun. 6, 2002 Sheet 1 of 7
`
`US 2002/0069192 Al
`
`Figure 1
`
`XSLT
`Stylesheet
`
`XML
`File
`
`XSLT
`Processor
`
`XI.vfL
`File
`
`(PRIOR ART)
`
`2
`
`

`

`Patent Application Publication
`
`Jun. 6, 2002 Sheet 2 of 7
`
`US 2002/0069192 Al
`
`Figure 2
`
`Servo
`
`XML
`Database
`
`, Servo
`Processor
`
`User
`Interface
`
`3
`
`

`

`Patent Application Publication
`
`Jun. 6, 2002 Sheet 3 of 7
`
`US 2002/0069192 Al
`
`Alice's Palm
`?,').~
`Alice's Storage
`
`Juan's Pocket PC
`'}'-1'1
`(Windows CE)
`
`\
`
`J
`
`Server
`Environment
`
`:310
`
`I
`
`3s1
`35'"'1
`
`\ {
`i
`Synchro,;izrr-
`
`3/0
`
`, ~,
`'
`-..
`I
`
`J \ "
`
`.-===-------,
`Alice's Storage
`Server RepliC11
`
`I
`
`""\ WAPUI
`/
`-.,., Interpreter
`~
`t• 1
`)t/0
`------------
`/
`\
`\
`\\ Juan's Storage
`~)} )
`/
`Serve,· Replica
`
`~--;:::::ules Data
`
`)
`
`,
`
`,
`
`/,~
`I/
`J/ ~ r o u p Storage
`
`Registrar::;:: __ -'-
`~---_,--__ - - Rules
`j3D
`;---
`~""schema
`
`" /
`
`'--~~
`"'"'2-
`.i I
`
`370
`
`/
`
`~Y
`Synchronizer
`3~i
`;{)'''---
`Data ~ ~ ' /' ,
`Integration Toolkit
`\
`
`I
`
`/
`XZ\1L Services
`3~0
`-
`
`Legacy\ JJ!'
`I
`
`r
`Relational
`Database
`
`Fig.3
`
`4
`
`

`

`Servo Template
`400 <xsl:template match='wh:obj' >
`402
`<html:div>
`404
`<html:span> < xsl:value-of select= '@barld'/> <lhtml:span>
`406
`<ts:edit select='wh:desc'/>
`408
`<ts:expandable>
`410
`<ts:hideable>
`412
`< xsl:apply-templates select= 'key("objByLast", @wh:barld)'/ >
`414
`</ts:hideable>
`416
`< /ts: expandable>
`418
`< /html:div >
`419 < /xsl:template >
`
`Fig. 4A
`
`Database Fragment
`420 < wh:objects >
`422
`<wh:obj wh:barld='271'>
`424
`< wh:desc > black metal cabinet< /wh:desc >
`426
`< /wh:obj >
`428
`<wh:obj wh:barld='259' wh:last='271' >
`<wh:desc>top shelf</wh:desc>
`430
`432
`< /wh:obj >
`434 < /wh:objects >
`
`Fig. 4B
`
`I")
`
`I")
`
`""C
`
`~ .... ~ = ....
`~ "Cl -....
`~ ....
`....
`0 =
`O' -....
`~
`~ ....
`....
`0 =
`~ = ?
`
`~~
`N
`0
`0
`N
`
`'JJ. =(cid:173)~
`~ ....
`0 ....,
`-..J
`
`,i;;..
`
`d
`'JJ.
`N
`0
`0
`~
`0
`0
`~
`\0
`'"""' \0
`N
`>
`'"""'
`
`5
`
`

`

`Patent Application Publication
`
`Jun. 6, 2002 Sheet 5 of 7
`
`US 2002/0069192 Al
`
`Figure 5A
`Interpretation multi-tree
`
`Figure 5B
`Geometric Layout
`
`[b] [a~
`
`[d]
`
`[e]
`
`~ - -+ -~~ - - - -+ - - -
`
`.
`
`•
`
`I
`
`[cl '\l2f 1j /black meta}
`~ ~i~l
`l'L fcabinetl~,Jlli
`' · - - - - -~ !;W
`I
`j259j top shelf/ :1
`/
`
`6
`
`

`

`Patent Application Publication
`
`Jun. 6, 2002 Sheet 6 of 7
`
`US 2002/0069192 Al
`
`Figure 6
`Context Node
`
`Geometry tree
`
`lnterpretation tree
`putnt pollitct ]E=::;:==:::::::( R'P~:=rion
`\
`\ Geometry subtree
`root (whorl)
`
`---~
`Interpretation subtree
`root (whorl)
`
`Figure 7
`Interior Socket
`
`Sum of number of context node children,
`transitive over interior whorls, but not
`beyond the first level of context nodes
`
`Sum of y span,
`transitive over
`all levels below
`
`Flags, including union
`of all flags below
`
`Pointer to child
`(context node or interior whorl)
`or cached information about
`unmaterialized object
`
`Figure 8
`Interior Whorl
`Parent pointer to parent
`interior whorl or parent context node
`containing the whorl referencing this
`/
`I . /
`
`----~~ I
`Each column is an interior socket
`
`7
`
`

`

`Patent Application Publication
`
`Jun. 6, 2002 Sheet 7 of 7
`
`US 2002/0069192 Al
`
`Figure 9A
`Sparse relative multi-b-tree
`
`Figure 9B
`Detail of context tree
`
`s
`
`s
`
`D
`
`[bl
`
`8
`
`

`

`US 2002/0069192 Al
`
`Jun.6,2002
`
`1
`
`MODULAR DISTRIBUTED MOBILE DATA
`APPLICATIONS
`
`[0001] RELATED APPLICATIONS
`[0002] This application is a continuation of U.S. Provi(cid:173)
`sional Application No. 60/251,285 filed Dec. 4, 2000, and
`incorporated herein in its entirety by this reference.
`
`COPYRIGHT NOTICE
`
`[0003] ©2001 ThinkShare Corporation. A portion of the
`disclosure of this patent document contains material which
`is subject to copyright protection. The copyright owner has
`no objection to the facsimile reproduction by anyone of the
`patent document or the patent disclosure, as it appears in the
`Patent and Trademark Office patent file or records, but
`otherwise reserves all copyright rights whatsoever. 37 CFR
`§1.71(d).
`
`TECHNICAL FIELD
`
`[0004] The present invention relates to software systems
`for distributed mobile computing and, more specifically, it
`includes a software platform-and application language(cid:173)
`for deployment of portable, reusable, and interoperable data
`viewing and modification applications in a distributed, inter(cid:173)
`mittently networked environment.
`
`BACKGROUND OF THE INVENTION
`
`[0005]
`Increasing numbers of workers are mobile, mean(cid:173)
`ing that they do their jobs outside of the conventional office.
`Laptop and palm-sized computers provide some communi(cid:173)
`cation and computing ability "on the road" and, with the
`decreasing size of data storage devices of all types, mobile
`workers can carry a lot of data with them. It is more difficult,
`however, to share data with others or access a centralized
`database. Specifically, mobile users ( or developers of wire(cid:173)
`less data systems) face several challenges, such as:
`[0006] Disconnected operation. Workers often lose con(cid:173)
`nectivity in certain areas such as, subways, buildings, etc.
`but they should be able to continue doing their job and, at a
`minimum, not have their data corrupted ( either locally or
`centrally) as a result of the disconnection.
`[0007] Limited screen size and user input. It is difficult to
`display large amounts of information, and enable a user to
`meaningfully "browse" the information on a tiny screen.
`User input is limited as well, especially with respect to
`PDAs and cellular phones.
`
`[0008] Latency. Another challenge facing developers is
`how to design applications that make best use of a range of
`bandwidths.
`[0009] Manageability. Applications should be able to
`grow, adding features and functions, without rebuilding
`them from scratch and without losing backward compatibil(cid:173)
`ity with other programs or services.
`[0010] The value of separation of data and format has
`become widely known, one example being the use of
`stylesheets as described in U.S. Pat. No. 5,860,073.
`Stylesheets alone, however, do not adequately address the
`mobile user problems outlined above. For example, a
`stylesheet or transformer can be written to translate data to
`HTML or WML for display on a small screen. But if the
`
`result is long, downloading may take awhile, and even if
`communication bandwidth is good, disconnection is a risk,
`and even after downloading, limited local processing power
`may result in long delay before the entire document can be
`randomly accessed by the user. Stylesheets enable some
`dynamic properties, but when applied in the context of a
`Web browser page viewing they do not provide a complete
`solution for disconnected operation.
`
`[0011] XML (Extensible Markup Language) is a known
`document processing standard ( a simplified form of SGML).
`It allows a developer to create a custom vocabulary or
`"schema" defining a custom markup language. This can be
`done using a document type definition (DTD) or with the
`XML Schema Definition (XSD), among other schema lan(cid:173)
`guages. The schema specifies what elements or tags and
`attributes can be used in a document and how they relate to
`each other. Many industry-specific DTDs are evolving, for
`example MathML, PGML, etc. XML parsers are publicly
`available for checking "well-formedness" of a document
`( compliance with the XML syntax specifications) as well as
`"validity" meaning compliance with the applicable schema.
`
`[0012] The Information and Context Exchange (ICE) pro(cid:173)
`tocol is designed to manage establishing "syndication" rela(cid:173)
`tionships and data transfer for content distribution. ICE is an
`application of XML. ICE enables establishing and managing
`syndicator-subscriber relationships for transferring content
`that is generally originated by the syndicator and consumed
`by the subscriber, such as news or weather reports. This
`system essentially supports one-way distribution of content,
`i.e., publication, rather than interactive, mobile applications
`implementing and synchronizing distributed databases. Still,
`it does suggest a data replication scheme mediated by XML
`messages.
`
`[0013]
`It has also been suggested to use text-based
`descriptive attribute grammar, like XML, to specify object(cid:173)
`oriented applications. U.S. Pat. No. 6,083,276 to Davidson
`et al. describes such a method. It is limited, however, to
`essentially translating the application description (in an
`XML-like language) to a set of software objects such as
`Java® component classes. Each element declaration in the
`source (markup language) file must be capable of being
`mapped to a corresponding application component class.
`Each element with children must result in a corresponding
`container component with analogous child components.
`Every attribute declaration must map to a corresponding
`property value in the corresponding component, and so on.
`Thus the application must be designed from the outset to
`align very closely with a selected object-oriented language
`and framework. Desired extensibility, reuse and similar
`goals are sacrificed, although the concept of initially
`describing an application using an XML-like syntax is
`interesting and has some obvious benefits. The '276 patent
`to Davidson, however, primarily teaches an automated
`method for translating that description into a specific object(cid:173)
`oriented program at which point the benefits of the descrip(cid:173)
`tive attribute grammar are lost.
`
`[0014] U.S. Pat. No. 6,012,098 teaches a system for iso(cid:173)
`lating the retrieval of data from the rendering of that data. A
`data retrieval "servlet" executes a query, and converts the
`results to an XML data stream, delivered to a downstream
`rendering servlet. The rendering servlet parses this XML
`data stream, using a stylesheet that may be written using
`
`9
`
`

`

`US 2002/0069192 Al
`
`Jun.6,2002
`
`2
`
`XSL, and creates an HTML data stream as output for
`communication to a client computer.
`[0015] XSLT, or Extensible Stylesheet Language-Trans(cid:173)
`formation, is a useful tool for working with XML docu(cid:173)
`ments. XSLT enables one to extract and transform the source
`information in various ways, for example into another
`markup language like HTML as is commonly done. See
`FIG. 1.
`[0016] Many software systems exist which implement or
`utilize the XML family of standards (XML, XSL, XPath,
`XML Schema Definitions, etc.). HTML and XML browsers
`are common. Many enable offline operation by accessing
`cached read-only data. HTML and XML editors are common
`as well, all of which form part of the general background of
`the invention.
`[0017] See also U.S. Pat. No. 6,167,409 to DeRose et al.
`"Computer System and Method for Customizing Context
`Information Sent with Document Fragments Across a Com(cid:173)
`puter Network."
`[0018] Glossary of Prior Art Terms and Acronyms
`[0019] Application server-One of a class of commer(cid:173)
`cially available software frameworks for integrating com(cid:173)
`putation into a web server environment.
`[0020] Load-balancing router-A router that takes into
`account the effective performance of a set of computational
`resources when deciding where to route a message.
`[0021] N-tier architecture-A software architecture in
`which computing resources can be layered to any depth. In
`contrast to "3-tier architecture."
`[0022] Namespace name (Namespaces)-A URI uniquely
`identifying a namespace. See Namespaces
`in XML
`[N amespaces].
`[0023] Public identifier (SGML)-Globally unique string
`to identify a resource. Could be accompanied by a system
`identifier, which was often a filesystem path on a private
`filesystem.
`[0024] Public identifier (XML)-Unique identity string.
`See XML 1.0 [XML].
`[0025] Self identity-Identity as self-assigned by an
`object, without the direct assistance of an issuing authority.
`The UUID is a standard created to support the implemen(cid:173)
`tation of self identity. Self identity is needed in situations
`where it is not necessarily possible or appropriate to request
`an identity from an authority.
`[0026] Session-An object representing a cached state to
`optimize an end user's interaction with the system.
`[0027] Synchronization point-The event during which a
`database incorporates information from another database,
`thus instigating replication or updating previously replicated
`information.
`[0028] Unique identifier-Any identifier that defines a set
`of rules, that, if followed, guarantee uniqueness.
`[0029] XML Extensible Markup Language-A simplified
`form of SGML, the Standard Generalized Markup Lan(cid:173)
`guage, in international documentation standard. XML is a
`document processing standard recommended by the World
`Wide Web Consortium (W3C).
`
`[0030] XSL Extensible Stylesheet Language-A part of
`the broader XML specification. An XSL document or
`stylesheet transforms an XML input document to an output
`document, essentially applying element formatting rules.
`
`[0031] XSLT Extensible Stylesheet Language-Transfor(cid:173)
`mation-The transform portion of the broader XSL lan(cid:173)
`guage specification.
`
`[0032] XPATH-A syntax for describing a node set loca(cid:173)
`tion in an XML document using expressions that consider
`the context in which they appear.
`
`[0033] URI-Uniform Resource Identifier. See RFC2396
`[URI].
`
`[0034] UUID-Universally Unique Identifier. A 128-bit
`unique identifier that can be allocated without reference to a
`central authority. From Universal Unique Identifier [DCE].
`
`SUMMARY OF THE INVENTION
`
`[0035] The present invention includes computer-imple(cid:173)
`mented methods for modular programming on distributed
`devices that brings together and extends industry standards
`in a unique way to create a platform for a class of portable,
`reusable, and interoperable data viewing and modification
`programs that can operate in a distributed, occasionally
`communicating environment, for example where client
`devices are loosely linked to hosts or servers via a wireless
`communications channel. The invention builds on XML and
`related standards, including, but not limited to, Namespaces
`in XML, XPath, XSL , XSLT, XPointer, XLink, XHTML
`and XML Schema Definitions [XSD].
`
`[0036] A complete distributed programming model is
`achieved by enabling declarations of shared or private data
`storage, declarations of schema translation, synchronization
`rules, editing actions, access rules, application packaging,
`label sets for default interfaces, and registration for distri(cid:173)
`bution and reuse. The invention exploits schema to enable
`seamless integration at both data and display levels. An
`application defined for the invention can extend another one
`dynamically, even if neither developer was aware of the
`other application.
`
`[0037] Thus, one important aspect of the invention is a
`computer-implemented, incremental process for executing
`an application servo in a client device. This process includes
`building a context tree in which each node expresses (by
`reference) a complete current state of the execution process.
`For example, the context node content includes a pointer to
`an element in the servo execution of which spawned the
`context node; a pointer that identifies a current data context
`by pointing into a source tree; a reference to a parent
`context; and an ordered, potentially sparse, list of pointers to
`zero or more child contexts.
`
`[0038] Another feature of the incremental execution calls
`for the creation of child spacer nodes in the context tree
`representing unmaterialized child contexts. These can be
`used for certain operations, and estimates, without waiting
`for evaluation of the entire source tree. In a presently
`preferred embodiment, the context tree is implemented
`using a relative b-tree structure, and each spacer is reflected
`in an interior node entry in the relative b-tree structure to
`facilitate searching unmaterialized contexts.
`
`10
`
`

`

`US 2002/0069192 Al
`
`Jun.6,2002
`
`3
`
`[0039] Another aspect of the invention is a servo definition
`language for defining a distributed application that supports
`disconnected operation. The language typically includes the
`following types of rules: application data schema; transfor(cid:173)
`mation rules; transaction handling rules; and interface object
`specifications. Importantly, the servo definition language
`can also implement opportunity rules to realize automatic
`extension or integration of servos through opportunity-based
`linking of an interface component representing an instance
`of a schema fragment to a template.
`[0040] The invention enables developers to rapidly create
`and deploy read-write distributed data interfaces for systems
`that employ relational databases or have XML interfaces.
`Even when wireless network service is available, efficient
`use of the network is important for the end-user and/or the
`service provider (depending on the pricing structure of the
`service contract). The invention addresses this by allowing
`many actions to be taken without immediate use of the
`network.
`[0041] Wireless service is unreliable and often unavailable
`(e.g., in basements, rural areas, and commercial aircraft).
`While it is not possible to access new information when
`service is not available, the invention makes it possible to
`review recent actions and initiate new actions of common
`types. Further, the present invention enables the develop(cid:173)
`ment of continuously evolving suites of applications by
`maintaining integration with legacy "servos" as new servos
`are created and deployed. Users need not be actively
`involved in the distribution process. Developers can focus
`their efforts on individual capabilities rather than frequent
`systemic overhauls. "Servos" as used herein, roughly analo(cid:173)
`gous to applications, are more precisely defined later.
`
`[0042] Additional aspects and advantages of this invention
`will be apparent from the following detailed description of
`preferred embodiments thereof, which proceeds with refer(cid:173)
`ence to the accompanying drawings.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`[0043] FIG. 1 is a simplified data flow diagram illustrating
`a common batch XSLT transformation process as known in
`prior art.
`
`[0044] FIG. 2 is a simplified data flow diagram illustrating
`interactive servo execution in accordance with the present
`invention.
`
`[0045] FIG. 3 is a simplified block diagram of a distrib(cid:173)
`uted system illustrating a deployment of the present inven(cid:173)
`tion in a wireless context.
`
`[0046] FIG. 4A is a code fragment from the asset man(cid:173)
`agement servo of Appendix B.
`
`[0047] FIG. 4B is sample data in the schema of the asset
`management servo.
`
`[0048] FIG. SA is a multitree diagram illustrating execu(cid:173)
`tion of the servo template of FIG. 4A over the sample data
`of FIG. 4B.
`
`[0049] FIG. 5B is an illustration of a screen display
`generated by the servo template of FIG. 4A.
`
`[0050] FIG. 6 is an illustration of a context node for use
`in incremental processing of a servo.
`
`[0051] FIG. 7 is an illustration of an interior socket for use
`in forming a relative b-tree structure.
`[0052] FIG. 8 is an illustration of an interior whorl for use
`in forming a relative b-tree structure.
`[0053] FIG. 9 is a simplified illustration of a single b-tree
`structure for use in constructing a context tree.
`[0054] Appendix A is a listing of a software description
`language (SDL) schema consistent with the present inven(cid:173)
`tion.
`[0055] Appendix B is a sample asset management servo
`expressed in the SDL of Appendix A
`
`DETAILED DESCRIPTION OF PREFERRED
`EMBODIMENTS
`
`[0056] The following terms are used in the present
`description of the invention. Some terms are described in
`this glossary only, while others are explained in more detail
`below. It is provided here as a convenient reference for the
`reader.
`[0057] Abstract interface object-An object that provides
`information to an end-user or other software component. An
`object that offers the ability for an end-user or other software
`component to provide information to the software system,
`such as enabling a choice or providing information in
`answer to a particular question.
`[0058] Concrete interface object-An interface object rep(cid:173)
`resenting a specific interface component that interacts with
`a human or another software component. For example, a
`graphical user interface widget such as a drop down list.
`[0059] Context, interpreter-An object which encodes,
`through its own data and the objects it references, the
`internal state of the interpreter at a specific point of evalu(cid:173)
`ation. This is explained in detail below. Computing
`server-A server used to run servos and reconcile with
`backing stores and other datasources.
`[0060] Database name-A string that can be used within
`one specific database as a short handle to another specific
`database.
`
`[0061] Datasource-An information resource that imple(cid:173)
`ments the datasource protocol. Datasources may include
`resident databases managed by the invention, specific com(cid:173)
`putational resources (such as applications written using
`other technologies), or gateways to other Internet resources.
`
`[0062] Datasource declaration-The means of specifying
`the existence and addressability of a datasource. Data(cid:173)
`sources are commonly registered with the registrar.
`[0063] Datasource protocol-A specific protocol for
`accessing information resources. SOAP [SOAP] is an
`example of a datasource protocol.
`
`[0064] Default servo-A servo associated by the registrar
`with a schema to be used in the event that a user encounters
`data in that schema and has not previously selected an
`application to use with that schema. Each schema has at least
`one default application. Different servos may be associated
`with different element and attribute declarations.
`[0065] Directory services-A location broker that pro(cid:173)
`vides a navigable index of available services.
`
`11
`
`

`

`US 2002/0069192 Al
`
`Jun.6,2002
`
`4
`
`[0066] Front-end server-One or more
`functionally
`equivalent servers used to process incoming requests and
`route them to appropriate computational resources using
`knowledge about the specific request (the content of the
`packet). A front-end server(s) may be a component of a
`load-balancing router.
`
`[0067]
`Incident reporting service-A service which tracks
`subscriptions to events associated with particular resources,
`and informs subscribers when those events occur. Used most
`commonly to track dependencies between source databases
`and databases that replicate parts of the source databases.
`
`[0068] Label-One or more strings or other objects such
`as sound or images associated with an element, attribute,
`model group or other component of schema that serve to
`provide identifying information for use in a user interface.
`
`[0069] Location broker-A component of the invention
`that can accept an identifier for a resource and provide
`means to contact that resource. Resources are not necessarily
`local to the broker.
`
`[0070] Opportunity-An association between a unit of
`schema and a view or other action that can provide a means
`to interact with, modify, or apply an operation to, an instance
`of that same schema.
`
`[0071] Public identifier-The public identifier used by the
`invention. An instance from a managed URL space. Com(cid:173)
`patible by subset with public identifier (SGML), public
`identifier (XML), URI, namespace name, unique identifier.
`
`[0072] Public identity-Identity as known to a central
`authority that issues unique identifiers. (For the invention,
`the authority is the registrar and the identifier is the invention
`public identifier.)
`
`[0073] Registrar-The system resource which manages
`the registration of schema, applications and datasources. The
`registrar enables reliable identification and data mappings as
`further described below.
`
`[0074] Schema translator-A software component that
`converts data of one specific schema to data of another
`specific schema.
`
`[0075] Servo-The unit of application packaging pro(cid:173)
`vided by the invention.
`
`[0076] Servo definition language (SDL)-A language in
`which servos are expressed.
`
`[0077] Servo transition-The action in which use of one
`application naturally leads to use of another by leveraging
`the common schema of the underlying data.
`
`[0078] Short identifier-Another term for database name.
`
`[0079] Storage declaration-Declaration of a persistent
`storage tree. See below.
`
`[0080] Synchronizer-A component of the
`invention
`which uses transaction definitions, synchronization point
`identifiers, time stamps, datasource declarations and data(cid:173)
`base instance-specific parameters to maintain correct data(cid:173)
`base state across a set of related databases managed by the
`invention. Also called transaction engine.
`
`[0082] Task allocator-A service that assigns interactive
`tasks to available computational resources based on suit(cid:173)
`ability to purpose (server load, access to resources, avail(cid:173)
`ability of cached database or session state).
`
`[0083] Task scheduler-A component of the invention
`that assigns computational tasks to available computational
`resources based on priority, aging, deadlines, load, etc.
`Typically the tasks handled in this manner are not m
`response to a current user request.
`[0084] Transaction engine-Another term for the syn(cid:173)
`chronizer.
`[0085] View-A grouping of transformation rules and
`components that define all or part of the interface for a servo.
`[0086] View declaration-Declaration of view-View
`declarations define how the application (servo) interacts
`with the user or another software component.
`
`[0087]
`
`Introduction to Servos
`[0088] We refer to an application in accordance with this
`invention as a servo. More specifically, a servo is the unit of
`application packaging provided by the invention. A servo is
`created by "declaring" it in accordance with an appropriate
`servo declaration language. In accordance with a presently
`preferred embodiment of the invention, an XML-based
`Servo Declaration Language (SDL) is provided, portions of
`which are attached as Appendix "A" Those skilled in the art
`will recognize that other SDLs along similar lines may be
`used within the scope of the present invention. Key aspects
`of the SDL will be described in detail below. In practice, a
`developer specifies ( or references) an appropriate schema in
`the SDL and then specifies ( declares) a desired application,
`or servo, consistent with that schema. The schema definition
`language may use a markup language-like syntax, such as
`XML. A sample servo, discussed in detail later, is shown in
`Appendix "B." Another important aspect of the present
`invention is an incremental process for interpreting or
`executing an application servo in a client device ( or a
`server). This process is described in detail later.
`[0089] All other things being equal, the less information
`the author of a software application needs to provide, the
`less time the author will need to spend to create and maintain
`the application. The present invention provides a concise
`way to declare distributed data management applications.
`The experience provided to the end-users is created by
`selectively combining servos, which may be created by
`different authors, and interpreting them on differing plat(cid:173)
`forms. This process is assisted by keeping the quantity of
`specification provided by the developer to a minimum.
`Platform independence is achieved through a minimal plat(cid:173)
`form independent application definition, supplemented by
`platform specific transformations where the defaults are not
`adequate to address the goals of the application author.
`
`[0090] As noted above, the present servo definition lan(cid:173)
`guage (SDL) is an XML-based language in which servos are
`expressed. The XSL vocabulary is referenced by the SDL
`schema. This enables developers who are familiar with XSL
`to make use of their experience and allows some of the
`experience gained developing servos to be used in other
`contexts.
`
`[0081] System identifier-An instance of a UUID used as
`a form of self identity for resources such as databases.
`
`[0091]
`Information about a particular session environment
`can be made available (subject to security restrictions) for
`
`12
`
`

`

`US 2002/0069192 Al
`
`Jun.6,2002
`
`5
`
`reference by SDL through a specially named input tree.
`Session environment information can include, but is not
`limited to, the physical location of the mobile user, identi(cid:173)
`fication of client hardware, quantification of available
`resources, and status of communication channel.
`
`[0092] Application data is available (subject to security
`restrictions) for reference in SDL as individually named
`input trees, using the names from storage declarations fur(cid:173)
`ther described below. These stores can be referenced as
`variables. Each characteristic of a servo preferably may be
`identified as overridable or not. This enables or disables
`user-specific customization. A simplified diagram of data
`flow is shown in FIG. 2.
`
`[0093] Consistent with a presently preferred embodiment,
`servos, data, and protocol (including queries and query
`results) are all represented in XML. For any computational
`task, the inputs, the outputs, and the instructions preferably
`are all expressed using XML. Since XML is simple and
`compact to transport, this computational model makes it
`simple to deploy more hardware to handle loads. This
`includes the opportunity to utilize thousands of servers as
`well as the opportunity to move computation to "smart"
`(invention-enabled) clients when appropriate. It also pro(cid:173)
`vides the means to transparently shift the underlying data(cid:173)
`base mechanisms to suit the different performance charac(cid:173)
`teristics of different stores.
`
`[0094] Further, the present invention can be said to imple(cid:173)
`ment "n-tier architecture"-a software architecture in which
`computing resources can be layered to any depth. The
`architecture allows independent information sources over a
`vast scale to be accessed through a single interface. Rich
`schema and interschema translation services enable infor(cid:173)
`mation to flow across the layer boundaries without loss of
`context as further explained below.
`
`[0095] Several specific features of a servo declaration are
`described in detail below. First, we provide some context by
`illustrating at a simplified high level an illustrative deploy(cid:173)
`ment of the invention, followed by a simple servo example.
`The sample office asset database application will then be
`used to illustrate incremental execution of servos and the
`execution context tree construct.
`
`[0096]
`
`Illustrative Deployment
`
`In FIG. 3, a server environment 300 is shown as
`[0097]
`currently supporting two mobile users, Alice and Juan.