Abstract: Systems and methods of executing and/or provisioning an application in an application specific runtime environment are disclosed. The application specific runtime environment is defined by an application environment specification to include a minimal or reduced set of software resources required for execution of the application. These software resources are optionally stored in a resource repository that includes resources associated with a plurality of operating systems and/or executable applications. Various embodiments of the invention include the development of hierarchical resource metadata configured to characterize the various files, packages and file families included in the resource repository. In some embodiments this metadata is used to select between files and different versions of files when provisioning an application specific runtime environment.

Abstract: An automation collaborative framework (ACF) is provided. The ACF includes an abstract automated model (AAM) that defines a generic data management scheme. The AAM is extended so as to define an extended data management scheme according to control solutions received from a user. A concrete automation model (CAM) then implements a concrete data management scheme, in which the concrete data management scheme is derived as a function of the generic data management scheme and the extended data management scheme.

Abstract: A computer-implemented software self-assembled system and method for providing an external override and monitoring capability to dynamically self-assembling software containing machines that self-assemble execution sequences and data structures. The method provides an external override machine that can be introduced into a system of self-assembling machines while the machines are executing such that the functionality of the executing software can be changed or paused without stopping the code execution and modifying the existing code. Additionally, a monitoring machine can be introduced without stopping code execution that can monitor specified code execution functions by designated machines and communicate the status to an output device.

Abstract: A method and system are provided for implementing a configurable browser-based form application. A configurable application toolset is provided, having a plurality of reusable browser-based form application components, or shells, that are configured in response to a received set of configuration parameters. Based on the configuration parameters, the toolset can be used to create any number of browser-based form applications. The application includes a browser-based form, a database, and rules governing the collection and storage of gathered and stored data. All of the configuration parameters are stored as data, so that no recompiling or modification of compiled software code in the shells is required when changes are needed, or an entirely new browser-based form application is desired. This reduces cost and time in software development.

Abstract: A method, computer System and computer program product for generating ontological information from design data are disclosed. The design data has a plurality of classes, the classes having at least one association with another class. The design data is processed on the basis of rules to identify environmental artifacts. The design data is processed on the basis of rules to identify implementation artifacts. All classes that are implementation artifacts are eliminated from the design data. New associations for non-eliminated design data that have broken class associations as a result of the elimination are established. The design data remaining following the elimination is processed to preserve environmental artifact relationships between the retained classes to generate an ontology.

Abstract: Mechanisms for evaluating software sustainability are provided. The illustrative embodiments provide code scanning tools for identifying authors of portions of a software product and various attributes about the development, maintenance, and improvement of portions of the software product over time. This information may be correlated with organizational information to identify portions of the software product that may be lacking in sustainability by the persons currently associated with the software organization. Moreover, this information may be used to obtain information regarding the relative quality of the composition or conception of portions of the software product, portions of the software product that have required a relatively larger amount of resources to develop over time, a relative indication of which portions of the software product are “harder” or “easier” to sustain and who is associated with those portions of the software product, and the like.

Abstract: An apparatus for performing fault tolerance against a failure occurring during driving robot software components includes: a component executor for executing the robot software components, which are assigned with one thread from an operating system and have a same priority and cycle, by using the assigned thread; and an executor monitor for periodically monitoring the operation of the component executor and determining whether or not there is a failure in the robot software components executed by the component executor. The apparatus further includes: an executor manager for generating the component executor which is assigned with the robot software components having the same priority and cycle and, when the executor monitor determines that there is a failure in the execution of the robot software components, generating a new component executor.

Abstract: A workflow schedule authoring tool enables a user to author a workflow by arranging building blocks in a particular order. Building blocks may correspond to events, conditions or actions. Each building block is associated with source code that defines an action to be taken when the building block is processed. The order of the building blocks determines the workflow schedule process. The building blocks allow a user to establish logic conditions for how the tasks in the workflow schedule are executed. A building block may require a user to input parameters before the building block may be executed. The workflow schedule is associated with an event such that the workflow schedule triggers when the event occurs. The building blocks simplify workflow schedule authoring because the user does not need to write any code.

