Method for translating distilled filed for handling of large data files and programs by computing devices with limited processing capability

[0002] The present invention relates to computer programming and data storage and transmission methods, as well as to user interface methods.

[0003] Handheld computers (also known as “palms” or “palmtops” are increasing in popularity. They are small, light, and can do many desired tasks without the user having to carry, boot-up, charge, etc. a laptop of other computer-type alternative.

[0004] A serious limitation of all palmtops relates to their capacity to store information. Palmtops lack hard drives, and must store whatever information is to be stored in hardware memory. Memory can be expanded only to a finite degree without sacrificing the very size and weight characteristics for which palmtops were designed, and nothing resembling hard drives, as such, is likely to be found in palmtops in the foreseeable future.

[0005] The only material way in which the capabilities for palmtops to manage larger volumes of information in the foreseeable future is through manipulation and management of the information itself, not through changes in the architecture of the palmtops.

[0006] The present invention presents a programming and data management methodology which greatly advances the capacity of a palmtop to retrieve and process information to a magnitude far beyond any comparable quantitative level as might be achieved through use of prior art data management methods, or through reasonable changes in palmtop construction.

[0007] As will be discussed below in considerable detail, properly allocating data gathering and data processing and interpretation tasks between a palmtop and a central computing unit increases a palmtop's capacity to prompt a user in providing, and then retrieve and store information for later processing in volumes far in excess of that possible with a palmtop's present capabilities while using present art data management and programming regimens.

[0008] The current state-of-the-art for remote user-interface generation and reporting is the hypertext markup language or “HTML”. This system differs in lacking the data distillation aspect. This weakness is manifested in several ways:

[0009] 1) When the script is transferred to the remote computer, the entire script is transferred, placing a greater burden on the bandwidth and storage requirements of the remote system.

[0010] 2) The remote computer must deal with the original HTML document, which requires it to parse and process enormous amounts of data irrelevant to the purpose of user interface generation.

[0011] 3) When a data record or “form” is returned from the remote site, field identifiers are attached to each field individually, vastly increasing the bandwidth requirement of the interaction. In the present system, data can be identified by it's position within a highly compacted data record, eliminating the need to transfer the id tags.

[0012] 4) HTML does not provide a platform-independent binary representation of the user interface. This requires extensive parsing functions to be provided by the system used to display the interface. The present distillation process can produce, as one aspect of the document, a binary representation that can be used on any computer.

[0013] 5) The automatic generation of a hierarchical representation when distilling the script for the user interface process eliminates the “infinite maze” problem found in conventional hypertext systems, where the “forward/back” paradigm commonly used does not give the user a clear mental image of the organization of the document.

[0014] Another language to be discussed in the data management realm is XML (extensible markup language). XML allows the development of custom tags, but does not contain the concept of distillation/expansion contained in the present invention. In fact, XML could be used as the underlying scripting language in a document distillation system. XML also differs conceptually in that it provides a document TYPE definition rather than a document INSTANCE definition. In other words, XML document processors refer to a template that describes in general terms the meaning of custom tags in the language, while a processor that operates on one of the distilled data records employed in the present methodology may also refer to the original document itself, which provides much more flexible and powerful processing capabilities, as well as the extreme data density allowed by the distillation process.

[0015] Conventional data compression techniques fall into two classes, “lossless” and “lossy”. An example of a lossy mechanism is that employed by conventional JPEG image files on the internet. Compression ratios in the range 50 or 100 to 1 are common, but at the expense of imperfect reconstruction of the original image. This is considered an acceptable tradeoff given the desire for rapid downloading of images.

[0016] In transferring data such as text, or selections from checkboxes on a user interface, clearly lossless compression is necessary. Lossless compression algorithms such as Lempel-Ziv-Welch (LZW) compression or Huffman encoding typically produce compression ratios on the order of two-to-one, depending on the type of data.

[0017] Consider a hypothetical example of a survey form consisting of 1000 checkboxes each with a twelve-character idtag as required by a conventional html system (the number twelve is an arbitrary but conservative estimate of the size of a typical field idtag, most programmers use “symbols” this large or larger). The data required for a single record by the conventional system would be at least (assuming no other formatting overhead and that the state of each checkbox is transmitted as a single byte of data):

[0018] 1000*12+1000*1=13000 bytes.

[0019] According to the present methodology, the data required is 4 bytes for the tag required to identify the original script, plus 1 bit per checkbox:

[0020] 4+1000/8=129 bytes.

[0021] This yields an effective compression ratio of:

[0022] 13000/129=100.77

[0023] Note that conventional compression schemes may be applied “on top of” the data representations employed by the subject methodology, thereby resulting in further reductions.

