Abstract: A computer operating system with a map that relates API namespaces to components that implement an interface contracts for the namespaces. When an API namespace is to be used, a loader within the operating system uses the map to load components based on the map. An application can reference an API namespace in the same way as it references a dynamically linked library, but the implementation of the interface contract for the API namespace is not tied to a single file or to a static collection of files. The map may identify versions of the API namespace or values of runtime parameters that may be used to select appropriate files to implement an interface contract in scenarios that may depend on factors such as hardware in the execution environment, a version of the API namespace against which an application was developed or the application accessing the API namespace.

Abstract: An energy based framework is disclosed that allows a software compiler or developer to make decisions between performance and energy consumption. In one aspect, a first program code (e.g., vector engine based computation) may alternatively be compiled into a second program code (e.g., register operations). Using measurements obtained from a processor for which the first and second program codes are being compiled, and the expected size of the data and a number of iterations, a comparison can be made between the expected energy consumption profile of the first program code and the equivalent second program code. Based on the comparison, a software developer or the compiler can choose the program code that minimizes energy consumption.

Abstract: Systems and methods are provided for optimizing application code for deployment to a client over a data link to minimize download time by supplying only the application code with a particular object that is required by the object. In a web application that includes multiple pages, the HTML and JAVASCRIPT may be scanned to identify code resources called by a particular web page. When all called resources are identified, they may be extracted and concatenated into a single resource file. When the page is downloaded to the client, the import file may be included with the page. The import file may be cached so that it need only be downloaded once, rather than being downloaded every time the page is requested. The disclosed systems and methods are suitable for use with other interpreted scripting languages.

Abstract: An extended Web services description language (WSDL) is provided to allow for the merging of call flow XML with the interface description. This is accomplished through additional WSDL bindings for operations that associate an operation with segments or message points within the call flow. In addition, the extension to WSDL defines a set of interactions that provide additional semantics for how the operation interacts with the call flow. These interactions capture the interaction points between the WSDL. The WSDL interfaces that are created may be used for outbound interactions (i.e. initiated through Web services from some event within the call flow) or for the usual inbound request response. An additional lifecycle listener interface is used to convey different binding points between an enhanced converged Web service processing engine and a converged application implementation of the WSDL.

Abstract: In one embodiment, the present invention includes a method for receiving an application linked against a first application binary interface (ABI), providing an ABI wrapper associated with the application, and binding the application to a native message passing interface (MPI) library using the ABI wrapper and the profiling message passing interface (PMPI). Other embodiments are described and claimed.

Abstract: A method, system, and computer program for installing a shared software component on a computer are proposed. The process is driven by an exploiter of this (new) shared component. If the required shared component is not available on the computer, it is installed at the desired location (specified by the exploiter). On the contrary, if another shared component is already available (for further exploiters), the process verifies whether this available shared component is at the required level. If not, the available shared component is upgraded accordingly; for example, this result can be achieved by causing the available shared component to refuse any new request and then waiting for the completion of any pending request. In this case, the install location of the available shared component is returned to the exploiter, so as to have it point to the available shared component automatically.

Abstract: A method for managing remote clients includes retrieving a client version identifier for an application program running on a client. The client version identifier is compared with a master version identifier for a master configuration file on a server. An active configuration of the application program on the client is altered while the application program is running.

Abstract: A dynamic and interchangeable set of application behaviors is implemented upon the same underlying software engine. Downloadable data provider behavior descriptors configure the UI generation application dynamically on demand to meet needs that are unknown at ship time, or otherwise cannot be predicted in advance—inputs, formats, contents, and the optimal user interface or experience, all change over time. A data provider supplies the data source locations, data feeds, poll/pull intervals on feeds, parameter definitions, data binding definitions, lists, groups, UI templates, data transformation logic, resources, and UI templates to plug into the base application engine, which transforms the supplied data to create a UI experience tailored to match the appropriate events and available data over time. The base application engine is agnostic to both the data provider and the input data received.

