Abstract:
A system and method for building software applications. The system includes a knowledgebase, an application scenario player, a service connector, presentation components, and underlying system component-services. The method speeds up software system development and provides a greater flexibility to system behavior. Developers or subject matter experts can omit multiple steps of translating application requirements into traditional programs, and instead directly store business rules and application scenarios written in “almost natural” language in the knowledgebase. The application scenario player and the service connector transform application scenarios into interactions with the knowledgebase, presentation components, and underlying application services. Application scenarios and business requirements/rules stored in the knowledgebase represent the application layer, providing a clean separation from the system layer with its underlying service components that include application services. A business expert, a developer, or a partner program can change and introduce new business rules or scenarios at run-time, and can add, replace, or remove service components. The invention provides a better separation between generic service components and specific rules and scenarios that distinguish the application. Services in knowledge-driven architecture are coded as integration-ready components and can be moved down to the system level along with the database and operating system. Business rules and scenarios that represent a very light application layer can be created and changed at run-time by business experts, who would have their chance to influence application behavior, and to say not only “what” should be done, but also “how”. The main component of the application is a knowledgebase that stores application requirements as application scenarios and business rules. The Application Scenario Player and the Service Connector transform application scenarios into interactions with the knowledgebase, presentation components, and underlying application services.

Description:
CROSS REFERENCE To RELATED APPLICATIONS  
       [0001]     The present application is based on the Applicant&#39;s U.S. Provisional Patent Application #60532384, entitled “Knowledge-driven Architecture,” filed on Dec. 29, 2003. 
     
    
     BACKGROUND OF INVENTION  
       [0002]     1. Field of the Invention  
         [0003]     The present invention relates generally to the field of software architecture. More specifically, the present invention discloses a method that integrates software and knowledge engineering in knowledge-driven architecture. The method allows developers or business experts to quickly build a software application layer by describing application flow as a set of scenarios and introducing application requirements as related business rules in a knowledgebase. An Application Scenario Player and a Service Connector transform application scenarios into interactions with the knowledgebase, presentation components and underlying application services.  
         [0004]     2. Background  
         [0005]     There is a gap in the current development process between the initial business input provided by business experts and the final implementation. The current process requires multiple transformations from user requirements into low-level programming functions and data tables. Multiple technology teams work hard to create multiple filter-layers to fill this gap and break the beautiful shapes of reality into small and simplistic pieces, transforming business rules into Boolean logics.  
         [0006]     This process hasn&#39;t changed much during the last twenty years.  
         [0007]     Some time ago, we thought of the C-language as a language for application development, while Assembly was the language for system development. Since the Assembly language was pushed down to the system level, we use languages like C, C++, C#, VB, and Java to code business algorithms in applications. This development paradigm has been in place for about 20 years.  
         [0008]     However, the current shift to service-oriented architectures and recent advances in knowledge technologies can allow us to cleanly separate generic services from application-level business rules and specific requirements of user-program or program-program interfaces.  
         [0009]     Using a knowledgebase, we can represent requirements as business rules described in “almost natural” language. We can finally shift our focus from ironing out all possible business cases in our design and code to creating flexible application mechanisms that allow us to change and introduce new business rules on-the-fly.  
         [0010]     We can also improve the pattern recognition process. Imagine that a set of rules which defines a recognition process, for example in a grammar file, is enhanced with the ability to access a knowledge engine. This would promise more intelligent recognition, based not only on the multiple choices prepared in the file, but also on existing facts and rules of the available world of knowledge, associations between related topics, etc.  
         [0011]     Software applications often represent a new combination of existing software components. These components often need to be polished or changed to fit into a new application mosaic. Service components are glued and compiled together with specific business rules, expressed as programming algorithms, that distinguish the application.  
         [0012]     Creating an application is a project, often a big project, for multiple teams; the initial team of business experts that know “what should be done” is just the tip of the iceberg. This invention can improve the development process by decreasing the transformation steps required, and thus stop the business requirements from getting watered down and distorted during the process.  
       SUMMARY OF INVENTION  
       [0013]     The invention provides a better separation between generic service components and specific rules and scenarios that characterize the application. Services in a knowledge-driven architecture are integration-ready components presented at the service layer locally or distributed over the network. Business rules and scenarios that represent a very light application layer can be created and changed at run-time by business experts, who would have their chance to influence application behavior, and to say not only “what should be done,” but also “how”.  
         [0014]     The main component of the application is the knowledgebase, which stores application requirements as application scenarios and business rules. The Application Scenario Player and the Service Connector transform application scenarios into interactions with the knowledgebase, presentation components, and underlying application services.  
         [0015]     Knowledge-driven architecture includes elements and mechanisms that provide information about the knowledge and services existing on distributed knowledge systems built with this architecture.  
         [0016]     These mechanisms and the collaborative mechanisms described in the Distributed Active Knowledge and Process Base (see Jeff Zhuk, U.S. patent application, Distributed active knowledge and process base, 2010044827, A1, http://uspto.gov ) allow separate systems to negotiate multiple forms of collaboration: to share or trade knowledge and services with sufficiently flexible levels of security. 
     
    
     BRIEF DESCRIPTION OF DRAWINGS  
       [0017]     The present invention can be more readily understood in conjunction with the accompanying drawings, in which:  
         [0018]      FIG. 1  is a diagram that shows the major blocks of knowledge-driven architecture.  
         [0019]      FIG. 2  shows details of the Presenter and knowledgebase components  
         [0020]      FIG. 3  is a collaboration diagram that describes the interaction between the components  
         [0021]      FIG. 4  illustrates details of the Service Connector component.  
         [0022]      FIG. 5  discloses details of the Scenario Player. 
     
    
     DETAILED DESCRIPTION  
       [0000]    
       FIG. 1 
     
         [0023]     Turning to  FIG. 1 , the present invention consists of the knowledgebase  100  as the main component that collaborates with the application scenario player  200  and the service connector  300 . The application scenario player  200  interprets application scenarios and interacts with the service connector  300  and presentation components  400 . The service connector  300  provides access to the knowledgebase  100  and service components  500 . This is the Functional View (or the Component View) of the architecture. Application requirements are directly represented by the business rules stored in the knowledgebase. A flow of application information as well as interactions between users and the program or/and between partner programs are described by application scenarios written with an XML based application scenario language (ASL).  
         [0024]     We can review the diagram from the position of the Model-View-Controller Design Pattern. From this point of view, the knowledgebase with business rules and scenarios, together with application service components, represent the Model. The presentation components represent the View. The Scenario Player  200  and the Service Connector  300  represent the Controller.  
         [0025]     The major component of the Model is the knowledgebase or Knowledge Engine (KE)  100 . Business rules are captured in the knowledgebase with an “almost natural” ontology language like CycL. A user or program agent  600  can also transmit an application scenario to the controller. Application scenarios are written in the Application Scenario Language. The Application Scenario Language allows developers or business experts to describe application flow as a set of scenario acts with conditional service invocations. The scenario acts can describe interactions between users and programs or between partner programs engaged in a common business transaction, and include calls to knowledgebase services for application business rules and related data.  
         [0026]     Traditional services, which are written with current programming languages like C# or Java and compiled into binary service components, can also capture some business rules and algorithms to support the Model. Services are designed as integration-ready components with separate APIs required by the Service Connector  300 . The Service Connector  300  transforms service requests from application scenario acts into direct calls to service components  500 .  
         [0027]     Each application scenario is a set of scenario acts. Each act is a very lightweight XML description that can invoke some services, exercise conditions or business rules, and include rules for the interpretation of expected user or program agent responses.  
         [0028]     There is a traditional View block of the MVC design pattern. The View delivers information in selected video, sound, or electronic formats; people as well as partner programs are its target audience. In the future, we will refer to presentation components or the View as the Presenter  400 .  
         [0029]     The Scenario Player  200  is connected via the Service Connector  300  to the knowledgebase  100  and other services  500  that represent a business model, and actively uses the knowledgebase  100  in the process of application scenario interpretation.  
         [0030]     The input information for the Scenario Player  200  can be data entered by a user via voice or any other method, an XML service request from the network, or an act of an application scenario. The Scenario Player  200  interacts with the Service Connector  300  that provides access to the knowledgebase  100  and traditional services  500 , as well as to the Presenter  400 , which transforms resulting data into the proper format. The format depends on two factors. A specific implementation of the Presenter  400  that gears towards specific video, audio, or electronic formats is a fixed factor. An application scenario can include some presentation definition-rules that provide extra flexibility for the presentation layer.  
         [0031]     The Scenario Player  200  is also responsible for the interpretation of service or knowledgebase responses. Interpreted responses are directed to the Presenter  400 , which performs the final transformational steps and delivers data to the target audience in the selected presentation format.  
         [0032]     The Presenter  400  can include special engines, like speech, handwriting, or image recognition, which might target a specific type of user input.  
         [0033]     Scenarios can describe sequences of expected events related to multiple agents  600 , and provide rules on handling these events. These scenarios will map each expected event to its observer object, or a set of observers that have interest in the events and handle them with the proper services  500 .  
         [0034]     The functionality described above provides for great flexibility, but can suffer in performance. The Optimizer  700  takes a snapshot of existing rules and scenarios and translates them into source, for example in Java or C#. This source can later be compiled into binary code to iron the current status of application rules into a regular application that lacks flexibility but provides better performance.  
         [0000]    
       FIG. 2 
     
         [0035]      FIG. 2  shows details of the Presenter  400  and knowledgebase  100  components.  
         [0036]     The Presenter  400  can include the Communicator  420 , the Performer  440 , and the Formatter  460  components.  
         [0037]     The Formatter  460  prepares data for audio or video interaction or for communication to other programs. HTML is an example of such formatting. The Performer  440  component uses formatted data for actual presentation via voice or screen. The Performer  440  can be implemented in multiple ways for different client device types. For example, the Performer  440  can display HTML data via the rich graphical interface of a thick client device or workstation.  
         [0038]     The Communicator  420  is responsible for formatted data communications via peer-to-peer distributed networks or other protocols.  
         [0039]     Knowledge and service elements can be distributed over the network, where they can promote their abilities and can be accessed via the Communicator  420  using the collaborative mechanisms described in the Distributed Active Knowledge and Process Base (see Jeff Zhuk, U.S. patent application, Distributed active knowledge and process base, 2010044827, A1, http://uspto.gov).  
         [0040]     The knowledgebase  100  component includes the knowledge service component  120  and the knowledge engine  140 .  
         [0041]     The KnowledgeService  120  component serves as the adapter to the knowledge engine  140 , and adapts the knowledge engine interface to the interface required by the Service Connector  200 .  
         [0000]    
       FIG. 3 
     
         [0042]     The collaboration diagram in  FIG. 3  describes interaction between the components.  
         [0043]     The diagram simplifies the activity of the application to 8 major steps. 
        The ScenarioPlayer object receives an XML instruction from the network, as an act of a current scenario, or a user&#39;s input related to the scenario.     The ScenarioPlayer interprets this input and translates it into a service request directed to the ServiceConnector (the most common action).     The ServiceConnector object uses its act( ) method to connect to or obtain (load at run-time) a necessary service object that will perform the requested operation/method.     The service object invokes the proper method with the necessary parameters, and delivers results back to the caller.     The ScenarioPlayer gets the results of the service, and passes them further to the Formatter object.     The Formatter implementation translates results into a presentation format and produces XML scenarios related to the expected user interaction.     The ScenarioPlayer interprets the results for the Performer object if the operation was a success. If the operation failed (for example, the knowledgebase query returns a “not found” string), the ScenarioPlayer can use the Communicator peer (if present) to outsource this operation to a network of knowledge peers.     The Performer object presents results on a screen or/and in a voice format. The alternative for this step is to communicate data to other peers (for example, if the local peer failed, another peer on the network may be able to resolve the request) or to partner programs. 
 
  FIG. 4  
       
 
         [0052]      FIG. 4  illustrates the details of the ServiceConnector component.  
         [0053]     Each component in the figure represents a block of software responsible for the proper functionality of a component.  
         [0054]     The Actor  310  block is able to play multiple object roles. It takes service and action names as parameters, and invokes the requested method on the requested object type.  
         [0055]     The Actor  310  receives the name of the service and the name of the operation to perform with the required parameters. The Actor  310  looks into the Object Registry  330  to check if there is an existing object of the requested service class. If there is no such service object yet, the Actor  310  works with the Object Retriever  320  to load the requested service class and instantiate the object of this class at run-time. The Actor  310  then registers (stores) the retrieved object in the Object Registry  330 .  
         [0056]     Multiple objects of the same service class are associated with object names. In this case, the Service Connector  200  receives an object name as an additional argument to service and action names that identify the service class and the method names. The registered object keeps its state during its lifetime, which can include many service invocations.  
         [0057]     The next step is to use Method Retrieval  340  to retrieve the proper method, which will perform the requested service operation. The Method Retrieval  340  selects one of the methods of the selected service object based on the provided method parameters. The Actor  310  then uses the Method Performer  350  to perform the operation.  
         [0058]     The Service Connector can be implemented in Java, C#, or other languages that allow systems to load service objects at run-time based on their names. The Method Retrieval mechanism consists of three steps/trials. 
        Use the method name and parameter types to find an exact match. For example, a Java implementation would use the mechanism offered by the Class.getMethod( ) method.     Unfortunately the exact match rarely happens in real programs. Parameter types are often subclasses of required argument classes. The second step is to check for method compatibility instead of the exact match. For example, a java implementation would use the mechanism offered by the Class.isAssignableFrom( ) method.     It is possible that both trials will fail because of implementation issues. For example, Personal Digital Assistants (PDA) or wireless phones do not have sufficient library support for such sensitive reflection mechanisms. In this case, the third attempt will invoke a specific method of the service object that serves as the dispatcher for other methods of this service class. For example, it may call a method named “dispatch( )” of that class according to the initial interface/agreement between the Service Connector and service classes. The “dispatch( )” method takes the name of a service operation (a method name) and the array of objects. These objects will be cast into specific types inside the “dispatch( )” method according to the requirements of the specified service method.        
 
         [0062]     The ScenarioPlayer  200  component is responsible for handling agent events. The ScenarioPlayer  200  also provides interpretation and performance of application scenarios, which contain rules for possible events and related handling procedures.  
         [0063]     Requested services can be implemented as service components  500  or as knowledgebase rules.  
         [0000]    
       FIG. 5 
     
         [0064]      FIG. 5  discloses details of the Scenario Player  200 .  
         [0065]     The Scenario Player  200  consists of two major parts: the Interpreter and the Act Player presented in  FIG. 5  with blocks  210 - 240  and  250 - 290  respectively.  
         [0066]     The Input Type Checker  210  checks current input and, depending on its type, submits the input to one of the interpreters.  
         [0067]     Knowledge-driven architecture includes elements and mechanisms that provide information about the knowledge and services existing on other istributed knowledge systems built with this architecture. These mechanisms include but are not limited to the Service Analysis  215  component and learning scenarios.  
         [0068]     The Success Analysis  215  component provides a history of success, history of interpretation failures, and, in the case of interpretation failure, invokes one of the learning scenarios that prompt an agent (a user or a program) to re-define the input or provide more details for better interpretation. If the learning scenario cannot be executed at that time (it was canceled, etc.), the scenario will be placed in the queue of scenarios with un-answered questions to be played later and to resolve unsuccessful interpretations.  
         [0069]     Each service component can have usage and value properties (see Jeff Zhuk, U.S. patent application, Distributed active knowledge and process base, 2010044827, A1, http://uspto.gov ). The Success Analysis  215  component re-evaluates these properties after each service request.  
         [0070]     The set of interpreters includes but is not limited to the Scenario Act Interpreter  220 , the Prompt Response Interpreter  230 , and the New Agent Request Interpreter  240 .  
         [0071]     All interpreters transform original input into scenario player APIs or service component APIs. Interpreters are connected to the Presenter  400  and can use the Formatter  460  and the Performer  440  services. For example, the input line can instruct the system to present information via a specified video or audio format. It is also possible that no current interpretation will be found. In this case, a default learning scenario would be played, prompting an agent (a user or a program) to re-define the input or provide more details. Default scenarios can be replaced at run-time with enhanced ones.  
         [0072]     Interpretation rules are stored in the knowledgebase  100 . Interpreters interact with the Query Performer  280  to access the knowledgebase  100  via the Knowledge Service  120 . When existing rules fail, the learning scenario (default or not) is given the questionable unresolved input, and is called upon to retrieve new definitions or more details from an agent (a user or a program). Upon successful execution, the scenario ends up with one or more acts that re-define existing rules or/and add more rules to the knowledgebase. If the learning scenario cannot be successfully executed at this time, the scenario will be stored in the Queue of Scenarios  245 , and will be tried again later. This provides for great flexibility, which is a welcomed feature for most business applications as well as educational systems.  
         [0073]     The Player part of the Scenario Player  200  consists of the Queue of Scenarios  245 , the Scenario Modifier  250 , the Current Scenario  255 , the Next Act Retrieval  260 , the Translator  265 , the Alias Retrieval  270 , the Condition Checker  275 , the Query Performer  280 , and the Service Performer  290 .  
         [0074]     The Queue of Scenarios  245  stores the current scenario when it cannot be executed at the present time, but needs to be executed later on. For example, if a user cannot provide answers to a learning scenario at this moment, but can do so afterward.  
         [0075]     The Scenario Modifier  250  receives results from every step of playing the scenario act. If the current act resolves the value of any variable in the scenario, the Scenario Modifier  250  replaces this variable with its value in the Current Scenario  255 . For example, the scenario can include the variable PEER-GROUP-NAME. Any act of the scenario that resolves this variable will pass the variable name and its value to the Scenario Modifier  250 , and the Scenario Modifier  250  will replace this variable in the Current Scenario  255  with the value of the variable.  
         [0076]     The Current Scenario  255  is loaded from the knowledgebase  100  or from the Queue of Scenarios  245 , and can be updated with run-time values by the Scenario Modifier  250 . Any current scenario consists of scenario acts: simple XML elements/instructions. Each instruction can be a prompt to an agent (a user or a program) or a service request, including internal and external services.  
         [0077]     The Next Act Retrieval  260  retrieves one act of a scenario at a time. This is usually the next act according to the sequence of acts stored in the scenario. The sequence of acts can be changed with conditional statements.  
         [0078]     Blocks  265 - 290  in  FIG. 5  can be considered as examples of internal services that are often used in the process of interpreting instructions or as responses to a prompt.  
         [0079]     The Translation  260  takes a set of arguments that describe the type of the requested translation. The translate element invokes the Translation  260  block. Here is an example of using the translate element: 
        &lt;prompt action=“prompt” service=“com.its.connector.ScenarioPlayer”    variable=“PERSON-NAME”    translate=“concatenate(REPLACE-WITH-INPUT)”    msg=“Please provide your name (First Last)”/&gt;       
 
         [0084]     The system will find the concatenate and startWithUpperCase methods in the available translator service components or in the knowledgebase where the action is stored as an executable rule. The action will concatenate a user&#39;s input and make sure that each word begins with the upper case. For example, if the input was “jeff zhuk” the first instruction will produce “jeffZhuk” and the second instruction will make it “JeffZhuk”.  
         [0085]     The Alias Retriever  270  checks for in-line aliases that can be used as the “aliases” element in the current scenario act. For example, the following element would instruct the Alias Retrieval  270  to interpret prompt responses like “Y”, “OK”, or “Sure” as “Yes”. 
        aliases=“Yes|y|ok|sure”       
 
         [0087]     The Alias Retriever  270  can be also invoked when an instruction includes the “inAliases” element that directs the Alias Retrieval  270  to look in the knowledgebase for a set of related aliases as provided in the example below. 
        &lt;prompt variable=“TRAINING-COURSE” perform=“prompt”    msg=“What subject do you want to learn?” inAliases=“Java TrainingCourses”/&gt;       
 
         [0090]     The knowledgebase can contain a set of rules/aliases related to course names. For example, entered keywords like “enterprise” or “server” will result in the name “J2EE”, while keywords like “PDA” or “wireless” will result in the course name “J2ME”.  
         [0091]     A found alias, for example, “J2EE”, will be passed to the Scenario Modifier  250  to replace the current variable name “TRAINING-COURSE” with its alias value. Otherwise, the variable name will be replaced with the original response.  
         [0092]     The Condition Checker  275  is invoked by the “condition” element in a scenario act. The “condition” element is followed by a specified condition, one from the list of conditions, (like “exists”, “!exists”, “equals”, etc., see the list of conditions in the application scenario language) and required arguments.  
         [0093]     A conditional statement is usually followed by an action to perform. If a condition is not met (returns false) the action will not be performed, and the next scenario step will be played instead.  
         [0094]     For example, a conditional instruction can check if a requested training course exists. 
        &lt;if condition=“!exists” pattern=“TRAINING-COURSE”lastMsg=“The course is not found. Enter more keywords.”/&gt;       
 
         [0096]     Conditional instructions, like “includes”, “equals”, etc. require two arguments: a pattern and a source. 
        &lt;if condition=“includes” pattern=“TRAINING-COURSE”source=“XML”perform=“playScenario(XMLTechnologies)”/&gt;       
 
         [0098]     The conditional instruction in the example above will check if a selected training course includes the “XML” keyword. If the condition is true the system will start playing the “XMLTechnology” scenario. Otherwise the next sequential act of the current scenario will be played instead.  
         [0099]     The Query Performer  280  is invoked by the query element when it is present in a scenario. 
        &lt;act queryResult=“PASSWORD-QUESTION=PASSWORD-ANSWER”query=“passwordOf(USER-NAME)”/&gt;       
 
         [0101]     The query instruction provided in the example above checks in the knowledgebase for a user&#39;s record and delivers one of the password questions with its answer. In the current example, knowledgebase records include more than one way to check a user&#39;s identity. There may be different password questions as well as password answers, and the knowledgebase would select one or more of them based on some rules established by your requirements.  
         [0102]     For example, the question can be as simple as “Password?”, or more complicated like “What is your mother&#39;s maiden name?”, etc. The question is retrieved along with the answer, and both are assigned to proper variable names.  
         [0103]     In the case of a successful query, the retrieved value will be passed to the Scenario Modifier  250  to replace the variable name in the current scenario.  
         [0104]     The Service Performer  290  is invoked by the action or perform elements at the very end of the execution of an act of a scenario regardless of the order in which the elements of the act were written. Translations, alias retrievals, conditions, and queries, if any, are done before the Service Performer invocation.  
         [0105]     The Service Performer  290  transforms the action or perform elements into a set of arguments including a service name, an optional object name (if multiple objects of the same service class are to be used), a service operation name, and a set of parameters. It then passes these arguments to the Service Connector  200 , which will access the proper service object and execute the proper service method.  
         [0000]     Application Scenario Language  
         [0106]     Application Scenario Language (ASL) is an XML-based language that describes application business flow in small scenarios. The scenario language constructs can be changed, improved, and extended; they are here in this form to illustrate the invention. Scenarios consist of XML elements: scenario steps or acts. Every act of a scenario is a prompt, a condition, or an execution step.  
         [0000]     Prompt the User or a Partner Program for an Answer  
         [0107]     The prompt might have additional arguments, specific rules for input interpretation, and conditional actions.  
         [0108]     Here is an extract from the addKnowledge.xml scenario, which allows someone to introduce a new object to the knowledge base.  
         [0000]     &lt;prompt variable=“NEW-OBJECT” service=“com.its.connector.ScenarioPlayer”action=“prompt”noinput=“reprompt(Your input is needed)”translate=“concatenate”msg=“Please provide a name for your new topic.”/&gt; 
         [0000]    
       
         
           
              &lt;if condition=“!exists“perform=“doNextStep(acceptNewObject)”/&gt; 
              &lt;act name=“reject”action=“query”constant=“NEW-OBJECT”lastMsg=“NEW-OBJECT is not new.”/&gt; 
              &lt;act name=“acceptNewObject”service=“com.its.connector.KnowledgeService”action=“createNewPermanent”constant=“NEW-OBJECT”/&gt; 
           
         
       
     
         [0112]     The prompt element of the scenario will invoke the prompt mechanism (method) of the ScenarioPlayer  200 . The prompt ( ) method of the ScenarioPlayer class works with the Presenter  400  component to deliver a prompt message. The method shifts the ScenarioPlayer into the interpretation state. It will interpret the user&#39; response and assign the variable provided with the prompt parameters to the value of the interpretation result.  
         [0113]     The prompt element of the XML scenario specifies the service-class name (com.its.connector.ScenarioPlayer) and the action-method name (prompt), and sets the prompt variable (NEW-OBJECT) to store the user&#39;s input. One of the most important arguments of the prompt element is the prompt message delivered to the target audience.  
         [0114]     The noinput and translate elements are optional interpretation parameters. The noinput element directs the program to re-prompt a user if the user just pressed the ENTER key.  
         [0115]     The translate element instructs the program to concatenate multi-word input into a single word that can better serve as a unique reference.  
         [0116]     A more complete example of the Application Scenario Language is provided in the attached Attachment 1-Application Scenario Language.  
         [0117]     By providing application requirements via business rules with “almost natural” predicate logics, we can take a short-cut past several steps of the traditional development process, where requirements are boiled down to traditional Boolean-logics based programs. The main reason is the difference between programming languages and ontology languages, which can be used to describe business rules. Ontology languages are closer to our natural language, and can express an unlimited number of relationships that can be provided with predicates, while programming languages are extremely limited with their syntax and especially with their set of relationships. The difference between predicate logics and Boolean logics is tremendous. In a way, traditional development translates natural language requirements into Boolean logics. Predicate logics require almost no translation.  
         [0118]     In the example below, we use the Cyc language (CycL), by Cyc Corporation, to describe several rules of an educational system. Let us say that the application allows students and instructors to collaborate in a group with multiple roles. A three-dimensional matrix of roles, related access types, and privileges describes access to documents and services (see Jeff Zhuk, U.S. patent application, Distributed active knowledge and process base, 20010044827, A1, http://uspto.gov).  
         [0119]     A very powerful and simple Cyc Language constant helps create unlimited hierarchies. The formula below means that every instance of the first collection, GroupMember, is also an instance of the second collection, SystemUser.  
         [0120]     (genls GroupMember SystemUser)  
         [0121]     In other words, SystemUser is a generalization of GroupMember.  
         [0122]     The genls predicate expresses the idea that one collection is subsumed by another.  
         [0123]     In the example below we can define a new function that will return the group role of a member.  
         [0124]     Here is an example of a definition for the function MemberRoleFn:  
         [0125]     (arity MemberRoleFn 2) 
        (arg1lsa MemberRoleFn User)     (arg2lsa MemberRoleFn Group)     (resultlsa MemberRoleFn GroupRole)        
 
         [0129]     We read this function definition as: the MemberRoleFn function has 2 parameters: user and group. The function returns the specific group role that the user plays in the specified group.  
         [0130]     The following example establishes a rule with the implies keyword:  
                                                                                               (implies                (and   (hasMe                mbershipIn ?USER ?GROUP)                (hasRole ?USER ?GROUP Admin)           (hasPrivilege ?USER ?GROUP Change                MemberRoles)))                      
 
         [0131]     This rule says that if a user has membership in a group and the user has the role of an administrator in this group this user has the privilege to change member roles in this group.  
         [0132]     “implies”, “and”, as well as “or”, and “not” are important Cyc&#39;s logical connectives.  
         [0133]     The benefits of using an ontology language versus a programming language become even more impressive when application rules are more complex and have a tendency to change frequently.  
         [0134]     Application scenario language allows us to describe business information flow and user or program interactions. Application scenarios complement business rules, providing direct access to application services. Application scenario language constructs describe service and operation names, define data flow conditions and provide interpretation rules for successful business operations. Application scenarios as well as business rules that comprise the application layer can be directly created by business experts, while application services will be created by programmers and can be considered as part of the system layer.  
         [0135]     Here is an example of the scenario for an educational system. The scenario allows the system to accept a new object and add this object to the knowledgebase, and provides integration of the new object with existing knowledge. 
        &lt;prompt variable=“NEW-OBJECT” perform=“prompt”noinput=“reprompt(Your input is needed)” translate=“concatenate” msg=“Please provide a name for your new topic.”/&gt;    &lt;if condition=“!exists”perform=“doNextStep(acceptNewObject)”/&gt;    &lt;act action=“query”constant=“NEW-OBJECT”lastMsg=“NEW-OBJECT is not new.”/&gt;    &lt;act name=“acceptNewObject” service=“com.its.connector. KnowledgeService”action=“createNewPermanent” constant=“NEW-OBJECT”/&gt;    &lt;prompt variable=“EXISTING-COLLECTION” perform=“prompt” msg=“Enter an existing topic name that can serve as a parent to your new topic.”/&gt;    &lt;if condition=“!exists”pattern=“EXISTING-COLLECTION”perform=“reprompt(EXISTING-COLLECTION is not found in the KB.)”/&gt;    &lt;act query=“(isa EXISTING-COLLECTION ?X)” queryResult =“COLLECTION-QUERY-RESULT”/&gt;    &lt;if condition=“!includes” pattern=“Collection” perform=“reprompt(EXISTING-COLLECTION is not a Collection)”/&gt;    &lt;act lastMsg=“NEW-OBJECT is integrated in the knowledgebase”/&gt;       
 
         [0145]     The example above prompts a user to provide an existing collection name that would relate a new subject to existing data. The following statements check if the user&#39;s input is worth trusting.  
         [0146]     Does this parent name really exist in the knowledgebase, or just in the user&#39;s imagination? Does this name meet the requirement to be a collection? (Not every existing object can be a parent. Only Collection type objects can.) This short scenario written by business expert can be easily extended or complemented by other scenarios without a programmer&#39;s participation.  
         [0147]     Examples of the constructs of the Application Scenario Language are provided in the attached document titled “Attachment 1-Application Scenario Language”.