WO2018236940A1

WO2018236940A1 - Simplified development of computer applications

Info

Publication number: WO2018236940A1
Application number: PCT/US2018/038377
Authority: WO
Inventors: Jonathan Bannon Maher
Original assignee: Pagerock, Inc.
Priority date: 2017-06-20
Filing date: 2018-06-19
Publication date: 2018-12-27

Abstract

Embodiments of the invention relate to the field of computer software application and website development.

Description

SIMPLIFIED DEVELOPMENT OF COMPUTER APPLICATIONS INVENTOR JONATHAN BANNON MAHER

TECHNICAL FIELD

[0001] Embodiments of the invention relate to the field of computer software application and website development.

REFERENCE TO RELATED DOCUMENTS

[0002] This application is provided the benefit and priority date of United States Patent and Trademark Office provisional patent application number 62/522,667, filed June 20^th 2017 by inventor Jonathan Bannon Maher, which is incorporated herein in its entirety.

BACKGROUND

[0003] This section is intended to introduce the reader to various aspects of the art that may be related to various aspects of the present techniques, which are described and or claimed. This discussion is believed to be helpful in providing the reader with background information to facilitate a better understanding of the various aspects of the present disclosure. Accordingly, it is understood that these statements are to be read in this light, and not a citation of prior any art.

[0004] Developing custom software applications and websites currently generally requires technical expertise. Furthermore, current methods of website and software development either integrate the programming of the front end displayed to the user, and the backend supporting display and processing of interactions with the front end, or allow for separation of the front end from the back end, but in all cases, require custom programming to create customized robust software applications and websites.

BRIEF DESCRIPTION OF THE ILLUSTRATIONS

[0005] An embodiment of the invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings, and embodiments may not contain all components, may contain additional components, and may contain functionally similar components.

[0006] FIG. 1 is an example of an embodiment of a screen produced by the integration function utilizing the template, settings, and content.

[0007] FIG. 2 is an example of an embodiment of a screen produced by the integration function displaying a form utilizing the template, settings, and content.

[0008] FIG. 3 is an example of an embodiment of a screen produced by the integration function displaying a table utilizing the template, settings, content, and a data source.

DETAILED DESCRIPTION

[0009] It is understood that, as in any engineering or design project, the development of any actual implementation will include numerous implementation specific decisions made to achieve the developers' specific goals, such as compliance with business related and system related constraints, which may vary from one implementation to another. It is understood that such a development effort might be complex and time consuming, but is nevertheless a routine undertaking of design, fabrication, and manufacture for those skilled in the art having the benefit of this disclosure. The disclosed steps may be read as prefaced by "In some embodiments, including one complete embodiment, ", may be executed or performed in other orders or sequences, and are not limited to the order and sequence shown and described, which are provided to enable ease in constructing an embodiment, and along with each components of each step, may be removed, modified, combined, or rearranged, and other steps and or step components may be added, without departing from the scope of this disclosure and or invention. Although embodiments of the invention have been described and illustrated in the disclosed implementations, it is understood that the present disclosed subject matter, including apparatuses, methods, specification, and illustrations, has been made only by way of example, not by way of limitation, and the methods and apparatuses may be used in other systems, and that numerous changes and optimizations in the details of implementation of the invention and or embodiment are made without such modifications departing from the spirit and scope of this disclosure and or embodiments of the invention. Although the disclosure has been shown and described with respect to one or more embodiments, features of the disclosed embodiments can be combined and rearranged in various ways, and changes including equivalent alterations, substitutions, modifications, and additional efficiencies will of course occur to someone of ordinary skill in the art without departing from the spirit and scope of this disclosure and or invention. In particular regard to the various functions performed by the described components, the terms used to describe such components are intended to correspond, unless otherwise indicated, to any component which performs the specified function of the described component, or is functionally equivalent to the described component, even though not structurally equivalent to the disclosed structure which performs the function in the implementations described in this disclosure. In addition, while a particular feature of the disclosure may have been provided with respect to only one of several embodiments, such feature may be combined with one or more other features of other embodiments as may be desired and advantageous for any given or particular application. In some instances, well-known circuits, structures and techniques have not been shown in detail in order not to obscure the understanding of this disclosure. Articles in this disclosure such as "a" "an" and "the" may allow for both singular and plural forms. Verbs in this disclosure such as "is" may be read as "may be". Conjunctions in this disclosure such as "or" as used herein may be interpreted as inclusive or meaning any one or any combination, where "A, B or C" means "any of the following: A; B; C; A and B; A and C; B and C; A, B and C". Relational terms in this disclosure, for example first and second, top and bottom, left and right, are to distinguish one entity or action from another, and may not necessarily require or imply a relationship, or order between, such entities or actions. The disclosure includes the best mode contemplated by the inventor, a completely described specific embodiment, along with optional components and alternative embodiments to best suit the implementer, measurements in imperial and metric units to support universal understanding, and dramatically exceeds claims support requirements and enablement requirements by allowing for selection and or construction of the required components to be carried out easily, quickly, and routinely by persons of ordinary skill in the art, who are provided the additional benefit of utilizing readily available commodity components whenever possible. The present disclosure includes material protected by copyrights, and the owner of the copyrights hereby reserves all rights, but with authorization for publication as required by government patent offices. Various embodiments of the present invention may provide all, some or none of the disclosed technical advantages.

