WO2001031427A9 - Method and system for automatically generating an application program based upon data characteristics - Google Patents

Abstract

A system and method (104) for automatically generating a custom application program (106) based upon a data source (102) is presented. The system analyzes an initial data source and automatically generates a number of graphical user interface objects ('GUI objects') (308) and other objects (310, 312, 324, 318) that encapsulate the initial data source and other information to generate an application program. The automatic generation of the GUI objects and other objects is based on a characterization of the initial data source that may be fully automated, user specified, or may involve a hybrid of automatic and user specified characterizations. Once the GUI objects are created, they are assembled into a fully-functional custom application program by an application shell program.

Description

METHOD AND SYSTEM FOR AUTOMATICALLY GENERATING AN APPLICATION PROGRAM BASED UPON DATA CHARACTERISTICS

COPYRIGHT NOTICE A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever. RELATED APPLICATIONS

This application is related to commonly owned application entitled METHOD AND SYSTEM FOR ENCAPSULATING AN APPLICATION PROGRAM, filed October 22, 1999, attorney docket no. 3889/5, which is hereby incorporated by reference into this application. BACKGROUND OF THE INVENTION

This invention relates to techniques for automatically generating application programs. More particularly, the invention relates to techniques for generating a custom application program based upon a characterization of a data source. The characterization process can be performed automatically, according to a user specification, or by a combination of these approaches.

Commercial application programs are typically difficult to create and maintain. Building commercial applications frequently requires large financial and human resource investments. In addition, many thousands of lines of computer code are typically needed to produce full-featured applications, making modifications and enhancements difficult, and making simple coding errors problematic to locate and eliminate. Programmers have endless programming choices and often get mired in design details, frequently producing non-standard applications that are difficult to use. In many cases, application programs are not well matched to the underlying data they manipulate.

In particular, programmers typically spend substantial time on user interface development. Originally, application programs focused on system functionality, with the user interface as a secondary consideration. With the advent of the graphical user interface (GUI), more programming time and attention is given to the user interface. Web browser technology has further increased the demands on interface programming by introducing additional graphics and layout options. As a result, programmers today spend a large percentage of their efforts in the design and layout of data. Despite these efforts, content data is still difficult to effectively access, explore and manipulate, and many application interfaces are non-standard. The time required to develop applications makes it difficult for programmers to keep up with the need for application programs, especially programs that provide customized access to specific data sets. Huge stores of valuable content data may be found in databases on older computer systems that are difficult to use or otherwise inaccessible. These legacy databases are a major bottleneck for organizations that wish to provide access to this data, and for users who want to access to legacy data. There are similar access problems for many types of business data, since the amount and availability of raw data has exploded in recent years. For example, thousands of data lists are available over the Internet, such as phone listings, classified advertisements, product catalogs, "best of lists, newspaper summaries, sports data, financial data, message boards, newsgroups, and more. Currently, access to legacy data and to much of the data available over the Internet is through conventional browsers and other systems that display content data as long sequences of single view web pages which allow no manipulation, or as text files which require additional programming for proper viewing and manipulation. Viewing information lists in a typical web browser is slower and more difficult to comprehend than viewing lists in a custom application program.

Systems that perform automated application generation and report generation to various degrees are known those skilled in the art. However, existing systems may be characterized as requiring relatively extensive specifications to create application programs with relatively low degrees of functionality. Most frequently, the generated application has diminished functionality, and is sometimes characterized as a 'report' rather than an application program. Thus, existing systems may be characterized as having a high ratio of effort to functionality, and frequently produce application programs with reduced functionality. The present invention may be distinguished from previous approaches in that it requires relatively little user input to create a full featured custom application program, and, in some cases, produces the full featured application program with no user input. There is thus a need for methods and systems for reducing or eliminating the work involved in generating application programs that provide substantial functionality in accessing and manipulating content data.

SUMMARY OF THE INVENTION It is an object of the present invention to solve the problems described above associated with existing approaches to application programming, database programming, and user interface programming.

It is another object of the present invention to provide access to data in a full featured application program without the need for hand-crafted custom programming. It is another obj ect of the present invention to provide a method of effectively and efficiently packaging content data and application programs.

It is another object of the present invention to generate an application program with minimal user intervention where the functionality of the generated application program is maximized. It is another object of the present invention to automatically generate a fully- functional application program with no user intervention.

