Abstract: A system that facilitates module design in an industrial environment is provided. The system includes a module component that defines operations to control an industrial process. At least one class component is defined within the module that identifies a generic operation for the module, where the class component executes one or more of the operations within the industrial control process.

Abstract: Lock granularization opportunities are identified in computer code. A processor is used to generate synchronized code blocks and fields (data) accessed in each code block. Each of the code blocks can then be represented by a set. A list of non-intersecting synchronized code blocks having no commonly accessed fields is generated, and a list of intersecting synchronized code blocks (code blocks each having at least one commonly accessed field) is also generated. Equal and superset-subset lists are then generated from the list of intersecting synchronized code blocks. Granularized locks are applied directly around the fields that are accessed within code blocks represented by non-intersecting and equal sets. Granularized locks are also applied around the fields that are accessed within code blocks represented by the superset, and the same locks are applied to code blocks represented by the subsets, thereof.

Abstract: To make functional expansions of business objects possible in a simple manner, it is proposed that one or more function units is assigned to the business object during the creation of the business object or after its creation, using meta knowledge. A function unit can thus be assigned to a business object even during the run time of the software. A design template for software architecture is thus created which makes it possible to resolve software problems in a particularly simple and elegant manner.

Abstract: A system, method, and computer readable medium for script logic graphical mapping comprises displaying a panel associated with at least one script, presenting a branching logic associated with the panel and creating a graphical map of the panel and the branching logic where the graphical map allows zooming in to show panel logic associated with the panel, and the graphical map allows zooming out to show the branching logic associated with the panel.

Abstract: Embodiments of the present invention provide a method, system and computer program product for model driven deployment of component based applications. In an embodiment of the invention, a method for model driven deployment of component based applications can include selecting units representative of corresponding programmatic objects to be deployed into a target environment and specifying a deployment topology for the target environment. The method also can include matching portions of the units to different automation signatures and filtering the different automation signatures to a set of automation signatures based upon the deployment topology. The set of automation signatures can be ordered according to known dependencies of a corresponding deployment model and the ordered set of automation signatures can be bundled into an automation workflow and published to an automation engine for execution to deploy the programmatic objects into the target environment.

Abstract: Systems and methods are disclosed to check properties of bounded concurrent programs by encoding concurrent control flow graph (CFG) and property for programming threads as a first-order formula F1; initializing an interference abstraction (IA); encoding the IA as a first-order formula F2; checking a conjunction of F1 and F2 (F1^F2); if the conjunction is satisfiable, checking if an interference relation (IR) is spurious, and iteratively refining the IA; and if the conjunction is unsatisfiable, checking if an interference relation (IR) is spurious, and iteratively refining the IA.

Abstract: Composite applications can be created that utilize a plurality of different services across a plurality of different cloud stack layers. The composite applications are defined using the Service Component Architecture (SCA) model. Composite applications can be translated from the SCA model into a format compatible for a virtualization platform, such as the Open Virtualization Format (OVF). Composite applications, as defined in the format compatible for the virtualization platform, can be deployed on the virtualization platform.

Abstract: In a method of building a firmware component to execute a sequence of instructions in a device having a computer, a plurality of build files is processed to form a set of buildable statements of hardware policy. The buildable statements are decoded to form a Configuration Manager namespace. Contents of the Configuration Manager namespace are linked to a UEFI compatible kernel program having a Configuration Manager capability. Alternatively, a data stream representing the contents of the Configuration Manager namespace is encoded to form a Configuration Manager database readable by the UEFI compatible kernel program at a run-time. A plurality of UEFI device driver programs and the UEFI compatible kernel program are linked to form the firmware component.

Abstract: Techniques for extending a service model with specification of information consumed. The service model includes specification of at least one exposed interface. A receiving operation receives specification of information consumed by a service implementation of the service model. The information consumed is information that is or needs be utilized by the service implementation without being passed through the exposed interface. A generating operation automatically generates an extended service model using a computer processor. The extended service model includes specification of the exposed interface and specification of the information consumed by the service implementation.

Abstract: A software application recreation in a computing environment is provided. One embodiment involves analyzing program execution trace data of a software application, and using the analysis results in recreating an executable version of the software application from data traced at significant points during the software application execution. Recreating an executable version of the software application involves creating white space code to simulate the software application execution timing by replacing business logic code of the software application with white space code in the recreated executable version. The recreated executable version of the software application programmatically behaves essentially similarly to the software application.

