Web-page-based system for designing database driven web applications   

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No. 11/742,907, filed May 1, 2007, which claims the benefit of U.S. Provisional Patent Application No. 60/797,112, filed May 2, 2006, and U.S. Provisional Patent Application No. 60/866,809, filed Nov. 21, 2006. The entire contents of the before-mentioned patent applications are incorporated by reference as part of the disclosure of this application.

This invention was made with government support under IIS-0347968 &IIS0427196 awarded by National Science Foundation. The government has certain rights in the invention.

1. Field

This disclosure relates to databases containing computer readable data. More particularly, it concerns a computer implemented, web-page-based system to assist users in designing database driven web applications.

2. Description of Related Art

In today\'s world, digital data is nearly everywhere. Digital data resides locally in personal computers, palm computers, watches, cell phones, global positioning system (GPS) devices, televisions, and hundreds of other such devices. But having so much data is useless without having a way to organize the data and to interact with the data.

One paradigm for people to interact with digital data is by using pre-designed database-driven web-accessible applications. These are hosted web applications implementing a special purpose process. “Hosted’ refers to the fact that the application\'s code and databases may reside at a host system that is distinct from the users\' systems or even from the designers\' systems. In this setup, software designers prepare the database structure (such as a database schema) and a web application that enables access to this database. Then they make the web application (and indirectly the underlying database) available online to users or, more generally, communities of users. Users employ web browsers to initiate their own databases, and thereafter to add, delete, and modify data from such databases, as they perform the steps of the special process implemented by the web application. Some examples of this paradigm include Evite, the upcoming Microsoft Office Live, and salesforce.com.

Although the foregoing paradigm enjoys widespread use today, and satisfies certain market niches, there are certain limitations, as follows. Although the data of these applications can be manipulated by users in pre-designed ways, the database structure and the business process captured by the web application are fixed. Therefore, the database structure and the web application only satisfies fixed information and process needs and patterns. This is not a problem if the user\'s needs are fully captured by the database structure and process of the pre-designed web application.

The disadvantage of pre-designed web applications is that they do not contemplate letting their users customize their own database structures and respective web applications to their needs. This can be frustrating because there are millions of communities whose information exchange and collaboration process needs are not captured by any existing hosted web application. Indeed, many of those communities will likely never be served by a pre-designed hosted web application for the simple reason that they are too small to produce a return on the investment of a hosted web application provider who would be interested to build and market such a hosted web application. One example includes universities organizing their intramural athletic events. A pre-designed web application that can support the events of each university would be fairly complex in order to accommodate the complexity of the process and its many variations from university to university. Furthermore, the customers for such a web application are too few and too unwilling to pay in order to warrant yet another pre-designed hosted web application provider catering to the particular community.

If no hosted web application does the job for a certain community, the community may consider hiring Information Technology professionals to design, develop, and deploy a custom Web application and database, to be used by members of the community to exchange structured data and collaborate. The problem is that many communities that need a customized web application do not have the budget to hire such professionals and therefore they cannot have a web application that is customized to their needs. In other cases, even if there is a sufficient budget, there is not enough time to deploy Information Technology professionals.

If there is no pre-designed database and web application serving a community and no budget to hire an IT specialist to build such, members of the community may attempt to build and host a database and web application themselves. The problem with this option is that such community members must be trained in the database design and web application programming art.

In contrast to the paradigm described above (namely, pre-designed hosted web applications implementing special purpose processes), a different paradigm is the document exchange hosted web application. Many hosted web applications enable their users to post documents, read the documents of other users, and in certain cases even edit the documents produced by other users. For example, Google Docs & Spreadsheets offers its users the ability to post documents or spreadsheets on the web and let other users to read and even edit them. Included in this class are blog providers, which are hosted web applications that enable their users to post documents (blogs) and search and read others\' blog entries. Also included in this class are wikis, which are hosted web applications that enable their user communities to collaborate on versioned and interconnected document collections. Another example includes photo sharing sites, such as flickr.com, where the shared documents are images. Still another example includes electronic groups, such as yahoogroups.com, where the members of the group post messages.

Document exchange hosted web applications suffer from limitations in both the (1) type of data exchanged and (2) the implemented collaboration process. Namely, these applications simply use documents of various sorts instead of organized formatting of data along objects with attributes and relationships, as is found in typical database systems.

Also, these applications are limited because the core process by which the community users of such hosted web applications cooperate is essentially a publish/subscribe process, where some class of users is allowed to publish and another class of users (often the set of all Internet users) can read or edit. There are variations on the core publish/subscribe theme, such as introducing a “moderator” class of users or providing versioning features when multiple users may modify a published document. However, for many users, none of these systems allows the collaborating community to implement sufficiently complex process schemes.

The present inventors have sought to identify and address the limitations of database driven applications, and further to develop new uses. One area of focus concerns web-accessible database driven web applications, where remote users are enabled to initiate and design the database and the web application, and the completed database and web application is made web-accessible to ultimate end-users.

SUMMARY

Broadly, the present disclosure concerns a system enabling the creation of database driven web applications by users who initiate and design the web pages of the application with mostly graphical user interface (GUI) actions. A user introduces fields to the page from a palette. A page may contain any combination of input, display, hyperlink, and iterator fields, where iterator fields contain other fields and lead to repeating structures, such as tables, lists, calendars with multiple entries, etc. In one case, the user creates iterators nested in a user-selected iterator, where the nested iterators operate within the context of the selected iterator and the system accommodates iterators that are recursive. In another case, the user adds both display and entry fields pertaining to a given user-selected iterator, retaining context of the selected iterator. Responsive to user introduced fields, the system automatically creates a database structure, automatically relates fields of the pages to the data structures in accordance with a predetermined logic, and provides mechanisms where the fields of the web application pages exchange data with the database.

The teachings of this disclosure may be implemented as various methods, apparatuses, logic circuits, computer storage media, or a combination of these. This disclosure provides a number of other advantages and benefits, which should be apparent from the following description.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A is a block diagram of the components and interconnections of one embodiment of system for designing web-page-based database driven applications.

FIG. 1B is a block diagram showing the database of FIG. 1A in greater detail.

FIG. 2 is a block diagram of a digital data processing machine.

FIG. 3 shows an exemplary signal-bearing medium.

FIG. 4 is a perspective view of exemplary logic circuitry.

FIG. 5 is a flowchart showing an example of one overall operating sequence.

FIG. 6 is a flowchart showing a more specific example of one operational feature.

FIG. 7 is a screen shot showing an example of a Publish Company Positions page.

