Abstract: The auditing of authorization decisions is facilitated by integrating or coupling an audit policy to access control decisions. In an example implementation, an audit policy of an auditing scheme is coupled to a semantic framework of an access control scheme such that the audit policy is specified using at least a portion of the semantic framework. In another example implementation, audit policy rules include audit content rules that specify what audit information from any of the inputs, the outputs, or the internal data of authorization decisions is to be included in an audit record. In yet another example implementation, a semantic of an audit trigger rule comports with a semantic framework of an access request and of a logical evaluation for an authorization decision.

Abstract: An Extensible Markup Language (XML) Application Server for storing, processing, communicating, and displaying dynamic semi-structured information. It comprises a declarative specification language, a transactional indexed XML data store, and an XML application server engine. An integrated architecture (a) provides for optimization, indexing, and backtracking search in a business logic layer, (b) provides for general-purpose programming idioms including recursive function definitions, iteration, and dynamic dispatch in data layer queries and updates, and (c) eliminates processing overhead and maintenance issues caused by transforming between relational, object-oriented, and semi-structured data paradigms.

Abstract: A framework for generating a semantic interpretation of natural language input includes an interpreter, a first set of types, and a second set of types. The interpreter is adapted to mediate between a client application and one or more analysis engines to produce interpretations of the natural language input that are valid for the client application. The first set of types is adapted to define interactions between the interpreter and the one or more analysis engines. The second set of types is adapted to define interactions between the interpreter and the client application.

Abstract: Mating of a modified user interface to existing user interface code is provided. When a user interface is modified, a pseudo code representation of the modified user interface is generated. At application runtime, the pseudo code representation is passed to a user interface render engine that is modified to parse the pseudo code representation to generate a representation of the modified user interface that may be processed by the render engine for rendering the modified user interface for display. A generic code library is generated for receiving events from the modified user interface and for passing the received events to proper event handlers in the existing code library without the need to modify the existing code library in response to modifying the user interface.

Abstract: Embodiments of the invention provide a framework for pre-processing Javascript files. In some embodiments, the framework includes a pre-processor component operable to determine whether pre-release Javascript file versions include pre-processing commands in a predefined syntax which is defined by the framework. The pre-processor component may maintain a mapping between any or all of these commands and one or more handler programs, such that the handler program(s) may be invoked to perform any of various pre-processing functions on a pre-release file version. The framework may be extensible and scalable in that it may accommodate the addition of or modification to any number of handler programs. A new handler program may be developed and invoked, for example, via a new pre-processing command which is defined to the pre-processor component and mapped to the handler program.

Abstract: An application program interface (API) provides a set of functions that make available support for processing XML documents for application developers who build Web applications on Microsoft Corporation's .NET™ platform.

Abstract: Declarative definition and composition of activities of a continuation based runtime. When formulating such a declarative activity of a continuation-based runtime, the activity may be formulated in accordance with a declarative activity schema and include a properties portion that declaratively defines one or more interface parameters of the declarative activity, and a body portion that declaratively defines an execution behavior of the declarative activity. The declarative activities may be hierarchically structured such that a parent declarative activity may use one or more child activities to define its behavior, where one or more of the child activities may also be defined declaratively.

Abstract: Provided are a method, system, and article of manufacture for using annotations to reuse variable declarations to generate different service functions. A declaration file has variable declarations in a first programming language environment for use by application functions. The declaration file includes a plurality of sets of annotations for a plurality of service functions. Each of the sets of annotations identifies variables in the declaration file to use with one of the service functions. The declaration file is processed to generate one of the service functions. The set of annotations in the declaration file for the service function to generate is determined. The determined set of annotations is processed to determine variables to include with the service function to generate. The determined variables from the declaration file are used to generate the service function.

Abstract: A programming language type system includes, in a memory, a set of numeric type including integer types, fixed-point types and floating-point types, a set of type propagation rules to automatically determine result types of any combination of integer types, fixed-point types and floating-point types, constant annotations to explicitly specify a result type of a literal constant, context-sensitive constants whose type is determined from a context of a constant according to the set of type propagation rules, an assignment operator to explicitly specify a type of a value or computation, and operator annotations to explicitly specify a result type of a computation.