Abstract: Embodiments of the present invention provide a method, a computer system and its computer program which are for presenting a candidate to be linked with a component when the component is to be linked to another component in a web application. In one embodiment, the method includes the steps of: displaying at least two components on a display device; allowing a user to select at least one tag from tags (first tags) on one component (a first component) of the at least two components; identifying a second component having the same tag as the selected first tag; and presenting the identified second component to the user.

Abstract: A method and system for creating a software application code for building an application comprising multiple Replaceable Self-Contained Components (RSCCs) is disclosed. The method includes creating each RSCC by instantiating and initializing an object instance of a Replaceable Component Class (RCC) that substantially encapsulates construction code of a Self-Contained Component (SCC). A method for creating communication code for allowing necessary collaboration between the RSCCs uses a Service Registration Object (SRO), implements necessary coupling code within the RSCCs that provide services for registering its services with the SRO and implements necessary coupling code within the RSCCs that require services for finding and getting the required services from the SRO.

Abstract: In various embodiments, a computer-implemented method for ontology-based application construction is disclosed. The method comprises generating, by a processor, a first component comprising a first ontology, matching, by the processor, a first parameter of the first component with at least one second component comprising a second ontology; and linking, by the processor, the first parameter of the first component with a second parameter of the second component.

Abstract: A method, apparatus, system, and computer program products for implementing non-function logic extensibly and independently of functional logic, the method comprising the steps of: acquiring association relationship between a policy and a required plug-in based on a loaded policy demand configuration; generating a plug-in context definition according to the acquired association relationship, the plug-in context definition being part of a plug-in context associated with the plug-in, wherein the plug-in context defines services provided by the plug-in and reference to other plug-ins related to the plug-in; and generating a plug-in context object based on the plug-in context definition, wherein the plug-in context object is an instantiated plug-in context definition.

Abstract: A programming interface and infrastructure of the present invention includes a Shell programming interface and infrastructure (Shell construct), at least one Logic construct, and at least one Data construct. A method for programming using at least one Shell construct, at least one Data construct, at least one I/O construct, and at least one Logic construct. In this method, the at least one Logic construct is independent from the at least one I/O construct.

Abstract: A system including a terminal machine and a service provider machine is modified using a service provider machine. The terminal machine includes a terminal application for displaying a prompt in a first sequence of prompts and accepting a user data entry in a first series of data entries. The service provider machine includes a provider application for receiving the user data entry. The update server machine sends a dialogue module including a first and second set of updated code to the terminal machine and the service provider machine, respectively. The dialogue module does not modify computer-executable instructions saved on the terminal or service provider machines. The first and second set of updated code adapts the terminal application and provider application, respectively, to use a second sequence of prompts and a second sequence of data entries.

Abstract: An information processing device for providing a program selected on the basis of a predetermined theme among recorded programs and programs to be received to a user. A special program is generated by selecting a predetermined program on the basis of a predetermined theme such as ‘person of the today’, ‘hot drama’, among recorded programs and programs to be received to a user and the contents of the selected program is displayed on a screen as information of a recommendation program. The contents of the special program are changed according to preference of the user, a displaying time of the screen, and setting by the user.

Abstract: A method for designing object-oriented software for implementing portlets, and an associated computer system and computer program product. The portlets are available to a user of the software who clicks on a link of a first page to identify an action object of an Action class and a state object of a State class. The software includes the State class, the Action class, and program code. The State class includes a method for displaying a view of a page. The Action class includes an actionPerformed method for performing an action and a setState method for setting the state object into the session. The program code is adapted to execute: the actionPerformed method of the action object to perform the action; the setState method of the action object to set the state object; and the method of the state object to display a view of a second page.

Abstract: The subject matter of this specification can be implemented in, among other things, a computer-implemented method for accessing a native application programming interface (API) of a computing device including receiving on the computing device one or more control objects from a first application written in a device-independent programming language. The control objects define a context for accessing the native API and the control objects include at least one control script. The method further includes compiling the control script on the computing device into a second application that is native to the operating system of the computing device. The method further includes executing the second application on the computing device. The executed second application accesses the native API of the computing device to generate an output through a hardware interface of the computing device based on the context.

Abstract: A computer implemented method, system and/or computer program product approve software objects for deployment. A change in a lifecycle state of a software object is detected in a governance service registry, resulting in the implementation of a governance lifecycle process for the software object by transmitting an approval process input to a governance approval process engine. In response to the governance approval process engine approving the software object for deployment, the first object is automatically deployed to a production service registry.