Abstract: The method according to the invention for generating software, from source files associated with components, including first variables initialized at zero and second variables initialized at specific values, capable of being run on a terminal, includes, for each software component, at least one of which is capable of a specific restart when the software is run, a compilation step and a linkage editing step. It comprises, for at least one restartable software component, a step for renaming a data storage, data and data initialization segment, associated with each object file of the component to be restarted, and configuring the linkage editor, performing specific linkage editing suitable for repositioning the values of the second initialized variables of the renamed segment at specific values resulting from the renamed segment, and values of the first variables of the renamed segment, when the component is restarted.

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

Abstract: The present invention provides a system and method for allowing integration of loosely coupled components for applications requiring templates and, more specifically, for utilizing the property broker and component technology to solve the missing sandbox model for Lotus Notes out of the box templates on the rich client. It utilizes the property broker and component technology so that components can communicate with one another as standard “out of the box” templates (such as Notes mail8.ntf and pernames.ntf) are allowed to publish properties automatically, e.g., when the selections in views/folders change. Customers are then allowed to define their own applications via an editor using pre-existing or “out of the box” components or custom components of disparate technologies. Component views from the out of the box templates can easily be reused by graphically dragging them from a component palette and dropping them onto the page.

Abstract: Methods and apparatus, including computer program products, to realize a software model are described. A user-centric modeling component is defined, the user-centric modeling component modeling an interactive software system and including a plurality of process steps, the plurality of process steps defining a business scenario. For each process step in the plurality of process steps one or more service requirements are identified, where a service requirement represents functionality necessary to accomplish a step. For each service requirement a process component capable of providing the service requirement is identified, the process component modeling software implementing a business process and defining a service operation for providing the service requirement and for interacting with other process components.

Abstract: A technique for generating good system decompositions is disclosed. The illustrative embodiment uses evolutionary programming in combination with a fitness function to generate a system decomposition that has a low degree of coupling and a high degree of coherence. A system is represented by an object-oriented specification using the Unified Modeling Language (UML); the UML specification is then represented by an eXtended Markup Language (XML) document, and the contents of the document are transformed into a nested-list data structure that resembles source code in a functional programming language such as Common LISP. The nested-list data structure and an appropriate fitness function are input to an evolutionary programming engine that operates on the nested-list data structure as though it were a source code program, and generates an output source code program. A system decomposition is then derived from the output source code program.

Abstract: A method of generating a tool for merging customizations made to a first version of a software artifact when migrating to a second version includes instantiating a mapping element for each top-level element in a first code set that does not have a complementary element in a second code set; requesting and receiving merge instructions for each top-level element for which merge instructions are not provided in the corresponding mapping element; determining whether the merge instructions for each top-level element for which merge instructions are provided require that customizations be merged into the second code set; determining whether the merge instructions for each top-level element set that requires customizations to be merged are valid; requesting and receiving merge instructions for each top-level element for which the merge instructions are not valid; and storing the merge instructions received for each top-level element in the corresponding mapping element.

Abstract: Methods, systems, and apparatus, including computer program products, for implementing a software architecture design for a software application implementing an internal projects application useful for planning and executing internal projects and measures, including network scheduling, resource staffing, cost estimation and management, time confirmation, and progress monitoring. The application is structured as multiple process components interacting with each other through service interfaces, and multiple service interface operations, each being implemented for a respective process component.

Abstract: Methods and apparatus, including computer program products, for forming deployment units. Groups of process components, each group characterizing software that is independently operable, are identified. Thereafter, a plurality of deployment units, each deployment unit associated with at least one identified group of process components are formed. Each process component is entirely included in exactly one deployment unit. In addition, each of the process components characterizes software implementing a respective and distinct business process, and each of the process components defines at least one respective service interface for interacting with other process components, wherein all communication and interaction between process components takes place through the respective interfaces of the process components.