Abstract: A development and runtime framework for applications that execute in real-time operating systems. Application development is enhanced through simple instructions that allow a programmer to declare functions and sets of functions as tasks and supertasks, respectively, and manage the execution of functions, tasks and supertasks with priorities. A compiler or pre-processor provides tools for generating the code for tasks and supertasks, and the management code for managing execution. Function calls may be made directly to functions within supertasks via respective entrypoints, and the tasks are managed based on the functions being invoked. Within a supertask, a higher priority function may be runnable while a lower priority function of that supertask is suspended. A cookie is used to recognize when a register update for a supertask may be omitted, enabling more efficient context switching.

Abstract: A data processing representation is expressed in the form of code sections, which may be nested, using multiple programming languages. The representation is read by an execution engine. The execution engine identifies the language of each code section, and a corresponding language specific processing unit is invoked to process the code section. The processing unit reads that section, identifying sub-sections specified in it's associated language and other sub-sections specified in unknown languages. It executes the sub-sections specified in its associated language with the intended semantics and in the appropriate order. When a sub-section specified in an unknown language is encountered, it delegates processing of that sub-section back to the execution engine, which repeats this process for the unknown sub-section. The execution result is returned back to the requesting language specific processing unit, which continues processing from where it left off.

Abstract: A database table of predefined data transformations is provided. Each predefined data transformation is associated in the table with a unique identifier, a corresponding description and a validity period. When a data modeler wishes to develop a data model for a desired prediction, he/she will first determine a set of variables that will be used therefor. The set of variables can include any of the predefined data transformations from the database table. The data model will then be developed by applying raw data to the set of variables and determining a mathematical relationship there between. Once the data model has been developed, the data modeler will write a reusable specification for applying the data model operationally. Thereafter, IT personnel or the like can code and deploy the data model using the specification.

Abstract: A method is presented that enables custom applications to embed rule authoring capabilities. In one embodiment, the method includes: imbedding a rule picker into an existing software application; presenting a choice of rules to be implemented in the existing software application, wherein a business vocabulary context defines and limits the choice of rules that is presented; and integrating a selected rule, from the choice of rules, into the existing software application. The business vocabulary context may be determined by a business vocabulary of the existing software application, wherein the business vocabulary is composed of software objects that describe a current session of the existing software application. The business vocabulary context may be defined as a name of a category that is passed to a rule creation engine by a rule picker in an Integrated Development Environment (IDE), such that a rule picker tag may be rendered in the IDE.

Abstract: A computer-implemented method is disclosed for encouraging downloads of a game. The method includes displaying an achievement advertisement and subsequently receiving input indicative of the achievement advertisement. The input is responded to by displaying a download component related to a game associated with the achievement advertisement.

Abstract: A computer-implemented technique for executing a process is provided. The technique includes providing a class having at least one annotation that defines at least a portion of the process. The annotation is a run-time-readable, non-executable declarative programming construct that is associated with a first method of the class, and specifies at least one transition rule and a second method of the class associated with the transition rule. A process engine, which runs on a computer and is not an instance of the class, parses the annotation to extract the transition rule. The process engine receives a message from a source external to the process engine, and evaluates whether the transition rule is satisfied, responsively to the message. Upon finding that the transition rule is satisfied, the process engine invokes the second method, so as to generate an output with respect to the message. Other embodiments are also described.

Abstract: A means is provided for specifying, applying, and managing sets of temporary or permanent additions or modifications to the behavior of object-oriented programs without having to change the code of the program, by using externalized rules. The points at which the externalized rules may be applied is determined by the implementation object model, thus making their specification natural to the program developers who are familiar with the program's implementation object model. The concept of dynamic method-based trigger or control points is disclosed for identifying potential rule attachment points in objects and identifying the rules that are applicable to each dynamic control point. At least one control point is flagged on the basis of being active such that the at least one control point and its associated rule is only processed if the at least one control point is flagged as being active.