Abstract: A method specifies a group of segmented functions of a plurality of segmented functions obtained by dividing a function of a module to be generated. The specified segmented functions commonalize a structural component of the module. The method classifies the input instructions into a select-input instruction non-inputted depending on an environment and a basic input instruction except for the select-input instruction. The method eliminates a combination of segmented functions in the group, the combination of the segmented functions corresponding to a combination of only the select input instruction non-inputted to the module. The method generates a combination component shared by a combination of the remaining segmented functions in the group, and generates a single component implementing a segmented function unclassified into the group. The method generates the module by linking the combination component and the single component with each other.

Abstract: A parse/build engine that can handle multi-format financial messages. The engine converts the different format messages into a common format, and the common format message is then processed by the business service application. A parser examines the message and determines an appropriate schema for the particular format of message received. The schema is a data structure in a schema registry that includes a grammar structure for the received format as well as pointers to handlers for converting the different fields of the message into the internal message format using the grammar structure (the “grammar” can include field sequence, field type, length, character encoding, optional and required fields, etc.). The handlers are individually compiled. As formats change, new formats or changes to old formats can be dynamically added to the parse/build engine by loading new schema and handlers.

Abstract: The present invention provides an open application program interface (API) service. A method of providing the API service includes generating meta-data for executing an API, generating resource data for generating a mash-up of the API, generating description data corresponding to the API, the meta-data, and the resource data, and generating an API package comprising the API, the meta-data, the resource data, and the description data. Accordingly, mash-up contents can be easily generated from various types of APIs.

Abstract: Software generates interfaces and functionality for an application program. At least a portion of an application is created by given names to data elements according to a syntax. Data tables are generated having fields that correspond to the elements and characteristics are associated with the fields specifying how the data in the fields interact with each other. Relationships among the elements are inferred as a function of their names. A functional interface can be generated from the inferred relationship.

Abstract: A system and method for supporting a virtual appliance is provided. In particular, a support engine may include an update server that can manage a workflow to update an appliance in response to detecting upstream updates to one or more software components that have been installed for the appliance. For example, the workflow may generally include managing a rebuild the appliance to install the upstream updates and further managing an integration test to verify that the rebuilt appliance behaves correctly with the upstream updates installed. In addition, the support engine may further include a support analysis manager that can analyze the software components that have been installed for the appliance in view of various heuristic rules to generate a support statement indicating whether support is available for the appliance.

Abstract: A method and apparatus for developing a computer program utilizing services that may not be available during development. A dummy service providing a naïve implementation of the service that is to be provided by the services is obtained or created. The computer program is modified such that it utilizes the dummy service. After an actual service is available, the computer program is modified once more to utilize the actual service instead of the dummy service.

Abstract: A method for generating authentication code for web service resources. The method includes receiving a selection of a resource method, where the resource method defines a method for interacting with a resource associated with a web service. The method further includes determining an authentication scheme for the resource method, where the authentication scheme defines an authentication mechanism required during execution of the resource method to enable interaction with the resource. The method further includes generating authentication code for the resource method using the authentication scheme, where the authentication code enables a user executing the resource method to interact with the resource.

Abstract: Traditional programming environments that support event-driven programming typically expose a model where the developer chooses an event to handle on a given object, and then writes the code for that event handler. In contrast, as described herein, the traditional flow of program development is reversed. A (configurable) event-handler (“behavior”) is selected. Upon selection of one of the behaviors, the event triggering the behavior is selected. This is a “what-then-when” approach rather than the traditional “when-then-what” approach for event-driven programming.

Abstract: An application registers a first component used by the application with a customizing mechanism, and a component setting unit notifies the customizing mechanism of a second component corresponding to the first component. In accordance with changeover of the second component corresponding to the first component by the component setting unit, the first component executes process using the second unit after the second unit has been changed over.

Abstract: This invention relates to a management method, more particularly by recording or external control, of software operations performed within the execution of an application process executed on a computer. This management applies in particular to the recording of operations in the form of logging data, or to a replay of operations according to a given execution corresponding to a running previously logged running This method applies in particular to operations returning at least one result datum to the managed process, and comprises the carrying out of at least one complementary management phase for the managed operation, this complementary management depending on the deterministic or non deterministic nature of the managed operation or of its result.