[0010] The computer code descriptions disclosed, in order to provide comprehensive enabling disclosure, rather than utilizing flow charts, which according to Patent Cooperation Treaty 11.11a are prohibited from containing "text matter, except a single word or words, when absolutely indispensable, such as... a few short catchwords indispensable for understanding", are provided in a text only format where the number of arrows preceding a line indicate logical block level, semicolons indicate a new segment of a logical block, and periods indicate the closure of one or more logical blocks. It is understood that any computer code representations in this disclosure are merely illustrative, rather than restrictive. While code may be written in nearly any computer language, including Java and C++, the illustrative computer code descriptions were derived from code written the Python language, which may be run through the Python interpreter, with appropriate supportive libraries, which at the time of disclosure, may run on nearly any computer, for example one with an Intel or AMD processor, running a current version of Linux, Windows, or Mac OS. All code components may read as if prefaced by "In some embodiments, including one complete embodiment, ". In some embodiments, functionality may be modified, rearranged, excluded, and added. To provide more fundamental computer system details, in some embodiments, the functionality associated with the disclosed computer code descriptions may be referred to as a script, module, software, software application, or code, and can be written in any form of language, including compiled, interpreted, declarative, or procedural, able to be deployed in any form suitable for use in a computing environment, including as an independent or integrated program, module, component, or subroutine, for execution by the computer system, implemented on one or more independent or integrated computers, utilizing a central processing unit in the form of one or more general or special purpose microprocessors, in conjunction with digital electronic circuitry, which may include special purpose logic circuitry such as a field programmable gate array or application specific integrated circuit, with the computer controlled by and operatively coupled to tangibly embodied software and or firmware, which may include code that creates an environment for code execution, including individual or combined use of processor firmware, a protocol stack, a database management system, and an operating system, where such software and or firmware may exist in one or more parts in memory on one or more computers, and is encoded on one or more tangible non transitory software carriers, such as individual or combined use of a random or serial access device or substrate, a semiconductor memory device, transient or persistent random access memory, a magnetic, magnetic optical, or optical disk, or encoded on an artificially generated transmitted signal, for example, optical, electrical, or electromagnetic, transmitted using a sending and a receiving apparatus, where the interaction between the user and the software may be implemented by operatively coupling, to the local implementing computer, or a local computer connected to one or more remote computers through a local or wide area network, a display device which may implement fluid crystals or light emitting diodes, a keyboard, and a pointing device.

[0011] The inventor retains absolutely no liability for any implementation of this invention, and the invention is implemented exclusively at the risk and liability of the implementer. [0012] Embodiments of the invention are the first to allow for fully separated non-repeating re-useable custom template components that can be assembled by an integrator, using assembly instructions specified in the content, with user interaction handled by a processor, using processor instructions specified in the content, thereby requiring no custom software development to develop full software applications. More specifically, this is accomplished by providing an integrator that takes a template, a content file that optionally specifies template components, which optionally specify one or more sources of data, optional menu and settings data, with the integration function generating a unified output presented to the user, and a processor function that handles data submissions by adding or modifying data sources and records, and that can be extended through optional custom libraries. The content text, menu text, and settings text, are all written in standard natural language, means that no programming or technical expertise is required to produce robust software applications. Additionally, rather than having to define one template per application screen, the system provides the advantage of unprecedented separation and simplicity of the template structure, by creating individual non-repeating template components that can be re-used across the entire application, with components specified in the content. This is the first invention to allow an entirely non-technical user to create fully featured applications and websites in a generic text editor by writing in basic non-technical text format.