[0024] Concerning external data representation, computer platforms differ in their binary format for representing data. For example, in many palmtop computers integers are stored using most-significant-byte-first format, whereas on standard PC platforms integers are stored in a least-significant-byte first format. The byte ordering must be reversed for data generated on one platform before it may be utilized on computers of the other platform.

[0025] In conventional systems such as the “remote procedure call” (RPC) system and the “sockets” system, which move data between different computer platforms, the process involves two stages of data translation into an intermediate “external” data representation, with the associated overhead. This intermediate representation may be binary or text-based, but always requires two translation layers.

[0026] According to the present invention, data is stored in the native format of the “low powered” system and is transformed only at the time of use. There is no wasted format translation, and no translation at all is required of the less capable platform.

[0027] Consider the following comparison between conventional inter-platform exchange and data exchange in accordance with the present invention:

[0028] Conventional Inter-platform Exchange.

[0029] Data entered on mobile system in native format

[0030] All data translated to “portable” format

[0031] Data sent to host computer

[0032] All data translated to host format

[0033] Some data accessed and used by host

[0034] The Current Invention's Inter-platform Exchange.

[0035] Data entered on mobile system in native format

[0036] Data sent to host system.

[0037] Data translated to host format only as required.

[0038] In what follows, note that the present techniques are not specific to the script syntax given as examples. In principle the present distillation mechanisms could be applied to industry-standard HTML, XML, or scripts based on other commonly used languages.

[0039] The methodologies of the present invention solve several problems associated with software development in general and mobile computing in particular:

[0040] Optimal use of limited bandwidth. The very-efficient data storage strategies of the present invention methodologies allow handheld computers with low data rate connections to transfer huge amounts of data. Today a central problem in practical computer usage is the ability to transfer information between networked computers. In desktop computers it is now common for home computers to have multi-megabit data rate connections to the internet through cable modems or other so-called “broadband” technologies. Palmtop computers are severely limited in their communications bandwidth, often operating over wireless connections at data rates of 9600 bps (bits per second) or even lower. This is a serious obstacle to the deployment of palmtop computers in remote data gathering applications.

[0041] Traditional data compression techniques cannot achieve compression ratios of greater than about two-to-one without loss of data. Higher ratios are possible for image data, but only in the case where image degradation through imperfect reconstruction is acceptable. Such popular image formats as “jpeg” use such techniques, but such “lossy” mechanisms are not applicable to transmission of binary data records of the type required by remote data collection applications.

[0042] Optimal use of limited memory and processing power on mobile and hand-held computer platforms. The “distilled” data records and documents of the present invention allow software applications with unprecedented levels of complexity to be stored and displayed rapidly on handheld computers with extremely limited processing power and memory.

[0043] By removing information from the script that is irrelevant to the user-interface process, the parsing of the script is simplified on the handheld computer, giving its users operational capabilities far in excess of that now possible with present day data management and structure, and presently otherwise possible only with vastly increased computing power. Many of the handheld computers often are entirely without the disk storage that is taken for granted on most desk top computers. In these devices all data records must be stored in small non-volatile memories, which are extremely limited in size. While a conventional word processing application may be able to use a megabyte of data for a simple document, handheld applications have no such luxury.

[0044] By completely separating the “meaning” of the data from the data itself, one achieves very high “information density”, making it possible to store large numbers of data records in even the limited memory of a diskless handheld computer.

[0045] Enhanced software productivity. The new document types involved in the present invention allow a non-technical user, generally a “domain expert” or expert in the subject matter, to create the content, data flow, storage elements, and screen elements without the need for programmer involvement. This enables true software development by people with NO software background, and in fact even those with marginal computer literacy skills.

[0046] Enhanced ability to capture expert knowledge and user Requirements. The knowledge-capture process is a perennial block to productivity in the software realm. The presently described new document types allow the domain expert to perform his or her own knowledge capture without programmer involvement. Given the script which defines the data elements which the content developer wishes to capture, the present combined distillation/expansion processes automatically perform user-interface creation, allocation of data storage, and report generation. The domain expert is therefore required only to specify the problem, the solution is generated automatically.

[0047] The syntax of the scripting language used is not critical to the process. An example is given here, which emphasizes a plain-English syntax to enhance readability. Such a language has in fact been used directly by non-technical users with brief training. Simple authoring tools based on the well known RAD (rapid application development) paradigm are also possible to further simplify script creation.

[0048] Ability to navigate very large amounts of data easily. “Information overload” is a serious problem with current computing paradigms. The ability of the present documents to automatically specify a hierarchical representation, and to specify filters which suppress irrelevant information, allow a user to navigate an unprecedented quantity of data in an extremely fast and efficient manner.

[0049] This problem of information overload and document navigation is particularly severe in the handheld arena, where display sizes are very limited. The hierarchy of display and filtering capabilities are essential to making practical the extraordinarily complex applications that are and will be required on handheld computers.