Abstract: A computer system and method of using a service oriented architecture (SOA) which runs business service application in a distributed network. The system has a channel dependent client layer containing a presentation layer and an application control layer, a channel independent service layer containing a business service layer and a data service layer and an integration layer. The integration layer can receive requests for service from the client layer and has a message generator for sending a request message to the service layer which is adapted to read the request message and in response, to run the business service application.

Abstract: A method derives a composite activity that specifies a behavior of a first system that interacts with a second system. The method specifies the composite activity containing a set of first simple activities in which each first simple activity is a basic activity specifying a message that is either sent from the first system to the second system or sent from the second system to the first system. Then, each first simple activity that specifies a message sent from the second system to the first system is replaced by a second activity for the first system to receive the message followed by an unspecified activity that is to be specified by a user to define an internal action the first system is to take. Also, each first simple activity that specifies a message sent from the first system to the second system is replaced by an unspecified activity that is to be specified by a user to define an internal action the first system is to take followed by a second activity for the first system to send out the message.

Abstract: The present invention provides a method and system for performing operations on data using XML streams. An XML schema defines a limited set of operations that may be performed on data. These operations include addition, subtraction, multiplication and division. The operations are placed in an XML stream that conforms to the XML schema. The XML stream may perform one or more of the defined operations on the data. The limited set of operations allows data to be validated and processed without excessive overhead.

Abstract: In scenarios involving a data set accessible through a protocol, operations sets may be formulated for performing various operations on the data set, and may be expressed as resource scripts according to a scripting language. However, such resource scripts may be difficult to design due to the complicated aspects of the interaction, such as asynchrony, network transport, the syntax of the scripting language, and the details of the protocol. A design environment may be devised to facilitate designers in generating resource scripts, e.g., through the manipulation of visual elements. The design environment may abstract the lower-level working details of the resource scripts, and may allow designers to focus on the logical designing of the operations set. The design environment may then automatically generate the resource script from the operations set in accordance with the constraints of the script language and the protocol.

Abstract: A computer-implemented method is disclosed for generating Dojo-conforming JavaScript Object Notation (JSON) objects for base objects of an object-oriented programming environment that have been annotated to denote which attribute declarations of the base object correspond to identified Dojo attributes. In a Java class, for example, annotations may be made to indicate which class attributes correspond to the identifier attribute of a Dojo JSON object and based on those annotations a Dojo-conforming JSON object may be generated.

Abstract: The present invention discloses a system, method and program code product for efficient component-based application development. Presentation code of a container component is generated by a container-component code generator (container CCG), which uses the class objects of component code generators (CCGs) as subcomponents. The CCGs, as standalone modules or classes, when properly instantiated and initialized could generate the application code of the subcomponents by their code-generating method (CGM) during execution. The container CCG assembles and integrates the subcomponents' application code in run time and fills in the code necessary to establish communication between any two of subcomponents in the resultant application code. One of the methods for establishing inter-component communication and for managing communication dependencies is a service registration object in the application code.

Abstract: In an embodiment, a technique for acquiring a class definition of a class, the class associated with an enumeration, the enumeration enumerating a partial list of instances of the class; generating a data structure based on the class definition, the data structure associating one or more identifiers with an instance enumerated in the enumeration; and storing the data structure in a computer storage.

Abstract: Systems and methods for generating and sharing interactive charts are described. The interactive charts are generated in an online portal that allows users to customize the interactive features of the chart. An online portal may also be provided to allow users to automatically embed interactive chart(s) in another website without reprogramming the code of the website each time the interactive chart(s) are changed or new interactive chart(s) are added.

Abstract: Methods and apparatus, including computer program products, to realize a software model are described. A plurality of process components characterizing software implementing a respective and distinct business process is defined, and each of the process components defining a respective service interface for interacting with other process components. The plurality of process components is divided into multiple deployment units, wherein each deployment unit characterizes independently operable software, and each process component is entirely included in exactly one deployment unit. Context independent interactions are defined among the plurality of process components.

Abstract: A system, method, and computer program product are provided for applying a regular expression to content based on required strings of the regular expression. In use, all required strings included in a regular expression are identified, the required strings including strings required by the regular expression. Additionally, it is determined whether the required strings match content. Furthermore, the regular expression is applied to the content, based on the determination.

