Abstract: Interoperability software modules comprise an architected .NET layer, an architected interpreter, an automatic interpreter and a library of COM objects. The architected interpreter where they are mapped to intermediate .NET interfaces compatible with the automatic interpreter by means of a Runtime Callable Wrapper (RCW). The architected interpreter also comprises an architected COM Callable Wrapper (CCW) that maps the intermediate COM interfaces into architected interfaces.

Abstract: A first acquisition unit acquires each of the resources defined by the scenario, from locations depending on identifiers of the resources. A judging unit judge, when a resource having same identifier and structure as the resource acquired is existent in the cache storage, erases the resource, the identifier thereof, and the receipt time information from the cache storage, and when not existent, stores the acquired resource in association with the identifier thereof and the receipt time information of the bookmark instruction, in the cache storage. A second acquisition, when the identifiers of the resources specified by a first scenario are existent in the cache storage, acquires the resources from the cache storage according to the receipt time information corresponding to the first scenario and identifiers of the resources, and when not existent, acquires the resources from a location depending on the identifiers.

Abstract: Access is obtained to an input object-oriented computer program. In the input object-oriented computer program, semantically equivalent objects are identified, which exist in different memory locations. If at least one of: a number of occurrences for the semantically equivalent objects exceeds a first threshold value, the threshold value being at least two; and a number of equality tests on the semantically equivalent objects exceeds a second threshold value, then a further step includes identifying an application program interface to reduce the semantically equivalent objects to a single object in a single memory location.

Abstract: Various embodiments provide an apparatus and method for building integrated distributed applications for use with a mesh network. An example embodiment is configured to receive a shared view that is shared among a plurality of components of a network; generate a schema for the plurality of components from the shared view; use the schema to generate code components; and use the shared view and the generated schema to generate integration code for integrating the code components.

Abstract: The present invention relates generally to computer programming, and more particularly to, systems and methods for parallel distributed programming. Generally, a parallel distributed program is configured to operate across multiple processors and multiple memories. In one aspect of the invention, a parallel distributed program includes a distributed shared variable located across the multiple memories and distributed programs capable of operating across multiple processors.

Abstract: Methods, systems, and apparatus for improved ease and flexibility in defining attribute values for jobs in a workflow processing system. The job attributes are presented to a user grouped or organized by their relationship to various elements of the workflow model used to process the job type. Further, default values for job attributes may be flexibly defined based on elements of the workflow model that utilize the job attribute and/or based on dynamic computations of functions involving the various job attributes and other parameters.

Abstract: In some embodiments, multiple heterogeneous information technology service management (ITSM) applications of different IT service partners (customers and service providers) are integrated via a service process integration grid employing a set of standard workflows and associated standard transaction types and data structures. Once a service partner's workflows and data structures have been mapped to the standard grid workflows and data structures, integration with a first and new service partners is relatively fast and convenient. Analysis of real-life ITSM applications led to the development of particular standardized workflows classified according to whether they are initiated by service provider or customer, and according to whether they do or do not include ownership-transfer transactions allowing a service partner (customer or provider) to transfer ownership of the service process to its counterpart for further action by the counterpart.

Abstract: A system and method is disclosed for creating a reusable control from various applications or portions of applications. Using a pre-existing application or one specifically developed for the control, a developer programmatically declares which functionalities of the original application are to be included in the new control. This control building logic becomes a part of the application code. On execution of the application with the added control building logic, the native code that will re-create the control functionality is automatically generated. The control developer may now extend the generated code using simple Object Oriented Programming (OOP) inheritance to add properties and parameters that will control its behavior. The resulting control may then be referenced by other developers when creating a new software application.

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: Device, system and method of modeling homogeneous information. For example, a method that includes providing to a model-based application an input model including a refinable homogeneous record having a base type, wherein said homogeneous record is defined with a homogeneous constraint to only include data members of a type compatible with the base type. The homogeneous record is defined in a modeling environment that is able to automatically enforce the homogeneous constraint for the homogeneous record and for refinements thereof.