[0050] Well-defined separation of client-side and server-side workload. In the present system, the different distillations clearly delineate the purposes and responsibilities of different subsystems: The handheld component (the “information retrieval computer”), who's advantage is mobility and simplicity, is responsible for acquiring and transmitting data. The “host” or “server” component (the “data processing computer”), is responsible for associating data records with the original scripts, and for performing processing that is beyond the scope of the handheld system.

[0051] In what follows, the new document type involved in practice of the present invention will be a “script”. A script defines a set of data fields as well as a hierarchy of organization. A script consists of token-value pairs. The specific tokens used here are not important, and in fact other tokens are substituted in some implementations.

[0052] The exact syntax of the script is likewise irrelevant. The token=value syntax presented here is only one possible implementation.

[0053] Script aspects. A key element of the script is the specification of multiple “aspects” of the problem in a way that can be “distilled” so that different users or computer systems need only deal with those aspects that concern them, and yet the different aspects may still interact when the results of different processes are combined by the expansion apparatus. Described in more detail below are some possible aspects, which are among those used in the present invention's experimental implementation:

[0054] The data field aspect

[0055] The representation hierarchy aspect

[0056] The contextual Filter aspect

[0057] The data processing aspect

[0058] The data position aspect

[0059] The field-idtag aspect

[0060] The user-defined aspect

[0061] The constraint aspect

[0062] The page-layout aspect

[0063] Clearly other aspects are possible. The accompanying sample script illustrates some possible aspects including the ones mentioned here.

[0064] The data field aspect. This aspect allows the specification of individual data-entry fields, which may be simple or complex and have an associated data type.

[0065] A simple example is a checkbox:

[0066] BEGIN FIELD

[0067] FIELD TYPE=checkbox

[0068] LABEL=cardio pulmonary arrest

[0069] END FIELD

[0070] This script specifies that one wishes to create a checkbox and to label the checkbox “cardio pulmonary arrest”. This is the most primitive aspect, which is combined with other script aspects to provide the significant benefits of the present invention.

[0071] The representation hierarchy aspect. The script defines a hierarchy of representation for the data, allowing the building of user interfaces using a shallow-tree hierarchy. This is done by defining sections and subsections within the script, which can then be used by a distillation device to produce a navigation hierarchy. One example of a syntax which accomplishes this is as follows:

[0072] BEGIN SECTION=(section 1 name)

[0073] BEGIN SUBSECTION=(subsection 1.1 name)

[0074] BEGIN FIELD

[0075] . . .

[0076] END FIELD

[0077] END SUBSECTION

[0078] BEGIN SUBSECTION=subsection 1.2 name

[0079] BEGIN FIELD

[0080] . . .

[0081] END FIELD

[0082] END SUBSECTION

[0083] END SECTION

[0084] BEGIN SECTION=(section 2 name)

[0085] . . .

[0086] END SECTION

[0087] For example, in a palm computer implementation developed according to the subject invention, the end product allows up to 20 script sections with 20 subsections per section. This allows a user, with only two pen taps on a mobile computer with a very limited display, to access 400 different subsections of a computer application. Each of these subsections may contain an arbitrary number of fields which can then be found using page-forward/page-back commands much like a conventional book or multi-page form.

[0088] This hierarchy may be extended by the nesting of fields:

[0089] BEGIN FIELD

[0090] FIELD TYPE=checkbox

[0091] . . .

[0092] BEGIN FIELD

[0093] FIELD TYPE=popup list

[0094] . . .

[0095] END FIELD

[0096] END FIELD

[0097] In this manner, by enabling fields to be contained within other fields and only displayed when “triggered” by use of the enclosing fields, the hierarchy may be extended to whatever depth required.

[0098] The contextual filter aspect. To further enable the navigation of extremely large data sets with very limited computer resources and limited display sizes, scripts allow the definition of “topics”, “detail levels”, and other filtering mechanisms which can enable the display apparatus to selectively limit the display of data fields.

[0099] For example, envision a medical application in which one wishes to display certain fields only if the user's patient is suffering from a particular problem. One can then specify topics in the script . . .

[0100] BEGIN TOPIC DEFINITIONS

[0101] BEGIN TOPIC

[0102] TOPIC IDTAG=Major Burn

[0103] END TOPIC

[0104] BEGIN TOPIC

[0105] TOPIC IDTAG=Chest Pain

[0106] END TOPIC

[0107] END TOPIC DEFINITIONS

[0108] One can then specify that the following field is only relevant for the “Burn” topic:

[0109] BEGIN FIELD

[0110] FIELD TYPE=checkbox

[0111] LABEL=smoke inhalation

[0112] TOPIC=Major Burn

[0113] END FIELD

