Abstract: According to one general aspect, a computer-implemented method may include sending, from a computing device to a server, a request to install a web-based application on the computing device. In various embodiments, the method may also include receiving, from the server, an installation procedure for the web-based application. In some embodiments, the installation procedure may include installing the web-based application on the computing device. The procedure may also include specifying a web extent for the web-based application. In various embodiments, the web extent may include a first web origin for the web-based application, and a second web origin for the web-based application.

Abstract: A method for executing a computer program involving obtaining a statement of the source code, where the statement comprises a method call, and where the source code is composed in a statically-typed programming language. The method also involves, upon entry into a loop included in the computer program: incrementing an entry counter by one; and, for each iteration of the loop, incrementing an iteration counter by one, incrementing a local counter by one to obtain an incremented value of the local counter, incrementing a summation variable by the incremented value of the local counter, and executing the iteration of the loop.

Abstract: Methods and apparatus, including computer program products, for defining interactions between two process components. For each process component, at least one inbound operation and at least one outbound operation are defined. The inbound operations can be initiated by the other process component to read or modify data encapsulated in a business object solely associated with the process component. The outbound operations can read or modify data encapsulated in a business object solely associated with the other process component. Each of the process components characterizes software implementing a respective and distinct process, and each of the process components defines a respective at least one service interface for communicating and interacting with other process components. In addition, all communication and interaction between process components takes place through the respective interfaces of the process components.

Abstract: A method is provided for designing and developing a service-oriented architecture (SOA) solution that comprises implementing a business process layer having a first set of architectural building blocks (ABBs) and configured to perform service composition and service decomposition; implementing a service component layer having a second set of ABBs and configured to perform service integration and service invocation; implementing a service layer having a third set of ABBs and configured to perform service discovery; and service aggregation; integrating the business process layer, the service component layer, and the service layer; and specifying a set of characteristics of the first, second, and third sets of ABBs to be reconfigurable based upon extensible rules.

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 readable media, includes instructions capable of being interpreted for execution by a computer processor. The instructions provide information sufficient for: reading a master telemetry definition data file; producing a source code for implementing a data stream telemetry method, and generating documentation files for the source code. The source code includes a get component, a format component, and a blocks component. The get component includes source code for accessing flight software variable values according to the master telemetry definition data file. The format component includes source code for scaling the flight software variable values according to the master telemetry definition data file. The format component includes source code for formatting the values as telemetry stream parameters according to the master telemetry definition data file.

Abstract: A system and method for defining and detecting pestware is described. One embodiment includes receiving a file and placing at least a portion of the file into a processor-readable memory of a computer. A plurality of execution paths within code of the pestware file are followed and particular instructions within the execution paths are identified. A representation of the relative locations of each of the particular instructions within the code of the file are compared against a pestware-definition file so as to determine whether the file is a potential pestware file.

Abstract: The present invention comprises apparatus and systems for measuring, monitoring, tracking and simulating enterprise communications and processes. A central message repository or database is constructed, comprised of monitoring messages sent from process messaging systems. The database may then be accessed or queried as desired. A simulation tool assists in reviewing present and proposed processes and sub-processes before modifying existent systems or creating new systems.

Abstract: A system and method for profiling a software application may include means for defining a custom cost metric that includes a cost metric identifier and a cost function. The cost function may apply a mathematical formula to data extracted from an event set to calculate a respective cost metric value for each of one or more events in the event set. The data extracted from the event set may include one or more respective profiling object identifiers and one or more other respective costs associated with each of the one or more events. A cost associated with an event in the event space may be associated with a function or basic block of instructions. The cost function may include a distribution formula for attributing at least a portion of the cost associated with a function or basic block to each of the instructions comprising the function or basic block.

Abstract: Provided is a method for mitigating the effects of an application which crashes as the result of supplemental code (e.g., plug-in), particularly a plug-in from a source other than the source of the operating system of the device or the source of the application that crashes. The method includes executing the application. As the application is running, it may be monitored to determine if normal execution of instructions ceases. When that occurs, the system will make a determination if code from a supplemental code module was the cause of the crash, and will make an evaluation if that supplemental code module is from a source other than the source(s) of the operating system and application in question. In some implementations, remedial steps may be provided, such as providing information on subsequent executions of the application.

Abstract: The software operation modeling device includes a function call order obtaining unit and a model generator. The function call order obtaining unit obtains or estimates an issuing order of function calls executed in each of specific events in the course of executing software. The model generator statistically grasps a co-occurrence relationship between the specific event and the issuing order of the function calls obtained or estimated by the function call order obtaining unit, and to record the grasped co-occurrence relationship as an operation model of the software.