Abstract: Embodiments of the invention provide a dictionary, which may be modified by a developer, that provides a mapping of the generation routine to be performed and a pointer or identifier of the generator employed for the specified generation routine. As will be appreciated, embodiments of the invention may employ a dictionary which comprises a plurality of generation routine-code generator identity data pairs. A generator routine may be, for example, associated with the generation of source code associated with a particular object class, fields, methods, method bodies, procedures, comments, subroutines and the like. By modifying a generation routine-code generator identity data pair in a generator dictionary, a developer or user is able to modify the source code (e.g., the structure and/or content of the source) which is ultimately generated by the generator.

Abstract: Methods are provided for creating a composite program module within a computing ecosystem. The ecosystem comprises physical and/or virtual computing resources of a company, department or other organization. When a user discovers a grouping of modules that is useful to him, the ecosystem or his workspace allows him to create a composite module that comprises the group of modules. He can then access their combined functionality by activating just the composite module, in which case all the modules are automatically opened, without having to activate each one individually. Further, the ecosystem may suggest complementary program modules to a user based on his pattern of activity with one or more other modules. A composite program module may be created to include a suggested complementary module, or just modules discovered independently by the user.

Abstract: A method of software evolution, software evolution system and program product therefor. A context specification handler stores context specifications describing requirements on context-adapted software. A Software Part Semantics Specification (SPSS) handler stores software part semantics specifications. A Software Implementation (SI) handler stores SIs. Behavior History handler stores a history of active software behavior analysis results of monitoring previous versions. A software rendering handler combines software behavior history with context specification, software part semantics specifications and SIs and distributes (and optionally deploys) context-adapted software. A software inspector continuously monitors context behavior of deployed versions and selectively identifies active context-adapted software failing to satisfy context specification for reassembly of a new version(s).

Abstract: A computer-implemented method of evaluating interactions between processes. The method includes storing a message choreography meta-model that includes an interaction meta class and a constraint meta-class. A user creates a message choreography model between a first process and a second process. The method further includes executing a verification computer program that performs a verification of the message choreography model. The verification includes verifying absence of an inconsumable message.

Abstract: A device and method automatically generate a program for buffering differences based on characteristics of a component. A buffer program for buffering differences of the way to use a component during different software environments is automatically generated. The device includes a controller for executing automatic generation of the buffer program, a memory including control information and a processing program, an input device for inputting the processing content of the component, and an output device for outputting the automatically generated buffer program. The memory records a plurality of forms for buffering the component as the control information and the controller extracts characteristic information based on the processing content of the component and records the extracted characteristic information as control information in the memory, selects a specified form based on the characteristic information, and generates the buffer program based on the selected form and the characteristic information.

Abstract: A system and method that does trustworthy multi-objective structural synthesis of analog circuits, and extracts expert analog circuit knowledge from the resulting tradeoffs. The system defines a space of thousands of possible topologies via a hierarchically organized combination of designer-trusted analog building blocks, the resulting topologies are guaranteed trustworthy. The system can perform a search based on a multi-objective evolutionary algorithm that uses an age-layered population structure to balance exploration vs. exploitation, with operators that make the search space a hybrid between vector-based and tree-based representations. A scheme employing average ranking on Pareto fronts is used to handle a high number of objectives. Good initial topology sizings are quickly generated via multi-gate constraint satisfaction.

Abstract: An arrangement for generating a telecommunications application (such as a voicemail application) is described. The arrangement provides a graphical user interface that enables a user to select telecommunications application building blocks and to position and connect those blocks on the display in order to define an algorithm. The algorithm can be implemented using pre-defined modules for said building blocks.