Abstract: A security privilege view object instance. The security privilege view object instance provides security at the view object instance level, permitting multiple application modules to utilize a single entity object with different data privileges. In an embodiment, a view object implementation method is overridden to add selected security filters at instantiation of a view object instance.

Abstract: Various technologies and techniques are disclosed for managing layout updates to user interface elements. A dirty state of user interface elements is tracked in a tree with multiple nodes of user interface elements. The dirty state allows dirty subtrees of the nodes to be identified. A root node is identified for each of the dirty subtrees. Affected portions of the tree are updated, starting with the root node that was identified for each of the dirty subtrees. As part of the update process, changes to ancestor nodes are detected and used to make a layout process more efficient. For example, any layout processes that are currently being performed on any descendant nodes of a changed ancestor are abandoned, and the layout process is resumed at the changed ancestor. After updating affected portions of the tree, the updated user interface elements are then rendered on an output device.

Abstract: A method of providing data communications between first and second computing devices over a data network may include receiving a request for data communication at the first computing device from the second computing device over the data network. After receiving the request for data communication, a request for a credential according to an authentication standard may be transmitted from the first computing device to the second computing device, and the request for the credential may identify the authentication standard. After transmitting the request for the credential according to the authentication standard, a credential according to the authentication standard may be received, and the credential maybe verified. Responsive to receiving the request for data communication and responsive to verifying the authentication credential, the requested data communication may be allowed.

Abstract: A programming language is implemented in terms of another programming language via deep and/or modified shallow embedding. Embedded language control structures and/or type system are decomposed to primitive features. These features are semantically mapped to host language features. Other embedded language features are explicitly constructed in the host language. A map can also be constructed as a function of implementation to facilitate mapping embedded language applications to host language applications.

Abstract: An Extensible Markup Language (XML) Application Server for storing, processing, communicating, and displaying dynamic semi-structured information. It comprises a declarative specification language, a transactional indexed XML data store, and an XML application server engine. An integrated architecture (a) provides for optimization, indexing, and backtracking search in a business logic layer, (b) provides for general-purpose programming idioms including recursive function definitions, iteration, and dynamic dispatch in data layer queries and updates, and (c) eliminates processing overhead and maintenance issues caused by transforming between relational, object-oriented, and semi-structured data paradigms.

Abstract: A declarative program definition. The definition is analyzed to produce an application contract that describes semantics for sending and receiving application messages during the successful execution of operations by the program. In addition, this analysis may also generate local behaviors associated with the local execution of the program. Alternatively or in addition, the analysis may infer secondary contracts regarding the sending and receiving of application messages, even though the full details of the secondary contracts are not present in the declarative program definition. For instance, the secondary contracts might include error contracts or consistency contracts.

Abstract: Systems, methods, apparatus and software can provide object interaction tools and techniques that allow a user to interact with a software object using familiar user interface elements. Information about the target object is provided so that an instance can be constructed. The object is introspect so available data and methods information can be used to populate a corresponding object interaction description and present an object interaction session.

Abstract: A system and/or methodology that enables personalization as a platform service for applications via a rich data view. More particularly, the subject invention provides for a rich data view to be rendered to an end-user whereas management of the data can be effected (e.g., personalized) thereafter. In other words, the invention enables a user to establish and access personalized mechanisms via a rich data view. The personalized mechanisms are based upon rule-based logic with respect to application data types.

Abstract: A technique to generate an executable task includes inspecting a task specification data structure to determine what software entities are to be generated to create the executable task, inspecting the task specification data structure to determine how the software entities will be linked after generating the software entities, inspecting the task specification data structure to determine logic to be executed by the software entities, and generating the software entities to create the executable task.