Abstract: Computer method and apparatus for providing pattern specification especially in computer software program modeling is disclosed. The invention method and apparatus defines patterns as a meta-class in a target domain. Each pattern has one or more pattern roles. The method and apparatus defines pattern roles as meta-properties and specifies one or more constraints between pattern roles in the context of the pattern meta-class. One or more connectors are used between meta-properties to represent relationships between pattern roles. One or more associations are used for representing high level relationships between pattern roles in a manner simplifying pattern specification.

Abstract: Systems, methods and computer readable media are provided for the creation of a business object. In one exemplary embodiment, the method may include defining the shell of a business object utilizing meta-data stored within a repository. The method may also include storing the defined business object shell within the repository. Moreover, the method may include generating a business object template utilizing the business object shell, meta-data, and hooks for calling generic business logic, and modifying the hooks to insert the generic business logic.

Abstract: Techniques are disclosed for debugging heterogeneous applications in a distributed environment. In one embodiment, an architecture for debugging heterogeneous applications in a distributed environment is configured to enable both location transparency and dynamic exposure of service state. Regardless of where the physical application state resides, the architecture describes or otherwise provides a mechanism that allows seamless debugging and troubleshooting of distributed applications. The location of the state is transparent to the debugger and the application being debugged. In addition, the architecture enables an individual service to expose its state dynamically at run-time. It is possible for the service to expose its state in a self-describing fashion, allowing service state to be exposed in the architecture regardless of the service environment.

Abstract: A method, system and program product for transforming a source code in one language into one or more target modules in one or more languages is provided. The method includes selecting one or more target programming languages suitable for transforming each source module of a source code into one or more target modules written in one or more target programming languages. The method further includes parsing the source code and looking up for a source function in the source code an equivalent target function in a target programming language, such that execution of the equivalent target function in the target programming language is optimized. The method further includes writing out in the target programming language the equivalent target function corresponding to the source function, such that each source module is transformed into one or more target modules whose execution in the one or more target programming languages is optimized.

Abstract: A method for automating variables in an end-user programming system is disclosed. The end-user programming system comprises a script, a shared repository, at least one database, a recorder, an interpreter, and an execution engine. The script comprises at least one command describing an event comprising a data value. Each user has a uniquely identified entry set for the entries distributed in at least one database. The interpreter automatically creates a variable for a data value in a command by comparing the data value with each entry value in the entry set for the user recording the command. The interpreter automatically instantiates a variable in a command with an entry value by comparing the variable with each entry name in the entry set for the user executing the command.

Abstract: A system and method for programmatically determining interface information for a graphical program. Interface information for a graphical program may include information necessary to invoke execution of the graphical program. A first program may receive a request for information regarding an interface of a graphical program. In response to the request, the first program may programmatically determine the information regarding the interface of the graphical program. The interface information may include such information as parameters of the graphical program, their respective data types, whether each parameter is an input parameter, an output parameter, or both, and default values for input parameters. The programmatically determined information regarding the interface of the graphical program may then be returned to a second program. The second program may invoke execution of the graphical program according to the received information.

Abstract: A mechanism is provided for distributing software features (particularly software products having a global portion and a user portion necessary for activating the software products) to client workstations of a network. Each client workstation has a multi-user operating system that may be accessed with different user profiles, each one associated with a corresponding operating context. A distribution package is received in the client workstation; the distribution package includes instructions associated with global activities for the client workstation as a whole or with user activities specific for the single profiles. A distribution agent (running outside the context of a current profile) executes only the global activity and schedules the user activities to be performed when a user next logs onto the workstation. A user agent loaded when the workstation is accessed with a selected profile executes the user activities in the corresponding context.

Abstract: A method for managing electronic content includes obtaining the content and associating top level contents of the obtained content with a deployment set. The top level content includes content that is specified by a user for deployment. The method also includes determining all dependencies of dependent content for each of the associated top level contents in the deployment set, incorporating the determined dependencies into discharge instructions for the deployment set, and generating a content deployment block including the associated top level contents, the dependent content, and the discharge instructions for the deployment set. The discharge instructions include dependency ordered deployment commands.

Abstract: A bulk install which evaluates prerequisites and performs installations of agents for multiple remote host computers performs a prerequisite check to identify prerequisite files, resources, or other objects expected by each agent on the hosts, and identifies potential shortcomings or failures before installation. A GUI identifies agents for installation on a plurality of host computers, which allows agent specification on an agent type, operating system, or individual host basis. Install files for each agent are identified and retrieved from a common media repository for transport to the target host. The prerequisite checks are also performed in bulk prior to the bulk install, such that the checks prevent a failed prerequisite check from disrupting an entire install. Such bulk install operations mitigate the time-consuming, repetitive nature of the conventional single agent install by iteratively installing each of the agents on the proper host.