Abstract: Methods and apparatus, including computer program products, for developing user interface applications using configurable patterns and for executing such pattern-based applications. The applications can be developed by generating a graphic representation of a pattern, which can include multiple pattern elements having prearranged user interface elements. The pattern can specify predefined actions that can be performed using the user interface elements, and the graphic representation can include graphic objects corresponding to the pattern elements. Application development can further include receiving user input identifying a selected graphic object and modifying the graphic representation to display information regarding the pattern element corresponding to the selected graphic object.

Abstract: Method, system, and computer program product for instantiating a template in a composite application infrastructure. A template that describes a composite application having a plurality of application components is created. The template includes a composite application component assembly descriptor which lists each application component of the composite application. The template is stored in a template library. The composite application is instantiated using the template for creating at least one composite application instance. In an application instance registry, composite application instance(s) and instance information related to the composite application instance(s) is/are registered. The composite application instances are transiently represented in the application instance registry by a respective table entry without creating a real object. The real object that is dynamically created represents a particular composite application instance during a composite application usage session.

Abstract: Component domains used to define a binding between various components associated with the component domain. The component domain tracks the various services to be imported by each component, and tracks the various services exported by each component. At runtime, rather than at compile time, the various interrelations between the components are bound using the service import and export data. Accordingly, depending on the components available and their characteristics, the bindings may differ. This permits applications to be much more flexible.

Abstract: An object-oriented product configuration system generally includes a model tool for modeling a particular product line and a runtime tool for making the modeled information available to one or more external software applications. More specifically, the model tool enables a modeler to create a ProductModel object, which is an automatically populating electronic file containing all of the necessary information about a particular product line. Once the ProductModel is created, the runtime tool provides an external application with an interface for accessing and utilizing the information. Thus, a single source can deploy useful information to various types of software applications.

Abstract: A method for configuring software modules that includes accessing a properties repository that includes a plurality of properties of the execution environment of the computer system. The method further includes generating a configuration file for each software module. Generating a configuration file includes obtaining a generator module defined for the software module, and executing the generator module to instantiate the configuration file for the software module. The generator module is configured to identify a property required for the configuration file, obtain the value for the property from the properties repository, and store the value for the property in the configuration file in accordance with a customized format required by the software module. The method further includes storing the configuration file for each of the software modules.

Abstract: A method of formatting source code in an Integrated Development Environment (IDE) environment includes the steps of: selecting a source statement in an IDE; associating a style sheet definition with a selected source statement; applying the style sheet definition to the selected source statement to format a display of the selected source statement; and in response to the style sheet definition being applied to the selected source statement, displaying content from the selected source statement in a visual style that is defined by the style sheet definition.

Abstract: Illustrative embodiments provide a computer-implemented method for configurable Unified Modeling Language building blocks. The computer-implemented method obtains a Unified Modeling Language specification and generates a set of logical units from the Unified Modeling Language specification to form a set of building blocks. The computer-implemented method further fetches desired blocks from the set of building blocks according to predefined criteria to form a set of desired blocks, and presents the set of desired building blocks to a requestor for execution of functions provided by the set of desired building blocks to complete a defined task.

Abstract: Methods and apparatus, including computer program products, implementing techniques for developing user interface applications using configurable patterns and for executing such pattern-based applications. The techniques include receiving an identification of a pattern, generating configuration data for the pattern, and storing the configuration data separately from the pattern. The pattern includes a predefined arrangement of user interface elements and specifies predefined actions that can be performed using the user interface elements. The configuration data specifies associations between one or more of the user interface elements and one or more entities in a back-end system, and further specifies customization data for the user interface elements.