Abstract: The present invention relates to an XML application framework (XAF). XAF applications are data driven such that all operations with the computer system are data focused. In addition, the components used in the XAF application are instantiated and connected according to how the data is displayed and what type of data is used. Applications within XAF comprise a user interface (UI) connector, an action module, and a data connector. UI connectors receive UI events and connect the UI event to an action module. The action module generates a standard format action from the UI event and sends it to the data connector. The data connector translates the standard format action into a data-specific action that changes data in a data store. A data connector then sends a standard format data representation corresponding to the changed data back to the UI connector to provide the changed data to the UI.

Abstract: A computer implemented system for a dynamic screen generation and navigation engine is provided. The system includes a set of screen templates, a screen data document, and a screen manager. The screen data document includes screen data for at least one screen template of the set of screen templates. The screen manager includes a generator engine and a navigator engine. In response to user input, the generator engine obtains screen data from the screen data document, obtains a screen template from the set of screen templates based on the obtained screen data, combines the obtained screen data with the obtained screen template to generate a screen, and displays the generated screen. The navigator engine obtains a user selection for the generated screen, references the screen data corresponding to the obtained user selection to determine a next screen to generate, and prompts the generator engine to generate the next screen based on the referenced screen data.

Abstract: Systems and methods of representing and extracting type information from typeless and dynamically-typed programming languages are provided. These systems and methods can be immune to source file edits and the order in which those edits are executed. Deriving type information from these languages allows tools to perform operations, for example, refactoring, intellisense, recognition of semantic errors, etc. These systems and methods can be implemented using processes that, implicitly or explicitly, gather type information for the program, and can also accept user input as well.

Abstract: Described herein is an implementation of a technology for the construction, identity, and/or optimization of operating-system processes. At least one implementation, described herein, constructs an operating-system process having the contents as defined by a process manifest. Once constructed, the operating-system process is unalterable.

Abstract: A reconfigurable, hierarchical component-based architecture and framework for rapidly developing sensor device enabling software applications can have a rule-based data structuring system, a series table system, and a system of acquiring data from a data provider. User defined relationships can be established to enable exchange of data between the rule-based data structuring system, the series table system, the system of acquiring data, another rule-based data structuring system, an object oriented wrapping system, a data filtering system, a data structure grouping and merging system, a data device writer system, and a network communications system.

Abstract: The present invention is to provide a method for enabling Blue-ray Disc Java (BD-J) to effectively obtain context of a corresponding application, namely an Xlet, while playing BD-J title, which comprises the steps of setting up source file attribute of each class by adding an Xlet context ID as an unique code to the class when loading all classes into a cache of the BD-J; looking up back onto a call stack to search for Xlet class of the current BD-J title when searching for Xlet context; and then obtaining the Xlet context through the Xlet context ID according to the source file attribute. Thus, the method of the present invention enables BD-J to normally play the BD-J title in the Blue-ray Disc Read Only Memory (BD-ROM) and, at the same time, effectively improves the playing performance.

Abstract: A system and method are provided for state management and workflow control. The system includes a metadata based state management system that can be used as a workflow control system. The system enables business rules to be separated from application logic, thus allowing businesses to easily change rules and adapt and respond to competition without requiring code changes. The system preferably includes database tables that interface with procedure calls in order to manage transactions in accordance with business rules. The business rules may include action permission rules that determine if a user is in a required state before allowing a selected action. A second set of rules determines an updated user state based on user actions.

Abstract: A framework is implemented. The framework is configured to execute an application within the framework, the application includes instantiated runtime objects. New instantiated runtime objects may be created and instantiated runtime objects destroyed while the application is executing. The framework is further configured to implement a debugger within the framework. At the debugger, instantiated runtime objects are correlated with lines of code of the application. Some embodiments allow users to debug executing applications. This can be accomplished by a user interacting with the executing application which then causes indications in the debugger or interacting with the debugger and which causes indications on instantiated runtime objects in the application.