The automatic application generation method and system described herein operates by characterizing patterns within a data set, using these characterizations to generate objects that encapsulate the data, and using the generated objects to automatically build a full- featured application program. The characterization process can be performed automatically, according to direct user specification, or via a hybrid of these two methods. This allows a flexible combination of automation and user control.

Inherent within most data sets is a full-featured computer application program. Thus, rather than hand-crafting a custom application program to fit the unique characteristics of a given data set, the instant invention utilizes the unique characteristics of a given data set to automatically generate a custom application program. Thus, the invention may be described as 'data-driven' or 'data-centric' application program generation.

For instance, a simple list of data intrinsically contains characteristics and patterns that can be used to create a full-featured list viewing application, and not just a 'page-by-page' view of the list data. A full-featured application is one in which multiple viewing formats such as lists, grids, cards, detail views, calendars, reports, drop down lists, drag & drop views, and graphs of the data are provided; where there is a full complement of support functions such as interaction widgets and dialogs; where the user can manipulate the data; and where the user can interact with the multiple data views.

The computerized method and system for generating an application program initially characterizes an initial data set. Characterization may be fully-automated, manually specified, or may combine both approaches. The automatic characterization is based on an adaptable set of pattern matching algorithms, heuristics and hinting mechanisms. User driven characterization may use a characterization editor, a preferences file or other method of obtaining and recording a user's data characterization preferences. In the hybrid approach, the data is automatically characterized unless a manual specification is given. Based on the characterization of the data set, any number of graphical user interface objects ("GUI objects") are produced. The GUI objects thus encapsulate characteristics of the content data that are useful in producing a full-featured application program. To complement the GUI objects, an intermediate data source may be generated in a neutral format to provide access to raw data, a set of query objects is generated to populate the GUI objects with data from the data source, a set of transaction objects are generated that structure the GUI objects, and a set of control objects are generated to provide additional application support. Once generated, the GUI objects may be flexibly assembled into a full- featured application program. This application program may be executed to allow access to, and manipulation of, the underlying content data source. Several automated methods of detecting characteristics of the initial data source are part of the application generation system. For example, the system is capable of detecting a date/time data field in the initial data source. The presence of date or time information is then used to generate one or more GUI objects that specifically encapsulate calendar object types and provide other information that describes the calendar objects to the application generation system, thus customizing the generated application to the underlying calendar data. If numeric data are detected, one or more GUI objects may be generated, such as a graphical GUI object. Similarly, if a Uniform Resource Locator (URL) is detected one or more GUI objects may be generated that describe web pages. In the general case, any regular expression or other form of pattern matching may be used so that when the pattern specified by the regular expression is matched a specific GUI object is generated.

The data characterization method used to generate the GUI objects takes special note of columnar or tabular data. In particular, columns of data are recognized in an initial data source and may be characterized individually. If columnar data are recognized then the application program generation system identifies column headings and uses these headings as field names. If no column headings are located or if the column headings are difficult to characterize then the automatic program generation system provides a set of default behaviors that may be overridden by user preferences.

An additional feature of the data characterization method described herein is the ability to detect repeated data values and generate a lookup table containing only the unique values. The lookup tables may be used to generate views that are grouped by common lookup values. For example, if a lookup table is created for states, then views can easily be grouped 'by state'. Additionally, the lookup tables may be used in the construction of drop down lists, described hereinbelow. The lookup tables can also provide data compaction since many large business data tables contain highly repetitive data and the lookup table is a more concise representation of the data.

As the GUI objects are generated, the automatic application generation system generates one or more queries associated with each GUI objects. These queries each provide access to the portion of the data set encapsulated in. an associated GUI object. The queries are used at run time to populate the GUI object with content data from the intermediary data source. A plurality of transaction objects are also created that structure and organize the GUI objects. A plurality of additional control objects are created to provide overall program structure and additional interface options. For example, an application object specifies the application name and an intermediary data source, and an outbar object creates a selection bar with shortcuts to the underlying GUI object views. The final application program is created when the GUI objects, transaction objects and control objects are parsed and read by an application shell program, which may be a data-centric browser, that creates instances of the GUI objects, transaction objects, and control objects, and assembles these objects into the final application program.