Abstract: The present invention is provided to apply a screen mockup developed for prototyping, without any modification, to actual product development for which the architecture differs. An automatic program generation device has: a storage part 170 for storing a screen mockup program 1720, a component setup file 1730, and execution architecture definition information 1760, a storage part 160 for storing component data, a mockup design information analysis part 110 for generating component design information from the screen mockup program 1720 and the component setup file 1730 and configuring a program execution infrastructure from the execution architecture definition information 1760, a component architecture decision part 130 for selecting on the basis of the component design information a program code fragment, which operates on the configured program execution infrastructure, and a program code generation part 140 for generating a program code from the selected program code fragment.

Abstract: An attribute-based component programming system and methodology for object-oriented languages is described. In one embodiment, for example, a method is described for dynamically generating program code adding behavior to a program based on attributes, the method comprises steps of: adding a component object to a program class of the program to create a component; defining at least one attribute specifying declaratively behavior to be added to the program; associating the at least one attribute with the component; and in response to instantiation of the component at runtime, generating a subclass based on the program class and the at least one attribute, the subclass including dynamically generated program code based on the at least one attribute.

Abstract: Systems and methods for developing, customizing, and deploying mobile device applications are provided through a mobile application development and deployment platform. Preferably, these systems and methods are implemented in an Internet based environment that allows non-technical users to build sophisticated, highly-customizable cross-platform mobile applications. The platform allows users to select, input, create, customize, and combine various content, design characteristics, and application components, such as modules, some of which make use of features and functionality associated with various mobile devices and mobile operating systems. In certain embodiments, the platform allows users to compile the mobile application for various mobile operating systems and generates a configuration file for the mobile application that can be distributed to end users for execution on various mobile devices.

Abstract: A method and a system have been presented to automate the development and customization of one or more business applications. The system is disclosed in the form of a framework, such as a Rapid Design Toolkit (RDT). Various examples of business applications may include Order Management, Inventory Management, Enterprise Resource Planning (ERP), and Supply Chain Management (SCM). The business applications help in improving operational efficiency and effectiveness of an enterprise. The method described above includes identifying one or more business requirements of a business application by an enterprise. Thereafter, logic is designed using one or more predefined reusable components based on the business requirements. The predefined reusable components are pretested. Thereafter, the designed logic is executed to automatically develop and/or customize the business application. The business application is developed and/or customized visually through configurations.

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.

Abstract: A system and method for integrating business logic implemented in Enterprise JavaBeans (EJBs) into a user interface framework are disclosed. A design-time environment includes an analyzer that analyzes selected EJBs and generates a model representation of the selected EJBs, and further includes a metadata provider to provide additional metadata to the model representation. A runtime environment has a generic model component to access the selected EJBs based on their model representation, and executes the selected EJBs in the user interface framework.

Abstract: An editor in an industrial automation environment comprises an input component that receives modification data relating to at least one of lifecycle and deployment of an object, the object is associated with a programmable logic controller and configured in accordance with a hierarchically structured data model. An implementation component can implement the modification data with respect to the object. The editor can further comprise a security component that determines that an entity providing the data to the input component is authorized to implement the modification data.

Abstract: Various embodiments provide a mechanism by which a driver writer can describe the operation set of a particular driver using an intermediary representation, such as an XML. A generation tool can then process the intermediary representation and generate client code and device driver code to support these operations. In one or more embodiments, driver operation and associated elements that support the driver operation can be described according to a customized schema that is specific to the operation of the particular device driver.

Abstract: Techniques are provided for representing and configuring flexible and extensible presentation patterns based on fine-grained architectural building blocks (ABBs). The techniques include defining ABBs, modeling the ABBs in a uniform manner, and creating at least one template using the ABBs, wherein the at least one template includes at least one of pre-configured static characteristics and user-specified service characteristics. In an embodiment of the invention, an exemplary method for designing and managing fine-grained ABBs can include identifying ABBs to compose an architecture for facilitating presentation and interaction between consumers and other elements in a solution, analyzing the ABBs to monitor computing resources used by individual ABBs, selecting a number of running instances of the ABBs based on (i) requests of a pertinent entity and (ii) available resources, and managing life-cycles of ABBs.