Abstract: A system and method for emulating the input/output performance of an application. A workload description language is used to produce a small but accurate model of the application, which is flexible enough to emulate the application's performance with varying underlying system configurations or operating parameters. The model describes I/O operations performed by the application, and reflects any dependencies that exist between different application threads or processes. The model is then executed or interpreted with a particular system configuration, and various parameters of the I/O operations may be set at the model's run-time. During execution, the input/output operations described in the model are generated according to the specified parameters, and are performed. The system configuration and/or I/O operation parameters may be altered and the model may be re-run.

Abstract: Methods, systems, and computer program products are disclosed for dynamically integrating software resources (such as web services and other back-end software resources) using the services of a content framework (such as a portal platform). A portlet model is leveraged to allow programmatic portlets to serve as proxies for web services, thereby extending portlets beyond their traditional visual role. A deployment interface and a system interface are described for these portlet proxies. The deployment interface is used for composing new web services, and a composition tool is described. The system interface allows for run-time management of the web services by the portal platform. The service provider for a particular function may be bound to the portlet proxy at development time or at run-time.

Abstract: A program start-up unit is provided which is capable of starting up a program at high speed and reducing the consumption of a memory. This program start-up unit analyzes the link relation between an application program and a shared library in the whole system, specifies a combination in which the management structure of a load state can be used in common to the utmost among application programs, and uses this management structure as a reference in the whole system.

Abstract: Systems, methods, media, and other embodiments associated with optimizing code motion with delayed exception handling are described. One exemplary system embodiment includes a data store to store information about a relocated instruction, a relocation logic to relocate instructions, and a run-time logic to detect exceptions raised by executed instructions. The run-time logic may selectively delay handling exceptions based on whether an executed instruction is a relocated instruction.

Abstract: An embodiment generally relates to a method of increasing efficiency in a dynamic linker. The method includes determining a length of a source string and a check segment of the source string and selecting a candidate string from a plurality of strings. The method also includes determining a candidate check segment of the candidate string based on the length of the source string and verifying the source string and the candidate string are identical in response to the check segment of the source string being identical to candidate check segment.

Abstract: A device control system, a device control method, and a device control program for rendering a trace function as a function added to a service object that provides the software application with an interface to a particular device based on the Microsoft .NET Framework. The device control system has a service object, a service object for tracing, and renders a trace function in a service object that provides a device interface to a software application based on the .NET Framework. The trace function can be rendered in the service object based on whether the trace function is disabled or enabled without modifying the software application.

Abstract: A computer implemented technique framework, prototype tool and associated methods that provide a high degree of visibility and control over the in-field execution of software in a minimally intrusive manner wherein developer-defined correctness tests and validation logic are embedded into the sensor node itself, making in-field software testing autonomous without necessitating continuous developer participation.

Abstract: Systems and methods consistent with the invention include propagating parameter definitions between computer elements and may include at least one memory device containing computer readable instructions. Also included is a computer processor executing the instructions on the memory device to perform the steps of selecting a sub-routine to be called by a calling unit. The processor may determine whether a definition for a parameter in the selected sub-routine is known to the calling unit using the computer processor, the calling unit also containing a definition for a parameter. The definitions for the parameters that are unknown to the calling unit are incorporated into the selected sub-routine using the computer processor. The process of the calling unit is executed. The computer processor is used to bind the definition for the parameter in the sub-routine to the definition of the parameter contained in the calling unit.

Abstract: A system, apparatus, method and article for a modular electronic mail software architecture are described. The apparatus may include a processing sub-system having a processor and memory. The memory may store software components for execution by the processor. The software components may comprise an application program implemented using a model driven application framework and capable of operating with multiple operating systems. Other embodiments are described and claimed.