[0114] Now the distillation apparatus may, at the time the field is presented, choose to display or not display each field based on the current context. The value of this filtering mechanism is greatly enhanced by the distillation process, which creates a new version of the script in which the enable status of each field is encoded in a single bit for each topic. This distilled version is delivered to the user-interface process, which thus is not required to perform the computationally-intensive parsing operations that would be required by prior-art script processing systems in order to determine the run-time form of the user interface.

[0115] Other contextual filters are possible and have been implemented. For example, the following field is only relevant for females in a certain age range. Note the SEX and AGE filters which are now included in the field . . .

[0116] BEGIN FIELD

[0117] FIELD TYPE=yesno

[0118] LABEL=home pregnancy test used

[0119] SEX=female

[0120] MIN AGE YEARS=10

[0121] MAX AGE YEARS=55

[0122] END FIELD

[0123] The data processing aspect. Data records produced using the script will in general be used for some type of analysis or reporting. Two examples are a printing process and an invoice-generation process.

[0124] Suppose, for example, we have an automatic printing process which composes text based on the labels within a field. Suppose further that we have a “yes/no” control type where we wish to print a specific format in the “no” case. We might then use a “print control” aspect to override the default printing logic:

[0125] BEGIN FIELD

[0126] FIELD TYPE=yesno

[0127] LABEL=remembers traumatic event

[0128] PRINTCON IFNO PRINT=does not remember

[0129] traumatic event

[0130] END FIELD

[0131] Consider a second example where an invoice generation process is used to automatically produce items based on the content of a distilled data record. To the user interface, this process is irrelevant, while to the billing process it is crucial. In the following field, we have used a BILLING CODE directive as an example of a data-processing aspect . . .

[0132] BEGIN FIELD

[0133] FIELD TYPE=yesno

[0134] LABEL=Patient defibrillated

[0135] BILLING CODE=12345

[0136] END FIELD

[0137] Clearly other such processing aspects are possible.

[0138] The data Position aspect. This aspect of the data is implicit within the script and depends on the simple observation that each field has a specific position within the overall script. The fields can simply be numbered from 1 to “N” where “N” is the total number of fields within the script. While seemingly trivial, this fact implies the ability to obtain the very efficient data storage described below.

[0139] The field-idtag aspect. This aspect allows any field in the system to be “tagged” with a symbol, which may be used to identify the field unambiguously from another field or to provide special processing for that field. For example, suppose that we wish to present the same data field in two different locations in the same user interface. The first field in the following example creates a checkbox. The second takes advantage of the field idtag aspect to create a duplicate field, which will be slaved to the same database information and present the same label. Note also that other aspects of the field, such as the conditions under which it will be enabled, may be over-ridden by the duplicate field:

[0140] BEGIN FIELD

[0141] FIELD TYPE=checkbox

[0142] LABEL=normal HEENT exam

[0143] PRINTCON USERDEFINED

[0144] FIELD IDTAG=normal HEENT exam

[0145] END FIELD

[0146] .

[0147] .

[0148] .

[0149] BEGIN FIELD

[0150] DUPLICATE=normal HEENT exam

[0151] DEFAULT DLEVEL2

[0152] END FIELD

[0153] Another use of the field idtag is to provide customized or non-standard processing for an individual field. One such example is outlined in the section discussing the “user-defined” aspect.

[0154] Note that field idtags may either be generated by hand, or be automatically generated by a script processing stage. Automated authoring tools may be used to guarantee that the idtags are unique and persistent across script revisions, so that custom processing will not be lost or disrupted when the script is edited.

[0155] In conventional script and computer language processing, the idtag concept is embodied as a “symbol table”. These are usually based on hashing or tree algorithms which require operating system support for large dynamic memory structures and look-up algorithms. In the present implementation, when the distillation process generates a version of the script for use in data storage or user interface generation, we may use the data position aspect to replace the idtag with a simple numeric index, which allows inter-field references to be no more complex than array references. This makes idtags practical in a resource-constrained system such as a handheld computer.

[0156] The user-defined aspect.

[0157] Consider the following field definition:

[0158] BEGIN FIELD

[0159] FIELD TYPE=checkbox

[0160] LABEL=normal HEENT exam

[0161] PRINTCON USERDEFINED

[0162] FIELD IDTAG=normal HEENT exam

[0163] END FIELD

[0164] Note the “PRINTCON USERDEFINED” tag. This informs the system that when this data is printed, the text to be printed is to be taken from a file generated by the user and associated with this field using the FIELD IDTAG. In the case where different users desire different custom processing, a separate file of user definitions is associated with every handheld device, and within that file field idtags are used to identify the fields to which custom processing applies. In this way the processing of the script may be completely customized on a per-user basis. The distilled data record need only be transmitted with some identifier specifying the originator, and the processing modified accordingly by the server-based data processing.