[0013] Embodiments are equally applicable to desktop software, mobile device software, and web based software, and may run either as an integrated whole, or server side, where the integration is completed before the screen is presented to the user, and or client side, where the data is integrated with the template through a client side implementation of the integration and or processing functions.

[0014] In some embodiments, including one complete embodiment, create an optional settings file. In some embodiments, including the one complete embodiment, settings text is maintained in plain text format, that optionally specifies settings to be integrated by the processor function, and or the integrator function into the template in specified corresponding placeholders before the output is displayed to the user, with example settings comprising:

> application title;

> application logo image file name;

> application background color; > database IP address;

> database name;

> the database username;

> database password.

[0015] In some embodiments, including one complete embodiment, create optional menu text. In some embodiments, including one complete embodiment, menu text is contained in a text format containing linked application screens, and link titles, to be displayed in the application menu, where for example when displaying in HTML, the format for menu items is one item per line, with the link, then the title, where example menu text contains titles and corresponding links comprising:

> / home

> /about/ about

> /order/ order

> /contact/ contact

[0016] In some embodiments, including one complete embodiment, create content text.

In some embodiments, including one complete embodiment, content text is provided, which contains data that will be integrated by the integrator into template components for display to the user, where the content text may specify plain text, one or more template items such as a form or a table, which specifies one or more data sets, where data sets may be in any format, which may include CSV, JSON, and SQL statements that return RDBMS objects containing data sets, and provide data rows that can be integrated into a template item specified surrounding the data set.

[0017] In some embodiments, including one complete embodiment, an example of a content file is where the first text block is identified as plain text content that will be displayed as presented to the user because it is not specified inside a template component, a second text block is data to be displayed through a template component as identified by enclosing tags that indicate which template component the data is to be integrated into, where for example, to display values inside the template's table template, if the format is HTML, the tag around the data could be "<template:table>" and "</template:table>", with data in formats including CSV, JSON, or a Structured Query Language data request to the data source specified in the previously disclosed settings file returning data, where the data is integrated for display into the specified template component. In some embodiments, including one complete embodiment, the example text has content comprising:

> a first line containing the text "Welcome to our Company".

> a tag indicating the start of a table, for example "<template:table>".

> a first data record containing the separated data to be displayed in columns within the table, for example "joe.jpg","CEO","Joe Smith".

> a second data record containing the separated data to be displayed in columns within the table, for example "bob.jpg","CFO","Bob Jones".

> a tag indicating the end of a table, for example "</template:table>".

[0018] In some embodiments, including one complete embodiment, create content text specifying display in a form template. In some embodiments, including one complete embodiment, a content file specifies data fields and settings for a form, to be processed by the integrator, into the form template, for display to the user, with the text comprising:

> a title.

> a tag indicating the start of a table template data is to be integrated into.

> the name of a first data type, followed by the name of the corresponding data store field, followed by the display title of the data field, for example "text credit card number Credit Card Number".

> the name of a first data type, followed by the name of the corresponding data store field, followed by the display title of the data field, for example "text credit card number Credit Card Expiration".

> the name of a first data type, followed by the name of the corresponding data store field, followed by the display title of the data field, for example "text amount Amount".

> the text "processor extension" followed by the name of an external processor to pass the data to, for example "credit_card_processor.py", to indicate that the submitted form data should be passed to a processor extension to process a credit card transaction.

> a tag indicating the end of data to be integrated into the table.

[0019] In some embodiments, including one complete embodiment, create a template file. In some embodiments, including one complete embodiment, a template is provided which may contain sub templates, which may contain any level of nested sub templates, for any graphical user interface element, where each sub template within the main template may be integrated with any data set by the integration function, and the template may be in any computer code format, including HTML as used in the example template, and contains enclosed sections for each graphical user interface component, such as tables, forms, and images, where the enclosed sections are identified by starting and ending tags, such as "<template:item>" and "</template:item>", and "item" is a name for the template item. In some embodiments, including one complete embodiment, within the template, the location of the values to be inserted is identified with the name of the value to be inserted identified by a method such as a double underscore on either side of the value to be replaced value . In some embodiments, including one complete embodiment, the template contains functionality comprising:

> specify the content type of the template, for example "<html>".

» provide a screen title place holder, for example "<title> title </title>".

» initialize the main screen body, for example "<body>".

» define the menu template, for example "<template:menu><table>";

»> define the menu item template including placeholders for label and value, for example

" <template : menu_item><tr><td><a