Abstract: The invention relates to a method for loading a software having several modules loadable in the non-volatile memory of a portable digital device. The loading of at least one module includes testing the existence of a data structure associated with the module in the non-volatile memory and, when necessary, to create the data structure indicating it as empty. The method further includes resolving links for totality of internal elements and, afterwards, in marking the structure as loaded. The existence of an associated data structure is determined for each other module referenced in the loadable module and, when necessary, the structure is created and indicated as empty. The invention makes it possible to reduce the space occupied by the on-board software during loading of modules.

Abstract: Deterministically resolving cycles in a library tree is disclosed. Resolving cycles supports certain processes such as safe library initialization. Cycles in the library tree are identified; at least one soft link in each identified cycle is identified; and the at least one soft link in each identified cycle is broken. If a cycle has no soft links, notification is provided indicating that the cycle cannot be broken. Identifying at least one soft link in each identified cycle comprises, for each link in the cycle, determining the dependent and supporting libraries; and determining if one or more functions in the supporting library are required for initializing the dependent library.

Abstract: Disclosed herein are systems, computer-implemented methods, and computer-readable storage media for call path enforcement. The method includes tracking, during run-time, a run-time call order for a series of function calls in a software program, and when executing a protected function call during run-time, allowing or causing proper execution of a protected function call only if the run-time call order matches a predetermined order. The predetermined order can be an expected run-time call order based on a programmed order of function calls in the software program. The method can include maintaining an evolving value associated with the run-time call order and calling the protected function by passing the evolving value and function parameters corrupted based on the evolving value. The protected function uncorrupts the corrupted parameters based on the passed evolving value and an expected predetermined call order. A buffer containing the uncorrupted parameters can replace the corrupted parameters.

Abstract: An execution apparatus for executing a function in response to a request received via a network obtains interface information representing an interface via which a component that provides a function accepts a request, and generates an interface for allowing the execution apparatus to accept a request via a network, based upon the obtained interface information of the component that accepts the request received via the network.

Abstract: Dependencies among components may be pre-calculated, validated and cached. The cached dependencies may then be used in an execution environment to inject dependencies into the component. In one example, components for a web application are submitted to the operator of the application. Dependencies among the components may be pre-calculated, and the pre-calculated dependencies may be stored in a catalog. When a client accesses the web application, the components may be downloaded to the client along with the catalog. The client may provide a virtual machine or other execution environment under which the components execute. The execution environment may provide a dependency injection feature that connects components together at runtime based on the pre-calculated dependencies in the catalog.

Abstract: Business logic may be separated into pieces and each piece may be pluggable (i.e. replaceable). An event model is created to allow subscribers to listen to business events, the business logic is implemented into a series of strategies that are subscribers to the business events and the business strategies are late bound so they can be replaced. Each strategy is written with granular protected behaviors.

Abstract: A storage medium readable by a computer is provided. The storage medium stores a program of instructions executable by the computer to perform a function for protecting a target function. The function includes generating an inserted function, having a function name identical to the function name of the target function, that includes code for a process relating to protection of the target function and a call instruction for calling the target function after this process, and generating a protected executable code on the basis of an object code, in which the function name of a function definition of the target function has been changed to a second function name, and the inserted function.

Abstract: Loading and unloading a plurality of libraries on a computing device having a loader lock and internal and external counts for each library in the plurality of libraries is disclosed. The libraries assume an initialize state, followed by an initialized state, a pending unload state, and an unload state according to when the internal and external counts are incremented and decremented. When in the pending unload state, the functions of a library that include functions that require acquiring the loader lock exit, the internal count is decremented by one, and the loader lock is released. Prior to entering the pending unload state, a library may be placed into a reloadable state. A library in the reloadable state may be reloaded upon request until a timer times out. When the timer times out, the library in the reloadable state transitions into the pending unload state.