Abstract: Optional components are delivered to a software platform as a database load. A component is deployed to an application server of a first system. The component comprises at least a portion of the software to be delivered as a database load to a second system that implements the software platform. A component export tool in the first system identifies database table structures and database table entries created by the deployment of the component. The component export tool generates a load delivery package based on the identified database table structures and database table entries and then exports the load delivery package to the second system. A component load tool in the second system generates application tables based on the identified database table structures in the shipment package. The database table entries are then imported into the generated application packages in the load delivery package so that the component can be loaded into the software platform.

Abstract: Disclosed herein are systems, computer-implemented methods, and non-transitory computer-readable storage media for obfuscating code, such as instructions and data structures. Also disclosed are non-transitory computer-readable media containing obfuscated code. In one aspect, a preprocessing tool (i.e. before compilation) identifies in a source program code a routine for replacement. The tool can be a software program running on a computer or an embedded device. The tool then selects a function equivalent to the identified routine from a pool of functions to replace the identified routine. A compiler can then compile computer instructions based on the source program code utilizing the selected function in place of the identified routine. In another aspect, the tool replaces data structures with fertilized data structures. These approaches can be applied to various portions of source program code based on various factors. A software developer can flexibly configure how and where to fertilize the source code.

Abstract: An apparatus, system, and method for hiding advanced XML schema properties in EMF objects. XML Schema may comprise both user-defined properties and internal properties related to the structural features of the schema. The present invention hides the internal properties from clients while still keeping them available such that a complete XML Schema model can be generated, but without exposing a client to the non-intuitive internal properties. An SDO implementation leverages EMF implementation artifacts to present a client with an SDO API exposing user-defined properties and metadata describing user-defined properties. The SDO implementation further provides an extended API through which a client may access internal properties and metadata describing the internal properties. The invention further accounts for both dynamic SDO objects and static SDO objects.

Abstract: A method and apparatus for providing variability rules for component model and architecture design are provided. The apparatus includes a category-determination unit which determines a category of implicit variability rules with respect to variability-set component model elements and elements associated with the variability-set component model elements; and an implicit-variability-rule-application unit which applies the implicit variability rules, which are given to the category, to the elements associated with the variability-set component model elements.

Abstract: A method and system for aggregating two or more templated components using an aggregation component is provided. Each templated component has at least one configurable element. The aggregation component comprises at least one configurable element, and an extraction mechanism operable to identify configurable elements of the components selected for aggregation. The aggregation component further comprises a mapping mechanism for mapping configurable elements of the selected components to configurable elements of the aggregation component; a storage mechanism for storing data identifying aggregated components and the corresponding mappings of the configurable elements; and a management mechanism for managing data identifying configuration settings of the aggregated selected components.

Abstract: Provided are a method and apparatus for managing variability points that represent variability of components of software. The method includes connecting variability points of components to each other and also connecting at least one variability point of the components to a corresponding variability point of at least one of source code and build script; receiving an input having a predetermined value and setting the predetermined value to a variability point of the components; reflecting corresponding values of the predetermined value to the connected variability point of at least one of the source code and build script.

Abstract: System and method for converting a class oriented data flow program to a structure oriented data flow program. A first data flow program is received, where the first data flow program is an object oriented program comprising instances of one or more classes, and wherein the first data flow program is executable to perform a first function. The first data flow program is automatically converted to a second data flow program, where the second data flow program does not include the instances of the one or more classes, and where the second data flow program is executable to perform the first function. The second data flow program is stored on a computer memory, where the second data flow program is configured to be deployed to a device, e.g., a programmable hardware element, and where the second data flow program is executable on the device to perform the first function.

Abstract: Methods, systems, and software for providing or utilizing a software solutions bag of development components and enterprise knowledge—whether developed internally or by third parties—are described herein. One method for managing reusable development components comprises providing a catalog of a plurality of development components to a user. The cataloged development components may include or reference at least a first development component of a first type and a second development component of a second type. A software solutions bag is then generated based on a user selection of at least one of the cataloged development components.

