Abstract: A method, system and apparatus for providing a web application or to generate the basis for a complete web application source code. Based on user interface input files provided by graphic designers, the web application or generates application framework code, an event handler skeleton and s logic foundation code. Web developers then prepare additional source code object-oriented programming language based on the event handler skeleton and business logic foundation code to create web application business logic objects and handler methods. Ultimately the graphical user interface input files prepared by the designers and web application source code prepared by the web developers dynamically bound at runtime.

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: A legacy machine-oriented language interface definition of a new module to be implemented within a legacy machine-oriented language application using an object-oriented language is received at a processor. An object-oriented class definition and bridging code that interfaces the object-oriented class definition to the legacy machine-oriented language interface definition is generated by the processor. An updated version of the object-oriented class definition is received that includes object-oriented code that implements functionality of the new module. A new version of the legacy machine-oriented language application is created that includes the new module as a new object accessible using the legacy machine-oriented language interface definition and as implemented by the object-oriented code in the updated version of the object-oriented class definition.

Abstract: Aspects of the subject matter described herein relate to mapping from application objects to an abstract data model. In aspects, a mapper receives registrations that indicate behavior (e.g., how objects are constructed, modified, or examined) of application objects. The behavior may be specified using user-supplied expressions. The mapper aggregates this data and uses it to map application requests for data access into one or more operations that operate on the abstract data model. A data access layer may then translate the operations into actions to access data corresponding to the requests from a store. If appropriate, data obtained from the store may then be inserted into application objects as indicated by the registrations.

Abstract: The formulation of an application object in a memory of a computing system. A system level of the computing system determines that an application object is to be created, but also determines that at least part of the object build information to be used to create the application object is available at an application running on the computing system. The system then interfaces with the application through an interface to cause the application object to be created in the memory using the object build information that is available at the application. As an example, the system level may be parsing a hierarchically structured document that defines various objects of a program.

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 system for dynamically integrating changes in the rules governing business operations into an application program that implements the rules in order to control business operations includes a dynamic business logic rule integrator (“DBLRI”) that essentially provides business logic rules to the application software as executable routines. The DBLRI presents to a user one or more graphical user interfaces (“GUIs”) through which the user writes functional-language expressions for the business logic rules. The respective GUIs correspond to various types of business logic rules, and provide to the user menus of associated functions, operators and parameters that are available for use. The set of parameters associated with a given GUI is dynamically updated, to correspond to changes in the underlying business logic rules. The user writes and/or edits the expressions for the respective business logic rules by selectively combining the available functions, operators and parameters.

Abstract: A method and system of performing Java language class extensions. At least some of the illustrative embodiments are computer-readable mediums storing a program that, when executed by a processor of a host system, causes the processor to identify a first class having a first name, and create a second class based on the first class (the second class is an abstract view of the first class, and the second class has a second name equal to a third name of a third class).

Abstract: According to one embodiment of the present invention a method is disclosed. The method includes requesting a class to be dynamically loaded during program execution. The class includes an attribute. A properties file is searched for the attribute. An associated delegation policy is found in the properties file. The associated delegation policy is associated with the attribute. The class is loaded by applying the associated delegation policy.

Abstract: Mechanisms for development tooling enablement of audit event generation are provided. The mechanisms automatically generate and insert compliance audit record generation code where appropriate in identified portions of program instructions based on established compliance policies and labels associated with keywords/library functions appearing in the source code. The mechanisms may analyze the program instructions to identify at least one portion of program instructions meeting a compliance policy requirement for generation of a compliance audit record. Compliance audit record generation code for generating the compliance audit record may be generated. The compliance audit record generation code may be inserted into the at least one portion of program instructions to generate modified program instructions. The modified program instructions may be output for execution on a computing device.

Abstract: A method of mapping a software installation, including: (a) providing a software installed on a computer with an operating system and at least one storage device, the installation including a plurality of software components and at least one entry in a system record on the storage device; (b) providing a plurality of potential interaction points between said installation and said computer; (c) executing at least one informer on said computer to obtain information about said potential interaction points of said installation with said operating system; and (d) determining a plurality of relationships between said components based on said interaction points on which information was obtained.

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.