Abstract: A method and apparatus for providing native undo, redo, and abort execution abilities of a runtime is disclosed. In one embodiment, a system includes a runtime to execute object-oriented source code with producer dependency declarations for methods, wherein a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance, wherein each producer dependency declaration for a given method identifies a set of zero or more producers with outputs that are an input to the given method. According to one embodiment of the invention, the runtime includes a client code tracking module to track the client code commands being run by the runtime. Furthermore, in one embodiment, the runtime also includes a runtime tracking module to track processes of the runtime performed in response to the client code commands being tracked and run by the runtime.

Abstract: One or more extension registrations are received for each of multiple software components installed on a computing device. The one or more extension registrations identify the software components as providers of functionality. A record of the one or more extension registrations for each of the multiple software components is maintained. Requests are received, from other software components installed on the computing device, that identify particular functionality. In response to such requests, the information regarding one or more of the multiple software components that provide the particular functionality is returned to the other software components.

Abstract: A Windows™ process loader is emulated for dynamic TLS data allocation during respective application runtime. A total required TLS data block size is initially calculated and corresponding data block duplicates are created preferably after initializing of the application. An event notification system such as a hooking system intercepts DLL loading and freeing activity as well as thread creation and exiting and provides event notifications for dynamic allocation of corresponding TLS data block duplicates.

Abstract: Data files, applications and/or corresponding user interfaces may be accessed at a device that collaborates in a mesh. The mesh may include any number or type of devices that collaborate in a network. Data, applications and/or corresponding user interfaces may be stored within a core object that may be shared over the mesh. Information in the core object may be identified with a corresponding user such that a user may use any collaborating device in the mesh to access the information. In one example, the information is stored remotely from a device used to access the information. A remote source may store the desired information or may determine the storage location of the desired information in the mesh and may further provide the desired information to a corresponding user.

Abstract: A method and apparatus is disclosed for optimization of Remote Procedure Call (RPC) communications. A first RPC request to open a first transport connection is sent to a RPC service. A first RPC response is received from the RPC service. The first RPC response includes first information which indicates that first transport connection is open. The first information is stored in a cache. In response to a second RPC request to close the first transport connection, the closing of the first transport connection is delayed.

Abstract: A solution for managing a set of artifacts for a runtime environment is provided, which enables improved tooling that supports runtime extensions to a runtime environment. In one embodiment, an extension handler is obtained for a runtime extension to the runtime environment. The runtime extension comprises a program code that can be included in the runtime environment to extend the default capabilities of a runtime engine/framework. The extension handler provides tooling support for extension artifacts that use/require the runtime extension. When a tooling request for an extension artifact is obtained, the tooling request is processed using the extension handler. In this manner, a tooling solution is shielded from needing to know the specifics of the extension artifact or corresponding runtime extension. Similarly, the developer of the extension handler for the runtime extension is shielded from needing to know any specifics of the tooling environment.

Abstract: A technique for allowing isolated JAVA applications (“isolates”) to share data between themselves is disclosed. According to one aspect, a shared object region, to which multiple isolates may attach, is defined in memory. A shared class loader associated with the region is stored in the region in conjunction with the region's creation. Isolates that can access the region can invoke that loader. The region only comprises objects whose type is defined by a bootstrap class loader or the region's associated shared class loader. Runtime representations of classes defined by the shared class loader are stored in the region. Thus, the types of objects stored in the region are known to all isolates that attach to the region. Isolates attached to the region may enter the context of the region to access objects stored therein. Within the context of a shared object region, all allocation instructions automatically allocate to that region.

Abstract: In some embodiments of the present invention, files are generated from .java files or .class files or .jar files. The generated files are directly linkable and interpretable by a Java Virtual Machine. The generated files may be stored in a directly addressable memory of a device. References between .class files may appear in the generated files as hard offsets or symbolic references. The generated files may be grouped so that cross-references between generated files in the same group appear as hard offsets.