The group of GUI objects generally consists of a calendar view object, a grid view object, a card view object, a tree view object, a drag & drop list object, a report view object, a graph view object, a drop down list object, and a detail view object. Further GUI objects may be developed by users or programmers and may be transparently integrated with the automatic application generation system. GUI objects may also be retrieved or transmitted via a telecommunications connection or the Internet. Thus, GUI objects form a basis for information sharing among many geographically remote computers which may be of different makes and models running different operating systems and application environments. GUI objects may also be stored on virtually any type of computer readable media as a concise and cost effective way to distribute content data. For example, a set of GUI objects may be stored and distributed on diskettes or CD-ROMs.

BRIEF DESCRIPTION OF THE DRAWINGS The invention is illustrated in the figures of the accompanying drawings which are meant to be exemplary and not limiting, in which like references are intended to refer to like or corresponding parts, and in which:

Figure 1 is a block diagram of an exemplary automatic application generation system in accordance with one embodiment of the present invention;

Figure 2 is a functional block diagram of the computing apparatus of Figure 1 that automatically generates computer applications;

Figure 3 is a flow diagram showing the flow of data in accordance with one embodiment of the present invention;

Figure 4 is a flow chart showing a process for automatically generating a computer application in accordance with the present invention; Figure 5 is a flow chart showing a process for automatically creating an intermediary data source;

Figure 6 is a flow chart showing a process for automatically building GUI objects, associated queries and view building transactions from the intermediary data source; Figure 7 is a flow chart showing a process for building GUI objects, associated queries and view building transactions from the intermediary data source based upon a user specification;

Figure 8 is a flow chart showing a process for creating the view building transactions in accordance with one embodiment of the present invention; and,

Figures 9a-9e are exemplary screen displays of an integrated application program generated in accordance with the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS As a general overview, the present invention is a method and system for automatically generating an application program based upon data characteristics. The method and system takes a initial data source, which may be derived from a database system, legacy

5 data, or other data, and creates a set of graphical user interface (GUI) objects; associated query objects; transaction objects; control objects; and an intermediary data source. In order to generate these objects, data in the initial data source is either automatically characterized or may be explicitly characterized by a user specification. An application program shell, which may be referred to as a data centered browser program, receives the GUI objects and uses the

10 transaction objects and other objects to create views of the GUI objects, which are populated with data by executing the associated queries on the intermediary data source. The user of the automatically generated program can view, navigate, and modify content data via the GUI objects and the intermediary data source.

Embodiments of the present invention will now be described in detail with

15 reference to the accompanying figures. Figure 1 shows a block diagram of an automatic application program generation system in accordance with one embodiment of the present invention. Illustrated in Figure 1 is an initial data source 102, which may contain any form of data such as information stored in a database system, information stored as a set of files in a computer file system, legacy data, Internet data, or information deriving from another source,

20 without limitation, as known to those who are skilled in the art. Furthermore, the data source 102 may reside on a remote computer, as in a client/server or web-based architecture, or the data source may reside on a local computer.

The data contained in the data source 102 are retrieved by an automatic application generation system 104 and processed to generate a computer application program

25 106. The computer application program 106 allows a user to read, navigate, and modify the underlying data that was retrieved from the data source 102. More generally, the automatically generated application program 106 accomplishes the full range of tasks that may be implemented in a full-featured application program such as would typically be handcrafted.

30 Figure 2 shows a block diagram of the automatic application generation system 104. The apparatus has a central processor unit (CPU) 204 that is coupled to, and accesses memory devices 202 and input / output devices 206. The memory devices 202 may include random access memory, disk storage and other forms of volatile or non- volatile storage. The input / output devices 206 may include user interface devices, network interfaces, and other computing peripherals. These hardware elements may be conventional elements such as in a mainframe computer, personal computer, laptop computer, handheld

5 computer, or personal digital assistant, as known to those skilled in the art, and are controlled by operating system and other conventional software.

A set of rules 210 determine how the application generator 208 characterizes the initial data source and generates GUI objects, transaction objects and other application program description objects 206. The rules 210 describe how the GUI objects 310 are

10 recognized, displayed, populated with data, what interaction widgets are associated with a GUI object 320 and other implementation specifics of a full-featured application program. A default set of predetermined rules 210 may be used, such as by being hard coded into the application generator, or the rules 210 may be modified by a user of the automatically generated application 106, such as by using user preferences dialog or incorporating a

15 configuration file. Furthermore, the user may explicitly specify the data characterization rules as described hereinbelow. The application generator 208 also accesses the initial data source 102 to generate an intermediate data source.