Abstract: A software framework based on semantic modeling and business rules, in which a method implemented in a data processing system, includes: receiving input from one or more first users to generate a first ontology describing a software requirement; and receiving input from one or more second users to map the first ontology to a second ontology describing software tools. The data processing system generates a software framework using the input that is received to map the first ontology that describes the software requirement to the second ontology that describes the software tools.

Abstract: A computer-implemented system and method for creating, managing, and reusing schema type definitions in SOA services, grouped in the form of libraries are disclosed. The method in an example embodiment includes: grouping a plurality of Extensible Mark-up Language (XML) schema (XSD) types, each XSD type defined in an individual XSD file; using a processor to bundle the plurality of individual XSD types into a type library, the type library including a type information file to register the individual XSD types in the type library, the type library further including a type dependencies file to register dependencies between the individual XSD types in the same or different type library; importing types from a different type library, when defining derived types or aggregated types; generating Java artifacts from the XSD types; and associating the Java artifacts with corresponding XSD types in the type information file of the type library.

Abstract: An aspect container being operable to generate an instance of itself at run time is provided. The aspect container comprises logic operable to create an instance of the aspect container by reading configuration information specifying a sequence of one or more aspects from an aspect container configuration file corresponding to the aspect container. The logic is also operable to generate instances of the aspects in the sequence, configure each aspect instance with its configuration information from an aspect configuration file corresponding to the aspect, and chain the aspect instances according to the specified sequence, such that the chain of aspect instances preamble and postamble activities of a class or method.

Abstract: A graph processing module is described for visualizing relationships among components, such as software components within a software system. The graph processing module generates group results based on grouping information which identifies groups of individual components. The graph processing module uses the group results to bias component-level analysis that it performs on the components. In one case, the component-level analysis can involve similarity analysis (e.g., using multidimensional scaling) to assess the similarity among components and importance analysis (e.g., using a network page ranking algorithm) to assess the relative importance of the components. The results of the component-level analysis can be presented for visualization. The biasing effects of the grouping results provide insight into the relationships among the components.

Abstract: The invention relates to an integrated software development system 4, comprising an interface description language adapted to specify constraints on input parameters, a program analyzer 6 adapted to identify input parameters of a software program 7, and a validation enforcement system 5 adapted to enforce that an interface description 8 in the interface description language complying with a predefined set of validation rules 9 is provided for the input parameters of the software program 7. The invention further relates to a method for validation, a computer arrangement and a computer program product.

Abstract: Architecture that facilitates the package partitioning of application resources based on conditions, and the package applicability based on the conditions. An index is created for a unified lookup of the available resources. At build time of an application, the resources are indexed and determined to be applicable based on the conditions. The condition under which the resource is applicable is then used to automatically partition the resource into an appropriate package. Each resource package then becomes applicable under the conditions in which the resources within it are applicable, and is deployed to the user if the user merits the conditions (e.g., an English user will receive an English package of English strings, but not a French package). Before the application is run, the references to the resources are merged and can be used to do appropriate lookup of what resources are available.

Abstract: A service providing apparatus (100) includes a request reception responding unit (101), a component injection unit (102), a configuration information storage unit (104), and a component loader group (150). The component loader group (150) of the service providing apparatus (100) includes a default component loader (110), component loaders (111), (112), . . . , and (11N), a default service class group (120), and customized class groups (121), (122), . . . , and (12N).

Abstract: A shared memory architecture is disclosed to support operations associated with executing shared functions from a shared memory space in such a manner that separate pieces of software can execute the shared functions.

Abstract: Described are techniques for processing a module. A module is generated for execution on a target operating system. The module includes four entry points and code portions associated with each of said four entry points. The four entry points correspond to four handlers invoked at different processing points in connection with a state associated with said module. The four handlers include a load handler, an unload handler, a start handler, and a quiesce handler. First processing is performed in connection with the module. The first processing including at least one of dynamically loading the module, dynamically unloading the module, starting module-specific processing performed by the module, and issuing a request to commence preparation for unloading the module. An appropriate one or more of the four handlers are invoked in accordance with the first processing performed.

Abstract: A method and apparatus for providing support for customization of a build configuration of a Unified Extensible Firmware Interface (UEFI) compatible component. The method includes modifying the build configuration of the UEFI compatible component to reflect modifications to a first file. A configuration parameter is received. The configuration parameter is used to create a configuration parameter symbol pointing to the first file. The first file is replaced with a second file, which includes modifications to the first file. The modifications support a functionality desired by a user.