FIG. 8 is a screen shot showing an example of a Submit Resumes page.

FIG. 9 is a screen shot showing an example of a Review, Comment and Rate Resumes page.

FIG. 10 is a screen shot showing an example of an Interview Comments page.

FIG. 11 is a screen shot showing shows an example of a dynamic web page instance, according to the prior art.

FIG. 12 is a screen shot showing an example of an interface for initiating an application.

FIG. 13 is a screen shot showing an example of an interface for declaring the pages of an application.

FIG. 14 is a screen shot showing an example of an interface for declaring the pages of an application (after pages have been declared).

FIG. 15 is a screen shot showing an example of an interface for declaring access rights to the pages.

FIG. 16 is a screen shot showing an example of the design interface, in the context of the example Hiring Application.

FIG. 17 is a screen shot showing an example of the design interface, in the context of the example Hiring Application, once the first two fields have been added.

FIG. 18 is a screen shot showing an example of the completely designed field structure of the example Publish Company Positions.

FIG. 19 is a screen shot showing an example of an interface that combines design interface functions with use interface functions (submitting data in this example).

FIG. 20 is a screen shot showing an example of an interface that combines design interface functions with use interface, after data has been submitted.

FIG. 21 a screen shot showing an example of data access rights interface, where designer specifies access rights pertaining to iterator.

FIG. 22 a screen shot showing an example of data access rights interface, where designer specifies access rights pertaining to non-iterator field.

FIG. 23 a screen shot showing an example of data access rights interface, where designer specifies access rights pertaining to nested iterator field.

FIG. 24 is a flowchart showing an exemplary sequence for operation of inference engine, covering describing steps when only data collection and iterator fields are added to page that has no report fields.

FIG. 25 is a flowchart showing one example of operation of the inference engine when report fields are added to page.

FIGS. 26A-26B are flowcharts illustrating operation of the inference engine, according to one example, when data collection fields and/or data collection iterators are added to page.

FIG. 27 is a flowchart showing one example for operation of semantic combination interface and data combination engine.

FIG. 28 is a screen shot showing an example of designer choosing a starting page in the semantic combination interface, in the context of the example Hiring Application.

FIG. 29 is a screen shot showing an example of field tree displayed by the semantic combination interface, in the context of the example Hiring Application.

FIG. 30 is a screen shot showing an example of designer choosing originating fields from the field tree and the data combination engine creating respective new fields, in the context of the example Hiring Application.

FIG. 31 is a screen shot showing an example of designer choosing originating fields from the field tree and the data combination engine creating respective new fields, including iterators, in the context of the example Hiring Application.

FIG. 32 is a screen shot showing an example where designer combines pages by reference relationship, in the context of the example Hiring Application.

FIG. 33 is a block diagram of data structures of a currently designed page and respective data structures created by the semantic combination interface.

FIG. 34 is a screen shot showing an example of hyperlinks in the context of the example Hiring Application.

FIG. 35 is a screen shot showing an example of the data combination engine providing guidance to the designer regarding pages that are possible targets of hyperlink.

FIGS. 36-37 show an example of inferred data structure and page sketch in the context of the example Hiring Application

DETAILED DESCRIPTION

Without any intended limitation, this disclosure employs certain terminology in order to encourage brevity, offer ease of reading, and promote clarity of discussion.

Designer. This refers to people who operate client machines (such as 100-100A of FIG. 1A, discussed below) to use resources of a host (such as 120 of FIG. 1A, described below) to design web applications.

User. This refers to end users who operate client machines such as 100-100A to interact with database-driven web applications (and therefore the underlying databases) residing on the host 120.

Client. This refers to digital data processing machines, such as 100-100A, which are employed by humans to access the host 120. According to one embodiment, no distinction is made between clients used by users and clients used by designers.

Record: This refers to any data object that has attributes/fields. For example, a “person” record has attributes such as “first name”, “last name”, “SSN” etc. It is possible that a record contains nested records. Records are often implemented as tuples of a relational database table, or XML elements of XML databases, or Java objects carrying attributes/properties.

Database & Schema. “Database” refers to a persistent data structure, such as 130. In general, the data structure contains sets of records of various types that conform to a schema. Without any limitation, this disclosure contemplates schemas such as a relational schema, XML schema, or any other specification that captures aspects of data such as the types of records of the database, records\' attributes, records\' relationships and constraints that the records may have to satisfy (such as uniqueness constraints or referential integrity constraints), and the like.

Database Management System (DBMS). This refers to digital data processing machines (such as 126 of FIG. 1A, discussed below) that enable retrieving and modifying data from persistent databases.

Browser. This refers to software operating on the client for use in accessing web pages, including dynamic web pages.

Web Application. This refers to software that is accessed with a browser over a network. The present disclosure focuses on database-driven web applications

Database Driven Application. A database-driven application interacts with a database in order to achieve the following functionalities including retrieving database data that are displayed to the user, and writing data provided by the user in a database.

Database Driven Web Application. A database driven web application performs functionalities including retrieving and using database data to produce dynamic web page instances, and writing data provided by the user over web pages in the database.

Web page: This refers to an information set (document) that is produced by a web application, such as 120, and is suitable for displaying data and interacting with browsers (such as 102-102A of FIG. 1A, discussed below).

Dynamic Web Page Instance: The present disclosure focuses on dynamic web page instances, i.e., pages that are constructed by the web application, as a result of computation. In contrast, the web application performs functions such as retrieving database data and creating pages by appropriately combining database data with the static parts of the page. In addition the application may input user-provided data from the pages and store such data in the database. To further understand the definition of dynamic pages, they are contrasted with static pages where the information set (document) is fully prepared by a user.

Dynamic Web Page: This refers to an Internet address, provided by a web application, that upon being accessed generates a dynamic web page instance. A dynamic web page may accept parameters or may even require parameters from the browser (and indirectly the user). In general, parameters are an input to the computation that produces the page instance. An example is the Yahoo™ Finance database-driven web application that, among other pages, produces Web pages that provide stock market quotes and other financial information upon being provided by the user (via a browser) a stock market ticker symbol. Such a web application relies on an underlying database that contains stock market data. More particularly, a dynamic web page has a given Internet address (URL). When a browser receives and executes this combination of Internet address and parameters, web application produces the corresponding dynamic web page. FIG. 11 shows an example of this.