With reference to Figure 3, a diagram showing the flow of data in the automatic application generation system 104 is presented. Generally, an initial data source

20 102 is processed to create an encapsulated application program 302, which is then used to create a full-featured application program 106. The application program encapsulation 302 contains one or more application level objects 306, an intermediate data source 314 containing one or more data tables 316, and a plurality of control objects 324. Each of the application level objects 306 is a concise, high-level representation of a portion of an

25 application program that includes GUI objects 308, query objects 310, and transaction objects 312. Each GUI object 308 is supported by a corresponding query object 310 that is used to populate the corresponding GUI object instance 322 with data. The transaction objects 312 structure the GUI objects 308 into interactive display views.

The intermediary data source 314 includes one or more DBMS tables 316,

30 which may be implemented using relational database tables, other database technologies, or internal program data structures. The intermediate data source may be derived from the initial data source 102 or also may be created or accessed while the generated application program is running. In the case where data is available only after the generated application program is running, the data tables 316 in the intermediary data source 314 are empty or are not generated, and data is obtained from the available data source. The set of control objects 324 included in the encapsulated application program 302 provide overall structure and interface elements for the generated application program, such as the title of the generated application program, such as folders, menus, outbars and other standard user interface features and controls.

The generated application program 106 is created from the application program encapsulation 302 by an application shell program, which may be a data centered browser or other program. In the generated application program 106, the application level objects 308 are instanced as application specific objects 318. Each application level object 318 combines a transaction object instance 320 with one or more GUI object instances 322. For each GUI object instance 322 to be displayed, the application shell program interprets a GUI object 308 and populates a corresponding GUI object instance 322 with data using the query 310 associated with the GUI object 308. A GUI object instance 322 is structured into a specific display by a transaction object 320 to present content data. Thus, a GUI object 308 is a general schema, structure and description for encapsulating data and program information while a GUI object instance 322 is fully functional application program interface element that enables direct user interaction with a data set. There are several GUI object types 308 including: grid objects, card objects, detail objects, tree view objects, calendar objects, graphic objects, drag & drop objects, drop down list objects, and report objects. Furthermore, additional GUI object types 308 may be defined at the user or system level to customize the application generator to specific data environments. Examples of specific GUI object types 308 are described hereinbelow. A grid GUI object encapsulates data that may be displayed as a set of rows and columns. Examples of grid data include data that may be a series of cells or fields arranged in a configuration of rows and columns. Grid data may come from computer spreadsheet programs such as LOTUS 123 or EXCEL, or a variety of other sources. An exemplary grid GUI object is shown as 802 in the screen display in Figure 9a. A card GUI object encapsulates data that would traditionally be represented on a card or card index. For example, business cards, addresses, recipes, or any data that might used in card-oriented data management systems such as HYPERCARD or SUPERCARD. An exemplary card GUI object is shown as 862 in the screen display in Figure 9e. A detail GUI object encapsulates a series of fields for different data types such as text, formatted text, integers, numeric ranges, and other data types without limitations. Detail view GUI objects are particularly useful in conjunction with other GUI objects such as grid GUI objects. An exemplary detail GUI object is shown as 903 in the screen display in Figure 9a. A tree view GUI object encapsulates data which may be represented in a hierarchical form. For example, the directory structure of a computer file system, a family tree, or a decision tree may all be represented by a tree GUI object. An exemplary tree view GUI object is shown as 940 in the screen display in Figure 9c. A calendar GUI object can encapsulate data representing dates and times. An exemplary calendar GUI object is shown as 950 in the screen display in Figure 9d. A graph GUI object can represent numerical information and the relationships among quantitative data. An exemplary graph GUI object is shown as 930 in the screen display in Figure 9b. A report GUI object can represent larger collections of text and data, including memoranda, articles, web pages, and virtually any type of structured or unstructured data. An exemplary report GUI object is shown as 942 in the screen display in Figure 9c. A drop down list GUI object displays a list from which items can be easily selected. The drop down list items are generally used to display and access data that may be stored in a lookup table. An exemplary drop down list GUI object is shown as 956 in Figure 9d. A drag & drop list GUI object displays a grid from which items can be dragged from one view and dropped into another other view. An exemplary drag and drop GUI object is shown as 954 in Figure 9d.