Abstract: Methods and arrangements to manage comment data that is associated with computer executable code are provided. Comment data associated with a line or lines of executable code can be stored, and a tag can be assigned to the comment, data or the line(s) of code. When it is desired to locate, information about lines of code, tags allow for an improved way to search for the desired lines of code. Thus, in response to a user query for information, a search engine can locate a specific tag or groups of tags and display code and comments associated with the located tag(s).

Abstract: Server side internet applications are created by placing interactive server side components (ISSC's) on internet pages. ISSC's encapsulate dynamic page functions including processing of user responses on the server and thus can be reused, which drastically reduces programming effort. The ISSC technique remembers information (in form of an ISSC object) about each ISSC during dynamic page generation on the server. Then, it generates HTML code in a way such that the ISSC event is sent to the server using a conventional HTTP GET or POST request. On the server, the event is then passed to the corresponding ISSC object. All components work without disturbing each other, even when nested or combined. A browser based editor can also be used to place ISSC's on pages and to modify their properties. During dynamic page generation, scripts and handles are embedded into the page that permit editing of the page itself.

Abstract: A dependency hierarchy of resources can be determined for a dynamic mashup. The dependency hierarchy can specify dependency relationships among a set of resources. A set of views that correspond to the set of resources can be ascertained. For each view, a view template can be determined that is to be applied to that view. The mashup can be dynamically created that includes the views, each of which is configured in accordance with the associated view template. The created mashup can also include content defined by the set of resources that is configured in a manner consistent with the dependency relationships of the dependency hierarchy.

Abstract: A software component, is constructed on the basis of a set of predetermined rules, and by utilizing a source object, a token value and a parameter, wherein the source object is stored in a source object repository, and wherein the source object comprises a component value and/or a token value, wherein the component value may be associated with the token value. For constructing the software component, the token value is processed and a token result, obtained by processing the token value, is utilized for constructing the software component, wherein the parameter may also be utilized for the processing of the token value and/or constructing the software component.

Abstract: A stripped-down version of a library is generated from server source code extracted from a server project. The transitive closure of program entities extracted from the server source code and referenced by the extracted program entities can be computed. A placeholder entity can be inferred for an entity defined by the transitive closure computation if a definition of the entity cannot be found in the server source code. The stripped-down library generated from the extracted server source code is received by a reflection-based component that uses reflection to generate documentation and disclosure information helpful in the development of the client source code. A placeholder entity can be marked or decorated to signal to the reflection-based component that client source code is not to be generated for the decorated entities.

Abstract: A system and method for generating an application based on a first component having definitions expressed in a structured definition language and a second component having a series of instructions. The component applications comprise data components, presentation components, and message components, which are written in XML code. The component applications further comprise workflow components which are written in a subset of ECMAScript, and are augmented with the XML code. The components define the processing on a device runtime environment of messages communicated over a network between the device and a datasource. The system and method have a data model for providing a persistent state of the application including the component definitions and the series of instructions. The system and method also have a code module for obtaining the components from the data model and for generating a first application element including code representing the component definitions.

Abstract: Methods and apparatus, including computer program products, for defining a software model business object are described. A plurality of business objects and interactions between these business objects are defined. Each business object is operable to encapsulate business data and can be associated with exactly one process component. Each of the process components characterizes software implementing a respective and distinct process and defines a respective at least one service interface for communicating and interacting with business objects in other process components. Moreover, all communication and interaction between process components takes place through the respective interfaces of the process components. Additionally, the interactions among business objects in different deployment units occur solely via the process component interfaces.

Abstract: The present disclosure describes an application development toolkit that includes a memory device configured to store programming constructs of a scripting language. The programming constructs may be configured to define an application. The application development toolkit includes a processing device configured to dynamically generate, in the memory device, an abstract tree structure including at least a portion of the programming constructs that define logic components of the application. The processing device is further configured to build a user interface for the application by concatenating user interface components received from the at least a portion of the programming constructs included in the abstract tree structure.

Abstract: Web portal application customization methods and systems using profiles allow developers to expose different functionalities and a different look and feel to users belonging to different user profiles. Specifically, the method allows a developer to define default and profile-specific transitions as well as default and profile-specific states. Upon request of a transition by a workflow engine, the system transparently provides the workflow engine with a profile-specific transition if a profile-specific transition associated with the user is available. If a profile-specific transition is not available, the system provides the application with a default transition. Likewise, the system transparently provides the application with a profile-relevant state according to the profile of the user and the availability of a profile-specific state. Accordingly, the method may implement highly customizable functionalities and look and feel effectively and cost-efficiently.

Abstract: The invention relates to programming hardware for useful data processing also used in the form of a suitable graphical editor. The inventive method consists in providing a plurality of modules, wherein each module can carry out at least one function for useful data processing, in defining the module connecting interfaces, in establishing, by a user, an additional connection of modules (topology) corresponding to a sequence of functions suitable for useful data processing, in classifying the modules into a plurality of module types according to predefined properties, in defining connection rules indicating admissible connections for different module types according to said types of modules in programming the hardware according to said topology.

Abstract: A method and system for creating a software application code including multiple Replaceable Self-Contained Components (RSCCs) is disclosed. In one embodiment, 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), creating an RSCC registration module which resides in each of a first set of RSCCs for registering each of the services provided by each of the first set of RSCCs with the service registration object, and creating an RSCC service finding module which resides in each of a second set of RSCCs for consuming each of the services provided by one of the first set of RSCCs for facilitating communication between the RSCCs in the software application code upon an event selected from the group consisting of a user event, a sensor event, a timer event, and a data/state change event.

