Patent Application
20130067432
This disclosure pertains to an application development toolkit configured to enable generation of an application using core, services, and user interface components.
Web applications are applications that are coded in a browser-supported language, e.g., hypertext markup language (HTML), JavaScript, and the like. A user will typically access web applications using a browser over a network. Web applications are popular due to the ubiquity of clients and because they are centrally updated at the host, eliminating the need for local deployment and update. Common web applications include webmail, chat, online retail sales, online auctions, blogs, online discussion boards, and the like.
Native applications, by contrast, are applications that are coded in an operating system supported language, e.g., C, C++, and the like. Native applications rely on the operating system to execute the native applications' code, resulting in applications that tend to be more functional and more responsive than corresponding web applications. The user typically may access native applications locally on the clients. The user may maintain native applications by installing available updates to a memory device local to the client. Manufacturers often initially install native applications before shipping the product, particularly in mobile communication devices.
Developers often seek tools that facilitate the design and development of both web applications and native applications.
The following is a summary to present some aspects and concepts associated with an exemplary application development toolkit as a prelude to the more detailed description of the same presented below. The summary does not identify key or critical elements nor does it delineate the scope of the exemplary application development toolkit.
The present disclosure describes an application development toolkit that, in one embodiment, includes a memory device configured to store programming constructs of a scripting language. The programming constructs may define an application. The application development toolkit includes a processing device configured to dynamically generate, in the memory device, an abstract tree structure including at least a portion of the programming constructs that define logic components of the application. The processing device is further configured to build a user interface for the application by concatenating user interface components received from the at least a portion of the programming constructs included in the abstract tree structure.
Additional aspects and advantages of an exemplary application development toolkit will be apparent from the following detailed description that proceeds with reference to the accompanying drawings.
Exemplary application development toolkit provides developers tools that facilitate the design and development of applications. Exemplary application development toolkit includes a memory device configured to store programming constructs of a scripting language. The programming constructs may be configured to define an application. The application development toolkit further includes a processing device configured to dynamically generate, in the memory device, an abstract tree structure including at least a portion of the programming constructs that define logic components of the application. The processing device is further configured to build a user interface for the application by concatenating user interface components received from the at least a portion of the programming constructs included in the abstract tree structure.
Moreover, a person of ordinary skill in the art will recognize that the exemplary application development toolkit may be implemented on other types of computing architectures, e.g., general purpose or personal computers, hand-held devices, mobile communication devices, multi-processor systems, microprocessor-based or programmable consumer electronics, minicomputers, mainframe computers, application specific integrated circuits, and like. For illustrative purposes only, system 100 is shown in
Similarly, a person of ordinary skill in the art will recognize that the exemplary application development toolkit may be implemented in a distributed computing system in which various computing entities or devices, often geographically remote from one another, e.g., computing device 102 and remote computing device 102R, perform particular tasks or execute particular objects, components, routines, programs, instructions, data structures, and the like. For example, the exemplary application development toolkit may be implemented in a server/client configuration (e.g., computing device 102 may operate as a server and remote computing device 102R may operate as a client). In distributed computing systems, application programs may be stored in local memory 106, external memory 136, or remote memory 134. Local memory 106, external memory 136, or remote memory 134 may be any kind of memory known to a person of ordinary skill in the art including random access memory (RAM), flash memory, read only memory (ROM), ferroelectric RAM, magnetic storage devices, optical discs, and the like.
The computing device 102 comprises processing device 104, memory 106, device interface 108, and network interface 110, which may all be interconnected through bus 112. The processing device 104 represents a single, central processing unit, or a plurality of processing units in a single or two or more computing devices 102, e.g., computing device 102 and remote computing device 102R. The local memory 106, as well as external memory 136 or remote memory 134, may be any type memory device including any combination of RAM, flash memory, ROM, ferroelectric RAM, magnetic storage devices, optical discs, and the like. The local memory 106 may include a basic input/output system (BIOS) 106A with routines to transfer data, including data 106E, between the various elements of the computer system 100. The local memory 106 also may store an operating system (OS) 106B that, after being initially loaded by a boot program, manages other programs in the computing device 102. The local memory 106 may store routines or programs, e.g., the exemplary application development toolkit 106C, and/or the programs or applications 106D generated using the toolkit. The exemplary application development toolkit 106C may make use of the OS 106B by making requests for services through a defined application program interface (API). The exemplary application development toolkit 106C may be used to enable the generation or creation of any application program designed to perform a specific function directly for a user or, in some cases, for another application program. Examples of application programs include word processors, database programs, browsers, development tools, drawing, paint, and image editing programs, communication programs, and tailored applications as the present disclosure describes in more detail below, and the like. Users may interact directly with the OS 106B through a user interface such as a command language or a user interface displayed on a monitor (not shown).
Device interface 108 may be any one of several types of interfaces. The device interface 108 may operatively couple any of a variety of devices, e.g., hard disk drive, optical disk drive, magnetic disk drive, or the like, to the bus 112. The device interface 108 may represent either one interface or various distinct interfaces, each specially constructed to support the particular device that it interfaces to the bus 112. The device interface 108 may additionally interface input or output devices utilized by a user to provide direction to the computing device 102 and to receive information from the computing device 102. These input or output devices may include keyboards, monitors, mice, pointing devices, speakers, stylus, microphone, joystick, game pad, satellite dish, printer, scanner, camera, video equipment, modem, monitor, and the like (not shown). The device interface 108 may be a serial interface, parallel port, game port, firewire port, universal serial bus, or the like.
A person of skill in the art will recognize that the system 100 may use any type of computer readable medium accessible by a computer, such as magnetic cassettes, flash memory cards, digital video disks, cartridges, RAM, ROM, flash memory, magnetic disc drives, optical disc drives, and the like.
Network interface 110 operatively couples the computing device 102 to one or more remote computing devices 102R, tablet computing devices 102T, mobile computing devices 102M, and laptop computing devices 102L, on a local or wide area network 130. Computing devices 102R may be geographically remote from computing device 102. Remote computing device 102R may have the structure of computing device 102, or may operate as server, client, router, switch, peer device, network node, or other networked device and typically includes some or all of the elements of computing device 102. Computing device 102 may connect to the local or wide area network 130 through a network interface or adapter included in the interface 110. Computing device 102 may connect to the local or wide area network 130 through a modem or other communications device included in the network interface 110. Computing device 102 alternatively may connect to the local or wide area network 130 using a wireless device 132. The modem or communications device may establish communications to remote computing devices 102R through global communications network 130. A person of ordinary skill in the art will recognize that application programs or modules 106C might be stored remotely through such networked connections.
The present disclosure may describe some portions of the exemplary application development toolkit using algorithms and symbolic representations of operations on data bits within a memory, e.g., memory 106. A person of skill in the art will understand these algorithms and symbolic representations as most effectively conveying the substance of their work to others of skill in the art. An algorithm is a self-consistent sequence leading to a desired result. The sequence requires physical manipulations of physical quantities. Usually, but not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. For simplicity, the present disclosure refers to these signals as bits, values, elements, symbols, characters, terms, numbers, or like. The terms are merely convenient labels. A person of skill in the art will recognize that terms such as computing, calculating, generating, loading, determining, displaying, or like refer to the actions and processes of a computing device, e.g., computing device 102. The computing device 102 may manipulate and transform data represented as physical electronic quantities within a memory into other data similarly represented as physical electronic quantities within the memory.
Modules, as described herein, refer to any programming construct, abstract or otherwise, including objects, components, routines, programs, instructions, data structures, and/or the like that define a compilation of attributes and behaviors, that bring together data with the procedures to manipulate them, that perform particular tasks or functions, or that implement particular abstract data types. Modules may be written in any programming language known to a person of ordinary skill in the art, including any scripting language such as JavaScript, VB Script, Jscript, XUL, Ajax, and the like. Some or all of the modules may be instantiated at run time by, e.g., a processing device 104 (
Exemplary application development toolkit 200 may dynamically create content for tailored applications in response to an abstract tree structure that represents at least some of the modules the present disclosure describes in detail below. Exemplary application development toolkit 200 may include modules that build and maintain the abstract tree structure in response to one or more conditions, for example, the plurality of entry points to the application, a universal reference locator for the application, a state of an operating system associated with the application, a state of the application, an action of a user, a hardware configuration of the computing device, or the like.
Exemplary application development toolkit 200 may be logically organized as three groups of modules: core modules 204, services modules 206, and user interface modules 208. Core modules 204 may be those modules used to create tailored applications. Services modules 206 may be those modules that are optional to generate or create tailored applications. User interface modules 208 may include modules responsible for the generation of user interfaces for tailored applications. Together, core modules 204, services modules 206, and user interface modules 208 provide a common framework from which to generate, design, or define tailored applications.
The present disclosure initially focuses on a description of three specific modules, namely, component tree module 231 and component module 230 included in user interface modules 208 and the tree node module 215 included in core modules 204.
A tree may be an abstract structure that uses a set of linked nodes to represent relationships between modules, objects, units, entities, elements, individuals, or the like, each represented by a node. Each node in a tree has zero or more child nodes, which are below it in the tree (by convention, trees are graphically represented growing downwards). A node that has a child is called the child's parent node. A node has at most one parent. A node without a parent is termed the root node, typically shown at the top of the tree.
A processing device, e.g., processing device 104 of
Tailored applications are built from various user interfaces, data components, and logic components. The World Wide Web Consortium (W3C) Document Object Model (DOM) standard is a platform and language-neutral interface that allows programs and scripts to dynamically access and update the content, structure, and style of a document that make up the user interface. Under DOM, an HTML tree may be used to describe the relationship between various user interface elements. Component tree module 231, in contrast, may be configured to build and maintain an abstract tree structure of logic components that define the tailored application. Logic components, in this context, may be modules that define the behavior or functionality of a tailored application. Logic components may include any of the modules that the present disclosure describes in detail below, either alone, or in combination with other modules.
An exemplary logic component tree may be built from tree nodes 215, e.g., JavaScript objects.
At run time, the processing device 104 may execute the application to build the tree structure based on various parameters, such as a plurality of entry points to the application, a universal reference locator for the application, a state of the OS associated with the application, a state of the application, an action of a user, a hardware configuration of the computing device, or user data, e.g., user name or chat history.
Entry points, as used herein, may refer to specific locations within an application where an end user enters the application experience. An entry point may be represented within the user interface using various elements, e.g., an image, title string, descriptive string, and the like. An entry point also may have an associated category that determines a location in the user interface where the entry point appears. Each application may have multiple entry points. At a minimum, an application may have a single entry point that opens the application's main view or main scene. An application may be launched with the same entry point from multiple locations within the OS.
Since each of the modules is self-contained, each module may be configured to implement its own policies for DOM caching depending on the context in which the processing device instantiates the module. Each of the modules the present disclosure describes herein may have different lifetime stages including construct, initialization, or shutdown and may have different user interface stages including initialize the user interface and shutdown the user interface. Each of the modules may attach or detach component nodes 215 from component tree module 231 based on lifetime, user interface stages, and the like. Examples of component node 215 APIs to manage attaching and detaching from the tree include appendChild( )and removeChild( ) described in more detail below.
Component module 230 may be an object configured to be used as a prototype to other objects to create the logic components used by component tree module 231 to build and maintain the tree structure. Component module 230 may be configured to handle logic components of the application, e.g., DOM lifetime, commands, and the like. Component module 230 may be configured to only directly communicate with children, example ChatApp 302 and ChatMeBar 304 (
Component module 230 may be built from objects as follows:
Component module 230 may have the following properties:
Tree node module 215 may be an object configured to implement a tree node with parent and children. Each node in a tree may have none or many children nodes, and at most, one parent node. Put differently, a node that has a child node is a parent node.
Tree node module 215 may have the following properties:
Referring to
Referring back to
As previously indicated, core modules 204 may be those modules used to create tailored applications. In addition to tree node module 215, core modules 204 may include object oriented module 210, attribute module 211, base module 212, hash module 213, event manager module 214, event target module 216, DOM module 217, general utilities module 218, and/or debug module 219.
Object oriented module 210 may include methods configured to aid in defining prototypal object inheritance and module reuse through the use of any of a variety of methods or techniques including, e.g., using a “mixin” object in JavaScript. These methods may allow the copying or augmenting of properties from a source module to a destination module. These methods may also allow for prototypal inheritance by allowing one constructor A to add its own functions to a constructor B without changing other modules that may use constructor B as a prototype.
Object oriented module 210 may have the following properties:
Attribute module 211 may be an object configured to store attributes. Attribute module 211 may be an object that stores attributes, e.g., default value, set function, get function, valid function, and/or change notification function. Attribute module 211 may support one- or two-way binding with other attributes. Attribute module 211 may have the following properties:
Base module 212 may be an object configured to provide initialization and shutdown functionality. Base module 212 may be an object having the following properties:
Hash2 module 213 may be an object configured to implement a hash table. Attribute module 211 may use hash2 module 213 to store attributes and may have the following properties:
Event manager module 214 may be an object configured to fire and handle events. Event manager module 214 may support routing, bubbling, and broadcasting and may have the following properties:
Event target module 216 may be an object configured to simplify and listen to events and may have the following properties:
DOM module 217 may be a set of DOM utilities having the following properties:
General utilities module 218 may be a collection of general utilities having the following properties:
Debug module 219 may include an object including a set of debugging utilities for error handling. Debug module 219 may have the following properties:
Services modules 206 may be those modules that are optional to create tailored applications. Services modules 206 may include log module 220, hydration module 221, navigation module 222, storage module 223, activation module 224, timer module 225, and/or resources module 226.
Log module 220 may be an object configured to log objects, errors, builds, and the like. Log module 220 may have the following properties:
Hydration module 221 may be an object configured to send dehydration and rehydration events, i.e., saving state, suspending state, restoring state, or resuming state to other modules. Hydration module 221 may have the following properties:
Navigation module 222 may be an object configured to synchronize a universal reference locator hash with local memory, e.g., memory 106 shown in
Storage module 223 may be an object configured to store hydration data in attribute module 211. Storage module 223 may have the following properties:
Activation module 224 may be an object configured to mock or mimic entry points to other modules or objects, simulate events without being in the host, and maintain state information. Activation module 224 may have the following properties:
Timer module 225 may be an object configured to set and maintain timers.
Resources module 226 may be an object configured to keep internationalization and localization information, e.g., localized strings in different languages.
As the present disclosure indicated previously, user interface module 208 may include modules responsible for the generation of user interfaces for tailored applications. In addition to component tree module 231 and component module 230, user interface modules 208 may include application module 232.
Application module 232 may be an object configured to manage the tailored application by containing navigation, storage, component tree root, and the like. Application module 232 may have the following properties:
A person of ordinary skill in the art will recognize that they may make many changes to the details of the above-described exemplary application development toolkit without departing from the underlying principles. Only the following claims, therefore, define the scope of the exemplary application development toolkit.
