Abstract: Infrastructure for capturing and correlating application context and database context for tuning, profiling and debugging tasks. The application context can include events such as data access events, and the database context can include events such as database server events. The events can be obtained from server tracing, data access layer tracing, and/or application tracing and written into respective log files. A data access event can indicate that an application consumed a row from a result set returned from a DBMS query. A post-processing step can correlate the application and database contexts by tokenizing strings and computing intersections between the tokenized strings. A tool inside a development environment may also suggest a query hint for the database or a data access API for the application based on the correlated context.

Abstract: Techniques for automatic dependency resolution are provided. A source machine and a previously successful modification for a given resource, which was modified on the source machine, are identified. Dependencies associated with the modification are identified on the source machine. One or more target machines are selected in response to having a similar profile to that of the source machine. A profile is deemed to be similar based on geographic location, category or role of a machine, and based on operating system of a machine. A profile is also deemed to be similar based on a fuzzy match between profile information. The dependencies are automatically resolved on the target machines and the modification is automatically processed on the target machines to modify the given resource.

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 invention provides, in some aspects, systems for proactive management of development and performance of a software application based on monitoring it (and/or one or more of its components) during the course of development or execution. Those systems signal alerts upon determining that actual or expected usage of the application (or its components) by users of like classes (or roles) is anticipated to, or does, exceed quotas, when the application is placed in production mode.

Abstract: A method is described that involves creating an instance of a software component for the substantially private use of a thread. A determination of whether to access an instance of a software component from one of a private software component instance collection and a software component instance pool is made, the private software component instance collection configured to include an instance of the software component that is not synchronized with an additional thread of the computer program, the software component instance pool configured to include an instance of the software component that is synchronized with the additional thread of the computer program, the determination based on a number of other threads accessing the software component instance pool and a complexity of whether the instance of the software component is to execute at least one of a single task and a few simple tasks.

Abstract: An integrated development system for editing computer software code defines an annotation that includes an annotation identifier, at least one value, and an associated language for each value. The system displays the annotation identifier with a first value in an editing user interface. The system detects that a user is editing the first value. In response to the detecting, the system automatically revises the display of the first value based on a corresponding first language.

Abstract: A method of verifying a software system includes receiving a description of a software system described utilizing a high-level modeling language, and responsive thereto, parsing the description and constructing an abstract syntax graph. The abstract syntax graph is transformed into a sequential logic representation of the software system. The sequential logic representation is formed by reference to a Hardware Description Language (HDL) library. Then, the sequential logic representation is transformed into a gate-level sequential logic representation. Following the transforming, the software system is verified based upon the gate-level sequential logic representation. Following verification, results of verification of the software system are output.

Abstract: A mechanism is provided for executing an interpreted programming language application from a server at a designated virtual machine on a client computer. A manifest file is extracted which indicates at least one resource for the interpreted programming language application as well as the repository file that provides the at least one resource. The repository file is located in a web start cache and copied to a run directory accessible by the designated virtual machine, outside the web start cache. After terminating the web start application, a particular virtual machine is designated from a plurality of virtual machines based upon the run directory to which the bootstrap class copied the resource repository file thereby forming the designated virtual machine. The interpreted programming language application is then executed from the run directory using the at least one resource.

Abstract: Modeling grid projects is provided. A prediction of processor and network availability in a grid computing system are identified during a period of time. A grid project description model is generated utilizing a modeling language designed to describe phases of the grid project. The grid project description model is processed to determine an amount of processor and network resources needed for execution of the grid project. A graph is generated including a first curve representing the prediction of processor availability and a second curve representing the prediction of network availability. A simulation of execution of the grid project is generated based on the prediction of processor and network availability. A plot of utilization of processor and network resources required to complete execution of the grid project is added to the graph while keeping utilization of processor resources within the first curve and utilization of network resources within the second curve.

Abstract: Symbolic execution identifies possible execution paths of a computer program or method, each having certain constraints over the input values. The symbolic execution also records updates of memory locations, e.g. updates of the fields of symbolic objects in the heap of an object oriented program, involving a description of the previous heap, the updated symbolic object, a field identification, and a newly assigned symbolic value. The symbolic execution can also record calls to summarized methods, involving a description of previous calls, an identification of the summarized methods, and its symbolic arguments. The behavior of summarized methods can be expressed by axioms. Axioms describe the relationship between summarized methods under certain conditions. Axioms can be generated from parameterized unit tests. A parameterized unit test is a method with parameters which executes a sequence of calls to methods of an implementation under test; it asserts constraints over the inputs and outputs of the calls.