Abstract: According to some embodiments, a visual design tool associated with a generic modeling framework may be selected, and a set of design-time functions used in the visual design tool may be identified. A set of design-time rules may be created (e.g., by a rule creator), each rule corresponding to an identified design-time function. In addition, parameters may be defined for each rule in terms of entities of a language of the generic modeling framework. A set of basic rule cases may then be defined for each rule to specify rule logic, and an extension mechanism may be provided to enable the defined set of basic rule cases to be extended outside the generic modeling framework. According to some embodiments, the set of rules and associated basic rule cases may be interpreted at run-time by the modeling framework.

Abstract: A system and method for accessing requested data in a database using result set objects. The invention also provides a set of enhancements to the EJB Query Language (“EJB QL”) for providing result sets using EJB QL and to efficiently access databases using select methods within Enterprise Java Beans. EJBQL language extensions allow for the selection and retrieval of result sets. Since the use of the invention is expressed in terms of object relational constructs defined in an EJB deployment, it allows for the retrieval of data from a database expressed in terms of the relationships defined in that EJB deployment.

Abstract: Systems and methods of representing and extracting type information from typeless and dynamically-typed programming languages are provided. These systems and methods can be immune to source file edits and the order in which those edits are executed. Deriving type information from these languages allows tools to perform operations, for example, refactoring, intellisense, recognition of semantic errors, etc. These systems and methods can be implemented using processes that, implicitly or explicitly, gather type information for the program, and can also accept user input as well.

Abstract: A method of automatically determining firing priority in a plurality of rules. The method includes the steps of determining a level of dependency of each rule; and generating a hierarchy of rules in response to the level of dependency of each rule, wherein the firing priority corresponds to the hierarchy of rules. In another embodiment, the method further includes the step of determining if the hierarchy results in an inconsistency. In another embodiment, the method further comprises the step of determining if the hierarchy results in a loop. In yet another embodiment, the step of determining a level of dependency of each rule is performed in response to an initial event. In one embodiment the method includes the step of determining if there are reciprocal dependencies between any two rules in the set of rules.

Abstract: A data processing system, method, and instructions executable on a computer inspect the quality of software code. A summary report is generated that summarizes aspects of the current status of a software project. The summary report may include which portions of code have been written, which have been edited to predetermined standards, and which remain to be written. Errors in the code may be identified. Warnings associated with portions of the code may be generated, as well as suggested changes to the code. For comparison, the suggested code changes may be displayed along side of the corresponding portions of the pre-existing code that the suggested code is intended to replace. Hard coded values may be automatically identified. Text elements corresponding to each hard coded value may be automatically created. Subsequently, each hard coded value may be automatically replaced by the corresponding text element. Revisions to pre-existing code may be inspected.

Abstract: A system receives a design document, parses the design document into voice extensible markup language (VXML) elements, and creates a VXML document from the parsed VXML elements.

Abstract: The present invention relates to a software development infrastructure and/or methodology in, for example, multi-platform computing environments. More specifically, this invention relates to a software development system and an approach for providing, for example in at least one embodiment, a lattice-based organization of interdependent software products for multi-dimensional progressive application specialization. The inventive system and method optionally starts with a generic root product node and incorporates more domain specific extensions in multiple tiers of constructs, facilities, and complexities, to create specialized applications.

Abstract: A method and apparatus for preventing rogue implementations of a security-sensitive class interface are provided. With the method and apparatus, a unique identifier (UID) is created by a server process when the server process is started. Anytime the server process, i.e. a server runtime environment, instantiates a new credential object following start-up of the server process, the encrypted UID is placed into a private field within the new credential object. In addition, the UID is encrypted and stored in a private class of the server runtime environment. A verification class is provided within the server runtime environment which includes one or more methods that receive the credential object as a parameter and return true or false as to the validity of the credential object.

Abstract: Various technologies and techniques are disclosed for using annotations in contracts to generate views and adapters. A framework is provided that supports annotations that can be used in a contract to allow a user to express how one or more members of the contract should be represented in at least one view, and to express how to adapt the members in at least one adapter. Annotations can also be used to indicate which of the components should be programmatically generated. The contract is accessed and at least a portion of the at least one view and the at least one adapter are generated based on the annotations and other information contained in the contract. For example, source code can programmatically be generated for a host side view, an add-in side view, a host side adapter, and an add-in side adapter using the various contract details and the annotations.