Iterators and Nested Iterators: This refers broadly to constructs of dynamic web pages that function as follows. During the generation of dynamic web page instances by a database-driven web application the iterator processes sets of records that are the result of retrieving data from the database and potentially filtering, combining and transforming them. The dynamic web page instances contain instances of the iterator where, for each processed record, the iterator instance contains one instance of a repeating structure. Iterators may be, without limitation, associated with tables displayed on dynamic web page instances. An iterator may contain other iterators, in which case such iterators are called nested iterators. Iterators can be implemented using a vast array of technologies. Iterators may also be referred to as iterator fields.

Iterator Instances: This refers broadly to constructs of dynamic web pages that function as follows. During the generation of dynamic web page instances by a database-driven web application the iterator processes sets of records that are the result of retrieving data from the database and potentially filtering, combining and transforming them. The dynamic web page instances contain instances of the iterator where for each processed record the iterator instance contains one instance of a repeating structure. The repeating structure may itself contain instances of nested iterators. Iterator instances are often displayed as tables or lists. In such case, the repeating structure is the table rows, which may contain nested tables.

Iterator context: The context of an iterator refers to the types of database records retrieved by this iterator, or the iterators in which this iterator is nested.

Introduction

One aspect of the present disclosure concerns a web-page-based system to enable people to design and host database driven web applications. This system may be embodied by various hardware and/or software components and interconnections, with one example being described by the system 101 of FIG. 1A.

For ease of description, the system 101 is usable to design web applications and also host the resulting web applications. However, different systems may be used for these purposes—one for design and another for hosting. Indeed many combinations are possible depending on where the application and the database are hosted. One option is to build the entire application plus database in one system, and then host it in another system. Another option is to host only the database in another system. This disclosure contemplates further arrangements, as will be apparent to those of ordinary skill having the benefit of this disclosure.

The system 101 includes a host 120 coupled to various clients such as 100-100a. Each client includes a web browser such as 102-102a. The host 120 is coupled to clients 100-100a by a telecommunications link 110, which may be implemented with numerous different hardware and communications protocols, with some examples including Internet, Intranet, satellite, LAN, WAN, fiber optic network, Ethernet, wireless telephony, landline telephony, etc.

Broadly, users operate the client machines\' web browsers to access the host 120 in order to design and host database driven web applications. The phrase “database driven web applications” refers to web applications that access an underlying database (via a DBMS) and produce dynamic web pages that do one or more of the following: (1) display database data in response to user requests, (2) allow modifications of the displayed data, (3) enable user input of new data, where the new data is (for example) stored in the database and can consequently be displayed at one or more pages, (4) enable interactive behavior (including browsing/navigation across pages) that is dependent on the available data.

At any time during the design, the host 120 may be provided to various users via the link 110 and client machines 100-100a or another such arrangement of link(s) and machine(s).

In the system 101, there are various data processing components, such as the clients 100-100a, the host 120, and the subcomponents 121-134 of the host 120. These may be implemented by one or more hardware devices, software devices, a portion of one or more hardware or software devices, or a combination of the foregoing. The makeup of these subcomponents is described in greater detail below, with reference to FIGS. 2-4.

Client

Referring to FIG. 1A in greater detail, the client machines 100-100a comprise personal computers, computer workstations, personal digital assistants (PDAs), internet enabled telephones, or any other computing devices appropriate to the operations described in detail below. The browsers 102-102a may be implemented using any Internet web browser.

Host

The host 120 may be implemented by one or more personal computers, computer workstations, mainframe computers, server, or other digital data processing device appropriate to the operations described in detail below. In one specific example, the host 120 is implemented by a server or computer workstation with resources sufficient to serve the anticipated number of users and processing load. In the example shown, the host 120 includes various subcomponents 121-134, and their respective subcomponents.

In the general case, multiple applications may be designed and hosted at host 120. Broadly, the representations of the structure and functionality of each web application hosted at host 120 is stored in web application sketches 153 (FIG. 1B, described below), while the structure of the underlying database is captured by web application database schemas 154 (FIG. 1B, described below). Together, the application schemas 154 and sketches 153 specify database-driven web applications. The data stored in clients\' web applications are stored in application databases 155 that are parts of the host\'s database 130.

Database and DBMS

In one example, the database 130 is a relational database and, respectively, the DBMS 127 is a Relational DataBase Management System (RDBMS). Other databases (e.g., Object Oriented databases, XML databases) and corresponding DBMSs that can store and retrieve structured information are possible alternatives for data storage and retrieval.

Database

Introduction

FIG. 1B describes the database 130 in greater detail. As shown the database 130 includes multiple sets of application sketches, schemas, and databases. Each set corresponds to a different web application, for example, web applications for different customers, purposes, etc.

For ease of illustration, a single set 151 of sketch-schema-database is described. As to the set 151, there is a corresponding application database 155, which is part of the database 130.

Application Schema

The application database 155 is structured according to an application schema 154, which captures aspects such as the various types of objects of the application, the attributes of the objects, the relationships between various types of objects and what constraints may apply on the database.

Sketch

A designer\'s web application is internally represented by a web application sketch 153. Basically, the sketch consists of page sketches and action nodes. In one example, a page sketch includes (1) an Internet address, which can be a relative address URL (from now on referred to simply as URL), and (2) a field structure. The URL identifies the page, and the field structure specifies the fields displayed on the page including, without limitation, input fields, display fields and hyperlinks.

As explained in greater detail below, a page sketch corresponds to a dynamic web page. Every time the sketch is activated it produces a “dynamic web page instance”.

Each page sketch corresponds to a dynamic page of the web application and captures the functionality and presentation/appearance of the page. Without limitation, the page sketch may capture any of the following aspects of dynamic web pages: (1) which data are collected by the page and how, (2) which data are reported by the page and how, (3) various interfaces (such as hyperlinks and buttons—without limitation) for modifying data, (4) various interfaces for effecting navigation and the activation of actions that may control navigation and/or modify the underlying database.

Action nodes correspond to software modules that may be interfaced with the pages in order to decide the next step of a web application and manipulate complex web application state. Action nodes are optional.

Application Server & Interfaces

To interface the data manager 126 with clients 100-100a, there are a number of interface components. The application server 121 manages all communications between the host 120 and the clients 100-100a. This includes addressing messages, observing the proper communications protocol, and the like. Also, the application server 121 directs incoming messages from clients to either a user interface 123 or a design interface 122 as appropriate. In addition to any added functionality of the present disclosure, the application server 121 acts to carry out the various known tasks of a web application server.

The user interface 123 enables users\' access to the web applications hosted by the host 120. In response to user request, the user interface 123 may utilize the data manager 126 to retrieve data from the application database 155 and pass them to a rendering engine 134 (described below).