Abstract: A method and computer program product for testing a system logger. Randomized input is provided into a logging facility and automated testing of the logging facility is performed in a multi-processing environment. Self-verification of data retrieved from the logging facility is performed to ensure no data loss occurs due to external system events or failures driven by a test tool. Real-time analysis of results received is performed by the test tool based on the randomized input into the logging facility. First failure data is captured and self-verification of results of a data recovery operation of the logging facility is performed in a disaster recovery scenario. Self-verification includes writing log blocks of random sizes to the log stream, iteratively forcing log data to be offloaded from primary storage to secondary storage, iteratively updating log stream attributes, and iteratively swapping duplexing modes.

Abstract: From source code specification of each of a plurality of threads, those variables of a data structure referenced by the thread are determined. For each thread, a respective adaptation of the source code specification of the data structure is generated. Each adaptation includes only variables of the data structure that are referenced in the respective thread. The source code specifications of the threads are compiled into respective object code segments using the respective adaptations of the data structures. Each object code segment requires memory space for the data structure for only those variables included in the respective adaptation. The source code specification of the data structure describes a network packet, and the respective object code segments are configured to operate on the respective portions of the network packet stored in separate memories while executing on respective processors.

Abstract: A compiler supporting a language in which selected semantic objects are represented as data objects. The data objects may be used in multiple ways to expand the capabilities of the programming language. Data objects may be passed to applications and used to create executable instructions for that application. In this way, instructions written in the native language of the compiler may be used to control applications that accept programs in a language inconsistent with the native language of the compiler. The syntax checking and variable binding capabilities of the compiler may be used for those instructions that will be executed by an application separate from the object code generated by the compiler. The semantic objects represented as data objects may be selected based on express operations included in the source code or may be based on implicit type conversion.

Abstract: A method includes generating a list of shared and private memory regions of a debuggee. A thread is injected into the debuggee for generating the list and communicating with the debugger. Associated shared memory region handles are added to the list. The handles are used to map the shared memory regions of the debuggee to a debugger. New shared memory regions corresponding to the private memory regions of the debuggee are created and mapped to the debugger. Handles for the new shared memory regions are provided to map the new shared memory regions to the debuggee. The debuggee private memory regions are freed. The new shared memory regions are mapped to respective virtual addresses of the debuggee corresponding to the respective freed private memory regions. In this manner, content of debuggee memory regions is directly accessible by the debugger, and computer processing resources are conserved.

Abstract: A mechanism is provided for providing a native code library from a server to an application written in an interpreted programming language for execution on a remote computer. An installer object is invoked from within a main class of the interpreted programming language application. The install object extracts a file list from the server including at least one native code library filename indicating a native code library. The native code library indicated by the native code library filename is installed to a target directory on the remote computer and the main class of the interpreted programming language application is then invoked on the remote computer. Additional native code library dependencies are also installed to the target directory on the remote computer.

Abstract: A read-only management object is created to contain information relating to firmware components that can be updated. This information includes a component identifier, a component version and a user-friendly name for the component. The information also includes a state identifier that indicates a state of a device that includes firmware components. Information from the management object can be used by other components as part of a firmware update process. An update management object is dynamically created to deliver an update package to the device. The update package can contain updates to multiple firmware components.

Abstract: In a method for the controlled execution of a program (26), the program (26) being intended for a virtual machine (VM, VM?), on a portable data carrier, wherein the data carrier has a processor that executes at least a first and a second virtual machine (VM, VM?), the program (26) is executed both by the first and by the second virtual machine (VM, VM?). If, during execution of the program (26), a difference is found between the operating state of the first virtual machine (VM) and the operating state of the second virtual machine (VM?), execution of the program is aborted. A data carrier and a computer program product exhibit corresponding features. The invention provides a technique for the controlled execution of a program, which technique prevents security risks due to an attack or a malfunction of the data carrier.

Abstract: Separation of parameterized unit tests (PUTs) from specific test cases supports many benefits including automated test case generation. Symbolic execution assigns symbolic input variables to parameters of a parameterized unit test. Path constraints of an implementation under test (IUT) are identified during symbolic execution. A constraint solver automatically generates test cases by determining the test inputs that satisfy one of more paths, each described by constraints, through the IUT. PUTs are used to populate behavioral summaries. Behavioral summaries are used later in future symbolic executions to emulate summarized methods. Behavioral summaries comprise behavioral purity axioms. Behavioral purity axioms require that an intensional heap before execution of a PUT be equal to the intensional heap after execution. An intensional heap is provided to represent state changes performed by summarized methods. The extensional heap is used to explicitly update memory locations, e.g.