[0165] The constraint aspect. It is useful in many user interfaces to build in “constraints” on the data that may be entered, such as ranges on the data or inter-field constraints on data items that are mutually exclusive. An example is a set of checkboxes which are mutually exclusive, conventionally known as “radio buttons”. This constraint may be applied by a “group identifier syntax” such as the following:

[0166] CREATE AUTO GROUP ID

[0167] BEGIN FIELD

[0168] FIELD TYPE=checkbox

[0169] LABEL=Patient arrived via ambulance.

[0170] GROUP ID=auto

[0171] END FIELD

[0172] BEGIN FIELD

[0173] LABEL=Patient was brought in by parents

[0174] GROUP ID=auto

[0175] END FIELD

[0176] Clearly other such constraints are possible.

[0177] The page layout aspect. In general a distillation apparatus can produce a user interface using only the hierarchy and field definitions. However, one aspect of the script allows us to override this automatic mechanism with tokens that give explicit “hints” or “directives” to the distillation apparatus. For example, if we wish two fields to appear side-by-side on the display where the automatic user interface generation would normally place the second field on a new line, we might write as follows (note the SUPPRESS LINEFEED directive)

[0178] BEGIN FIELD

[0179] FIELD TYPE=checkbox

[0180] LABEL=Fever

[0181] END FIELD

[0182] BEGIN FIELD

[0183] FIELD TYPE=checkbox

[0184] LABEL=Sore Throat

[0185] SUPPRESS LINEFEED

[0186] END FIELD

[0187] Clearly other such directives are possible to selectively override aspects of the automatic generation of user interfaces.

[0188] FIG. 1 is a flowchart showing how the system operates in practice. Initially the entire script is created using a text editor, or by means of the simplified authoring tools which do not require a high degree of programming expertise. The desktop computer or Web Database stores the entire script, indexing it by “meaning tag” or “script key”. In the drawing, two different branches of distillation are shown. One, the palmtop distillation, optimizes the script for display, and contains the “meaning tag” and pre-computed user-interface logic. In the other branch, the distillation process optimizes the script for data processing according to the requirements of the situation.

[0189] During the palmtop distillation process, a hierarchical user interface has been created, allowing rapid navigation of large amounts of data and thus, a very efficient data entry process by the user. After the data have been entered, they are transmitted along with the “meaning key” back to the data processor. This transmission, because of the minimal size of the packet, does not require a high bandwidth data link.

[0190] Upon receiving the data and the “meaning key” (or “translation means” in the claims) the processor sends the key to the storage archive to retrieve the script and optimize it for data processing. The data may then be used for any or all of the usual activities; printed or stored patient records, billing procedures, or any other desired purpose.

[0191] The present invention relates to enabling very complex computer application uses, data gathering, data processing, and data transmission, particularly in the context of using handheld or “palmtop” computers to gather the initial information for transmission to remote, higher-powered computers, which processes are not possible through practice in the present art to the same degree as is possible though practice of the present invention.

[0192] The present invention depends on, as applicable, the creation, use, or carrying out of the following components or steps:

[0193] A “script” which is a machine-readable document.

[0194] An apparatus for processing this script or “distilling” the meaning of the script into other representations which are reduced in size and optimized for various purposes, such as user interface generation, data processing, or data transmission.

[0195] “Distilled” representations of the script which are in general very greatly reduced in size or optimized for alternative purposes, which contain “meaning tags” for re-expansion of the distilled representations.

[0196] Data records which are stored in an efficient manner by completely separating the meaning of the data from the data itself.

[0197] An apparatus for regeneration or “expansion” of distilled representations for purposes of user-interface generation.

[0198] An apparatus for regeneration or “expansion” of distilled representations for purposes of data processing.

[0199] Authoring tools to simplify the process of script creation.

[0200] The present invention represents a new technology which allows the use of a single document, called a script, to serve many functions which were previously done by hand or by a number of separate tools. This process is called “distillation” for present purposes. Also part of the present methodology are new types of data records which carry internal information allowing great flexibility and efficiency in their use.

[0201] Some of the characteristics of this technology are:

[0202] Very efficient use of the resources of handheld computers.

[0203] Extremely space-effective data storage by complete separation of the “meaning” of the data from the data itself.

[0204] Self-describing data records which allow movement of data between machines having different internal data formats.

[0205] Simultaneous and automatic performance of multiple functions using a single document or “script”.

[0206] Among these are:

[0207] Creation of user interface elements

[0208] Automatic user interface screen layout

[0209] Automatic creation of database entries and other storage records.

[0210] Automatic transfer of data records between mobile computers and other computers.

[0211] Specification of “filtering” to allow a single document to present only aspects relevant to the current situation.

[0212] Automatic generation of printed reports and other human-readable summaries of the underlying data.

