US20050246304A1 - End-user application customization using rules - Google Patents

End-user application customization using rules Download PDF

Info

Publication number
US20050246304A1
US20050246304A1 US10903762 US90376204A US2005246304A1 US 20050246304 A1 US20050246304 A1 US 20050246304A1 US 10903762 US10903762 US 10903762 US 90376204 A US90376204 A US 90376204A US 2005246304 A1 US2005246304 A1 US 2005246304A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
application
rules
decision
user
data
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US10903762
Inventor
Holly Knight
Praveen Seshadri
Robert Gerber
Stephen Dossick
Vincent Curley
Shyamalan Pather
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Microsoft Technology Licensing LLC
Original Assignee
Microsoft Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06NCOMPUTER SYSTEMS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N5/00Computer systems utilising knowledge based models
    • G06N5/02Knowledge representation
    • G06N5/022Knowledge engineering, knowledge acquisition
    • G06N5/025Extracting rules from data
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/30Creation or generation of source code
    • G06F8/34Graphical or visual programming

Abstract

Rules architecture that facilitates data management of an application such that the application can be personalized by the end-user for the end-user. Included is a customization component that facilitates the exposing of an application generated event to an end-user. A rules component allows the end-user to create one or more rules to process the event, which one or more rules facilitate the submission of application data associated with the event for external and internal processing.