Abstract: An integration server architecture (ISA) that facilitates communication between processes that do not share a common message format or use a common communication protocol. The ISA comprises a combination of adapters and a Queuing and Translation Engine (QTE). Every process that uses the ISA must have an adapter designed to understand that process's native message format. The adapter forwards the message to the QTE. The QTE places the forwarded message in an incoming message queue (IMQ). The QTE then retrieves messages from the IMQ in the order they arrive, identifies the sender, and locates an entry for the sender in a Configuration Database (CDB). The CDB entry designates a translation map that enables the QTE to properly translate messages into the receiving process's native format. The QTE uses the map to translate the messages into the receiving process's native format, and then forwards the translated message to the appropriate adapter.

Abstract: Use of declarative constraints in an error validation framework of a graphical modeling tool. The declarative constraints define one or more rules that objects of a graphical model should adhere to. When enforced against the graphical model, objects that do not conform to the rules may be identified. A declarative relationship between the non-conforming object and its visual representation in a graphical diagram may be used to allow for visually identifying the visual representation in the graphical diagram.

Abstract: A method for optimizing functions is described. A query including an invocation of a function is received. A function declaration indicates that the function is associated with a first set of datatypes. At compile-time, static type-checking is performed on the query. During the static type-checking, a second set of datatypes is determined for the function. The second set of datatypes includes the datatype of each argument of the function that is specified in the invocation. The query is compiled, where compiling the query includes compiling the function with the second set of datatypes.

Abstract: A system and method for managing service interactions launches a process that is defined by a programming abstraction based on a syntax of a general purpose programming language. Interaction with a service, such as a web-based service, is initiated and the process requests the service to perform an action. Execution of the process is suspended until a response is received from the service. Execution of the process continues after receiving a response from the service.

Abstract: A method for a system control to automatically provide highly reliable calculations and decisions based on information from sources of input whose timing is less than reliable. With application of the method in a familiar environment, the program optimally and automatically suspends the execution of decisions or calculations until such time as a reliable set of input conditions can be confirmed. The method allows the use of existing computer language constructs with no need to address time-lagging, random input or intermittent device operation. With the use of the method a system automatically gains high reliability.

Abstract: A method of converting a declaratively defined and language & user interface platform agnostic view to source or binary computer code that is then used to display the view at application run-time. The method includes processing of the view definition, reading the component definition for each component defined in the view, loading and executing each component builder code module to retrieve the output code for each component, and then integrating the output code for each component into a single output for the view. The method allows for new components to be introduced to the system, unknown at the time of the system's packaging, and it provides means for the view to be fully declarative in nature, including no software instructions of any kind.

Abstract: A prototyping tool is provided to an artistic team, which can use the tool to experiment with, demonstrate, and communicate aspects of the user interface interaction with various user interface elements. These user interface elements can be defined within a layered graphics representation of the user interface artwork, rather than individual flattened graphics files. By setting properties on individual user interface elements through the prototyping tool, the artistic team can review how the elements will appear and behave during typical interaction with a user. Furthermore, a description of the interaction properties and relationships of these user interface elements, as defined by the artistic team, is captured for communication to a programming team. The programming team can then load the layered graphical representation and the interaction description to implement the user interface interactivity developed and proposed by the artistic team.

Abstract: A method for effecting a preliminary software service in at least one productive system of a plurality of logical systems of a software system landscape, wherein the logical systems are interconnected by logical transport paths and each logical system has associated therewith one of a plurality of system roles, the method comprises: providing system role types, each system role being associated to one of the system role types; providing an association of tasks to system role types; providing a transport track that defines a route for software services through logical systems in a particular order and specifies one source system in which software services are permitted, adjacent interconnected systems, and at least one target system; providing a preliminary software service relating to at least one of the code and the data of at least one productive system; and generating a hot fix instance from the preliminary software service, the system role types, the association and the transport tracks, the hot fix insta