[0213] Specification of a data hierarchy, which allows construction of user interfaces which can be rapidly navigated.

[0214] Customization of data processing on a per-user basis.

[0215] The distillation and expansion apparatus. In what follows we use the term “data record” or “record” to mean all of the data generated by a form or a computer program. This is equivalent to a “data file” produced by a conventional program. When referring to a single item within the data record we will use the term “field.”

[0216] A key observation is that of the many aspects of a given document, only certain of these are relevant for a given use of the document. The distillation apparatus strips irrelevant aspects from a document, producing an alternative “distilled” representation appropriate to a specific use. At the same time, the distillation process may “pre-compute” data that is necessary to generate the user interface or form the data record, actually enhancing the script with information that was only implicit in the script's original form.

[0217] The examples we will consider are as follows:

[0218] The distilled data record, for which the page layout aspect is irrelevant.

[0219] The user interface apparatus, for which the data processing aspect is usually irrelevant.

[0220] The data processing apparatus, for which the contextual filter aspect is usually irrelevant.

[0221] The distilled data record. Consider the case of a user interface that consists of 1000 checkboxes each of which has a long descriptive label. If shown on a 50-line display this would comprise 20 pages of data. Clearly each checkbox can be stored as a single bit of data. However a single bit by itself is of no value if we do not have an associated “meaning” for this bit of data. In conventional general-purpose user interface display systems, such as those using HTML scripts and web browsers, the meaning of the data is transmitted along with the data (see the section on background). In the present system, a single 32-bit number or “meaning token” is included in the distilled data record, which serves to uniquely identify the original script upon which the data record was based. In one such implementation, this value is taken to be a time-stamp, based on the exact instant at which the script was last modified. This is a simple way to guarantee uniqueness of the script id (assuming the production of scripts is coordinated in some way so that we can guarantee no two are produced at the same instant.)

[0222] Suppose that after a script has been edited, it is run through an archiver which adds the time stamp to the script, for example, in the form:

[0223] SCRIPT ID=956074524

[0224] and then saves the script with this id as part of a file name or database key. This script could, for example, be saved with a file name:

[0225] SCRIPT_—956074524.TXT

[0226] When the script is distilled and sent to the handheld computer, this key is also sent. The handheld then embeds this key in every data record produced based on this script. When this data record is then returned to a central location for processing, the key is returned as part of the data (here are using the terms “key” and “meaning token” interchangeably).

[0227] In this way the data may be transmitted at a density equal to its theoretical maximum of 1000 bits plus 32 bits of overhead for the meaning token. The expansion apparatus can then retrieve the original script, and use it to extract information related to the interpretation and processing of each bit within the transmitted data record.

[0228] So in a hypothetical example of a survey form consisting of 1000 checkboxes each with a twelve-character idtag (an idtag is required for each field when using a conventional html system) the data required for a single data record by the conventional system would be at least (assuming no other formatting-overhead and that the state of each checkbox is transmitted as a single byte of data, a conservative assumption),

[0229] (1000*12)+(1000*1)=13000 bytes.

[0230] In the present system the data required is 4 bytes for the tag required to identify the original script, plus 1 bit per checkbox:

[0231] (4+1000)/8=129 bytes.

[0232] The methods taught by the present invention, therefore, improves storage and bandwidth efficiency by a factor of:

[0233] 13000/129=100.77

[0234] Note that in principle further data compression schemes of a conventional nature such as run-length-encoding may be “layered” on top of this system so that even higher effective compression ratios are achieved.

[0235] Note also that the requirement of a 32-bit number as the “meaning token”, i.e. the information used to retrieve the original script for expansion, is not necessary. Any convenient representation could be used.

[0236] Note also that the single-bit data type is not essential. Each data field may be a bit, an integer, a string, or any other data type. The single-bit data type is used here for illustration, the mechanism has been implemented for other data types, including textual data, as well.

[0237] Interpretation of the data record. The processing apparatus need only know that the data within the record is stored “in order”, i.e. that the 100'th bit within the record corresponds to the 100'th field in the original script. Then, by retrieving the script indicated by the meaning-token, all the information specifying the meaning and processing for this bit may be retrieved and utilized.

[0238] Of course there need not be data present in the record for all fields. Unused fields may be skipped over using conventional escape codes which would remove the requirement that all fields be present in the record, providing further storage efficiencies.

[0239] Data representation. The distilled data record of the present invention, by convention, stores data in the binary format of the handheld processor. This data record is processed as an “object” which uses “access functions” to retrieve the data elements in the native form for the current machine. On the handheld machine, which typically has more limited processing power and which must provide a responsive interface, the data is already in the correct form and the access functions are compiled as simple data fetches. On the server machine, where processing power is greater, and the user interface responsiveness requirements are lower, the access functions are compiled to provide any necessary conversion.