In contrast to the user interface 123, the design interface 122 enables designers operating clients 100-100a to design web applications. In some embodiments, the design interface 122 may provide many or all of the functionality provided by the user interface while in other embodiments the design interface may provide design functionality exclusively. Broadly, the design interface 122 relays user commands that affect the application sketch 153 to the corresponding modules.

The design interface 122 comprises sub-modules that perform various tasks, these sub-modules including (in one example, without any intended limitation): (1) a page access rights interface 140 that the designer utilizes to specify which groups of users have access to each page, (2) a semantic combination interface 141, which allows designers to specify how data of other pages are potentially combined and reported in the currently designed page, (3) a field creation interface 142, which allows designers to create interfaces for the collection of new data, and (4) a data access right interface 143 that controls the data display, edit, remove, and insert interfaces that web application users have on the currently-designed page.

Data Manager

The data manager 126 oversees users\' data storage and retrieval from the application databases 155. During the design mode of the application, the data manager 126 may also (1) assist the creation and modification of the application schemas 154 as directed by the inference engine 123, and (2) assist the creation and modification of application sketches as directed by the schema inference engine 124 and the data combination module 123.

The inference engine 123, schema inference engine 124, and data combination module 125 are discussed in greater detail below.

Rendering Engine

Basically, the rendering engine 134 produces a dynamic web page instance by transforming the retrieved database data into a web page according to the page sketch. This page is displayed by the user interface 123. In response to user request, the user interface 123 may also effect insertions, deletions and modifications of data in the database.

Without any intended limitation, the rendering engine 134 may serve to prepare browser compatible information sets such as HTML or another markup language.

In one embodiment, the rendering engine operates as an interpreter of the sketch, whereas in every step it inputs the page sketch and the data and produces a web application page. A number of rendering frameworks may be used for the implementation of such a rendering engine, involving server-side only or both server-side and client-side computation.

In a different embodiment, the functions of the rendering engine may include compiling code. In this embodiment, the rendering engine inputs an application sketch and compiles the corresponding code. Such compiled code need only receive data needed for pages; it does not need to receive the application sketch since the code already reflects the application sketch information. The performance and flexibility trade-offs of the two embodiments are typical of the trade-offs between interpreted and compiled versions of software. Without any intended limitation, examples in the present disclosure utilize the interpreted version for ease of explanation.

Inference Engine

Broadly, the inference engine 123 acts to automatically create data structures representative of pages of a database-driven application, including various fields introduced into the pages. The inference engine 123 automatically relates fields of the pages to data structures in accordance with a predetermined logic, as described in greater detail below. As one example, the inference engine 123 may act to automatically convert high-level user input submitted by a graphical user interface into actions to create and modify data structures, thereby providing a powerful but easy-to-use database-driven application.

The inference engine 123 includes a schema inference engine 124 and a data combination module 125.

The schema inference engine 124 automatically infers how to modify the application sketch and how to infer or modify the application database schema so that they serve the purposes of the designed web application in cases where the application database schema needs to be modified to capture what data are collected by the application. The schema inference engine 124 interprets the designers\' actions/instructions that pertain to data collection into application sketch and application schema creation and modification instructions. This inferential output 124a is passed to the data manager 126. The schema inference engine 124 examines the pages drawn by the designer and automatically derives the application database schema (i.e., the structure of the underlying database) and parts of the web application sketch. In other words, the schema inference engine 124 analyzes the field structure of the drawn pages and other aspects of the web application, and infers the structure (schema) of the underlying database.

As described in greater detail below, this permits designers to design their web applications using intuitive, largely graphical actions. Based on the client\'s submitted instructions, the schema inference engine 124 makes various predetermined inferences in order to identify the appropriate instructions, of significantly more specificity, for transmittal to the data manager 126. The operation of the schema inference engine 124 is described in greater detail below.

Broadly, the data combination module 125 infers how to modify the application sketch so that it serves the purposes of the designed web application in cases where the application sketch needs to be modified to capture how the designed application reports data.

In a more specific example, the data combination module 125 accomplishes three related tasks. For one, it inspects designer preferences and the application sketch, schema and, in special cases also the database and suggests to the designer semantically meaningful ways to combine and report data. The inferential output 125a of this activity is passed to the design interface 122 and, in particular, the semantic combination interface 141. The second task of the data combination module 125 is to interpret the designers\' actions/instructions that pertain to data combination, filtering (including filtering induced by access rights to the data of a page) and reporting into application sketch. The inferential output 125a of this activity is passed to the data manager 126, which updates the application sketch accordingly and, in special cases discussed later, may also effect actions on the application schema and application database. The third task of the data combination module 125 is to formulate queries (which can be computed or retrieved from the sketch) and appropriately query the database in order to retrieve the data that are needed by certain pages and updates (also attached to the sketch) that update the application database with the data submitted by the user

Data Structure

Detail: Fields & Sketches

According to the disclosure, the functionalities and presentation aspects of a page are described in a sketch by an appropriate field structure. Those trained in the art (and having the benefit of this disclosure) will be able to employ appropriate techniques for modularizing and separating the presentation aspects of the page sketch and its fields from the functionality aspects of the page sketch and its fields.

In the described embodiment, the sketch accommodates the following field types: data collection, report, hyperlink, iterator.

When the database driven application is operated by and end-user, the rendering engine 134 receives the sketch and produces a web page instance, often by combining the sketch 153 with data received from the application database 155. The web page instance consists of field instances, whereas each field instance corresponds to a field of the sketch. However, a field of the sketch may correspond to zero or more field instances. The correspondence between fields and field instances is explained in detail by this disclosure\'s description of the operation of the rendering engine.

Detail: Common Components of Fields

In the described example, every field is associated with a widget, logical specification, design guide, and initialization/default policy.

Widget. The widget associated with a field specifies the type of field instance that will be included in the web page instance when the particular field is rendered, including presentation aspects of the field instance such as (but not limited to) the font and size of print letters, etc. It is also possible to associate a field with more than one widgets. In such case, depending on the context created for the field instance, the field instance may be based on a different widget.

Logical Specification. The logical specification specifies field aspects such as the association of the field with the application schema and the data type associated with the particular field. The logical specification aspects of a field are dependent on the field type (i.e., data collection, report, hyperlink, iterator) and the widget choice for this field, i.e., there are logical specification aspects that pertain to particular widgets only.

Design Guide. The design guide of a field provides to the designer the ability to specify the widget and its logical specification. The design guide is dependent on the widget, since different widgets may have different customization options.

Initialization/default policy. The initialization/default policy specifies the default configuration of properties of the logical specification of the widgets that have not been set. The initialization policy for a field may recursively invoke the initialization policies for the fields that it contains.