Abstract: An application software generator automatically generates an application software unit. The application software generator includes an application composer that combines components extracted from a component repository with an application framework to generate the application software unit. Each component in the component repository includes a component shell, a component interface and a component core. The application framework includes configurable parameters that determine how the application software unit is generated and operates. The configurable parameters can be entered by a user using a graphical user interface. The user can be assisted using a wizard format. The application framework also provides connectivity between components so that they can pass messages to one another. The connectivity can be, for example, by a message bus or event registry and event dispatch. Components themselves can be automatically generated using the application software generator.

Abstract: A system, method, and medium are disclosed for implementing an application component container. The container is configured to detect that a component managed by the container is dependent on an interface that is implemented by a dynamic module provided by a dynamic module system. The container uses a dependency injection framework to inject the implementation into the dependent component in a type-safe manner.

Abstract: Automatically creating a current project in an application developer workspace is provided. In response to reading a project file for the current project, it is automatically determined whether the current project has one or more dependent projects based on data contained within the project file. In response to determining that the current project does have one or more dependent projects, a build file is automatically generated for each of the one or more dependent projects. The build file calls importing targets within each of the one or more dependent projects. Then, the current project and the one or more dependent projects are automatically imported into the application developer workspace to form a created current project. The created current project is created without launching an application developer application. In addition, the created current project is stored in a source code control repository.

Abstract: A framework may be provided for facilitating adoption of mathematical and logical solvers. A model, representing a problem, may be defined. The model may be defined: via a series of statements in a type safe common-language-specification compliant modeling language; via an intermediate format; or via a series of calls to a standardized application program interface. The framework may translate the defined model to an intermediate format, which many solvers may understand. The framework may provide a number of solver-related services including, but not limited to, services for creating a model, analyzing a model, selecting a well-suited solver based on analysis of a model, decomposing a model into multiple sub-models and providing the multiple sub-models to multiple solvers as multiple parallel threads, data binding, simulation, and post optimality analysis.

Abstract: Various embodiments of a system and method enabling a user to create a statechart and select an event mode for the statechart are disclosed. The statechart may be created in a graphical manner in response to user input and displayed on a display. A graphical user interface enabling a user to select from a plurality of event modes for the statechart may be displayed. The plurality of event modes may include both a synchronous mode and an asynchronous mode. The statechart may be configured to receive events from an external program either synchronously or asynchronously, depending on which event mode the user selects.

Abstract: A system may identify a workflow associated with a graphical model and execute the workflow in a number of stages. The system may display a number of components of the graphical model and identify which of the displayed components are associated with or affected by execution of a current one of the stages of the workflow.

Abstract: It may be advantageous to facilitate communication between two types of source code. For example, a wrapper may be generated to translate between managed source code and native source code. Current techniques may translate a single type of native source code into a managed binary wrapper. However, as provided herein, a managed source code wrapper may be generated based upon a variety of native source code formats. A native binary descriptor describing a set of native code may be received. A provider may be selected based upon the format of the set of native code. The provider may be executed upon the native binary descriptor to produce a common native binary description. A managed source code wrapper may be generated based upon the common native binary description. Because the managed source code wrapper may be in a textual source code format, a developer may easily maintain and/or customize the wrapper.

Abstract: An application builder tool creates business applications from user provided business descriptions. The application builder is customized using metadata and the metadata may be extended. The metadata provides a set of business terms to the user and the information required to generate an application from those terms. The user either selects terms from the list or enters new business terms to describe the business problem they want the application to automate. The application builder analyzes the terms the user provides and uses the metadata associated with those terms to select, generate and combine business application components. The result is a functioning business application.