Abstract: A system that can enable the atomization of application functionality in connection with an activity-centric system is provided. The system can be utilized as a programmatic tool that decomposes an application's constituent functionality into atoms thereafter monitoring and aggregating atoms with respect to a particular activity. In doing so, the functionality of the system can be scaled based upon complexity and needs of the activity. Additionally, the system can be employed to monetize the atoms or activity capabilities based upon respective use.

Abstract: The present invention concerns methods and apparatus for implementing a model-based paradigm for use in developing systems of software solutions. In a method of the present invention, a developer defines templates for use in creating software architecture elements which comprise a software solution or a system of software solutions. The template definitions comprise specifications of template attributes. The developer specifies relationships and dependencies among the templates using a computer programmed to receive the template definitions.

Abstract: A computer-usable storage medium having instructions embodied therein that when executed cause a computer system to perform a method for using an application platform for designing an application. An interface for developing an application is provided at a computer system. A plurality of components are provided at the interface for use in visually designing the application. A selection of a component from the plurality of components is received at the interface. A placement of the component in the application is received within the interface. The application is compiled with the component and the placement of the component such that the application executes natively on a target processor, and wherein the application is bound directly to a native graphics library associated with the target processor.

Abstract: This disclosure relates to methods, systems, and software for processing a coherent multi-dimensional business process model. The software includes computer-readable instructions embodied on media to identify a coherent multi-dimensional business process model based on at least a portion of a first model for a business process and at least a portion of a second model for the business process. The software then parses the multi-dimensional business process model to identify at least one extension point, each extension point operable to interface a disparate business tool with the business process. The software is further operable to present an extension wizard to a client for a particular one of the identified extension points. It can create entities and extensions in various modeling environments and development environments.

Abstract: A system and associated method for automatically generating a service specification of a Service Oriented Architecture (SOA) solution. A process model framework and a data model framework are received as inputs. Processes in the process model framework perform services of various complexity levels. Processes are decomposed into a respective set of atomic service processes in the lowest complexity level and data objects are extracted from the decomposed atomic service processes. The data objects are associated with data elements of the data model framework. The data model framework is extended and flexibility patterns are added for reusability of the service specification. The service specification of the SOA solution is generated as process interfaces represented with the data objects according to inputs from a user customizing aspects of the service specification, for either a desired service of the SOA solution or a desired process in the process model framework.