Detail: Data Collection Fields

A data collection field is a field that leads to the collection of new data, i.e., data that do not overwrite prior data. Furthermore, introduction of a data collection field leads to modification of the schema to define a new record field. Data collection field instances may comprise input forms on the dynamic web page instance that is presented to the user. For example, but without any intended limitation, in an HTML rendering of the web page instance, a data collection field instance may be implemented as a HTML text box or a HTML dropdown menu, depending on the chosen widget. In this regard, detail on the specifics of HTML is widely known by ordinarily skilled artisans. The data collected by data collection field instances during the use of the application are written in the database by means of insert operations or, potentially, update operations that do not overwrite previously collected data. A data collection field instance does not have to be always rendered as an input form, as will be illustrated in examples below. According to the definitions of this disclosure, a data collection field is a separate concept from a report field that is in edit mode, as described in the next paragraph.

Detail: Report Fields

A report field leads to the reporting of data that have been collected by one or more other pages and/or action nodes. The reporting can involve a number of functions, such as the ones listed below, without any intended limitation: (1) show data collected in another page, (2) show data reported in another page, (3) perform a computation that combines and transforms data collected by other pages according to (1) or (2). A report field is rendered by the rendering engine as a report field instance. A report field may also operate in edit mode, in which case it appears an input field and allows one to overwrite the reported data. According to the definitions of this disclosure a report field that is in edit mode is a separate concept from a data collection field.

Detail: Hyperlink Fields

A hyperlink field is a field that displays a hyperlink to a page instance of the application. When a hyperlink field appears in an iterator, there are produced as many instances of the hyperlink field as the number of record instances of the iterator. Each one of those hyperlink instances transfers to a different page instance, where the particular instance is conditioned by the context created by the particular record instance, as will be displayed next.

Detail: Iterator Fields

An iterator field (in short, iterator) contains other fields, which recursively may be iterators themselves. An iterator is called a report iterator if it contains report fields. Basically, from the designer\'s point of view, a report iterator combines and reports the data collected or reported in one or more other pages. In a web page instance a report iterator instance has a repeating structure that shows zero or more records that have been obtained by combining data of one or more other pages.

A report iterator\'s logical specification contains data that lead to the inference of a parameterized query Q. Basically, this query is responsible for fetching the records that the report iterator instance displays. During operation the use interface 123 instantiates the parameters of the query Q and instructs the data manager 126 to fetch records by running the instantiated query. The data manager returns zero or more records. These records are used by the rendering engine 134 in order to produce the report iterator instance.

A report iterator may be associated with widgets that have a repeating part, in order to accommodate the fact that zero or more records may need to be rendered. One example is a table widget, which is the most common way of rendering reports. The table widget has a header footer part and a repeating row structure that displays the records.

In some cases the query Q of an iterator is guaranteed to return at most one tuple. Such iterators are referred to herein as singleton iterators.

An iterator is called data collection iterator if it contains data collection fields. In the described embodiment, an iterator (and corresponding the iterator instances) may be: (1) a report iterator (respectively, report iterator instance), (2) simultaneously a report and data collection iterator (basically, a report and data collection iterator instance collects data by providing data collection fields while it also has other fields that are report fields); (3) a data collection iterator (instance).

Collaboration Aspects and Access Rights

Introduction

Designers of web applications need to coordinate (1) which users or groups of users have access to each page of the application, (2) read access restrictions: once a user access a page what access restrictions (limits) are placed with respect to data that this user can read, (3) edit restrictions: what access restrictions apply with respect to the ability of the user to edit the displayed data, (4) delete restrictions: what access restrictions apply with respect to the ability of the user to delete displayed data, (5) insert restrictions: what access restrictions apply with respect to the ability of the user to insert data.

Page-Level Access Rights

The designer may associate a group of users with each page. Consequently only those users can have access to (instances of) this page.

In more elaborate embodiments of page-level access rights, the designer may make access to a page, for a certain group of users, contingent on a condition being true. Such conditions may or may not depend on the data of the application database.

Top Iterator (Data-Level) Access Rights

In the presented embodiment data-level access rights are implemented by attaching to the iterator field-based conditions that restrict which data records will be displayed/editable/removable. Therefore the disclosure also calls such data-level access rights to be iterator-level access rights. Iterator-level access rights are properties of the logical specification of the iterator fields. The presented embodiment includes, but is not limited, to the following:

Data Collection Right thief this right is provided then the corresponding iterator instances always provide to the users appropriate interfaces by which the users can input new data records in the web page instance.

Display Right: In the presented embodiment the display right of an iterator controls whether the corresponding iterator instances display data records. While the display right has to be enabled for report iterators, it may also be enabled for data collection iterators, the meaning being that the data collection iterator displays the data it has collected.

Delete Right: Basically, when a top-level iterator has the delete right enabled the corresponding iterator instances provide to the user appropriate interfaces (such as “delete” buttons, “delete” hyperlinks, or “delete” checkboxes) by which the users can request that particular displayed records are deleted from the page and therefore from the database also. The delete right may be inapplicable or its meaning may require further input from the user in cases where the report iterator performs certain complex data combinations and transformations, as described below.

Edit right (on iterators): Basically, when a top-level iterator has the edit right enabled the corresponding iterator instances provide to the user appropriate interfaces (such as buttons, hyperlinks, or checkboxes) by which the users can request that particular displayed records are edited.

Edit mode and display mode: Upon the user requesting an edit of a top-level record the presented embodiment places the corresponding record in edit mode. Normally records are in display mode. A field instance that is in edit mode can receive input while a basic field instance that is in display mode simply displays. Placing a record in edit mode does not automatically imply that the field instances of this record are placed in edit mode. Vice versa, a field instance may be in edit mode, even if its enclosing record is in display mode.

According to the presented embodiment a basic field instance is in edit mode or display mode according to a function that considers (1) the (edit versus display) mode of the enclosing record and (2) edit rights associated with the field.

One embodiment of such a function assumes each basic field is associated with an edit right and this edit right takes the following three values: (1) “Edit Disabled”: If the edit right is disabled then this basic field is always on display mode, even when its enclosing record is in edit mode. (2) “Edit Always Enabled”: If the edit right is “always enabled” then this basic field is always in edit mode, even if its enclosing record is in display mode. (3) “Edit Upon Request”: If the edit right is “edit upon request” then the basic field is in edit mode if and only if its enclosing record is in edit mode.

The field instances that correspond to this node will be placed (or not) in edit mode based. Next, the discussion addresses how the basic (non-iterator) field instances that correspond to this record will respond.