Abstract: Systems, methods and computer program products are provided for a distributed associative memory base. Such methods may include providing a distributed memory base that includes a network of networks of associative memory networks. The memory base may include a network of associative memory networks, a respective associative memory network comprising associations among a respective observer entity and a plurality of observed entities that are observed by the respective observer entity. Ones of the associative memory networks are physically and/or logically independent from other ones of the associative memory networks. Methods include imagining associations from the associative memory base using a plurality of streaming queues that correspond to ones of a plurality of rows of ones of the associative memory networks.

Abstract: A namespace-based static metadata model is projected into a dynamic programming environment. A dynamic object is created for each static namespace. The host environment populates the dynamic object with a top-level namespace of the static namespace. The dynamic objects are defined such that a request for a member a member of the namespace lazily populates the static metadata into a projected sub-namespace object or a projected type object.

Abstract: A method of exposing the functionality of an application in a command interface includes generating a command line interpreter (“CLI”) from a component of an application. The application's components are used to automatically generate the CLI to interpret commands to access the functionality of the application. The generated CLI parses, maps, and dispatches the commands and any associated arguments in accordance with the application's components. Application metadata is used to modify the generated CLI to customize the exposure of the functionality of the application in the command interface.

Abstract: A broker-program generating unit generates a broker program by using an interface-definition-language file defining interface definition information concerning a plurality of applications described in various programming languages. The broker program is installed in a middleware platform that absorbs and hides a common object request broker architecture, and brokers an interaction between the applications with a structure that stores data in a binary format as an interface to the middleware platform.

Abstract: A method and system for providing help information for a computer program. The help system provides help information based on a schema that specifies the structure of a valid computer program. The schema provides definitions of program element types that are specific instances of a program element type derived from more general program element types. The help system identifies a “derivation” of program element types relating to the selected program element. The help system then displays the derivation to the user. The user can then select to display documentation associated with the displayed program element types.

Abstract: Various embodiments of systems and methods for an application creation tool (ACT) toolkit are described herein. The ACT toolkit includes a set of application creation APIs and an application creation service for invoking the set of application creation API. An ACT is in communication with the application creation service of the ACT toolkit. The ACT sends an application creation request to the application creation service for creating a UI application. The ACT can be customized by re-defining the application creation service of the ACT toolkit and establishing a communication between the re-defined application creation service and the ACT. The re-defined application creation service invokes the set of API to create a customized application object for the UI application.

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: A method of exchanging data among software components includes acquisition by each software component of all the data that is to be provided by another software component, from a predetermined software component. Each software component delivers all data that is to be provided by it to another software component, to the predetermined software component. Providing and acquiring of all data is performed according to a predetermined standard, according to which the data comprises values and attributes. The respective data values are assigned to attributes, and semantically identical data values are assigned to the same attribute and are made distinguishable from each other by respective hierarchical information. A software component that delivers data to or acquires data from the predetermined software component, receives the respective hierarchical information from another software component. Acquiring and providing data by a software component includes transferring the respective hierarchical information.

Abstract: The present invention relates to machine vision computing environments, and more specifically relates to a system and method for selectively accelerating the execution of image processing applications using a multi-core processor system. To this extent, a multi-core processor system is generally defined as one that is multi-platform, and potentially distributed via a network or other connection. The invention provides a machine vision system and method for executing image processing applications referred to herein as an image co-processor that comprises (among other things) a plurality of multi-core processors (MCPs) that work to process multiple images in an accelerated fashion.

Abstract: In an embodiment, a class definition of a class may provide an indication whether a property, which is part of the class, is immutable. The indication may be made implicitly or explicitly. A value of the property may be established (e.g., set) during a creation of an instance of the class. An attempt to set the value of the property after the instance is created may be disallowed. Further, an error (e.g., an error message, exception condition) may be reported in response to disallowing the attempt.

Abstract: A method, system and computer program product for optimizing an object-oriented program, which comprises identifying synthetic accessor methods added to the program during a compilation to allow access to the members of the inner classes and replacing the synthetic accessor methods with direct accesses to the members of the inner classes.

Abstract: A method of automatically defining a new class in a class hierarchy includes creating a descendent class that descends from one or more specified ancestor classes; sequentially analyzing each class along each inheritance path from the specified ancestor classes to a specified similar class to identify each class item in each class that is not selected from the specified ancestor classes; storing a respective pointer for each class item identified in each class that is not inherited by the class referencing the class item and associated with the class; storing a respective pointer for each class item identified in each class that is inherited and redefined by the class referencing the class item and being associated with the class if a pointer referencing the class item is not already stored; and copying each class item referenced by a stored pointer to the descendent class.