[0240] An example of such a platform dependency is the byte order with which integers are stored. On the majority of handheld computers, integers are stored most-significant-byte first (the so-called “big endian” representation). Desktop machines however are overwhelmingly “little endian”, meaning an integer is stored least-significant-byte first. Accordingly, the present data records are stored big-endian, so no reformatting is required on the handheld, but are automatically swapped by the present intelligent data records as part of the data expansion process.

[0241] The user interface apparatus. This apparatus, which for example may be embodied as a component of a handheld computer, uses a document distillation which may be in binary form and will include only that information required for the generation of the user interface and creation of distilled data records. In addition, it may make use of pre-computed values which are generated by the distillation process to reduce the computational burden on the handheld or other computer used to display the user interface.

[0242] Removal of irrelevant script aspects. In the sample script, the first subsection of the user interface contains a special tag, “PRINTCON SUBSECTION LABEL”. This is a “print control” tag, which tells the data processing apparatus that the label that appears on the subsection should not be used when generating printed reports. The label used on the handheld device, “HPI” is highly abbreviated as is important for a device with an extremely limited display. The longer label, “History of Present Illness”, described by the print control, is irrelevant to the generation of the user interface.

[0243] When the document is distilled to it's binary form and downloaded to the hand-held device, these print-control entries are entirely deleted. They are unnecessary and irrelevant to the user-interface apparatus.

[0244] Pre-computation of user interface logic. This user-interface distillation will frequently be in a binary form, to reduce the processing requirements associated with parsing the document. For example, the FIELD TYPE may be stored as an integer rather than a text string, to allow rapid numerical lookup of the correct processing code for a given field.

[0245] The pre-computation aspect of the distillation is well exhibited by the ENABLE strings shown in the topics section at the beginning of the script. These strings represent a list of bits, one bit per field in the document, and two strings per topic. When the user interface is displayed, the display device need only examine the string for the current topic and detail level to determine immediately which fields are enabled. The strings are not present when the script is initially created by the content author, but rather are generated by the distillation apparatus when the script is sent to the computer (typically a handheld computer) responsible for the user interface generation.

[0246] Let us examine in detail the pre-computation and use of the enable-bits described above. As part of the script processing, a program first builds a list of all topics. It also prepares an array of bits for each topic, which will define which fields in the script are enabled for that topic. It than passes through the script, examining the “enable” syntax for each field and setting the required bits in each topic's enable string.

[0247] For example, in the first field in the present sample script, we find the following directive:

[0248] TOPIC DLEVEL1=Pregnancy

[0249] This directive says “this field should be enabled if the topic is “Pregnancy”.

[0250] Upon seeing this, the distillation process sets the first bit in the array of bits for the “Pregnancy” topic, and leaves the bit cleared for all other topics.

[0251] We then proceed to the second field, which has a more complex set of enable directives:

[0252] DEFAULT DLEVEL1

[0253] EXCLUDE TOPIC DLEVELL1=Wound Check

[0254] EXCLUDE TOPIC DLEVELL1=Suture Removal

[0255] The first directive says “this field is a default (always displayed) field at detail level 1“. However the second two directives say “However exclude this field for the Wound Check and Suture Removal topics. The distillation process then sets the second bit of the bit arrays for all topics except the two that were excluded.

[0256] Additional layers of filtering may be implemented in a similar manner, as exemplified by additional directives in the first field:

[0257] SEX=female

[0258] MIN AGE YEARS=10

[0259] MAX AGE YEARS=55

[0260] These directives may be pre-processed into arrays in a manner similar to that done with the topic-enable information, or may be parsed at runtime in a less efficient manner once the bulk of the work has been done by the topic-enable mechanism.

[0261] Use of pre-computed logic by the handheld computer. When the script is downloaded to the handheld computer, we do not send all the directives defining the enabling of each field. Rather, we send, in binary form, the bit arrays computed above. Then, when the user selects a topic, e.g. a physician is seeing a patient for a Suture Removal, the handheld computer can determine whether a field number “n” should be displayed merely by examining bit number “n” in the bit array. This is an extremely fast operation for a microprocessor.

[0262] Were it not for the distillation process, the fields must be “parsed” at runtime, an extremely expensive computation even for a script that has been compiled into a binary form. The distillation process makes this dynamic re-configuring of the application on the handheld unit feasible and allows the display of extremely complex applications on a computer platform with very limited computational resources.

[0263] The data processing apparatus. This apparatus, which may be embodied as a software process on a server or other computer, needs information not required for user-interface generation. For example, the print-controls described in the previous section may be used by the data processing apparatus as part of the printed-report generation process.