Description

    CROSS-REFERENCE TO RELATED APPLICATIONS
  • [0001]
    This application clams the benefit of U.S. Provisional Patent Application Ser. No. 60/567,153 entitled “END-USER APPLICATION CUSTOMIZATION USING RULES”, filed on Apr. 30, 2004, U.S. Provisional Patent Application Serial No. 60/567,149 entitled “DERIVED SET—A RULES-BASED QUERY-LIKE MECHANISM THAT DEFINES CONTENTS OF A COLLECTION” filed on Apr. 30, 2004, and U.S. Provisional Patent Application Ser. No. 60/567,165, entitled “RULES FRAMEWORK FOR DEFINITION AND EXECUTION OF END-USER RULES LOGIC”, filed on Apr. 30, 2004. This application is also related to co-pending U.S. Patent Application Ser. No. ______ (Atty. Dkt. No. MSFTP668USA) entitled “RULES FRAMEWORK FOR DEFINITION AND EXECUTION OF END-USER RULES LOGIC” filed on Jul. 30, 2004. The entireties of the above-noted applications are incorporated herein by reference.
  • TECHNICAL FIELD
  • [0002]
    This invention is related to software that facilitates application customization, and more specifically, a rules abstraction architecture that facilitates application customization by an end-user.
  • BACKGROUND OF THE INVENTION
  • [0003]
    Computers and computing have always divided the world of users into two classes: the knowledgeable “high priests” who know how to use computers in complex ways, to shape programs and enable behaviors that are valuable and rich; and the novice users, who are at their mercy, denied easy or cheap access to knowledge or information or the education to make computers serve their needs well. However, major breakthroughs in computing have occurred when technology has broken down some of these barriers to access.
  • [0004]
    In the world of the mainframe, computers were too expensive for all but the largest businesses to afford. The advent of mini-computers, and then personal computers (PCs), broke down the cost barrier and made computers available to small businesses and individuals.
  • [0005]
    In the 1980's, programmers struggled to build graphical user interface (GUI) applications, and without rich and consistent GUIs, were unable to build valuable applications for PC users. The Visual Basic revolution and the use of controls and event-based GUI construction enabled a whole army of application developers who could easily build rich applications. This also established a virtuous cycle with many more end-users who could exploit these applications.
  • [0006]
    In the 1990's, end-users struggled to overcome a lack of access to information. The growth of the Internet and the web transformed this space, making almost all valuable information accessible to anyone with a browser. However, there are still significant barriers to overcome.
  • [0007]
    Computing is not personal. There is very little about a PC that is truly “personal”. The data on the local disk is personal. But the behavior of the machine (what it does on behalf of the user) is close to identical across millions of users. Despite owning an amazingly powerful general purpose computer, the average user treats it as a static tool, useful as a communication end-point, useful as a search entry-point, useful to execute some canned mass-market applications, but otherwise incapable of any “personal computing” in the true sense of the word. The personalization capabilities available in current applications just scratch the surface of what is possible and desirable.
  • [0008]
    Computing is manual. Consider the daily routine of most typical computer end-users. The PC gathers information, reacts to communications, makes decisions and acts upon them—initiates or responds to communications, organizes information, buys and sells goods, travel, etc. Computers have improved communication between people, and have improved access to information. However, PCs have done little to relieve the end-user's responsibility to make decisions and act upon them at the right time. In the business world, there are decision support systems for major organizational decisions. Still software does not help the average PC user in the many everyday, yet important and personal decisions.
  • [0009]
    Computing is not contextual. Computer software typically provides optional settings that are rather static and unrelated to the actual context of the user (e.g., “Why should I have the same set of messaging buddies at work and at home?”).
  • [0010]
    Thus, users are still in the “pre-industrial age” of software by being increasingly trapped in the tyranny of manual information processing—spending hours every day sifting, sorting, searching, and reacting to e-mail, documents and other personal data.
  • [0011]
    End-user software should be personalized, aware of the needs and preferences of the end-user, acting specifically in a manner guided by those needs and by the user context. Further, computer systems and software should provide every end-user with a personal executive assistant who works 24 hours a day gathering and sifting information of interest to the end-user, and reacting to that information.
  • [0012]
    The most valuable class of end-user computing activity deals with information flows and search, such as ensuring the end-user sees relevant information (e.g., “Tell me if there is a school closing due to bad weather.”), enhancing person-to-person communication with personalized behavior (e.g., “If I'm out of the office when my wife calls, let her know when I'll be back.”), ensuring important information is not lost (e.g., “If there's an urgent e-mail, make sure it gets forwarded to me on my mobile device.”), and automating the management of information (e.g., “As new photographs arrive, place them in the right folders and shares based on their timestamp, GPS location, and any relevant calendar entries.”).
  • [0013]
    The way to accomplish this is by allowing the end-user to “program” the behavior of the computer. However, traditional programming languages are clearly not the answer, in that, the end-user is not (and cannot become) a trained developer.
  • [0014]
    What is needed is an improved mechanism that allows an end-user to personalize an operating system and an application.
  • SUMMARY OF THE INVENTION
  • [0015]
    The following presents a simplified summary of the invention in order to provide a basic understanding of some aspects of the invention. This summary is not an extensive overview of the invention. It is not intended to identify key/critical elements of the invention or to delineate the scope of the invention. Its sole purpose is to present some concepts of the invention in a simplified form as a prelude to the more detailed description that is presented later.
  • [0016]
    The present invention disclosed and claimed herein, in one aspect thereof, comprises architecture that facilitates data management of an application. Applications can now be personalized by the end-user for the end-user. Included is a customization component that facilitates the exposing of an application generated event to an end-user; and a rules component that allows the end-user to create one or more rules to associate with the event, which one or more rules facilitate the submission of application data associated with the event for external processing. Since each rule-enabled feature of the application is defined by the decision point, an event/trigger/change at the decision point can be managed by the end-user for various purposes. Application data exposed by the decision point can be processed externally to return a result to the application that modifies behavior of the application.
  • [0017]
    Various functions of the application are rule-enabled. The end-user can then create rules for those functions to further manipulate data associated with the functions. Two kinds of application customization are called loosely-bound and tightly bound customization. In a loosely-bound customization, the application exposes an interceptor point, or “decision point” at which the end-user can attach customization rules. A rules is associated with the decision point by setting up an attachment type. Multiple different rules can be attached to a single application customization decision point using corresponding attachment types. The application does not “know” about the attached rules, but calls a method on the decision point item, and then processes the results. The method call causes a rules engine to be invoked on the right rules.
  • [0018]
    In a tightly-bound customization, decision points are not used. The application invokes the rules directly, which allows greater control to the application on which the rules will be invoked, and what types of rules are allowed when the rule engine processes rules to return application customization results. Thus, the tightly-bound application identifies the correct rules for the rules-based decision and user by issuing a file system query for the rules that correspond to that application, user, decision and input, to be provided with the rules. In contrast with the loosely-bound application, the choice of rules based on the user, decision, and input is determined by the rules platform whenever the desision point input method is invoked by the calling application.
  • [0019]
    In another aspect of the present invention, a learning component is provided that faclitates the application learning end-user behavior, and captures the behavior in the form of rules.
  • [0020]
    To the accomplishment of the foregoing and related ends, certain illustrative aspects of the invention are described herein in connection with the following description and the annexed drawings. These aspects are indicative, however, of but a few of the various ways in which the principles of the invention can be employed and the present invention is intended to include all such aspects and their equivalents. Other advantages and novel features of the invention will become apparent from the following detailed description of the invention when considered in conjunction with the drawings.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0021]
    FIG. 1 illustrates a system that facilitates application customization in accordance with the present invention.
  • [0022]
    FIG. 2 illustrates a block diagram of a model for interaction of a customized application with a rules engine in accordance with the present invention.
  • [0023]
    FIG. 3 illustrates a diagram of item types and their relationships of the rules architecture.
  • [0024]
    FIG. 4 illustrates a flow chart of application customization of a loosely bound model from a runtime perspective in accordance with the present invention.
  • [0025]
    FIG. 5 illustrates a flow chart of a methodology for a tightly bound model from a runtime perspective in accordance with the present invention.
  • [0026]
    FIG. 6 illustrates a flow chart of one methodology associated with instantiation of a decision point in accordance with the present invention.
  • [0027]
    FIG. 7 illustrates a system that employs a learning component in accordance with the present invention.
  • [0028]
    FIG. 8 illustrates a block diagram of a computer operable to execute the disclosed architecture.
  • [0029]
    FIG. 9 illustrates a schematic block diagram of an exemplary computing environment in accordance with the present invention.
  • DETAILED DESCRIPTION OF THE INVENTION
  • [0030]
    The present invention is now described with reference to the drawings, wherein like reference numerals are used to refer to like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It may be evident, however, that the present invention can be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to facilitate describing the present invention.
  • [0031]
    As used in this application, the terms “component” and “system” are intended to refer to a computer-related entity, either hardware, a combination of hardware and software, software, or software in execution. For example, a component can be, but is not limited to being, a process running on a processor, a processor, an object, an executable, a thread of execution, a program, and/or a computer. By way of illustration, both an application running on a server and the server can be a component. One or more components can reside within a process and/or thread of execution, and a component can be localized on one computer and/or distributed between two or more computers.
  • [0032]
    As used herein, the term to “infer” or “inference” refer generally to the process of reasoning about or inferring states of the system, environment, and/or user from a set of observations as captured via events and/or data. Inference can be employed to identify a specific context or action, or can generate a probability distribution over states, for example. The inference can be probabilistic-that is, the computation of a probability distribution over states of interest based on a consideration of data and events. Inference can also refer to techniques employed for composing higher-level events from a set of events and/or data. Such inference results in the construction of new events or actions from a set of observed events and/or stored event data, whether or not the events are correlated in close temporal proximity, and whether the events and data come from one or several event and data sources.
  • [0033]
    Rules Architecture
  • [0034]
    The rules architecture of the present invention is a platform against which developers can build applications that run rich end-user logic in the form of rules. Application customization provides the choice of a loosely-bound model, a tightly-bound model, or both, which can be employed in an application to support data driven end-user choices. An application can expose one or more triggering events. If the application is using the tightly bound model there may be no exposed triggering event—just a place in the flow of logic in the application where the application supplies input to one or more rules, gets the results, and processes those results. The rules selected are queried for by the application. In the loosely-bound model, the application itself supplies the rule triggering events (in the form of items called decision points) as input to a rules engine. By providing a decision point, the application gives the end-user the capability to control the application decision with rules. The rules engine then evaluates rule conditions and returns application specific results for those rules whose conditions evaluated to true. The results are then interpreted by the rules customized application.
  • [0035]
    Referring now to FIG. 1, there is illustrated a system 100 that facilitates application customization for data management in accordance with the present invention. The system 100 includes a customization component 102 that facilitates the exposing of an application generated event in an application 104 to an end-user. A rules component 106 allows the end-user to create one or more rules to associate with the event, which one or more rules facilitate the submission of application data 108 associated with the event for external processing. Various functions of the application are rule-enabled. The end-user can then create rules for those functions to further manipulate data associated with those functions. Each rule-enabled feature of the application is defined by a decision point, included as part of the customization component 102. Thus, an event/trigger/change at the decision point can be managed by the end-user for various purposes. Application data exposed by the decision point can be processed externally to return a result to the application that modifies behavior of the application.
  • [0036]
    Referring now to FIG. 2, there is illustrated a block diagram of a model 200 for interaction of a customized application 202 with a rules engine 204 in accordance with the present invention. The rules architecture is a platform against which developers can build applications that run rich end-user logic in the form of rules. For application customization, the application itself supplies rule triggering events 206 as input to the engine 204, the rules engine 204 evaluates rule conditions, and returns application specific results 208 for those rules whose conditions evaluated to true. The results are then interpreted by the rules customized application. A process boundary separates external process (e.g., the application 202) from a store process in which the rules engines 204 runs. The application 202 submits events across the process boundary to the rules engines 204, which then returns results back across the boundary that are run by the external processes.
  • [0037]
    The existence of the process boundary between the application 202 and the rules engine 204 is merely an implementation choice, as indicated by the dashed line. Another implementation choice can be to embed the rules engine 204 into the application 202 so that invoking it does not cause a process switch.
  • [0038]
    The rules engine 204 supports application customization. Application customization is the model that is used to support data driven end-user choices of what had traditionally been relatively fixed option settings in applications. For example, today, most e-mail authoring applications allow the user to specify a single signature file for all outgoing e-mail. An example of application customization is to employ rules that allow the user to set the signature file for outgoing e-mail based on the recipient of the e-mail.
  • [0039]
    The rules platform facilitates the use of one or both of the following models for application customization: a first model that called loosely bound, and a second model that is called tightly bound.
  • [0040]
    Referring now to FIG. 3, there is illustrated a diagram of item types and their relationships of the rules architecture of the present invention. An end-user logic “program” is a rule—a set of statements. The rule is the complete unit of logic. Each rule is a unit of authoring. Note that the input to the rule is a data item. The rule is a declarative statement about an item of a particular item type. As an extension to the basic model, non-item data (transient data or XML) can be provided as a rule input. The items to which the rules apply depends on the deployment of the rules. The rule is the unit of deployable end-user logic. The rules is deployed by attaching it to an item scope (a source of item inputs or decision points). This association is captured in the file system as the RuleSetAttachment (RSA). An RSA represents a connection between the DecisionPoint and Rule items. These connections can be modeled either as physical, stored “Links”, or as computed “common value associations”. In either case, the function is the same—the connection from a Rule to the DecisionPoint for which is was created. Rules are all file system items.
  • [0041]
    The input scope is any item of any type. Input scopes are used by the operating system to limit the scope of rule evaluation to a specific item or folder, but are typically not used by individual applications. The labels on the lines in the above graphic show the names of the relationships between items. The rule set attachment item relates a decision point to a rule (and to an input scope, if one exists). The rule set item contains relationships to zero or more rule statements. Decision point items enable an application to use the rules platform. Rules describes rule items, including constraints, conditions, and results. Rules contain rule statements. Rule statements are statements of the form: on input, if condition, then results. For application customization, the results are defined by the application and consumed by the application. Rule set attachments items store information about the connection between a decision point and a rule set. The user attaches rules in a rule set, and the application provides input to the decision point to return results.
  • [0042]
    Referring now FIG. 4, there is illustrated a flow chart of application customization of a loosely bound model from an runtime perspective in accordance with the present invention. While, for purposes of simplicity of explanation, the one or more methodologies shown herein, e.g., in the form of a flow chart, are shown and described as a series of acts, it is to be understood and appreciated that the present invention is not limited by the order of acts, as some acts may, in accordance with the present invention, occur in a different order and/or concurrently with other acts from that shown and described herein. For example, those skilled in the art will understand and appreciate that a methodology could alternatively be represented as a series of interrelated states or events, such as in a state diagram. Moreover, not all illustrated acts may be required to implement a methodology in accordance with the present invention.
  • [0043]
    At 400, the application registers a set of decision points to the operating system during application installation. Decision points are created by an application as a mechanism to submit input to the rules engine. By exposing a decision point, the application gives the end-user the ability to control an application decision with rules. Input data flows to the rules engine (either directly or via a decision point) to produce application customization results. A decision point is only needed for loosely-bound application customization. At 402, application decision points are exposed at which application behavior has been customized. At 404, a method is invoked at each decision point object to process the end-user customization at that decision point. When the application code reaches a point at which a decision needs to be made, it invokes a method on a decision point object (item). This causes the rules engine to evaluate appropriate end-user rules and return the expected results. At 406, the method submits the decision point rules to the rules engine. At 408, the rules engine processes the rules and sends one or more results back to the application. The application then processes the results in an application-specific manner. The process then reaches a Stop block.
  • [0044]
    As indicated, for loosely bound application customization, the application does not know about the rules. It simply calls a method on the decision point item, and then processes the returned results. The method call causes the rules engine to be invoked on the right rules.
  • [0045]
    Referring now to FIG. 5, there is illustrated a flow chart of a methodology for a tightly bound model from a runtime perspective in accordance with the present invention. At 500, the application chooses rules for customized execution. At 502, the application directly executes the rules to produce an application customization decision. At 504, the decision(s) are sent to the rules engine. At 506, the rules engines processes the decisions, and returns the results back to the application, where the application processes the results in an application-specific manner. The process then reaches a Stop block.
  • [0046]
    As indicated, tightly bound applications are applications that invoke rules directly, which allows greater control to the application on which rules will be invoked, and what types of rules are allowed when the rule engine processes rules to return application customization results. This control places a greater burden on the tightly bound application. Specifically, a tightly bound application identifies the correct rules for the rules-based decision and user by issuing a query for the rules that correspond to the application and user, decision, and input to be provided to the rules. Instead of using a decision point, the application directly invokes an execute method on the rules, passing it the input item and the rule constraint. The rule constraint is used to identify the subset of rules that should be applied to the particular input.
  • [0047]
    A rule constraint can more accurately be thought of as a rule signature. The signature is used to filter which rules run given a particular invocation with a particular input. Rule constraints are specified in two places: on each rule, and on each submission point. There are no rule constraints on RSAs.
  • [0048]
    On rules, the rule constraint is used for enforcement to ensure that the rule conforms to what it says it conforms. The output of each action matches what the rule constraint says the output is. This is the same for the input. The constraint on a rule dictates where it can be attached. Validation will fail if inappropriate attachment of the rule is attempted. Rules are attached to decision points. Only rules consistent with the decision point constraints will be allowed to be attached.
  • [0049]
    To contrast this, for loosely bound applications, the choice of rules based on user, decision, and input is performed by the platform whenever the decision point input method is invoked by the calling application.
  • [0050]
    One or more rules are associated with a decision point by setting up the RSA. A particular RSA can be more restrictive than the rule constraint provided by the decision point. That is, it may specify that the rules should be applied only for a subset of the potential invocations of the decision point by the application. Specifically, it can constrain the rules along any of the following dimensions:
  • [0051]
    User: every RSA is associated with a particular user, and is only invoked for those decisions that are requested on behalf of that user.
  • [0052]
    Type: the RSA can specify that the attached rules should only apply to inputs of a particular type.
  • [0053]
    Input Scope: the RSA can, in general, specify application-specific information that causes the rules to be invoked only for a subset of potential invocations. In the case of the built-in application that allows control of changes in the item store to be controlled by the user with rules, the following kinds of input scope are expected: an item defining containment scope for query or change eventing; and, if the application supports composite operations in a single decision point (e.g., New Item or Item Modified), then the RSA can specify a further constraint which can specify a subset of the operations.
  • [0054]
    Input Content: the RSA can, in general, specify content-based filters (e.g., only apply this rule to input items owned by user). In one implementation, these filters could be deduced from the attached rule.
  • [0055]
    Note that based on this reasoning, there can be multiple RSAs attached to an application customization decision point, and the platform has to support it.
  • [0056]
    Referring now to FIG. 6, there is illustrated a flow chart of one methodology associated with instantiating a decision point in accordance with the present invention. At 600, the methodology is to define each decision point. At 602, the application provides a name. This identifies the decision context (or nature) in which the end-user rules should be applied. At 604, the application provides a signature (or application name) that identifies the owner of the decision point in terms of input data types and the expected result type. In one implementation, transient data is also supported (via, for example, XML-eXtended Markup Language) to support cases where the data does not naturally live in the storage system, and where the overhead of persisting the data is unreasonable. At 606, the application provides any constraint on the kind of rules logic allowed for this decision. For example, some conditions are allowed and some are not. In one implementation, the granularity of rule constraints can be limited to entire item types (i.e., a rule constraint can be expressed in terms of item types). The process then reaches a Stop block.
  • [0057]
    When a decision point is invoked with a particular input of a particular type, only those RSAs whose constraints (user, type, scope, content filter) match this input are invoked. The results from all RSAa are aggregated into a single ResultSetElement (RSE). This return value contains the aggregate results (after conflict resolution) of all attached rules.
  • [0058]
    The application should expect that all results correspond to the rule constraint defined in the decision point and it is possible for the application to distinguish between the results produced by each matching RSA.
  • [0059]
    In accordance with one optimization, a rule is allowed to have different kinds of rules, that is rules with different constraints. The effect of this is that the rules engine dynamically evaluates these rules constraints to decide which of the rules should be applied. It also means that the “direct” execution interface requires a rule constraint. If it was required to only have rules of the same constraint within it, then constraint checking can be performed at the time of rule attachment and membership. However, this reduces the flexibility of using a rule as an organizational device.
  • [0060]
    The lack of a RuleConstraint in a tightly-bound application does not mean that there is no end-user customization. The rules can be just as rich in tightly-bound, as in loosely-bound scenarios. What is missing from the tightly-bound scenario is the capability for a Universal Rules user interface (UI) to present the customization options. There is nothing for it to reflect on in order to determine those options. It is up to the tightly-bound application to present its custom UI for rules building. In this way it can control the available conditions and actions.
  • [0061]
    Rules Input/output (I/O) Model
  • [0062]
    The rules engine receives input, evaluates rules based on this input, and returns the results of any matched rules as output to the calling application. To support application customization and non-item data, the I/O model is extended to return Application Views rather than RSE. Application Views describes structured data returned from rules evaluation. The action model is extended to execute actions contained in an Application View. An RSE can be optionally persisted if the application requests it, but it will not be the expected pattern for customizing applications.
  • [0063]
    Input to the rules engine consists of an operation name and, optionally, can point to an item to which it is related. Inputs can be thought of as “verbs”, like “item created”, which can have a pointer to the item which has been “created”. For instance, given the situation in which a new MP3 file is created in a folder, the item creation is the input operation, and the MP3 would be an item referenced by this input submission.
  • [0064]
    In addition to support for referring to an item as part of submitting input to the rules engine, it is possible for inputs to refer to XML data.
  • [0065]
    DecisionPoint Items contain methods, for example, DecisionPoint.Submit( ) and DecisionPoint.SubmitAndWait( ) are used by developers to submit input into the rules engine. Each DecisionPoint defines the operation name and (optional) item type it accepts as Input.
  • [0066]
    Submitting input that refers to existing types is thus straightforward. When an application would like to submit a set of data that is not schematized, there are two possibilities: the developer defines a new item type using a custom schema, where this item type holds the proper information, and instances of this type are submitted to the rule engine; and the developer uses XML support to submit the data. As an example of the first option, consider that the developer of an application wants to enable users to create rules around the processing of one of the applications events (non-schematized data). To clarify, a developer wants to craft a type, and provide the type as input to a decision point via a submit. The developer then expects as a response one of the methods on the type to be the action the end-user wants to take. For example, if the object is a soda can, and the methods were Drink, CrushAndDiscard, and SetOnTable, then the conditions would be if“empty” and “recycle bin handy”, then CrushAndDiscard. If “not empty”, and “not thirsty”, then SetOnTable.
  • [0067]
    DecisionPoints may optionally require “input scopes”. Certain decision points may involve rules constrained to a particular portion of the file system. These DecisionPoints require that any rules attached to them include a relationship to an Input Scope. For instance, the hypothetical “Item Created” decision point above could require an input scope—and would thus be denoting that it requires any rules attached to it to provide a scope within the file system where these item creation inputs would come from.
  • [0068]
    The logical building block in the rules-based architecture is the collection. A collection is made up of a “scoping” item and a relationship type. Any items that are the targets of relationships of the specified type emanating from the “scoping” item are considered to be part of the collection rooted at the scoping item.
  • [0069]
    RuleSetAttachment items contain methods used for evaluating entire collections simultaneously (e.g., RuleSetAttachment.Evaluate( ) and RuleSetAttachment.EvaluateIntoCollection( )). These methods the items in the attached input scope as input for the engine to consider. The items are evaluated as if they were submitted individually. The rules engine does not treat collections specially for purposes of evaluation.
  • [0070]
    Each call to one of the DecisionPoint submit( ) methods or the RuleSetAttachment evaluate( ) methods will cause one or more attached rules to be evaluated by the rule engine. Results from these evaluations are written into a single RuleSetEvaluation item per call.
  • [0071]
    The RuleSetEvaluation item has a nested element set of RuleResultElements. Each RuleResultElement carries the result name and the structured data necessary to describe the result. These results are application-specific; that is, they are expected to be understandable by the application through/for which the Rule was created and submitted the event. In many cases, the result name carried within the RuleResultElement may actually be a fully-qualified class-level (static) CLR (common language runtime) method name, and the structured data may correspond to parameters for that method. The RuleResultElement type includes an execute( ) method capable of taking this data, and, using CLR reflections, call the named method with the proper parameters. In one implementation, these are limited to setter/getter methods on the properties of the input item as well as static methods found in libraries available within the execution context of the rules customization application.
  • [0072]
    In another implementation, a new RuleSetEvaluation item is generated for each attachment to the decision point to which the input was submitted.
  • [0073]
    A FunctionInfo type is shared between the nested types RuleResultElement and Action, the latter being part of the Rule definition.
  • [0074]
    For those applications wishing to receive results in an XML format, an alternate form of RuleResultElement is provided that can contain the XML data of choice.
  • [0075]
    Referring now to FIG. 7, there is illustrated a system 700 that employs a learning component 702 in accordance with the present invention. The system 700 includeds the customization component 102 that facilitates the exposing of an application generated event in the application 104 to an end-user. The rules component 106 allows the end-user to create one or more rules to associate with the event, which one or more rules facilitate the submission of the application data 108 associated with the event for external processing. Various functions of the application are rule-enabled. The end-user can then create rules for those functions to further manipulate data associated with those functions. Each rule-enabled feature of the application is defined by a decision point, which can be processed externally to return a result to the application that modifies behavior of the application.
  • [0076]
    The subject invention can employ various artificial intelligence based schemes for carrying out various aspects of the subject invention. For example, a process for determining where to place a decision point can be facilitated via an automatic classifier system and process. A classifier is a function that maps an input attribute vector, x=(x1, x2, x3, x4, xn), to a confidence that the input belongs to a class, that is, f(x)=confidence(class). Such classification can employ a probabilistic and/or statistical-based analysis (e.g., factoring into the analysis utilities and costs) to prognose or infer an action that a user desires to be automatically performed.
  • [0077]
    A support vector machine (SVM) is an example of a classifier that can be employed. The SVM operates by finding a hypersurface in the space of possible inputs, which hypersurface attempts to split the triggering criteria from the non-triggering events. Intuitively, this makes the classification correct for testing data that is near, but not identical to training data. Other directed and undirected model classification approaches include, e.g., naïve Bayes, Bayesian networks, decision trees, and probabilistic classification models providing different patterns of independence can be employed. Classification as used herein also is inclusive of statistical regression that is utilized to develop models of priority.
  • [0078]
    As will be readily appreciated from the subject specification, the subject invention can employ classifiers that are explicitly trained (e.g., via a generic training data) as well as implicitly trained (e.g., via observing user behavior, receiving extrinsic information). For example, SVM's are configured via a learning or training phase within a classifier constructor and feature selection module. Thus, the classifier(s) can be used to automatically perform a number of functions, including but not limited to determining the location of decision points based in the particular end-user or the application to customized, determining where to place the decision points based on end-user history of decision point placement, and what decision points can be employed based on the type of application. The classifier can be employed to determine what rule to attach to a decision point for a loosely bound model. Similar classifier operations employed for decision points in the loosely bound model can be applied to rules for the tightly bound model.
  • [0079]
    In a more robust implementation, the classifier performs the complete end-to-end application customization process for the end-user based on end-user preferences and past customizations. Further, the classifier can be used to determine when to use a loosely bound or tightly bound model of application customization and according to a given end-user.
  • [0080]
    Referring now to FIG. 8, there is illustrated a block diagram of a computer operable to execute the disclosed architecture. In order to provide additional context for various aspects of the present invention, FIG. 8 and the following discussion are intended to provide a brief, general description of a suitable computing environment 800 in which the various aspects of the present invention can be implemented. While the invention has been described above in the general context of computer-executable instructions that may run on one or more computers, those skilled in the art will recognize that the invention also can be implemented in combination with other program modules and/or as a combination of hardware and software.
  • [0081]
    Generally, program modules include routines, programs, components, data structures, etc., that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the inventive methods can be practiced with other computer system configurations, including single-processor or multiprocessor computer systems, minicomputers, mainframe computers, as well as personal computers, hand-held computing devices, microprocessor-based or programmable consumer electronics, and the like, each of which can be operatively coupled to one or more associated devices.
  • [0082]
    The illustrated aspects of the invention may also be practiced in distributed computing environments where certain tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules can be located in both local and remote memory storage devices.
  • [0083]
    A computer typically includes a variety of computer-readable media. Computer-readable media can be any available media that can be accessed by the computer and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media can comprise computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital video disk (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by the computer.
  • [0084]
    Communication media typically embodies computer-readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism, and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of the any of the above should also be included within the scope of computer-readable media.
  • [0085]
    With reference again to FIG. 8, there is illustrated an exemplary environment 800 for implementing various aspects of the invention that includes a computer 802, the computer 802 including a processing unit 804, a system memory 806 and a system bus 808. The system bus 808 couples system components including, but not limited to, the system memory 806 to the processing unit 804. The processing unit 804 can be any of various commercially available processors. Dual microprocessors and other multi-processor architectures may also be employed as the processing unit 804.
  • [0086]
    The system bus 808 can be any of several types of bus structure that may further interconnect to a memory bus (with or without a memory controller), a peripheral bus, and a local bus using any of a variety of commercially available bus architectures. The system memory 806 includes read only memory (ROM) 810 and random access memory (RAM) 812. A basic input/output system (BIOS) is stored in a non-volatile memory 810 such as ROM, EPROM, EEPROM, which BIOS contains the basic routines that help to transfer information between elements within the computer 802, such as during start-up. The RAM 812 can also include a high-speed RAM such as static RAM for caching data.
  • [0087]
    The computer 802 further includes an internal hard disk drive (HDD) 814 (e.g., EIDE, SATA), which internal hard disk drive 814 may also be configured for external use in a suitable chassis (not shown), a magnetic floppy disk drive (FDD) 816, (e.g., to read from or write to a removable diskette 818) and an optical disk drive 820, (e.g., reading a CD-ROM disk 822 or, to read from or write to other high capacity optical media such as the DVD). The hard disk drive 814, magnetic disk drive 816 and optical disk drive 820 can be connected to the system bus 808 by a hard disk drive interface 824, a magnetic disk drive interface 826 and an optical drive interface 828, respectively. The interface 824 for external drive implementations includes at least one or both of Universal Serial Bus (USB) and IEEE 1394 interface technologies.
  • [0088]
    The drives and their associated computer-readable media provide nonvolatile storage of data, data structures, computer-executable instructions, and so forth. For the computer 802, the drives and media accommodate the storage of any data in a suitable digital format. Although the description of computer-readable media above refers to a HDD, a removable magnetic diskette, and a removable optical media such as a CD or DVD, it should be appreciated by those skilled in the art that other types of media which are readable by a computer, such as zip drives, magnetic cassettes, flash memory cards, cartridges, and the like, may also be used in the exemplary operating environment, and further, that any such media may contain computer-executable instructions for performing the methods of the present invention.
  • [0089]
    A number of program modules can be stored in the drives and RAM 812, including an operating system 830, one or more application programs 832, other program modules 834 and program data 836. All or portions of the operating system, applications, modules, and/or data can also be cached in the RAM 812.
  • [0090]
    It is appreciated that the present invention can be implemented with various commercially available operating systems or combinations of operating systems.
  • [0091]
    A user can enter commands and information into the computer 802 through one or more wired/wireless input devices, e.g., a keyboard 838 and a pointing device, such as a mouse 840. Other input devices (not shown) may include a microphone, an IR remote control, a joystick, a game pad, a stylus pen, touch screen, or the like. These and other input devices are often connected to the processing unit 804 through an input device interface 842 that is coupled to the system bus 808, but can be connected by other interfaces, such as a parallel port, an IEEE 1394 serial port, a game port, a USB port, an IR interface, etc.
  • [0092]
    A monitor 844 or other type of display device is also connected to the system bus 808 via an interface, such as a video adapter 846. In addition to the monitor 844, a computer typically includes other peripheral output devices (not shown), such as speakers, printers etc.
  • [0093]
    The computer 802 may operate in a networked environment using logical connections via wired and/or wireless communications to one or more remote computers, such as a remote computer(s) 848. The remote computer(s) 848 can be a workstation, a server computer, a router, a personal computer, portable computer, microprocessor-based entertainment appliance, a peer device or other common network node, and typically includes many or all of the elements described relative to the computer 802, although, for purposes of brevity, only a memory storage device 850 is illustrated. The logical connections depicted include wired/wireless connectivity to a local area network (LAN) 852 and/or larger networks, e.g., a wide area network (WAN) 854. Such LAN and WAN networking environments are commonplace in offices, and companies, and facilitate enterprise-wide computer networks, such as intranets, all of which may connect to a global communication network, e.g., the Internet.
  • [0094]
    When used in a LAN networking environment, the computer 802 is connected to the local network 852 through a wired and/or wireless communication network interface or adapter 856. The adaptor 856 may facilitate wired or wireless communication to the LAN 852, which may also include a wireless access point disposed thereon for communicating with the wireless adaptor 856. When used in a WAN networking environment, the computer 802 can include a modem 858, or is connected to a communications server on the LAN, or has other means for establishing communications over the WAN 854, such as by way of the Internet. The modem 858, which can be internal or external and a wired or wireless device, is connected to the system bus 808 via the serial port interface 842. In a networked environment, program modules depicted relative to the computer 802, or portions thereof, can be stored in the remote memory/storage device 850. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers can be used.
  • [0095]
    The computer 802 is operable to communicate with any wireless devices or entities operatively disposed in wireless communication, e.g., a printer, scanner, desktop and/or portable computer, portable data assistant, communications satellite, any piece of equipment or location associated with a wirelessly detectable tag (e.g., a kiosk, news stand, restroom), and telephone. This includes at least Wi-Fi and Bluetooth™ wireless technologies. Thus, the communication can be a predefined structure as with conventional network or simply an ad hoc communication between at least two devices.
  • [0096]
    Wi-Fi, or Wireless Fidelity, allows connection to the Internet from a couch at home, a bed in a hotel room or a conference room at work, without wires. Wi-Fi is a wireless technology like a cell phone that enables such devices, e.g., computers, to send and receive data indoors and out; anywhere within the range of a base station. Wi-Fi networks use radio technologies called IEEE 802.11 (a, b, g, etc.) to provide secure, reliable, fast wireless connectivity. A Wi-Fi network can be used to connect computers to each other, to the Internet, and to wired networks (which use IEEE 802.3 or Ethernet). Wi-Fi networks operate in the unlicensed 2.4 and 5 GHz radio bands, with an 11 Mbps (802.11a) or 54 Mbps (802.11b) data rate or with products that contain both bands (dual band), so the networks can provide real-world performance similar to the basic 10BaseT wired Ethernet networks used in many offices.
  • [0097]
    Referring now to FIG. 9, there is illustrated a schematic block diagram of an exemplary computing environment 900 in accordance with the present invention. The system 900 includes one or more client(s) 902. The client(s) 902 can be hardware and/or software (e.g., threads, processes, computing devices). The client(s) 902 can house cookie(s) and/or associated contextual information by employing the present invention, for example. The system 900 also includes one or more server(s) 904. The server(s) 904 can also be hardware and/or software (e.g., threads, processes, computing devices). The servers 904 can house threads to perform transformations by employing the present invention, for example. One possible communication between a client 902 and a server 904 can be in the form of a data packet adapted to be transmitted between two or more computer processes. The data packet may include a cookie and/or associated contextual information, for example. The system 900 includes a communication framework 906 (e.g., a global communication network such as the Internet) that can be employed to facilitate communications between the client(s) 902 and the server(s) 904.
  • [0098]
    Communications can be facilitated via a wired (including optical fiber) and/or wireless technology. The client(s) 902 are operatively connected to one or more client data store(s) 908 that can be employed to store information local to the client(s) 902 (e.g., cookie(s) and/or associated contextual information). Similarly, the server(s) 904 are operatively connected to one or more server data store(s) 910 that can be employed to store information local to the servers 904.
  • [0099]
    What has been described above includes examples of the present invention. It is, of course, not possible to describe every conceivable combination of components or methodologies for purposes of describing the present invention, but one of ordinary skill in the art may recognize that many further combinations and permutations of the present invention are possible. Accordingly, the present invention is intended to embrace all such alterations, modifications and variations that fall within the spirit and scope of the appended claims. Furthermore, to the extent that the term “includes” is used in either the detailed description or the claims, such term is intended to be inclusive in a manner similar to the term “comprising” as “comprising” is interpreted when employed as a transitional word in a claim.

Claims (36)

  1. 1. A system that facilitates data management of an application, comprising:
    a customization component that facilitates exposing of an application-generated event to an end-user; and
    a rules component that allows the end-user to create one or more rules to process the event, which the one or more rules facilitate the submission of application data associated with the event for processing.
  2. 2. The system of claim 1, the event is associated with a rules-based decision point.
  3. 3. The system of claim 1, the application data is processed at least one of externally and internally to return a result to the application that modifies behavior of the application.
  4. 4. The system of claim 1, the end-user creates explicit rules that define how the event will be processed and the application customized.
  5. 5. The system of claim 1, further comprising a learning component that facilitates the application learning end-user behavior, and captures the behavior in the form of rules.
  6. 6. The system of claim 1, the end-user can explicitly modify the one or more rules.
  7. 7. The system of claim 1, the application exposes an item that is a decision point at which the end-user can customize behavior of the application.
  8. 8. The system of claim 7, the application exposes a name that identifies context of the decision in which the one or more rules are applied.
  9. 9. The system of claim 7, the application exposes a signature that describes input data types and an expected result type.
  10. 10. The system of claim 7, the decision point is registered when the application is installed.
  11. 11. The system of claim 1, the customization component facilitates selection of one of a loosely-bound model and a tightly-bound model for customization of the application.
  12. 12. The system of claim 1, wherein an application that is tightly bound chooses a subset of the one or more rules created by the end-user, and directly executes the subset to produce a customization decision.
  13. 13. The system of claim 1, wherein the application exposes a decision point that provides a name to identify the nature of a decision that is to be made, an application name that identifies the owning application, and a rule constraint that identifies the kind of rules allowed for the decision point.
  14. 14. A computer readable medium having stored thereon computer executable instructions for carrying out the system of claim 1.
  15. 15. A computer readable medium having stored thereon the components of claim 1.
  16. 16. A computer that employs the system of claim 1.
  17. 17. A system that facilitates data management of an application, comprising:
    a customization component that facilitates customization of the application by an end-user by exposing of an application-generated decision point to the end-user; and
    a rules component that facilitates the creation of one or more rules by the end-user to associate with the decision point, which one or more rules facilitate the submission of application data associated with the decision point for external processing.
  18. 18. The system of claim 17, the end-user can explicitly modify the one or more rules.
  19. 19. The system of claim 17, the application exposes a name that identifies context of the decision point in which the one or more rules are applied and a signature that describes input data types and an expected result type.
  20. 20. The system of claim 17, wherein the application directly executes the one or more rules to produce a customization decision.
  21. 21. The system of claim 17, wherein the application identifies one or more correct rulesets in accordance with a query for the one or more correct rulesets that correspond to the application.
  22. 22. The system of claim 21, wherein the query corresponds to the application, user, decision, and input that is to be provided to the one or more rules.
  23. 23. The system of claim 21, wherein the decision point is associated with a decision point input method that is invoked by a calling application.
  24. 24. The system of claim 17, the rules component facilitates associating a rule constraint with the decision point, which rule constraint filters which rules will run for a given invocation and a particular input.
  25. 25. A computer-readable medium having computer-executable instructions for performing a method of facilitating end-user customization of an application, the method comprising:
    exposing an application-generated decision point of the application;
    creating one or more rules that operate on data of the decision point;
    associating the one or more rules with the decision point; and
    processing the one or more rules to expose the data for external processing.
  26. 26. The method of claim 25, further comprising directly executing the one or more rules to produce a customization decision.
  27. 27. The method of claim 25, further comprising querying for one or more correct rules that correspond to the application.
  28. 28. The method of claim 25, wherein the end-user explicitly modifies the one or more rules.
  29. 29. The method of claim 25, further comprising invoking a decision point input method that is called by a calling application.
  30. 30. The method of claim 25, further comprising filtering which rules will run for a given invocation by processing a rule constraint associated with the decision point.
  31. 31. The method of claim 25, further comprising exposing a name that identifies context of the decision point in which the one or more rules are applied and a signature that describes input data types and an expected result type.
  32. 32. The method of claim 25, further comprising associating a rule constraint with the decision point and one or more of the rules.
  33. 33. The method of claim 25, further comprising the acts of,
    directly invoking an execute method on the one or more rules;
    passing an input item that is an input to the one or more rules; and
    passing a rule constraint that enforces an input and an output.
  34. 34. A method of facilitating end-user customization of an application, comprising:
    exposing an application-generated decision point of the application;
    creating by an end-user one or more rules that operate on data of the application;
    in first mode, attaching the one or more rules to a decision point and calling a method on an item of the decision point to expose the data for processing; and
    in a second mode, identifying correct one or more rules for the application, and processing the correct one or more rules directly to expose the data for processing.
  35. 35. The method of claim 34, further comprising filtering which of the one or more rules will run for a given invocation by processing a rule constraint associated with the decision point.
  36. 36. The method of claim 34, further comprising employing both the first mode and the second mode for end-user customization of the application.
US10903762 2004-04-30 2004-07-30 End-user application customization using rules Abandoned US20050246304A1 (en)

Priority Applications (4)

Application Number Priority Date Filing Date Title
US56714904 true 2004-04-30 2004-04-30
US56716504 true 2004-04-30 2004-04-30
US56715304 true 2004-04-30 2004-04-30
US10903762 US20050246304A1 (en) 2004-04-30 2004-07-30 End-user application customization using rules

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
US10903762 US20050246304A1 (en) 2004-04-30 2004-07-30 End-user application customization using rules
EP20040779694 EP1634186A2 (en) 2004-04-30 2004-07-30 End-user application customization using rules
JP2007510696A JP2007537511A (en) 2004-04-30 2004-07-30 End-user applications customized using the rule

Publications (1)

Publication Number Publication Date
US20050246304A1 true true US20050246304A1 (en) 2005-11-03

Family

ID=35637308

Family Applications (2)

Application Number Title Priority Date Filing Date
US10903762 Abandoned US20050246304A1 (en) 2004-04-30 2004-07-30 End-user application customization using rules
US11096454 Active 2029-02-23 US8051406B2 (en) 2004-04-30 2005-04-01 Rich end-user data views

Family Applications After (1)

Application Number Title Priority Date Filing Date
US11096454 Active 2029-02-23 US8051406B2 (en) 2004-04-30 2005-04-01 Rich end-user data views

Country Status (4)

Country Link
US (2) US20050246304A1 (en)
EP (2) EP1625513B1 (en)
JP (1) JP2007537511A (en)
KR (2) KR101120788B1 (en)

Cited By (45)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20060195411A1 (en) * 2005-02-28 2006-08-31 Microsoft Corporation End user data activation
US20080183304A1 (en) * 2007-01-25 2008-07-31 Dae-Ryung Lee Framework and programming model for efficient sense-and-respond system
US20090048025A1 (en) * 2007-08-17 2009-02-19 Pepper J Kent Method and apparatus for a rule development process for inducement prizes
US20090048857A1 (en) * 2007-08-17 2009-02-19 Pepper J Kent Method and apparatus for a rule development process for inducement prizes
US7673227B2 (en) 2000-06-21 2010-03-02 Microsoft Corporation User interface for integrated spreadsheets and word processing tables
US7676843B1 (en) 2004-05-27 2010-03-09 Microsoft Corporation Executing applications at appropriate trust levels
US7689929B2 (en) 2000-06-21 2010-03-30 Microsoft Corporation Methods and systems of providing information to computer users
US7692636B2 (en) 2004-09-30 2010-04-06 Microsoft Corporation Systems and methods for handwriting to a screen
US7712022B2 (en) 2004-11-15 2010-05-04 Microsoft Corporation Mutually exclusive options in electronic forms
US7712048B2 (en) 2000-06-21 2010-05-04 Microsoft Corporation Task-sensitive methods and systems for displaying command sets
US7721190B2 (en) 2004-11-16 2010-05-18 Microsoft Corporation Methods and systems for server side form processing
US7725834B2 (en) 2005-03-04 2010-05-25 Microsoft Corporation Designer-created aspect for an electronic form template
US20100146014A1 (en) * 2008-12-04 2010-06-10 Microsoft Corporation Extendable business type system in a performance management platform
US7743063B2 (en) 2000-06-21 2010-06-22 Microsoft Corporation Methods and systems for delivering software via a network
US7774376B1 (en) 2004-07-30 2010-08-10 Microsoft Corporation Type-system extensions for object-oriented language based on coercive subtyping with restrictions
US7818677B2 (en) 2000-06-21 2010-10-19 Microsoft Corporation Single window navigation methods and systems
US7865477B2 (en) 2003-03-28 2011-01-04 Microsoft Corporation System and method for real-time validation of structured data files
US7900134B2 (en) 2000-06-21 2011-03-01 Microsoft Corporation Authoring arbitrary XML documents using DHTML and XSLT
US7904801B2 (en) 2004-12-15 2011-03-08 Microsoft Corporation Recursive sections in electronic forms
US7913159B2 (en) 2003-03-28 2011-03-22 Microsoft Corporation System and method for real-time validation of structured data files
US7912863B1 (en) 2004-07-30 2011-03-22 Microsoft Corporation Compositional lifting of operations over structural types
US7925621B2 (en) 2003-03-24 2011-04-12 Microsoft Corporation Installing a solution
US7926030B1 (en) 2005-09-30 2011-04-12 Harmony Information Systems, Inc. Configurable software application
US7937651B2 (en) 2005-01-14 2011-05-03 Microsoft Corporation Structural editing operations for network forms
US7971139B2 (en) 2003-08-06 2011-06-28 Microsoft Corporation Correlation, association, or correspondence of electronic forms
US7979856B2 (en) 2000-06-21 2011-07-12 Microsoft Corporation Network-based software extensions
US8001459B2 (en) 2005-12-05 2011-08-16 Microsoft Corporation Enabling electronic documents for limited-capability computing devices
US8078960B2 (en) 2003-06-30 2011-12-13 Microsoft Corporation Rendering an HTML electronic form by applying XSLT to XML using a solution
US8117552B2 (en) 2003-03-24 2012-02-14 Microsoft Corporation Incrementally designing electronic forms and hierarchical schemas
US8200975B2 (en) 2005-06-29 2012-06-12 Microsoft Corporation Digital signatures for network forms
US8487879B2 (en) 2004-10-29 2013-07-16 Microsoft Corporation Systems and methods for interacting with a computer through handwriting to a screen
US8813028B2 (en) * 2012-07-19 2014-08-19 Arshad Farooqi Mobile application creation system
US8819072B1 (en) 2004-02-02 2014-08-26 Microsoft Corporation Promoting data from structured data files
US8892993B2 (en) 2003-08-01 2014-11-18 Microsoft Corporation Translation file
US8918729B2 (en) 2003-03-24 2014-12-23 Microsoft Corporation Designing electronic forms
US8949168B1 (en) 2012-06-27 2015-02-03 Emc International Company Managing a memory of an event-based analysis engine
US9024779B2 (en) 2011-11-17 2015-05-05 Raytheon Company Policy based data management and imaging chipping
US9098804B1 (en) 2012-12-27 2015-08-04 Emc International Company Using data aggregation to manage a memory for an event-based analysis engine
US9195631B1 (en) 2012-03-26 2015-11-24 Emc Corporation Providing historical data to an event-based analysis engine
US9354762B1 (en) 2012-06-26 2016-05-31 Emc International Company Simplifying rules generation for an event-based analysis engine by allowing a user to combine related objects in a rule
US9430125B1 (en) * 2012-06-27 2016-08-30 Emc International Company Simplifying rules generation for an event-based analysis engine
US9569284B2 (en) 2014-12-29 2017-02-14 International Business Machines Corporation Composing applications on a mobile device
US20170061026A1 (en) * 2014-02-07 2017-03-02 Quixey, Inc. Systems and Methods for Generating Search Results Using Application-Specific Rule Sets
US9753618B1 (en) 2016-05-11 2017-09-05 Vignet Incorporated Multi-level architecture for dynamically generating interactive program modules
US9983775B2 (en) 2016-03-10 2018-05-29 Vignet Incorporated Dynamic user interfaces based on multiple data sources

Families Citing this family (24)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9552141B2 (en) 2004-06-21 2017-01-24 Apple Inc. Methods and apparatuses for operating a data processing system
US7475075B2 (en) * 2005-09-09 2009-01-06 Microsoft Corporation Integration rich client views in server presentations
US20080086695A1 (en) * 2006-10-10 2008-04-10 International Business Machines Corporation Method to color tag e-mail content containing multiple replies to ease reading
US7844915B2 (en) 2007-01-07 2010-11-30 Apple Inc. Application programming interfaces for scrolling operations
US20080168402A1 (en) 2007-01-07 2008-07-10 Christopher Blumenberg Application Programming Interfaces for Gesture Operations
US8326814B2 (en) * 2007-12-05 2012-12-04 Box, Inc. Web-based file management system and service
US8645827B2 (en) 2008-03-04 2014-02-04 Apple Inc. Touch event model
DE112009000002T5 (en) 2008-03-04 2010-01-07 Apple Inc., Cupertino Processing touch events for websites
US8416196B2 (en) 2008-03-04 2013-04-09 Apple Inc. Touch event model programming interface
US8717305B2 (en) 2008-03-04 2014-05-06 Apple Inc. Touch event model for web pages
US8122066B2 (en) * 2008-10-14 2012-02-21 Hewlett-Packard Development Company, L.P. Database query profiler
US8566044B2 (en) * 2009-03-16 2013-10-22 Apple Inc. Event recognition
US9311112B2 (en) 2009-03-16 2016-04-12 Apple Inc. Event recognition
US8566045B2 (en) 2009-03-16 2013-10-22 Apple Inc. Event recognition
US8285499B2 (en) 2009-03-16 2012-10-09 Apple Inc. Event recognition
US9466050B2 (en) * 2009-05-22 2016-10-11 EVDense Holding Company, Inc. System and method for interactive visual representation of items along a timeline
EP2275952A1 (en) 2009-07-01 2011-01-19 Thomson Telecom Belgium Method for accessing files of a file system according to metadata and device implementing the method
US9684521B2 (en) 2010-01-26 2017-06-20 Apple Inc. Systems having discrete and continuous gesture recognizers
US8732146B2 (en) * 2010-02-01 2014-05-20 Microsoft Corporation Database integrated viewer
US20110307833A1 (en) 2010-06-14 2011-12-15 Thomas Andrew Cooke Dale Control Selection Approximation
US9298363B2 (en) 2011-04-11 2016-03-29 Apple Inc. Region activation for touch sensitive surface
US9558278B2 (en) 2012-09-11 2017-01-31 Apple Inc. Integrated content recommendation
US9733716B2 (en) 2013-06-09 2017-08-15 Apple Inc. Proxy gesture recognizer
US9697203B2 (en) 2014-02-03 2017-07-04 World Software Corporation System and method for interactive visual representation of metadata within a networked heterogeneous workflow environment

Citations (24)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5446885A (en) * 1992-05-15 1995-08-29 International Business Machines Corporation Event driven management information system with rule-based applications structure stored in a relational database
US5495603A (en) * 1993-06-14 1996-02-27 International Business Machines Corporation Declarative automatic class selection filter for dynamic file reclassification
US5831606A (en) * 1994-12-13 1998-11-03 Microsoft Corporation Shell extensions for an operating system
US5917489A (en) * 1997-01-31 1999-06-29 Microsoft Corporation System and method for creating, editing, and distributing rules for processing electronic messages
US6142684A (en) * 1997-04-03 2000-11-07 Hewlett-Packard Company Joining a plurality of type hierarchies in an object oriented programming language without inheriting from a base class and without modification to the type hiearchies
US6266811B1 (en) * 1997-12-31 2001-07-24 Network Associates Method and system for custom computer software installation using rule-based installation engine and simplified script computer program
US6272521B1 (en) * 1997-12-08 2001-08-07 Object Technology Licensing Corporation Apparatus and method for allowing object-oriented programs created with different framework versions to communicate
US6292937B1 (en) * 1998-07-22 2001-09-18 Matsushita Electric Industrial Co., Ltd. Program conversion device for translating an object-oriented language source program
US6341369B1 (en) * 1998-12-03 2002-01-22 International Business Machines Corporation Method and data processing system for specifying and applying rules to classification-based decision points in an application system
US6401097B1 (en) * 1998-01-23 2002-06-04 Mccotter Thomas M. System and method for integrated document management and related transmission and access
US6407753B1 (en) * 1999-05-04 2002-06-18 International Business Machines Corporation System and method for integrating entities via user-interactive rule-based matching and difference reconciliation
US6519597B1 (en) * 1998-10-08 2003-02-11 International Business Machines Corporation Method and apparatus for indexing structured documents with rich data types
US6633889B2 (en) * 2001-01-17 2003-10-14 International Business Machines Corporation Mapping persistent data in multiple data sources into a single object-oriented component
US6636845B2 (en) * 1999-12-02 2003-10-21 International Business Machines Corporation Generating one or more XML documents from a single SQL query
US20040143604A1 (en) * 2003-01-21 2004-07-22 Steve Glenner Random access editing of media
US20040193575A1 (en) * 2003-03-25 2004-09-30 Chia-Hsun Chen Path expressions and SQL select statement in object oriented language
US20040216086A1 (en) * 2003-01-24 2004-10-28 David Bau XML types in Java
US20050060281A1 (en) * 2003-07-31 2005-03-17 Tim Bucher Rule-based content management system
US6944819B2 (en) * 1997-01-10 2005-09-13 Eastman-Kodak Company Computer method and apparatus for previewing files outside of an application program
US20050222996A1 (en) * 2004-03-30 2005-10-06 Oracle International Corporation Managing event-condition-action rules in a database system
US6965889B2 (en) * 2000-05-09 2005-11-15 Fair Isaac Corporation Approach for generating rules
US6976020B2 (en) * 2000-01-27 2005-12-13 Poppet International, Inc. Software composition using graph types, graph, and agents
US7181694B2 (en) * 2002-05-31 2007-02-20 Sap Aktiengesellschaft Software customization objects for programming extensions associated with a computer system
US7409405B1 (en) * 2002-12-06 2008-08-05 Adobe Systems Incorporated File dispatcher for multiple application targets

Family Cites Families (40)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5627764A (en) * 1991-10-04 1997-05-06 Banyan Systems, Inc. Automatic electronic messaging system with feedback and work flow administration
US5751914A (en) * 1995-10-10 1998-05-12 International Business Machines Corporation Method and system for correlating a plurality of events within a data processing system
US5925108A (en) * 1995-11-03 1999-07-20 Novell, Inc. Event notification in a computer system
US5828376A (en) * 1996-09-23 1998-10-27 J. D. Edwards World Source Company Menu control in a graphical user interface
US6061740A (en) * 1996-12-09 2000-05-09 Novell, Inc. Method and apparatus for heterogeneous network management
US6233726B1 (en) * 1997-02-05 2001-05-15 Sybase, Inc. Development system with reference card and parameter wizard methodologies for facilitating creation of software programs
US6272559B1 (en) * 1997-10-15 2001-08-07 Sun Microsystems, Inc. Deferred reconstruction of objects and remote loading for event notification in a distributed system
US5966707A (en) * 1997-12-02 1999-10-12 International Business Machines Corporation Method for managing a plurality of data processes residing in heterogeneous data repositories
WO1999040512A9 (en) 1998-02-09 2000-02-17 Reuters Ltd Method and system for user defined interactions between plurality of active software applications
US6133915A (en) * 1998-06-17 2000-10-17 Microsoft Corporation System and method for customizing controls on a toolbar
US6237135B1 (en) * 1998-06-18 2001-05-22 Borland Software Corporation Development system with visual design tools for creating and maintaining Java Beans components
US6633888B1 (en) * 1999-02-03 2003-10-14 International Business Machines Corporation Method and apparatus for visually creating and testing object oriented components
US6738964B1 (en) * 1999-03-11 2004-05-18 Texas Instruments Incorporated Graphical development system and method
US6360357B1 (en) * 1999-06-10 2002-03-19 Dassault Systems Adding code in an application during runtime to enrich object behavior
US6332163B1 (en) * 1999-09-01 2001-12-18 Accenture, Llp Method for providing communication services over a computer network system
US20020104067A1 (en) * 1999-12-29 2002-08-01 Green David W. Method and system and article of manufacture for an N-tier software component architecture application
JP2001282556A (en) * 2000-01-25 2001-10-12 Fujitsu Ltd Device and method for deciding dynamic data flow by action chain, computer readable recording medium and program deciding dynamic data flow by action chain
US7412501B2 (en) * 2000-06-07 2008-08-12 Microsoft Corporation Event consumers for an event management system
US6892228B1 (en) * 2000-08-23 2005-05-10 Pure Matrix, Inc. System and method for on-line service creation
WO2002021269A1 (en) * 2000-09-08 2002-03-14 Dxcribe Technologies Pty Ltd Software application development
US6734882B1 (en) * 2000-09-29 2004-05-11 Apple Computer, Inc. Combined menu-list control element in a graphical user interface
US20030217333A1 (en) * 2001-04-16 2003-11-20 Greg Smith System and method for rules-based web scenarios and campaigns
US20040205706A1 (en) * 2001-05-31 2004-10-14 Portwood Michael T. Method for the automatic generation of computer programs which interact with existing objects
CA2360645C (en) * 2001-10-31 2006-03-07 Ibm Canada Limited-Ibm Canada Limitee Dynamic generic framework for distributed tooling
US7549129B2 (en) * 2001-10-31 2009-06-16 Microsoft Corporation Computer system with enhanced user interface for images
JP3712984B2 (en) * 2002-02-18 2005-11-02 日本電信電話株式会社 Business progress control device and method and a recording medium recording the work progress control program, and the program
KR20050003466A (en) * 2002-05-17 2005-01-10 코닌클리케 필립스 일렉트로닉스 엔.브이. Rendering a first media type content on a browser
US20040012627A1 (en) * 2002-07-17 2004-01-22 Sany Zakharia Configurable browser for adapting content to diverse display types
US7373350B1 (en) * 2002-11-07 2008-05-13 Data Advantage Group Virtual metadata analytics and management platform
US7203667B2 (en) * 2002-11-11 2007-04-10 Zxibix, Inc. System and method of facilitating and evaluating user thinking about an arbitrary problem using an archetype process
US7788588B2 (en) * 2003-02-07 2010-08-31 Microsoft Corporation Realizing users' preferences
WO2004099896A3 (en) * 2003-05-12 2005-02-17 An Mo Jeong Method and system of developing a software with utilizing extented metadata of component under component-based development environment
US7734690B2 (en) * 2003-09-05 2010-06-08 Microsoft Corporation Method and apparatus for providing attributes of a collaboration system in an operating system folder-based file system
US7310443B1 (en) * 2003-09-17 2007-12-18 Sonic Solutions, Inc. Automatic red eye detection and correction in digital images
US20050262481A1 (en) * 2003-09-30 2005-11-24 Coulson Julia C Customizable toolbar creation and control
EP1676204A2 (en) * 2003-10-13 2006-07-05 Philips Electronics N.V. Storage allocation per application
US20050091181A1 (en) * 2003-10-23 2005-04-28 Mckee Timothy P. System and method for the presentation of items stored on a computer
US7921076B2 (en) * 2004-12-15 2011-04-05 Oracle International Corporation Performing an action in response to a file system event
US20060195411A1 (en) * 2005-02-28 2006-08-31 Microsoft Corporation End user data activation
US7565663B2 (en) * 2005-02-28 2009-07-21 Microsoft Corporation Automated data organization

Patent Citations (26)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5630127A (en) * 1992-05-15 1997-05-13 International Business Machines Corporation Program storage device and computer program product for managing an event driven management information system with rule-based application structure stored in a relational database
US5446885A (en) * 1992-05-15 1995-08-29 International Business Machines Corporation Event driven management information system with rule-based applications structure stored in a relational database
US5495603A (en) * 1993-06-14 1996-02-27 International Business Machines Corporation Declarative automatic class selection filter for dynamic file reclassification
US5831606A (en) * 1994-12-13 1998-11-03 Microsoft Corporation Shell extensions for an operating system
US6944819B2 (en) * 1997-01-10 2005-09-13 Eastman-Kodak Company Computer method and apparatus for previewing files outside of an application program
US5917489A (en) * 1997-01-31 1999-06-29 Microsoft Corporation System and method for creating, editing, and distributing rules for processing electronic messages
US6142684A (en) * 1997-04-03 2000-11-07 Hewlett-Packard Company Joining a plurality of type hierarchies in an object oriented programming language without inheriting from a base class and without modification to the type hiearchies
US6272521B1 (en) * 1997-12-08 2001-08-07 Object Technology Licensing Corporation Apparatus and method for allowing object-oriented programs created with different framework versions to communicate
US6266811B1 (en) * 1997-12-31 2001-07-24 Network Associates Method and system for custom computer software installation using rule-based installation engine and simplified script computer program
US6401097B1 (en) * 1998-01-23 2002-06-04 Mccotter Thomas M. System and method for integrated document management and related transmission and access
US6292937B1 (en) * 1998-07-22 2001-09-18 Matsushita Electric Industrial Co., Ltd. Program conversion device for translating an object-oriented language source program
US6519597B1 (en) * 1998-10-08 2003-02-11 International Business Machines Corporation Method and apparatus for indexing structured documents with rich data types
US6341369B1 (en) * 1998-12-03 2002-01-22 International Business Machines Corporation Method and data processing system for specifying and applying rules to classification-based decision points in an application system
US6407753B1 (en) * 1999-05-04 2002-06-18 International Business Machines Corporation System and method for integrating entities via user-interactive rule-based matching and difference reconciliation
US6636845B2 (en) * 1999-12-02 2003-10-21 International Business Machines Corporation Generating one or more XML documents from a single SQL query
US6643633B2 (en) * 1999-12-02 2003-11-04 International Business Machines Corporation Storing fragmented XML data into a relational database by decomposing XML documents with application specific mappings
US6976020B2 (en) * 2000-01-27 2005-12-13 Poppet International, Inc. Software composition using graph types, graph, and agents
US6965889B2 (en) * 2000-05-09 2005-11-15 Fair Isaac Corporation Approach for generating rules
US6633889B2 (en) * 2001-01-17 2003-10-14 International Business Machines Corporation Mapping persistent data in multiple data sources into a single object-oriented component
US7181694B2 (en) * 2002-05-31 2007-02-20 Sap Aktiengesellschaft Software customization objects for programming extensions associated with a computer system
US7409405B1 (en) * 2002-12-06 2008-08-05 Adobe Systems Incorporated File dispatcher for multiple application targets
US20040143604A1 (en) * 2003-01-21 2004-07-22 Steve Glenner Random access editing of media
US20040216086A1 (en) * 2003-01-24 2004-10-28 David Bau XML types in Java
US20040193575A1 (en) * 2003-03-25 2004-09-30 Chia-Hsun Chen Path expressions and SQL select statement in object oriented language
US20050060281A1 (en) * 2003-07-31 2005-03-17 Tim Bucher Rule-based content management system
US20050222996A1 (en) * 2004-03-30 2005-10-06 Oracle International Corporation Managing event-condition-action rules in a database system

Cited By (59)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7712048B2 (en) 2000-06-21 2010-05-04 Microsoft Corporation Task-sensitive methods and systems for displaying command sets
US9507610B2 (en) 2000-06-21 2016-11-29 Microsoft Technology Licensing, Llc Task-sensitive methods and systems for displaying command sets
US8074217B2 (en) 2000-06-21 2011-12-06 Microsoft Corporation Methods and systems for delivering software
US7743063B2 (en) 2000-06-21 2010-06-22 Microsoft Corporation Methods and systems for delivering software via a network
US7673227B2 (en) 2000-06-21 2010-03-02 Microsoft Corporation User interface for integrated spreadsheets and word processing tables
US7979856B2 (en) 2000-06-21 2011-07-12 Microsoft Corporation Network-based software extensions
US7689929B2 (en) 2000-06-21 2010-03-30 Microsoft Corporation Methods and systems of providing information to computer users
US7900134B2 (en) 2000-06-21 2011-03-01 Microsoft Corporation Authoring arbitrary XML documents using DHTML and XSLT
US7818677B2 (en) 2000-06-21 2010-10-19 Microsoft Corporation Single window navigation methods and systems
US7779027B2 (en) 2000-06-21 2010-08-17 Microsoft Corporation Methods, systems, architectures and data structures for delivering software via a network
US8918729B2 (en) 2003-03-24 2014-12-23 Microsoft Corporation Designing electronic forms
US7925621B2 (en) 2003-03-24 2011-04-12 Microsoft Corporation Installing a solution
US8117552B2 (en) 2003-03-24 2012-02-14 Microsoft Corporation Incrementally designing electronic forms and hierarchical schemas
US7865477B2 (en) 2003-03-28 2011-01-04 Microsoft Corporation System and method for real-time validation of structured data files
US9229917B2 (en) 2003-03-28 2016-01-05 Microsoft Technology Licensing, Llc Electronic form user interfaces
US7913159B2 (en) 2003-03-28 2011-03-22 Microsoft Corporation System and method for real-time validation of structured data files
US8078960B2 (en) 2003-06-30 2011-12-13 Microsoft Corporation Rendering an HTML electronic form by applying XSLT to XML using a solution
US9239821B2 (en) 2003-08-01 2016-01-19 Microsoft Technology Licensing, Llc Translation file
US8892993B2 (en) 2003-08-01 2014-11-18 Microsoft Corporation Translation file
US8429522B2 (en) 2003-08-06 2013-04-23 Microsoft Corporation Correlation, association, or correspondence of electronic forms
US7971139B2 (en) 2003-08-06 2011-06-28 Microsoft Corporation Correlation, association, or correspondence of electronic forms
US9268760B2 (en) 2003-08-06 2016-02-23 Microsoft Technology Licensing, Llc Correlation, association, or correspondence of electronic forms
US8819072B1 (en) 2004-02-02 2014-08-26 Microsoft Corporation Promoting data from structured data files
US7676843B1 (en) 2004-05-27 2010-03-09 Microsoft Corporation Executing applications at appropriate trust levels
US7774620B1 (en) 2004-05-27 2010-08-10 Microsoft Corporation Executing applications at appropriate trust levels
US7774376B1 (en) 2004-07-30 2010-08-10 Microsoft Corporation Type-system extensions for object-oriented language based on coercive subtyping with restrictions
US7912863B1 (en) 2004-07-30 2011-03-22 Microsoft Corporation Compositional lifting of operations over structural types
US7692636B2 (en) 2004-09-30 2010-04-06 Microsoft Corporation Systems and methods for handwriting to a screen
US8487879B2 (en) 2004-10-29 2013-07-16 Microsoft Corporation Systems and methods for interacting with a computer through handwriting to a screen
US7712022B2 (en) 2004-11-15 2010-05-04 Microsoft Corporation Mutually exclusive options in electronic forms
US7721190B2 (en) 2004-11-16 2010-05-18 Microsoft Corporation Methods and systems for server side form processing
US7904801B2 (en) 2004-12-15 2011-03-08 Microsoft Corporation Recursive sections in electronic forms
US7937651B2 (en) 2005-01-14 2011-05-03 Microsoft Corporation Structural editing operations for network forms
US20060195411A1 (en) * 2005-02-28 2006-08-31 Microsoft Corporation End user data activation
US7725834B2 (en) 2005-03-04 2010-05-25 Microsoft Corporation Designer-created aspect for an electronic form template
US8200975B2 (en) 2005-06-29 2012-06-12 Microsoft Corporation Digital signatures for network forms
US7926030B1 (en) 2005-09-30 2011-04-12 Harmony Information Systems, Inc. Configurable software application
US8752014B2 (en) 2005-09-30 2014-06-10 Harmony Information Systems, Inc. Configurable software application
US20110167408A1 (en) * 2005-09-30 2011-07-07 Harmony Information Systems, Inc. Configurable software application
US8001459B2 (en) 2005-12-05 2011-08-16 Microsoft Corporation Enabling electronic documents for limited-capability computing devices
US9210234B2 (en) 2005-12-05 2015-12-08 Microsoft Technology Licensing, Llc Enabling electronic documents for limited-capability computing devices
US20080183304A1 (en) * 2007-01-25 2008-07-31 Dae-Ryung Lee Framework and programming model for efficient sense-and-respond system
US7779104B2 (en) 2007-01-25 2010-08-17 International Business Machines Corporation Framework and programming model for efficient sense-and-respond system
US20090048025A1 (en) * 2007-08-17 2009-02-19 Pepper J Kent Method and apparatus for a rule development process for inducement prizes
US20090048857A1 (en) * 2007-08-17 2009-02-19 Pepper J Kent Method and apparatus for a rule development process for inducement prizes
US20100146014A1 (en) * 2008-12-04 2010-06-10 Microsoft Corporation Extendable business type system in a performance management platform
US9024779B2 (en) 2011-11-17 2015-05-05 Raytheon Company Policy based data management and imaging chipping
US9195631B1 (en) 2012-03-26 2015-11-24 Emc Corporation Providing historical data to an event-based analysis engine
US9354762B1 (en) 2012-06-26 2016-05-31 Emc International Company Simplifying rules generation for an event-based analysis engine by allowing a user to combine related objects in a rule
US9430125B1 (en) * 2012-06-27 2016-08-30 Emc International Company Simplifying rules generation for an event-based analysis engine
US8949168B1 (en) 2012-06-27 2015-02-03 Emc International Company Managing a memory of an event-based analysis engine
US20150012908A1 (en) * 2012-07-19 2015-01-08 Arshad Farooqi Mobile Application Creation System
US8813028B2 (en) * 2012-07-19 2014-08-19 Arshad Farooqi Mobile application creation system
US9098804B1 (en) 2012-12-27 2015-08-04 Emc International Company Using data aggregation to manage a memory for an event-based analysis engine
US20170061026A1 (en) * 2014-02-07 2017-03-02 Quixey, Inc. Systems and Methods for Generating Search Results Using Application-Specific Rule Sets
US9916387B2 (en) * 2014-02-07 2018-03-13 Samsung Electronics Co., Ltd. Systems and methods for generating search results using application-specific rule sets
US9569284B2 (en) 2014-12-29 2017-02-14 International Business Machines Corporation Composing applications on a mobile device
US9983775B2 (en) 2016-03-10 2018-05-29 Vignet Incorporated Dynamic user interfaces based on multiple data sources
US9753618B1 (en) 2016-05-11 2017-09-05 Vignet Incorporated Multi-level architecture for dynamically generating interactive program modules

Also Published As

Publication number Publication date Type
EP1625513A4 (en) 2012-11-28 application
EP1634186A2 (en) 2006-03-15 application
EP1625513B1 (en) 2018-04-18 grant
KR20070037281A (en) 2007-04-04 application
KR101120788B1 (en) 2012-03-23 grant
EP1625513A2 (en) 2006-02-15 application
KR20070037559A (en) 2007-04-05 application
US20050246637A1 (en) 2005-11-03 application
US8051406B2 (en) 2011-11-01 grant
JP2007537511A (en) 2007-12-20 application

Similar Documents

Publication Publication Date Title
US7451403B1 (en) System and method for developing user interfaces purely by modeling as meta data in software application
US7363578B2 (en) Method and apparatus for mapping a data model to a user interface model
US6985939B2 (en) Building distributed software services as aggregations of other services
Fidler et al. The PADRES Distributed Publish/Subscribe System.
US20090150168A1 (en) Litigation document management
US20040054690A1 (en) Modeling and using computer resources over a heterogeneous distributed network using semantic ontologies
US7979245B1 (en) Model-based systems and methods for monitoring computing resource performance
US20080082490A1 (en) Rich index to cloud-based resources
US7693586B2 (en) Process model transformation for event-based coordination of composite applications
US20040193707A1 (en) Architecture and system for location awareness
US20030182394A1 (en) Method and system for providing context awareness
US20070201654A1 (en) System and method for extending a component-based application platform with custom services
US20070299796A1 (en) Resource availability for user activities across devices
US20090165022A1 (en) System and method for scheduling electronic events
US20090150431A1 (en) Managing relationships of heterogeneous objects
US20070100704A1 (en) Shopping assistant
US6269473B1 (en) Method and apparatus for the development of dynamically configurable software systems
US20080307392A1 (en) System architecture for business process development and execution
US20090036102A1 (en) Context-Based Data Pre-Fetching and Notification for Mobile Applications
US20100131916A1 (en) Software for modeling business tasks
US7177859B2 (en) Programming model for subscription services
US20120023544A1 (en) Data assurance
US7177865B2 (en) Data synchronization method and system
US20050086360A1 (en) Methods and systems for real time integration services
US7370335B1 (en) System and method for providing a public application program interface

Legal Events

Date Code Title Description
AS Assignment

Owner name: MICROSOFT CORPORATION, WASHINGTON

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:KNIGHT, HOLLY;SESHADRI, PRAVEEN;GERBER, ROBERT H.;AND OTHERS;REEL/FRAME:015651/0074

Effective date: 20040730

AS Assignment

Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034766/0001

Effective date: 20141014