Abstract: A method and apparatus for integrating aspect-oriented programming (AOP) into the deployment layer of an application server. In one embodiment, the method includes analyzing a structure of a deployment within an application server, and translating the deployment from a first form to a second form using results of the analyzing. The method further includes indicating in the deployment that a cross-cutting concern is to be resolved by aspects at runtime.

Abstract: A device receives selection of a function category associated with a dynamically-type programming language, receives selection of a function associated with the selected function category, dynamically generates one or more function signatures associated with the selected function, and stores at least a subset of the one or more function signatures in a memory or displays at least a subset of the one or more function signatures to a user.

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: Dynamic code generation and memory management techniques are provided for component object model (COM) objects with corresponding representations in script code and native code. A browser component can receive script code including the code representing the COM object and a marshaling component is provided that marshals, based on a request for native code representing the COM object, the code representing the COM object to the native code based on a pre-constructed intermediate data structure. The pre-constructed intermediate data structure, such as a virtual table, is pre-constructed based on a dynamic type representation associated with a prototype of the COM object and cached for re-use by the marshaling component. Other embodiments provide finalizer support for memory management of COM objects having script and native world representations including an implementation of a two-phase commit protocol that enables efficient and conservative recycling of objects and associated memory.

Abstract: A method and system for selecting a technology to implement a service integration. Functional and non-functional service requirements are received. Technology preference relative weights for a pre-defined set of technologies and requirement relative weights for the requirements are received. Responses are received. The responses are associated with the requirements and with the requirement relative weights in a one-to-one correspondence. The responses are associated with the technology relative weights in a many-to-one correspondence. Each response indicates a characteristic that satisfies a requirement. A technology for implementing the service integration is selected from the pre-defined set of technologies based on the technology preference relative weights and the requirement relative weights.

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: The disclosed invention presents a multi-phased approach for developing a service oriented architecture (SOA) solution using front end SOA components that endure throughout the SOA development lifecycle. The approach can determine interface requirements between a set of services to be implemented in a SOA solution and SOA front end. The SOA front end can conform to the determined interface requirements. The SOA front end can also be interactively utilized early within and can be applicable to all phases of a SOA lifecycle, which includes design, development, and implementation phases. The SOA front end can be combined with a service emulator to form an interactive prototype of the SOA solution. The SOA front end can also be combined with a set of SOA back end components to form the SOA solution.

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: In one embodiment, a technique for controlling one or more devices within a physical room of a structure is provided. One or more devices in the structure are coupled, either directly or indirectly, to a programmable multimedia controller configured to issue control commands which, when implemented, change the state of the devices. A virtual room-based user interface is displayed on a display screen. The virtual room-based user interface may include one or more virtual rooms, each virtual room including a substantially photo-realistic depiction of a portion of the structure, including substantially photo-realistic depictions of one or more devices located within the portion of the structure. In response to the selection of a particular substantially photo-realistic visual depiction, the programmable multimedia controller may issue control commands which, when implemented, change the state of a particular device. The appearance of the particular virtual room may be updated to reflect the changed state.

Abstract: According to a second aspect there is provided a method and system to automatically regenerate software for an object to relational mapping system. The system automatically regenerates a first set of classes. For each class, the system reads class information; reads meta-data based on the class information; and automatically regenerates the class based on the meta-data without overwriting associated custom code. The first set of classes includes base code that is associated with the custom code. The first set of classes and the base code are utilized by the object to relational mapping system to enable access to data that is persistently stored in a database.

Abstract: A method for using type analysis to generate an implementation of a type includes the step of identifying a request to generate a first implementation of a type. A type model associated with the type is received. A second implementation of the type model is identified as suitable for a high-performance implementation. The second implementation is generated on a target processor. The second implementation is represented as the first implementation.