href=" link "> value </a></td></tr></template:menu_item>";

» close the menu template, for example "</template:menu>".

» define the table template, for example "<template:table><table>";

»> define the table header tow template, for example "<template:table_header><tr>";

»» define the table header row item template including a value placeholder, for example

"<template:table_header_item><td><b> value <^</td></template:table_header_item>"

»» close the header row item template, for example "</tr></template:table_header>"; »> close the header row template, for example "</tr></table_header>".

»> define the table row template, for example "<template:table_row><tr>"

»» define the table row item template, for example

"<template:table_row_item><td> value </td></template:table_row_item>";

»» define the table row administration options item template including update and delete, for example "<table:table_row_administration><td><a

href="/?action=update&id= value ">update</a> <a

href="/?action=update&id= value ">delete</a></td></table:table_row_administration>"; »> close the table row template, for example "</table:table_row>".

» close the table template, for example "</template:table>".

» define the form template, for example "<template:form><table>"

»> define the form row template, for example "<template:form_row><tr>"

»» define the form row item template including a place holder for field name and a user input box, for example "<template:form_input><td><input type=text

name= name > value </td></template:form_input>";

»» close the form row item template, for example "</template:form_row_input>".

»> define a hidden field for email to send form submission notification to and define a placeholder value, for example "<input type=hidden name=email_notification

value= value>";

» close the form template, for example "</template:form>".

» close the template body definition, for example "</body>".

> close the template definition, for example "</html>".

[0020] In some embodiments, including one complete embodiment, optionally create a translation function. In some embodiments, including one complete embodiment, a content translator is provided, where the complete separation of the content from the rest of the application allows for the content to be easily run through an external translation service to display content in any language. The computer code function may take three parameters, the text, the source language and the destination language. In some embodiment, the translation results are stored locally so as to reduce calls to an external translation service. In some embodiments, including one complete embodiment, software providing translations provides functionality comprising:

> define a function to translate content that accepts parameters including source language, destination, and text to translate;

» encode the text to translate for transit;

» prepare a call to retrieve a translation of the text that includes the address of the translation service, the source and destination languages, and the text to translate;

» read the translated text provided to the translation address;

» return the translation result to the requesting function. [0021] In some embodiments, including one complete embodiment, create the software code providing the integrator function and the processor function. In some embodiments, including one complete embodiment, an integrator function is created, which is computer code, written in any language, that reads in the template content and replaces values in the template, with text from the content file, and any specified text data and data from data sources and data stores, for example tables in a relational database management system, and returns the resulting output for display to the user, where the integrator can either run on the client side, for example through a scripting language like JavaScript, or native mobile application code, or the server side, in nearly any computer language. In some embodiments, including one complete embodiment, computer code is created that processes all user data submissions, accessed by passing form values by the server, where the processor takes each field and corresponding value submitted by the form, and as specified in the submission, may save them to a data store table, write them to a file, and email the submitted data, with the email address and file name specified in hidden fields submitted as part of the form. In some embodiments, the integrator and or processor is accessed as an internally integrated function within a mobile or desktop application. In some embodiments, including one complete embodiment, an action may be specified in a hidden field in the form, along with a corresponding code file name, to further utilize an external code file for processing, where such code files may be provided as a library and or custom developed, and if a corresponding code file is found, fields and data are passed to an instance of the class contained in the code file to perform additional functions, such as processing a charge on a credit card that was submitted with the form. It is therefore possible using basic text to create a custom order form on a website, have it save to an orders table, and have a credit card charge processed. In some embodiments, including one complete embodiment, the computer code is executed on an Internet connected server, started from the command line, that binds to the IP address of the server to provide an interface through a web browser over standard HTTP or HTTPS ports. In some embodiments, user interface rendering and interaction may be performed by means including native application code, or rendering user interfaces inside the application from a format such as HTML. In some embodiments, including one complete embodiment, this functionality is provided through software code providing functionality comprising:

> optionally import the previously created translation library;

> define a function to display the user interface; » define an array to hold the content segments to be integrated;

» define an array to hold the template components to be integrated;

» define a variable to hold the compiled output to display to the user;

» define a variable and set it to any additional action specified with the request;

» read the template definition to a variable;

» initialize a variable for the application title;

» initialize a variable for the application background color;

» read the optional application settings text and set variables for the application including title and background color to those settings;

» replace the template placeholder values for application title and background color equal to those provided in the settings file;