The application generator processing method of the preferred embodiment will now be described generally with reference to the flow chart in Figure 4. In step 402, the initial data source is opened. At step 404, the data from the original data source is characterized to determine the patterns inherent in the data. In one embodiment, this characterization of the source data is accomplished automatically according to various specially formulated rules or heuristics. Alternatively, the initial data source is explicitly characterized by a user. For example, the user can identify the data or field types of each column of data in a proposed or actual data source. Furthermore, automatic and user characterizations may be combined. The application generation system may initially characterize all of the data automatically, and then allow the user to override the automatic characterizations and explicitly characterize certain portions of the data. For example, source data representing dates or times may be automatically recognized by matching the source data 102 with standard patterns that represent dates. This same source data could also be specified by a user to represent simple text strings or generic numeric data. Continuing with reference to Figure 4, at step 406, a plurality of GUI objects are generated based on the data characterization. In step 408, the intermediate data source 314 and associated data tables 316 are generated. Queries 310 associated with the GUI objects are generated in step 410 and transactions associated with the GUI objects are generated in step 412. In step 414, control objects, which provide additional program support and control are generated. The program generation terminates at step 416.

Figure 5 is a flow chart that describes the process of creating the intermediary data source 314 and associated DBMS tables 316. In step 502, the initial data source is opened, or otherwise retrieved. The application generator 104 scans for columns of data, which may be an arbitrary slice of data in a non-tabular data set, and retrieves the data column, step 506. Here, the application generator 208 characterizes an initial set of columns of the source data 102 as identifying fields to better obtain context information. In the preferred embodiment, the first four fields are used as identifying fields. The application generator then determines if the column is a known data type, step 508. If the column is a known data type, such as a date, time, numeric, floating point, URL, text, or other known type, then the specific data type is determined in step 510 by characterizing the data through detecting known patterns. If the column does not contain a known data type, then a default column type is created, step 512, such as alphanumeric or text. At step 513, the automatic program generation system detects if there are remaining columns of data. If columns of data remain then the program returns to step 506 and retrieves another column of data. Otherwise the automatic program generation system continues on to step 514 and creates a new data table in the data source for storing the characterized data.

Continuing with reference to Figure 5, a new data table 316 is created in step 514 and data from the initial data source 102 is retrieved and loaded into a new database table 310, step 516. Source data 102 is then added to the data table. After the source data has been added to the data table then the data table is analyzed, step 518, to determine if the field contains repetitive data. If there are repeating fields in the source data 102, then the application generator 104 creates a lookup table to store the repetitive data, step 522. Once the table is created it may be linked to other data tables, step 524. Thus, additional instances to the repeating data will reference the lookup table. If more data fields are available, the application generator then returns to step 518 and processes additional data. When there are no further fields, the application generator continues to step 530 and terminates. Several heuristics are used to locate identifying fields, which specify information about the type and structure of the underlying data. For example, the leftmost columns of data tend to have important data, such as a time sequence, that relates to the other columns of data. For this reason, the application generation system obtains identifying fields from left to right, in the preferred embodiment the first four columns of data in a tabular data source are used to obtain identifying fields.

Figure 6 presents an alternative embodiment to the process of automatic characterization of the initial data source. In this alternative embodiment, object characterizations, as well as field names in some embodiments, are obtained from a user in step 602. The user specified characterization may be accomplished interactively through a guided series of dialog boxes, such as a wizard program, or may be accomplished via a control file, stored preferences, program control, or other user specification method. These user specified data characterizations can be flexibly intercombined with the automated data characterization and may be used to selectively override automated data characterizations. The user specified characterizations may be stored and used again without reentry by the user. Thus, the application may be regenerated without reentering characterization information. Once object characterizations are specified, a data source is then opened in step 604. The automatic program generation system creates a new data table 316 in the intermediary data source 314, step 606. Template data tables are created in step 608. The user may indicate repetitive data fields in step 610. If repeating values are indicated by the user in step 610 then a template lookup table is created in step 612 and linked with the other tables in step 614. The template lookup table does not actually contain the values of repeating data, but is structured to receive these data when they become available at run time. When the user indicates they are finished with data specification in step 616, the automatic program generator proceeds to step 618 and terminates. Once the data tables are built, the transaction objects 320 are processed and