Abstract: A system and method for defining and dynamically invoking polymorphic call flows in a call flow system. Call flows are defined that include a publisher call flow and subscriber call flows. A first trigger point in a publisher call flow is defined. Triggers specifying late-binding references to trigger points are defined in the subscriber call flows. Subsequent to the call flows being published in a repository, the publisher call flow is executed, the first trigger point is located, and the publisher call flow is executed. Without changing any other call flow and without terminating and restarting the publisher call flow, a call flow is added to the call flow system and invoked or a call flow is removed.

Abstract: A method, apparatus, and system are provided for a Graphical User Interface (GUI) for monitoring classloading references. In an embodiment, the GUI includes a graphical representation of one or more resources of an application server. The one or more resources may be selectable via, for example, a cursor control device. In an embodiment, a graphical representation of a selected class loader and one or more associated classloading references are displayed in the GUI, responsive to receiving a selection input specifying one of the displayed resources.

Abstract: A networked spreadsheet template designer allows administrators to easily create and deploy robust reporting and input applications that leverage existing spreadsheet templates and knowledge in an easy to use user interface. Templates are created to operate directly in the particular spreadsheet program environment, such as Microsoft Excel®, and can be created using existing templates and modeling workbooks of that spreadsheet program without the need for any code to be written. A library of dynamic link library (DLL) worksheet functions makes creation of templates a faster, simpler task. The template designer uses these DLL worksheet functions directly on template worksheets to perform specified actions. The DLL functions enable a user to create an interactive, custom application by automating/encapsulating complex tasks.

Abstract: A computing device may receive a Web service archive that includes a Web service implementation and a Web service deployment descriptor. The Web service deployment descriptor may specify how the Web service implementation is to be configured on the computing device. The computing device may deploy a Web service based, at least in part, on the received Web service archive.

Abstract: The present invention extends to methods, systems, and computer program products for automated generation of different script versions. Received scripts can include comments containing descriptive data from which instructions for implementing specified further functionality (e.g., debugging, testing, tracing, etc.) can be inferred. Received scripts can also include anonymous function names. Modules within a script pre-processor can access the descriptive data and infer instructions for implementing specified further functionality. Modules with the script preprocessor can also infer and assign global identifiers to anonymous functions such that the scripts are subsequently identifiable using the global identifiers. The modules within the script pre-processor can interoperate to generate versions of the script that implement the specified further (e.g., debugging) functionality without requiring a developer to write additional code.

Abstract: Abstract of the Disclosure A method for recognizing strings and annotating, or labeling, the strings with a type label. After the strings are annotated with a type label, application pro gram modules may use the type label to provide users with a choice of actions. If the user's computer does not have any actions associated with a type label, the user may be provided with the option to surf to a download Uniform Resource Locator (URL) and download action plug-ins for that type label. One or more recognizer plug-ins perform the recognition of particular strings in an electronic document. The recognize r plug-ins may be packaged with an application program module or they may be written by third parties to recognize particular strings that are of interest. One or more action plug-ins provide possible actions to be presented to the user based upon the type label associated with the string.

Abstract: A facility for setting and revoking policies is provided. The facility receives a request from a controlling process a request to set a policy on a controlled process, and determines whether the controlling process has privilege to set the policy on the controlled process. If the facility determines that the controlling process has privilege to set the policy on the controlled process, the facility sets the policy on the controlled process, which causes the policy to be applied to the controlled process to determine whether the controlled process has authorization to access one or more resources.

Abstract: A method and apparatus include comparing a called DLL file with DLL file names listed in a database. If a file name of the called DLL file is one of the DLL file names listed in the database, a compatibility mode associated with a DLL file name that matches the called DLL file is referenced. Based on the referenced compatibility mode, an operation of a processor is affected using the compatibility mode associated with the DLL file name.

Abstract: An apparatus, system, and method are disclosed for supporting service components written in non-native runtime code in a Service Component Architecture (“SCA”). A read module is included to read an implementation type definition having metadata identifying executable code that executes a new implementation type. A receive module is included to detect a dynamic service call to a service component having the new implementation type. The dynamic service call is defined in an SCA message from a calling SCA component. A passing module is included to pass the dynamic service call to a predefined SCA implementation handler associated with the new implementation type. The SCA implementation handler includes native runtime code and implementation logic for executing the dynamic service call by executing non-native runtime code that returns a result to the SCA implementation handler. A packaging module packages the result in an SCA return message to the calling SCA component.