» initialize an array of template item components, and split the template into an array of components, utilizing the established tag that distinguishes the start of a template component; » iterate through each item in the template array;

»> set the name of the template item to the name specified in the template identification tag; »> set the template array item, at index of the template item name, equal to the content of the current item, between the start and end tags;

» if there is menu text specified, integrate the menu items' titles and links into the menu item template, and then integrate the integrated menu items into the menu template, and replace the menu in the template with the integrated menu;

» read in the content file for the specified screen;

» create a content array, by splitting the text in the content file by template tag;

» for each item in the content array, identify any template component for the content, remove the template tags from the content, and insert the content into the appropriate template component placeholders;

»> if the content type is a form, retrieve the form template, split the form data into rows of field type, field name, and field label;

»» create a variable to hold the integrated form rows;

»» iterate through each row in the form;

»»> integrate form fields into the form template row place holders, integrate the form rows into the form, and add the integrated form row to the complied form rows variable; »» integrate the integrated form rows into the form template, and add the integrated form to the variable holding the output to be returned to the user; »> if the content type is a table, retrieve the table template, split the table data into rows; »> create a variable to hold the compiled table rows;

»» iterate through each row of the table

»»> add a table row to the variable holding compiled table rows by replacing template components with the corresponding data;

»» integrate the table rows into the table, and add the integrated table to the output;

»> if there is no content type associated with the content item, simply add the content item text to the output;

» delete all remaining unintegrated template items from the output;

» display the complied output screen to the user.

> define a function to process user interactions;

» import the appropriate data store library;

» create an account ID variable, and if a session ID is provided, retrieve and store the associated account ID to the account ID variable;

» read in the values posted from the user interface, which may include the requested action, the ID and file name of the record to acted upon;

» if the action is to start, verify that the accounts table exists in the data store provided in the application settings, and if not send a command to the data store that creates the accounts table with fields of email address and password, as well as the sessions table with fields of account ID and session ID, then check if the provided email address is listed in accounts, and if not, create an account, and if it is, verify the password is correct for the account with the provided email address, then if a new account was created, or an existing account with a matching password was found, create and associate with the account and record a session ID, record the account ID and session ID to the sessions table, and provide it to the user interface to include with requests;

» if a record ID number is provided, and the action isn't to delete the record, default the action to update;

» establish a variable to hold the content;

» check if the file name contains an extension, for example ".db", that indicates it is a table name in the data store;

» if a data store table was specified, set the data store table name to act upon equal the provided file name less the extension indicating it is a database table; » ask the data store if the structure exists, and if the data store structure doesn't exist, execute a command to create it with the fields provided by the form, by iterating through each field to build a create data structure statement, such as a create table SQL statement, then execute the statement on the data store;

» if the requested action is to insert the submitted data as a data store record, build an insert statement, such as an SQL insert statement, by iterating through the field value pairs of the form, and if applicable include the field for account ID and its associated value, and execute the statement on the database;

» if the requested action is to update the record in the database, build and execute an update statement, such as a SQL update statement, by iterating through the form fields and using the ID provided by the form as the ID of the record in the database;

» if the action is to delete, build and execute a delete statement, such as a SQL delete statement, to delete from the specified data structure the record with the matching ID;

» proceed if the file name does not indicate a database table;

» if the specified file doesn't exist, create it and write a header row to it of the list of form fields;

» create a record as a text string by iterating through the form values;

» if the action is insert, read in the specified file if it exists and determine the ID number for the new record, otherwise start with a record ID of 1, and create the file with a header row consisting of a comma separated list of field names;

» if the action is to update the record, read in all records in the file, and replace the one with the ID with the new record with the same ID;

» if the action is to delete the record, read in all the records, then overwrite the file with all records except the one with the specified ID;

» if a processor extension was specified in the form, create an instance of the named class and call the associated name function with the submitted data fields and values;

» if a notification email address was specified, create a text string for the message body containing the form field value pairs, and call the email library to send the message;

» redirect the user back to the submitting page or display a message such as one indicating the requested actions have been performed.

[0022] In some embodiments, including one complete embodiment, build an optional extension to the processor. In some embodiments, including one complete embodiment, an optional extension to the processor function is implemented, which may contain and execute external code. If the content file specifies an action in a hidden field, and that action corresponds to a code file, that named code file and associated class and main function will be passed the submitted data. In some embodiments, including one complete embodiment, an example of an extension to the processor provides functionality comprising:

> define a class to extend the processor by executing credit card transactions;