Abstract: A method for building a client commerce system for a client networked environment can include the steps of: collecting one or more business requirements for the client commerce system, gathering one or more characteristics of the client networked environment, retrieving an initial client commerce system, and modifying the initial client commerce system to operate in the client networked environment and to provide the collected business requirements for the client commerce system. In the method, the initial client commerce system provides at least a portion of the collected business requirements and is configured for operating a network environment most closely matching the gathered characteristics of the client networked environment.

Abstract: In one embodiment, a build orchestration framework orchestrates building of one or more individual buildable components of a deliverable software product. At least some buildable components reference respective sub components on which they depend. Building creates a structure associated with each respective buildable component of the one or more buildable components. In this structure, if the respective buildable component references a sub component on which the respective buildable component depends, a symbolic link is created to an output of a build of the sub component to provide access to the output of the sub component for use in building the respective buildable component. Further, in this structure, if the respective buildable component is used by another buildable component, a symbolic link is created to an output of a build of the respective buildable component.

Abstract: An application development system for developing an application with application components is described. The system application development includes a modeling tool. The modeling tool imports the application components in a comparable component definition format, and defines a data relation between data, screens, and operations embodied in the application components in an application model. The application model has a static structural characteristic, a dynamic behavioral characteristic and an implementation characteristic. The static structural characteristic defines parts of the application. The dynamic behavioral characteristic defines responsiveness of the application to events or actions, and the implementation characteristic describes elements required for deploying the application. The modeling tool updates the cross-component mapping.

Abstract: Embodiments of the invention provide an IDE tool that provides rapid application development features for a variety of disparate data sources. Further, developers may customize and extend the rapid application development features to suit their development needs in a particular case. In a particular embodiment, the rapid application development template may be configured to generate a set of configuration files localized used to deploy a “lightweight” application, such as a web-service, to a particular application server.

Abstract: An analytical software design system arranged to receive informal system design specifications and to convert them into verified design specifications for use in creating source code and carrying out implementation testing of the source code is described. The system comprises a verified black box specification generator arranged to process the received informal system design specifications to create formal specifications; to generate from the formal specifications mathematical models representing the system behavior; to analyze the mathematical models to determine if they have the required behavior; to adjust the formal specifications until the required behavior is achieved; and to derive the required verified design specifications from the mathematical models.

Abstract: A method of creating assets for agile software development includes detecting selection of an asset type for an asset template, receiving values of one or more attributes for the asset template, and creating the asset template. Upon detecting an action to select the asset template, creation of an asset of the selected asset type and having the received values is initiated.

Abstract: Methods and apparatus, including computer program products, for defining one of a plurality of process components. At least one inbound operation initiated by an external process component to read or modify data encapsulated in a business object solely associated with the process component is defined. Additionally at least one outbound operation to read or modify data encapsulated in a business object solely associated with an external process component is defined. 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 system and method for interactive graphical construction of computer programs known as subassemblies, which are used to construct components of cross sectional frameworks for generating 3D models of complex infrastructure configurations, such as roadway intersections, drainage tunnels and utility vaults. The system and methods disclosed are adapted to allow such subassembly construction to be performed without computer programming experience, skill, knowledge, or activity on the part of the user. In at least one embodiment, computer software provides an interactive graphical user interface for facilitating construction of subassemblies without programming by the user, and a runtime component comprising at least one dynamically constructed compiled program library file, referenced program library files, and other non-object code files used in operation.

Abstract: Technologies are presented herein for self-describing re-usable software components. Metadata is generated and published with a re-usable software component that identifies the capabilities of the software component, identifies other software components that the re-usable software component may be integrated with, and identifies mechanisms for integrating the re-usable software component with other software components. The metadata can then be used to discover re-usable software components and to integrate the re-usable software components with other software components.