Abstract: A computer system and method for software delivery that include articles of manufacture having two or more installed, functional software applications organized in a protoset, the protoset configured to enable creation of one or more subsets (also called reduced metasets) from the two or more installed, functional software applications, each of the one or more subsets configured to be operable with a predefined computer system independent of the protoset; and a protoset module configured to operate on the protoset to enable creation of the one or more subsets of the two or more installed, functional software applications, the module responsive to one or more requests for the creation of the one or more reduced metasets.

Abstract: The present invention provides a configuration system, method, and software program for efficiently configuring products with dynamic components. Component definitions in the configuration system can include both static and dynamic attributes. Static attributes are fixed and are defined prior to the user configuring a product. Dynamic attributes are defined during a configuration session, and the values of dynamic attributes are unique to a configuration session. When an attribute of a dynamic component is specified or changed during the configuration process, the configurator creates only a partial instance of the component with the specified dynamic attribute, and it associates a state of the configuration process with such partial instance. When the configurator executes a constraint that involves a component with one or more dynamic attributes, the configurator uses, for each dynamic attribute, the most recent partial instance of the component with a value for that attribute.

Abstract: Various technologies and techniques are disclosed for offering and applying source code modifications based upon a context of a user in a development environment. For example, code snippets can be offered to the user and customized programmatically. A code editor accepts user input comprising source code. Code snippets of sample source code are stored in a data store. A code completion tool monitors user actions and detects a triggering action in the monitored user actions. A code snippet associated with the triggering action is identified. An option is offered representing the code snippet. In response to user selection of the option, the associated code snippet is inserted into the code editor and is automatically customized based upon the user context. As another example, aspect-oriented source code transformations are offered based upon the user context. As yet another example, solutions to commonly problematic tasks are offered based upon the user context.

Abstract: An electronic device and method of automatically generating measuring programs receives a design document of a product, obtains keywords from the design document, and searches graphic element data and dimension data indexes according to the keywords. Graphic elements are located according to the dimension data indexes. One or more measuring points for each of the graphic elements are obtained by dividing each graphic element into one or more sections according to the graphic element data and a predetermined dividing number, and a single measuring program is generated according to the measuring points.

Abstract: Methods and apparatus for configuring process, environmental, industrial and other control systems generate and/or utilize models representing configurations of control systems and/or the systems controlled by them. Records of changes to the models or the configurations represented by them are maintained, thereby, for example, providing bases for determining current states, prior states and histories of changes. Objects in the model have characteristics, such as an object type characteristic and an area characteristic. Users can have corresponding permissions. A security mechanism apparatus controls access by users to the objects. Composite objects are defined by definition objects and are displayed in encapsulated or expanded formats. Objects can include an edit control type identifier that determines how they are presented for editing. Functionality responds to user commands by transferring characteristics of a first object depicted by the graphical user interface to a second object.

Abstract: The present invention discloses an automated method for detecting configuration problems in an ECLIPSE-based software application. Such a method can begin with the receipt of a user-command to test a configuration of an ECLIPSE-based software application or with a detection of a feature addition/update when an auto-testing feature is enabled. Information about the available sites for the ECLIPSE-based application can then be obtained. Then, a list of software elements required to operate the ECLIPSE-based software application can be compiled. At least one data attribute can be extracted from the meta data of each software element in the compiled list. The extracted data attributes can then be analyzed. When the analysis identifies a configuration problem, the existence of the configuration problem can be validated.

Abstract: A method is provided for facilitating generation of a server-side application capable of calling a function of a wireless application on a mobile device. A structured data file defining the wireless application is retrieved. The structured data file is parsed for identifying exposed functions. Code stubs are generated for each of the exposed functions. The code stubs are configured to be included as part of the server-side application and to define a message to be transmitted to the wireless application upon execution of the code stub.

Abstract: A process for managing customizations for components in a component tree includes for each customization associated with the parent of a component, matching the pathname of the component with the customization path. The process further includes associating the customization with the component, if the matching results in a partial match. The process further includes applying the customization to the component, if the matching results in a complete match.