Abstract: According to one embodiment of the invention a computer-readable media stores code that is operable to be executed on a processor. The code includes a JAVA class having objects with associated attributes and also having at least one method. The at least one method is operable, when executed on the processor, to search the objects across any attribute of the objects.

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: Visual representations of different versions of an object are automatically generated and presented to users. Users can compare these visual representations to determine appropriate level of detail transition points based on the visual appearances of different versions of an object. The specified level of detail transition points are converted into level of detail parameter values to be used to select one or more versions of an object for rendering, simulation, or other tasks. The visual representation of each version of an object can include an image sequence of the version at a range of distances from the camera. Each image corresponds to a view of the version at a specific level of detail parameter value. A user interface allows users to view the image sequences associated versions of an object as still images or animation. Users can select images in image sequences as level of detail transition points.

Abstract: A performance analysis model may be determined based on a development model associated with development of a software process, the development model defining an execution of the software process, and the performance analysis model being annotated with performance data characterizing the execution. At least one user-specified performance profile characterizing performance parameters associated with an improved execution of the software process according to the development model may be determined. An assessment computation model may be determined, using the performance analysis model and the at least one user-specified performance profile. At least one performance-based characteristic associated with the improved execution of the software process according to the development model may be determined.

Abstract: A solution is proposed for developing software applications on a data processing system. A corresponding method starts with the step of providing an analysis model of a software application (such as based on a use case diagram); the analysis model represents the software application with stereotypes (i.e., use cases) each one representing a requirement of the software application. The method continues by estimating an optimum number of features of the software application (each one representing a function of the software application); the optimum number of features is estimated according to the analysis model. The stereotypes are then organized in packages; each package includes a set of logically correlated stereotypes, which expose a corresponding feature. A number of the packages are determined according to the optimum number of features and used to implement the software application.

Abstract: Mechanisms that allow frameworks significant flexibility in varying the library of common base classes in a manner that better suits the domain of applications served by the framework. Instead of providing the base class library, the runtime provides a data contract for the data structure of each base class. The frameworks can then define each base class in a custom way so long as the data contract is honored. Thus, for example, the framework may provide custom framework-specific methods and/or properties as is appropriate for the framework. Another framework might define the base classes in a different way.

Abstract: The present invention defines a single Java annotation model. A method in accordance with an embodiment includes: receiving a Java annotation declaration in a Java annotation model; receiving a Java annotation definition in the Java annotation model; receiving domain specific context rules in the Java annotation model; and providing access to combined meta-data information derived from the Java annotation declaration, the Java annotation definition, and the domain specific context rules through the Java annotation model.

Abstract: A computer-implemented method of developing a packet processing application can include receiving a user input specifying a first function and a second function and automatically generating a high level programming language description of the packet processing application including a packet data storage unit (605, 610, 615). Packet units can be stored within the packet data storage unit at locations determined according to the first function and the second function. The high level programming language description also can be stored (630).

Abstract: Automatically generated user interfaces are provided to aid data population of object instances in graphical programming environments. A selection gesture identifies an instance of an object type. The public fields defined for the instance are automatically determined, and a user interface is automatically generated with the name of each defined field and a currently assigned value for each field that has one. Fields which have no currently assigned value are optionally displayed with a hint. The user interface can be placed in an application under development, such as a sequential workflow application, as a class initializer and/or as an object configurator. When the object to be populated has another object as a field, the fields of that nested object are similarly displayed. Data can be entered into a container object through the user interface without replacing prior value(s) of the container object.

Abstract: A method and architecture is described that discovers software application metadata and generates data access applications based on the discovered software application metadata. The discovered metadata along with handcrafted metadata goes through a discovery process and is converted into common, generic abstract metadata objects. The abstract metadata objects then go through an instantiation process to be translated into concrete metadata objects that represent the unique configuration, context and terminology of the source software application. The concrete metadata objects can be generated into numerous forms for the purposes of data access and information sharing. The system also has upgrade protection.

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: 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: A system, method and carrier medium for modeling a Financial Service Organization (FSO) business in a computer software program and for storing the model of the FSO business in a database. An object-oriented business model representing the FSO may be created and stored in a business model database. The one or more business objects included in the business model may be configured to describe various products, methods, functions and properties associated with an FSO. A process map business object may describe a process workflow. The process workflow may identify a sequence of tasks to be performed by an FSO production system to process an FSO transaction. The sequence of tasks associated with an FSO transaction may be consistent with pre-defined business logic for the transaction. Selecting a task object from a plurality of task objects and transferring the task object to a process map display representing the process map business object may create the process workflow.