[0264] However, note that information relating to the field-filtering and display generation may be irrelevant and excluded by the distilled representation used for data processing. For example, the “DEFAULT DLEVELL1” token, which tells the user-interface process that this field is a default field at complexity level 1, is irrelevant to the data processing. The data processing cares only that if data has been entered into this field, then it should be processed.

[0265] So, for example, if the data processor finds that bit number 173 in the data record has been set, it can go to the original script and look for relevant directives. If it finds a directive such as the following embedded in field number 173:

[0266] BILLING CODE 12345

[0267] It can decide that this information is relevant to the billing process, and automatically route an invoice to the financially responsible party, selecting the party and the charge level according to the code which was found.

[0268] Consider another example, the user-defined printout field. This field consists of a checkbox, which occupies a single bit in the distilled data record that is transferred from the handheld device to the processing device. The user-defined printout can be stored either in the original script or in a separate file of user definitions. When the data record is processed, the printout text is associated with this single bit, and a printed report of arbitrary length and complexity may be generated by the transmission of a single bit of data from the handheld device to the processing server. These user-defined fields may be further qualified by the source of the data (the user of the handheld device), or on other aspects of the data record, resulting in even greater flexibility in the processing aspect.

[0269] Variable token sets. Conventional computer languages are defined largely by the “tokens” they require. For example, we have presented in the present script the “FIELD TYPE” token:

[0270] FIELD TYPE=popup list

[0271] In the present system, the parsing apparatus may use alternative token sets so that this same line of script may be represented, e.g., as:

[0272] X=12

[0273] What we have done is allowed the distillation apparatus to substitute a new set of tokens. As long as the parsing apparatus is aware of the “current token set” then the distilled script will be parsed successfully.

[0274] Two examples will clarify the value of this mechanism. In the example given, the advantage is a large reduction in script storage and bandwidth requirements. In the first token set, the script is “human readable” but this one line of script requires 21 bytes of storage. In the second example, the script is no longer meaningful to a human, but the storage/bandwidth requirement has been lowered to 4 bytes of data.

[0275] Consider a second example taken from the “topics” section of the present script:

[0276] TOPIC IDTAG=Chest Pain

[0277] Consider a possible alternative representation:

[0278] CHIEF COMPLAINT=Chest Pain

[0279] In the second representation, the abstraction of a “TOPIC IDTAG” has been replaced with the term “CHIEF COMPLAINT”. This term is meaningful to a health care professional. While the processing of the script is unchanged, the script has been rendered meaningful to a non-programmer in the industry towards which the script has been targeted.

[0280] Variable token sets may be implemented by having a token set directive in the script

[0281] TOKEN SET=3

[0282] Then, the processing program may choose a token set, as for example an array of pointers to strings. It may also choose, if transforming the script for another purpose such as transmission to a handheld device with limited memory and bandwidth, to replace the tokens with those from a different token set. To do this it must of course replace the TOKEN SET directive before sending the script to a new destination.

[0283] The distillation-expansion-processing cycle. Let us take as an example the present hypothetical 1000-checkbox questionnaire used by field representatives using palmtop computers with very limited bandwidth and storage capacity at remote sites. The following steps occur.

[0284] 1) Author makes a list of the questions he would liked asked at the remote site. This can be an extremely simple representation such as a plain-text file listing the questions.

[0285] 2) This list is converted to a script using either a gui-based authoring tool or a conventional text editor.

[0286] A distillation apparatus then processes the script, inserting the meaning token, computing and inserting any pre-computed information such as the enable bits described above, and finally archiving the script with a name or database ID based on the meaning token.

[0287] 3) A distillation apparatus removes all aspects of the document that are irrelevant to user-interface generation to produce a distilled representation. Included in this representation is the “meaning tag” and the pre-computed information required by the user-interface process. Note that this representation may be fairly large because it must include all the labels necessary for display generation, although it will still be vastly smaller than the original document.

[0288] 4) The distilled representation is transmitted to the hand-held computer. This is a one-time-only operation and so is not severely bandwidth constrained. In general this operation need not be done remotely but may be “loaded” onto the mobile device in a preparation stage.

[0289] 5) The field agent uses the device to collect data records. Note that each data record will require only 1000 bits (for the data) plus 32 bits (for the meaning-tag), for a total of 1032 bits or only 129 bytes of data for a 50 page form! The field agent collects 1000 data records, comprising a mere 129,000 bytes of data. Well within the storage limits of current palmtop computers.

[0290] 6) The field agent transmits the data records by conventional wireless mechanisms to a central office for processing.

[0291] 7) The expansion apparatus at the central office extracts the meaning tag from each data record, retrieves the associated script, and uses the information in the script to interpret and process each bit in the data record.

[0292] To summarize the sequence of events:

[0293] SCRIPT→distillation→Interface spec

[0294] Interface spec→remote computer

[0295] Interface spec→data record

[0296] data record→expansion→analysis/reporting process