GUI objects, associated queries and control objects are created as described in Figure 7. In step 702, each identifying and lookup table is processed. In processing step 704, a grid GUI object is built that contains each column of data. In step 706, a detail GUI object is created that contains all of the relevant source data 102 for a grid field. In step 708, a card GUI object is created. In step 712, a drop down list GUI object is created. In step 714, a tree GUI object is created. The application generation system tests for the presence of a date/time fields, step 716. Ifthere are data or time fields then a calendar object is created, step 718. In step 720, the application generation system looks for the presence of numeric data. If numeric data is detected then a graphical GUI object is created, step 722. In step 724, a report GUI object is created and is linked to a grid GUI object.

At step 726, query objects are created that provide access to the intermediary data source 314 to populate the GUI objects 320 with content data. In step 726, each query is also associated with an intermediary source data table and a related GUI object. In step 728, transaction object instances are created that assemble the GUI objects and associated query objects into fully functional view. If more fields remain, the program continues iterating, returns to step 702, and creates additional GUI objects. Ifthere are no remaining data fields then the program generator 104 continues to step 730 and terminates.

Figure 8 describes the processing steps for creating transaction objects that structure and link the GUI objects. In step 802, a GUI object transaction is created. The program generator creates a grid transaction in step 812 and links the grid elements to associated Detail GUI objects. In step 820, the program generator creates a card transaction and links the card GUI object with a n associated detail GUI object. In step 830, the program generator creates a tree transaction step 832, links the tree transaction with an associated card GUI object, and further links the associated card GUI with an associated detail GUI object. In step 840, the application program generator creates a report GUI object transaction, step 842. In step 850, the application program generator creates a graph transaction, step 852. And, in step 860, the application program generator creates a drop down list transaction, step 862.

Figs 9a-9e show screen displays from a generated application program 106 including component GUI objects 320. Figure 9a shows a screen display with a grid GUI object instance 902 and an associated detail record showing further information for a selected grid row 904. Here the application generation rules automatically link the grid view GUI object instance 902 with the detail view GUI object instance 904 allowing the user to 'drill- down' into the grid GUI object instance. In general, 'drill-down' operations occur when the user selects a GUI object element and requests further, more detailed information. Figure 9a also shows a full application program, implemented as a stand alone browser, that includes a fully functioning menu bar 906, short cut list 908, window controls 910, scroll bars 912, resize controls 914, a status line 916 and other application program controls which may be determined at runtime by the specific target environment.

Figure 9b shows a generated application program screen with a graph GUI object 930 displayed using the full application screen. Figure 9c shows a generated application program screen with a tree GUI object 940 and homepage GUI object 942 displayed. Figure 9d shows a generated application program screen with a calendar GUI object 950, detail GUI object 952, drag & drop GUI object 954 displayed. Figure 9e shows a generated application program screen with a card GUI object 962, detail GUI object 964 and tree GUI object 960 displayed.

While the invention has been described and illustrated in connection with preferred embodiments, many variations and modifications as will be evident to those skilled in this art may be made without departing from the spirit and scope of the invention, and the ; invention is thus not to be limited to the precise details of methodology or construction set forth above as such variations and modification are intended to be included within the scope of the invention.

Claims

WHAT IS CLAIMED IS:

1. A computerized method for generating an application program based upon a data source containing a data set, the method comprising: characterizing the data set in the data source; generating a plurality of GUI objects based at least in part upon the characterization of the data set; and integrating the GUI objects into an application program which may be executed to thereby allow access to and manipulation of the data set in the data source through the GUI objects.

2. The method of claim 1, wherein the step of characterizing the GUI objects comprises a user specifying one or more data characterizations, and the step of generating the GUI objects comprises generating the GUI objects based upon the one or more user specified characterizations .

3. The method of claim 1 , wherein the step of characterizing the data set comprises automatically detecting one or more GUI object types based upon a detected pattern in the data source, and the step of generating che GUI objects comprises generating the GUI objects based upon the one or more automatically detected GUI object types.

4. The method of claim 3, wherein the step of characterizing the data set by automatically detecting one or more GUI object types based upon a detected pattern in the data source comprises automatically detecting a date/time data field in the data set, and wherein the step of generating the one or more GUI objects comprises generating a calendar view GUI object based upon the presence of the date/time data field.

5. The method of claim 3, wherein the step of generating the one or more GUI objects comprises generating a grid view GUI object.

6. The method of claim 3, wherein the step of generating the one or more GUI objects comprises generating a list view GUI object.