Access Rights of Nested Iterators

One novelty of the present disclosure is the possibility to have iterators nested within iterators. The nesting of iterators raises issues regarding how to control the mode (edit versus display) of the fields of nested iterators, as well as how to control the availability of interfaces for data collection, record deletion and record editing in inner iterators. In many cases, the most appropriate behavior is that a nested iterator instance provides data collection, edit and delete right interfaces only if its enclosing record is in edit mode. Such behavior is enabled by extending the access rights of iterators as follows, when they are nested.

Each one of the data collection, edit and delete rights of nested iterators may take one of three values: (1) “Disabled” (2) “Always Enabled” (3) “Tracks Enclosing Record\'s Edit (TERE)”. If the data collection right is disabled then the corresponding iterator instance does not provide interfaces for inserting new data, regardless of the mode of the enclosing record. If the data collection right is always enabled then the corresponding iterator instance always provides interfaces for inserting new data, regardless of the mode of the enclosing iterator. Finally, if the iterator “tracks the enclosing record\'s edit” then the iterator instance provides interfaces for inserting new data only if the enclosing iterator is in edit mode.

The behavior of the edit and delete rights is similar.

Exemplary Digital Data Processing Apparatus

As mentioned above, data processing entities (such as the clients 100-100a, host 120, subcomponents 121-134, etc.) may be implemented in various forms.

Some examples include a general purpose processor, digital signal processor (DSP), application specific integrated circuit (ASIC), field programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. A general purpose processor may be a microprocessor, but in the alternative, the processor may be any conventional processor, controller, microcontroller, or state machine. A processor may also be implemented as a combination of computing devices, e.g., a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a DSP core, or any other such configuration.

As a more specific example, FIG. 2 shows a digital data processing apparatus 200. The apparatus 200 includes a processor 202, such as a microprocessor, personal computer, workstation, controller, microcontroller, state machine, or other processing machine, coupled to a digital data storage 204. In the present example, the storage 204 includes a fast-access storage 206, as well as nonvolatile storage 208. The fast-access storage 206 may be used, for example, to store the programming instructions executed by the processor 202. The storage 206 and 208 may be implemented by various devices, such as those discussed in greater detail in conjunction with FIGS. 3 and 4. Many alternatives are possible. For instance, one of the components 206, 208 may be eliminated; furthermore, the storage 204, 206, and/or 208 may be provided on-board the processor 202, or even provided externally to the apparatus 200.

The apparatus 200 also includes an input/output 210, such as a connector, line, bus, cable, buffer, electromagnetic link, network, modem, or other means for the processor 202 to exchange data with other hardware external to the apparatus 200.

Signal-Bearing Media

As mentioned above, various instances of digital data storage may be used, for example, to provide storage used by the system 101 (FIG. 1A), to embody the storage 204 and 208 (FIG. 2), etc. In one example, some more specific examples of digital data storage components include the schemas 154, sketches 153, and tables 130.

Depending upon its application, this digital data storage may be used for various functions, such as storing data, or to store machine-readable instructions. These instructions may themselves aid in carrying out various processing functions, or they may serve to install a software program upon a computer, where such software program is then executable to perform other functions related to this disclosure.

In any case, the signal-bearing media may be implemented by nearly any mechanism to digitally storage machine-readable signals. One example is optical storage such as CD-ROM, WORM, DVD, digital optical tape, disk storage 300 (FIG. 3), or other optical storage. Another example is direct access storage, such as a conventional “hard drive”, redundant array of inexpensive disks (“RAID”), or another direct access storage device (“DASD”). Another example is serial-access storage such as magnetic or optical tape. Still other examples of digital data storage include electronic memory such as ROM, EPROM, flash PROM, EEPROM, memory registers, battery backed-up RAM, etc.

An exemplary storage medium is coupled to a processor so the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. In another example, the processor and the storage medium may reside in an ASIC or other integrated circuit.

Logic Circuitry

In contrast to signal-bearing media that contain machine-executable instructions (as described above), a different embodiment may employ logic circuitry to implement processing certain features.

Depending upon the particular requirements of the application in the areas of speed, expense, tooling costs, and the like, this logic may be implemented by constructing an application-specific integrated circuit (ASIC) having thousands of tiny integrated transistors. Such an ASIC may be implemented with CMOS, TTL, VLSI, or another suitable construction. Other alternatives include a digital signal processing chip (DSP), discrete circuitry (such as resistors, capacitors, diodes, inductors, and transistors), field programmable gate array (FPGA), programmable logic array (PLA), programmable logic device (PLD), and the like.

FIG. 4 shows an example of logic circuitry in the form of an integrated circuit 400.

Having described the structural features of the present disclosure, the operational aspect of the disclosure will now be described. The steps of any method, process, or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by hardware, or in a combination of the two.

Overall Sequence of Operation

FIG. 5 shows a sequence illustrating one example of the method aspect of this disclosure. Broadly, this sequence provides an overview of the operations of installing and utilizing web application design software, as well as the subsequent operations of making the finished product available to users. For ease of explanation, but without any intended limitation, the example of FIG. 5 is described in the specific context of the system 101 (FIG. 1A) described above.

The sequence 500 is initiated in step 502. In step 510, software setup occurs. Namely, operators design, install, and configure the components 121-134 of the host 120. This may be performed by one person, a team, or a series of different people. In one example, programmers design the components 121-134, and system administrators install the completed product on the host 120. Regardless of the progress in the sequence 500, step 510 may be repeated in order to modify, update, improve, expand, or otherwise change the host programming.

In step 512, people make the completed product accessible to (web application) designers and their end users. For instance, step 512 may involve making the host 120 available online in the form of an Internet web site. As a prerequisite to using the host 120, this Internet web site may require prospective application designers to register, submit a fee, agree to a payment contract, or take other such action.

Step 513 shows an operation where an exemplary designer accesses the host 120 to set up a web application. As discussed in greater detail below, this is achieved by the designer operating the design interface 122 to define and modify various web pages and fields.

In response to mostly graphical actions of the designer in step 514, the schema inference engine 124 interprets these actions and carries out representative tasks of designing and modifying the corresponding application\'s sketch and database schema 154 in step 516. Step 515 occurs when the designer is finished with step 514. Ultimately, responsive to the designer\'s completion of the web application, and designer directions to do so, the application server 121 makes the web application accessible to end users in step 522. Unlike step 512, where people manually made the host 120 accessible to web application designers and their end users, in the sense that they had to install such a host, step 522 is performed automatically by the application server 121, in the sense that it simply allows users access to the appropriate applications hosted at host 120. Namely, the application server 121 makes the designer\'s web application (database) available to end users in the form of an Internet web site.