Abstract: Techniques for configuring direct communicating between browser elements running in a browser and for direct communication between a browser element and an external application are described. Browser elements communicate with each other by referencing unique identifiers associated with the browser elements. External applications communicate directly with browser elements by referencing unique identifiers associated with the browser elements. Browser elements are configurable as web services and communicate using various communication architectures and protocols. Application programming interfaces associated with browser elements configured as web services are accessible to web browsers through web scripting modules.

Abstract: The present invention is directed toward automatically integrating a late bound program language into an external environment. The external environment may be an early bound environment, a late bound environment or some combination thereof. Associated with the late bound program environment is a modular execution engine and an interface mechanism, wherein the interface mechanism is capable of expressing late bound semantics in a format compatible with the external environment.

Abstract: An apparatus for creating composite services includes a processing unit which identifies at least one constituent component for a composite service by a processor unit. The constituent component has a runtime state. The apparatus includes a data-store having past composition decisions and corresponding runtime states. The processing unit locates a past composition decision regarding the constituent component that has essentially the equivalent runtime state in the data-store, and reuses the past composition decision for the constituent component for the composite service. A method for creating composite services includes the steps of identifying at least one constituent component for a composite service by a processor unit, the constituent component having a runtime state. There is the step of locating a past composition decision regarding the constituent component that has essentially the equivalent runtime state in a data-store by the processing unit.

Abstract: An application server may include a Web service client having a service endpoint interface. The service endpoint interface may expose a method of a Web service to the Web service client. The Web service client may also include a logical port to define a configuration of the service endpoint interface.

Abstract: System(s), method(s), and/or technique(s) (“tools”) are described that enable a user to open a network-enabled electronic document in either a specific software application associated with the electronic document or a network browser. In some cases the tools do so using a single link. On selection of the link, if the user's computing device has access to the specific software application, the tools may load the electronic document using that application. Or, if the user's computing device does not have access to the specific software application, the tools may render the electronic document with a network browser. In so doing, the tools may make the document available to a larger set of potential users through their browsers, allow users the convenience of accessing the document within a browser, optimize users' experience in working with the document through a specific software application, or provide a simpler opening procedure.

Abstract: A networked spreadsheet template designer allows administrators to easily create and deploy robust reporting and input applications that leverage existing spreadsheet templates and knowledge in an easy to use user interface. Templates are created to operate directly in the particular spreadsheet program environment and can be created using existing templates and modeling workbooks of that spreadsheet program without the need for any code to be written. The template designer uses dynamic link library (DLL) worksheet functions directly on template worksheets to perform specified actions. The DLL functions enable a user to create an interactive, custom application by automating/encapsulating complex tasks. The DLL functions are managed across a computer network through an administrator interface to create the functions and a viewer interface that combines an Explorer® window to select the functions and a spreadsheet window for the actual spreadsheet program that implements the DLL functions.

Abstract: A system, method and computer program product for permitting use of multiple hooking applications to hook an interface. Included are a first hooking application and a second hooking application. Further provided is computer code including a vector and a stub dynamic link library (DLL) for permitting the first hooking application and the second hooking application to both hook an interface.

Abstract: Embodiments of the invention provide techniques that improve resource management on a massively parallel computing system having a plurality of hybrid compute nodes. For example, a job scheduler may be provided which determines a library to link to an application based on system and user requirements. In one embodiment, the libraries may provide optimizations for job execution time, and also provide optimizations directed towards a specific processor architecture. Once the library is determined, the job scheduler may configure the environment of the application so that the application links with the optimized library during run-time. Doing so may improve overall system performance of the massively parallel computing system.