» define a function to extend the processor by executing credit card transactions that accept as parameters the form fields and values;

»> import the credit card processing company's application programming interface (API); »> execute the credit card transaction through the imported API.

[0023] In some embodiments, including one complete embodiment, run the code to start the application. In some embodiments, including one complete embodiment, once the code is complete, it may be started in the manner corresponding to the language used and or type of application created. In some embodiments, where the code is written in Python, and saved as "application. py", the application may be started by typing at the command line "python application. py" and pressing enter.

[0024] In some embodiments, including one complete embodiment, verify displayed output of main screen. In some embodiment, including one complete embodiment, in reference to FIG. 1, an example of output provided by the integrator to the user is displayed combining the menu, settings, content or translation of content, and template in the manner previously described, with title 1000, menu 1001, plain text 1002, an integrated table 1003, and additional links 1004.

[0025] In some embodiments, including one complete embodiment, view displayed output of form. In some embodiments, including one complete embodiment, in reference to FIG. 2, an example of a generated form is displayed as a result of the integration function bringing together the content text, menu text, and settings text, where the generated order form may now be filled out and submitted to the processor function, including title 2000, integrated form 2001, and menu 2002. [0026] In some embodiments, including one complete embodiment, review form processing to file. In some embodiments, including one complete embodiment, an example of the data text that results from the form data being posted to the processor would be displayed, where the first row in the file is the names of the fields, and is only added when data is added, if the file doesn't exist, where the first text line contains sample titles for the data columns of "Name,Address,Product", the second text line contains sample values for the data columns of "Joe Smith, 1 Birch Street, Annual Membership", and the third test line contains additional sample values for the data columns of "Bob Jones,34 Main Street,Annual Membership".

[0027] In some embodiments, including one complete embodiment, review form processing to data table. In some embodiments, including one complete embodiment, an example of an alternate embodiment and representation of form data storage in a database management system is contained in Data Table Orders, and if the table doesn't exist, it is created with the field names that are specified in the content, which for example contains sample titles for the data columns of "Name,Address,Product", sample values for the data columns of "Joe Smith, 1 Birch Street, Annual Membership", and sample values for the data columns of "Bob Jones,34 Main Street, Annual Membership".

[0028] In some embodiments, including one complete embodiment, verify display of processed form data. In some embodiments, including one complete embodiment, an example of content text to display data for orders that were submitted by the generated order form, with data comprising:

> a tag specifying use of the table template component in presenting the data, for example "<template:table>".

> the name of the file containing formatted data to insert into the template, for example "Orders. csv".

> a closing tag for the template indicating there is no more data to include, for example "</template:table>".

[0029] In some embodiments, including one complete embodiment, in reference to FIG. 3, the output described may reassemble the output an example of output to the user as a result of the integration of previously described components in the example code in Displayed Output Orders Received, where the first displayed component is the title of the application taken from the settings file 3000, the second displayed component is the menu generated for the application from the menu file 3001, the third displayed component is the plain text title set by the user to display above the table from the content file 3002, the fourth displayed component is the data from the orders file displayed after integration with the table template 3003.

Claims

CLAIMS What is claimed is:

1. A system providing for computer application user interface creation, in contrast to current methods utilizing one template per screen rather than per application, with the invention comprising:

a user interface template containing reuseable individual user interface component templates;

application settings, which may include including menu items and data store location and credentials;

application content, able to specify template components the content should be integrated into, where content may be composed of one or more components including text, a referenced data file, a data store query;

integrating said application settings and said application content into said application template and displaying the result to the user.

2. A non-transitory computer-readable recording medium holding stored instructions, which when executed by one or more processing devices, cause the one or more processing devices to implement a method comprising:

a memory which is able to store a series of characters including template information, content information, and data in a structured format; a memory controller which combines said template and said content along with any associated data stored in memory;

a display which is operatively connected to said memory for displaying the integration of said template, said content and any associated data.

3. A system providing computerized processing of the submitted computer data, in contrast to current methods requiring pre-defined structures, with the improvement comprising:

a data submission processor that accepts the submission of data, and optionally emails said data, optionally passes said data to another data processor, and optionally records said data to a data store including automatically creating if none exists a data store structure comprised of submitted fields, or adjusting said data structure to add new submitted fields, and adding the new data record. A machine for processing input from a user interface comprising:

a memory that is able to store data structures and associated records consisting of characters, and add fields to said data structures in memory if they are submitted by the user and don't already exist, and is able to add a data record to memory.