7. The method of claim 3, wherein the step of characterizing the data set by automatically detecting one or more GUI object types based upon a detected pattern in the data source comprises automatically detecting a hierarchical data fields in the data set, and wherein the step of generating the one or more GUI objects comprises generating a tree view GUI object based upon the presence of the hierarchical data fields.

8. The method of claim 3, wherein the step of generating the one or more GUI objects comprises generating a graph view GUI object.

9. The method of claim 3, wherein the step of characterizing the data set by automatically detecting one or more GUI object types based upon a detected pattern in the data source comprises automatically detecting a text data field in the data set, and wherein the step of generating the one or more GUI objects comprises generating a report view GUI object based upon the presence of the text field.

10. The method of claim 3, wherein the step of characterizing the data set by automatically detecting one or more GUI object types based upon a detected pattern in the data source comprises automatically detecting a regular expression in the data set, and wherein the step of generating the one or more GUI objects comprises generating a specific GUI object based upon the presence of the regular expression.

11. The method of claim 3, wherein the step of characterizing the data set by automatically detecting one or more GUI object types based upon a detected pattern in the data source comprises automatically detecting a Uniform Resource Locator (URL) data field in the data set, and wherein the step of generating the one cr more GUI objects comprises generating a web page view GUI object based upon the presence of the URL field.

12. The method of claim 1 , comprising locating columns of data in the data set and storing the data set in a first table having a plurality of fields corresponding to the columns of data in the data set.

13. The method of claim 12, comprising identifying column headings representing the columns of data in the data set and assigning the column headings as field names for the corresponding fields in the first table.

14. The method of claim 12, comprising determining types of data for each column in the data set and assigning the data types to the corresponding fields in the first table.

15. The method of claim 12, wherein the step of detecting a characteristic of the data set comprises detecting repeated data values in any given field in the first table, and comprising generating a lookup table containing unique lookup values for the repeated data values in the given field.

16. The method of claim 15, comprising generating a lookup table containing unique lookup values for each field in the first table in which repeated values are detected.

17. The method of claim 15, wherein the step of generating the plurality of GUI objects comprises generating at least one GUI object for the first table and for each lookup table.

18. The method of claim 15, comprising generating one or more drop down list GUI objects from the unique lookup table values so that data from the data set that corresponds to the unique lookup table value may be viewed and manipulated as a group.

19. The method of claim 12, comprising generating one or more queries for each GUI object, the queries being associated with each providing access to the data set.

20. The method of claim 1, wherein the step of integrating the GUI objects comprises generating a plurality of transaction objects each defining display behavior of one or more GUI objects.

21. The method of claim 20, wherein the plurality of transaction objects each defining display behavior of one or more GUI objects includes transaction objects that coordinate GUI object views such that selecting a field in a first GUI object view that is coordinated with a second GUI object view causes a modification to the second GUI object view that indicates the coordination with the first GUI object view.

22. The method of claim 21, wherein the modification to the second GUI object view that indicates the coordination with the first GUI object view comprises expanding the data display of the second view to indicate drilling-down into the data.

23. The method of claim 20, wherein the step of generating a plurality of transaction objects is performed in accordance with a set of rules.

24. The method of claim 20, wherein the step of generating a plurality of transaction objects comprises generating at least one transaction object defining display behavior on a single screen display of a plurality of GUI objects, the at least one transaction object further defining interaction between the GUI objects defined in the at least one transaction.

25. The method of claim 1, wherein the step of generating the GUI objects comprises selecting one or more GUI object types from the group consisting of a list view object, a calendar view object, a grid view object, a card view object, a tree view object, a drag & drop view object, a drop down list object, a report view object, a graph view object, and a detail view object.

26. The method of claim 1, comprising retrieving the data source via a telecommunications connection.

27. A computer readable medium storing program code for causing a computer upon which the program code is executed to perform a method for generating an application program based upon a data source containing a data set, the method comprising: characterizing the data set in the data source; generating a plurality of GUI objects based at least in part upon the characterization of the data set; and integrating the GUI objects into an application program which may be executed to thereby allow access to and manipulation of the data set in the data source through the GUI objects.

28. A system for generating an application program based upon a data source containing a data set, the system comprising: means for characterizing the data set in the data source; means for generating a plurality of GUI objects based at least in part upon the characterization of the data set; and means for integrating the GUI objects into an application program which may be executed to thereby allow access to and manipulation of the data set in the data source through the GUI objects.