The sequence 500 concludes in step 530.

Detail: Application Design

FIG. 6 illustrates greater detail of an exemplary process of designing a database-driven web application and implementing the corresponding schema 154 and sketch 153. Without any intended limitation, this process is described to illustrate the operations of steps 514-516 (FIG. 5) in greater detail. For ease of explanation, but without any intended limitation, the example of FIG. 6 is described in the specific context of the system 101 (FIG. 1A) described above. In this discussion, actions performed by a designer are assumed to be performed using a client machine (such as 100-100a) to access functions of the host 120.

The sequence 600 begins in step 602. As illustrated, the process starts (step 602) when step 514 (FIG. 5) is first performed. In step 610, a designer operates the design interface 122 to initiate one or more pages. As an alternative, or additional operation, the host 120 may provide one or more template starter pages to designers. In this case, the operation 610 may be replaced with an operation of selecting a template.

Next, the designer adds a new field or modifies an existing field (step 611). This operation is described in greater detail by steps 612a-618a. Each such operation 612a-618a is followed by a respective operation of making an inference (operations 612b-618b) that modifies the application sketch and the database application schema.

Operations 612a-618a depict the operations of a designer adding/modifying respective field types that include (in this example): input, display, hyperlink, and iterator. Responsive to each user action 612a-618a, the schema inference engine 124 and the data combination module 125 make appropriate inferences 612b-618b. The inference 612b-618b specifies the configuration of the schema 154 and the sketch 153 needed to implement the designer\'s input 612a-618a. The operation of the schema inference engine 124 and the data combination engine (which includes management of hyperlinks) are discussed in detail below.

Example of Database-Driven Web Application

The following discussion introduces an example of a web application in order to further illustrate examples of the components of FIGS. 1B and 1C.

This example concerns the hiring process of summer interns in a fictitious technology company. The process starts with the human resources (HR) personnel advertising, using the web application, company positions for which applicants are invited to apply. Then applicants submit their resumes through an appropriate page of the web application and declare for which of the advertised company positions they are applying. Thereafter engineers review the resumes and enter public and private comments about each applicant, as well as ratings that pertain to how strong an applicant is for each of the company positions that he applied for. For example, an applicant may get a rating of eight when judged for his strength as a software developer and get a rating of six when judged for his strength as director of engineering. Then HR personnel reviews the ratings and makes selections for interviews. An HR manager, who is the designer in this example, will be able to create a customized database-driven web application that perfectly fits the data and process needs of the above procedure.

FIGS. 7-10 show web pages that combine to form a customized web application supporting the hiring process described above. These pages correspond directly to the stages in the process: (1) “Publish Company Positions” page (accessible by the HR personnel) (2) “Submit Resume” page (accessible by applicants), (3) “Review, Comment and Rate Resumes” page (accessible by the engineers), (4) “Schedule Interviews” page (accessible by the HR personnel).

In FIG. 7, the “Publish Company Positions” pages is where the HR personnel can see the available positions and also declare new available positions by providing the name of the available position, the expected salary and the list of expected responsibilities. In FIG. 7, the example snapshot of the page, the logged-in user sees records of available positions created by other users also but is allowed to remove and edit only the records that he provided.

The field structure of the page is as follows: The top-level iterator of the page is a data collection iterator that has display and insertion enabled. Therefore, the top part of the iterator instance, which corresponds to the display part of the iterator instance, displays available positions previously posted while the lower part of the iterator instance corresponds to the interfaces for insert part of the iterator instance.

In FIG. 8, the “Submit Resume” page collects application information from the applicants. This includes personal particulars and educational background. The use of nested iterators such as “positions applied” and “education” that have more than one record for each resume. The ability to enter more than one record is indicated by the “add more” hyperlink and its enclosing box.

After the applicants have filled in their respective forms, the data can be shared and viewed by multiple parties along the hiring process. “Review, Comment and Rate Resumes” (FIG. 9) is the first web page in this process. The employees review the applications and can provide (1) public comments for each employee, i.e. comments that the other employees can also see (2) private comments, i.e., comments that only the HR personnel will see and (3) private ratings of the strength of each employee for each of the positions for which the applicant has applied.

On the right of the page, a search filter has been applied, such that only applicants who have graduated from Stanford or Berkeley are currently displayed.

In FIG. 10, a “Schedule Interviews” page shows each available position, the names of the applicants that have applied for this position (an applicant may have applied for more than one positions) and the “Interview” column, which allows the HR person, to schedule one interview date for every pair of position and applicant interested in the position (notice that Joe has two scheduled interview dates—one for each position he is interested in).

Even though the example of FIGS. 7-10 exemplifies a short collaboration process between a small number of parties, with the current state of the art, the design of such a customized database-driven web application from scratch requires several technical activities and abilities, which are only possessed by Information Technology professionals. These include: (1) designing a database schema to store the data, (2) programming a web application to insert, retrieve, update and delete the data, (3) implementing a security scheme for user authentication and access control, and (4) making the database/web application accessible to multiple users through the Internet/internal network.

Since these technical activities require prior technical expertise, as well as implementation timeframes in the range of weeks to months, the design of customized web applications has traditionally resided in the domain of technical specialists, or those with the resources to employ their services. Techniques of this disclosure relieve owners from the above activities, thereby allowing regular, computer literate owners to easily create customized web applications within hours or minutes.

Example: Illustrating Operations of FIG. 5

The sequence of FIG. 5 is now described in the context of the example hiring application. First people deploy the completed product to a web site such as app2you.org (in this example) and make the building of applications at app2you.org available for a fee (step 512).

The designer of a new application, who in this example is a member of the HR personnel, visits the web site provided by the host 120 and after signing up he reaches the page of FIG. 12 where he initiates a new application (step 513) by providing data such as the name of the application, a description of it and the URL (Internet address) of the new application. In step 514, the designer defines and/or modifies web pages and fields. The following discussion illustrates some details of operations 514.

The designer may elect to use the pages of template applications (see “install template” link in FIG. 13) or elect to build the pages of the application himself or a combination of the two. In our example, let us assume that the designer builds all the pages by himself.

By clicking the “create page” link of FIG. 13 the designer initiates a new page of the application and is prompted for data such as the name and the address for the new page.

At the snapshot of FIG. 14 the designer has initiated the pages of the example application. In FIG. 15 the designer specifies which groups of users have access to each page.

After the designer has clicked the “design” link of a page, the application server 121 presents to the designer the page of FIG. 16 where the designer can introduce fields into the page. The snapshot of FIG. 16 is taken after the designer elected to design the “Publish Company Positions” page.

The system automatically includes in the “Publish Company Positions” page its top-level iterator. This iterator will be referred to as the “Publish Company Positions” iterator or the “top-level iterator of the Publish Company Positions page”.

In the example, the designer adds into the “Publish Company Positions” iterator the input fields “Position name” and “Expected salary” by selecting from the right column the widget “Single Text Line” for the “Position name” and the widget “Number” for the “Expected salary” (see FIG. 17).

The designer also adds in the “Company Positions” iterator the data collection “Responsibilities” iterator by selecting the “Table of Entries” (“entries” is used synonymously to “records”) widget from the right column, dropping it in the “Company Positions” and setting the name of the newly created field to be “Responsibilities”. The action of introducing the “Responsibilities” iterator from the field creation interface 142 makes the “Responsibilities” be a data collection iterator. Consequently, using the same process the designer adds the fields “Duty” and “Answer To” in the “Responsibilities” iterator. The resulting “Publish Company Positions” page is shown in FIG. 18. At this point the part of the application schema that corresponds to the “Publish Company Positions” page has been created.

In the example embodiment the designer can obtain the experience that his users will be having using the designer\'s web application by submitting data to the form page. FIG. 19 shows that the designer has written data about an available company position into the input fields of the page. Upon clicking the “Submit” button the data are persistently stored in the underlying database and also appear in the report part of the “Publish Company Positions” iterator, as shown in FIG. 20.

The designer can control who can see, remove or edit records submitted by the “Publish Company Positions” page. In the particular example, let us assume that the designer wants to allow everyone from the HR Personnel to see the posted company positions (regardless of whether they are posted by him/her or other colleagues of the HR personnel) but only the HR personnel person that posted a certain company position should be able to edit or remove the particular company position. In the example embodiment the designer achieves this by using the design guide of the “Company Positions” iterator, illustrated in FIG. 21. The display option is enabled (the corresponding box is checked) and there is no limitation that a user sees only the company position records that he has created. The edit and remove options are also enabled but notice that the limitation that a user can edit and remove only the records he/she created is also enabled.

Upon clicking the “edit” link of a submitted company position record, the record goes in edit mode and the fields of the corresponding company position record appear as input fields.

The designer can also control which of the fields of an iterator can be edited and under what conditions they will be editable. This example is expanded, assuming that the designer wants (1) the “Position Name” field of a record to become an input field, initialized with the current value of the field, once the user clicks the “edit” link of the corresponding record, (2) the “Expected Salary” not to be editable, i.e., even if the user clicks the “edit’ link of the corresponding record the “Expected Salary” field will still be a display field, and (3) the “Responsibilities” iterator to present an insert tuple when the “Company Positions” record is edited.

The described goals are achieved as follows: The designer invokes the design guide of the respective fields “Position Name”, “Expected Salary”, and “Responsibilities”.

FIG. 22 presents a snapshot of the design guide of the field “Position Name”. The edit property has been enabled (the corresponding box has been checked) but the always-on-edit property is not enabled. The design guide of “Expected Salary” has the edit property disabled.

FIG. 23 presents a snapshot of the design guide of the iterator “Responsibilities”. The insert property is enabled. Since this is a nested iterator (since the iterator “Responsibilities” is nested within the “Company Positions” iterator) the track-parent\'s-edit sub-property applies to the insert property. By enabling the track-parent\'s-edit property the designer specifies that the insert tuple of a “Responsibilities” iterator instance should appear only when the parent iterator instance is in edit mode.

The track-parent\'s-edit sub-property also applies to other access properties, such as the remove and the edit. The example of FIG. 23 shows that the designer has enabled the TERE value of the remove right. Therefore the “remove” link appears only on the “Responsibilities” iterator instances that are in edit mode.

The top level field in the sketch of the “Company Positions” page is the “Company Positions” iterator, which contains the basic data collection fields “Position Name”, “Expected Salary” and the data collection iterator field “Responsibilities”. The “Publish Company Positions” iterator is a data collection iterator with the display mode also enabled.

The iterator “Responsibilities” contains the basic data collection fields “Duty” and “Answer To”.

The “Publish Company Positions” iterator has the display, edit and remove rights enabled and also has the user-id limitations on edit and remove enabled.

FIG. 20 presents an instance of the “Company Positions” iterator that reports one record (more than one are generally possible) and also provides data collection.

In the snapshot of FIG. 20 the created fields “Position Name” and “Expected Salary” appear as input fields in the insert tuple of the iterator and appear as display fields in the report part of the iterator.

The “Submit Resume” page is created by the same process. The new feature of this page (with respect to features outlined in the “Company Positions” page) is the “Position Applied” reference field, which refers to the iterator “Publish Company Positions” and displays the “Position Name”. The “Position Applied” field appears as a radio button input field. The role of a reference field is to collect references to the records collected by the referred record.

Detail: Operation of Inference Engine

Introduction

In FIGS. 5-6, the designer does not explicitly design the application database 130 by coding, programming, or other manual means. Indeed, this is one distinct advantage offered by this disclosure. The designer need not be an expert in database design in order to construct a database-driven application.

Nevertheless, since the designer does not explicitly design the application database, the present disclosure includes a technique to automatically design the database in response to the designer\'s actions. Largely, these actions are performed by the schema inference engine 124 (FIG. 1A).

In the described embodiment, the schema inference engine 124 continually modifies the database application schema 154 in response to the designer\'s introduction of each field in a page. In particular, in the described embodiment the schema inference engine 124 continuously modifies the page sketch and the part of the database schema corresponding to a page in response to designer actions adding or modifying fields in the page, as illustrated in FIG. 6.

In step 610 of FIG. 6 the top level iterators of a page are inserted. This may be accomplished automatically or by user instruction or by a combination of the two. For example, in step 610 the technique of the described disclosure may automatically introduce the top-level iterator of the page. In the context of the example of FIGS. 7-10, the top level iterator of the page “Publish Company Positions” is the iterator with the same name. The top-level iterator initially is empty of fields and is not marked as either “data collection” or “report”. Top-level iterators that are empty of fields are the only cases in the described embodiment where an iterator is not marked as either “data collection” or “report”.

Step 610 may also be accomplished in non-automatic ways. For example, the designer may explicitly place one or more top-level iterators in a page by introducing a corresponding number of iterator widgets (such as the “List of Records” and “Table of Records” widgets of the example) in the top level of the page.