International Business Machines Corporation

James Irwin Knutson

Craig Henry Becker

Russell Ley Newcombe

John A Cook

Liane Elizabeth Haynes Acker

Troy Douglas Folger

Dana Lea Price

Leho Nigul

Gregory Louis Truty

John William Alcorn

Ping Chen

Stephen Joseph Kinder

James Lee Van Oosten

Stephen James Cocks

Dana M Duffield

Michael Cheng

Karalee Brown LeBlanc

King Shing K Lui

Wei-Li Alexander Huang

Zhong-Yu Zhou

A method, system, and computer program product for managing a managing a middleware architecture is disclosed. As such, a plurality of specification levels can be managed concurrently within a same runtime. An application manager and a set of runtime execution stacks are established to form a middleware. The application manager is configured to establish an interface to the set of runtime execution stacks. The runtime execution stacks are configured to run independent of one another using representative specification technology runtimes. A request to start an application is received. The application includes an application manifest. A particular runtime execution stack of the set of runtime execution stacks on which to run the application is determined. The determination is made based on the application manifest and the representative specification technology runtimes. Using the particular application runtime execution stack, the application is started.

Managing middleware using an application manager

A method provides an annotated language extension for the class of an object, the extension identifying an internal state that may be exposed via simple accessor methods. The extension could apply to an entire object type, or to a specific state within the object. Annotations that can be added to the extension include @Accessable, @Gettable and @Settable. In one embodiment, a method selectively accesses one or more object states. The method includes generating an annotated extension identifying each internal object state to be exposed for access, adding a usage annotation to the extension that defines an accessor method associated with each identified state, and operating a virtual machine to call the accessor method associated with a particular identified state. The particular state may then be accessed, as defined by the called accessor method.

Method for accessing internal states of objects in object oriented programming

A method in a data processing system for attaching an informational dialog to a program. The program is morphed to extend an existing interface to the program to become a dippable program. A dip is created, wherein the dip modifies runtime behavior of the existing interface of the dippable program to include an informational dialog. The dip is added to the dippable program, wherein the informational dialog is attached to the dippable program. The dialog is displayed just before the dippable program is displayed.

Method and apparatus for attaching an informational dialog to a java bean

A method, apparatus, and computer implemented instructions for binding object references from a remote name space into a local name space using a Web application. Information is collected to generate a request for an object reference. Information, such as an application server to use as the source, a source name space path, an identification of destination server, and a destination name space path to which the object reference is to be bound, may be used. The request is sent using a communications protocol, such as hypertext transfer protocol to the application server to be used as the source for the object reference. An object reference is located using the name space. The object reference may be serialized into a format, such as a common object request broker architecture format and sent to the destination. The destination will unserialize the object reference and perform binding using the destination name space path.

Legacy CORBA name space integration using web application servers

A method and implementing computer system are provided in which route mapping for vehicles is determined between starting and destination points designated by an operator. Selected mapping is determined in accordance with operator selected travel-related criteria and augmented with traffic-related information. In one embodiment, after an initial route is set, the route is automatically updated whenever the vehicle strays from the set course, or whenever there is a change detected in related traffic conditions, or whenever subsequent changed travel points are input by the operator. The travel route and other related messaging may be conveyed to the operator by audio and/or visual devices onboard the vehicle.

Mapping travel routes

A software wrapper for interfacing to pre-existing software code is provided. The software wrapper is capable of inheriting from a first application program interface (API) and a second API. For calls to the first API, the software wrapper delegates to a pre-existing enumeration of objects. The wrapper creates a vector identifying elements of the enumeration. Iterators provided by the wrapper maintain positional cursors for calls to the second API. A comparison is made between each of the positional cursors and the vector. If a positional cursor exceeds the size of the vector, additional elements are extracted from the enumeration, placed in the vector, and returned on the second API. Otherwise, if the positional cursor is smaller than the vector size, the wrapper delegates directly to the vector. The first API can be a java-based enumeration API and the second API can be a java-based collection API.

Method and system for implementing collection program interface for accessing a collection of data associated with a legacy enumeration application interface

A process and system for providing name service scoping behavior is implemented. In an object-oriented data processing system, a request is received for an initial context for a namespace from a requesting object. A scoped initial context factory object is constructed, and an initial context is requested from the scoped initial context factory object. A class for the scoped initial context factory object may be determined from a variable in a hash table object passed as an argument. In response to the request for an initial context from the scoped initial context factory object, an initial context is requested from a non-scoped initial context factory object. The scoped initial context factory object may be a subclass of the non-scoped initial context factory object. The initial context returned by the non-scoped initial context factory object is scoped to a partition of the namespace, and the scoped initial context is returned. The initial context returned by the non-scoped initial context factory object may be scoped by performing a name service lookup on the partition of the namespace. The requesting object and the scoping object may be implemented in a platform-independent object-oriented programming language, such as Java.

Process and system for providing name service scoping behavior in java object-oriented environment

A method and implementing system are provided in which CORBA (Common Object Request Broker Architecture) Life Cycle Service FactoryFinder capabilities are combined with CORBA Naming Service resolve operations on a Naming Context. The methodology allows EJBHomes in a distributed network to be found using CORBA Life Cycle Services while maintaining support for the EJB (Enterprise Java Bean) programming model of using JNDI (Java Naming and Directory Interface) lookup calls to locate EJBHomes. Usage of Life Cycle Services in an EJB environment for finding EJBHomes by using Naming interfaces is enabled while using Life Cycle Service semantics. An exemplary embodiment is provided to allow deployment in different environments (including environments without Life Cycle support) and reconfiguration of the FactoryFinder being used, without requiring changes to source code.

Finding named EJB homes via life cycle support

A system, method, and program product, in which a stateful EJB session bean is used as the front end to client calls. In this configuration, a queue is represented by a session bean instance. &ldquo;Put&rdquo; and &ldquo;get&rdquo; are called on the relevant session bean instances. Thus, for example, a client, instead of first finding a home for a given type of OMs then calling &ldquo;put&rdquo; on the home to send out messages, will find a session bean home, create a session bean instance corresponding to a queue, and call &ldquo;put&rdquo; on the bean instance to send messages. In this manner, the message queue can be managed using standard EJB techniques.

EJB adaption of MQ integration in componetbroker

A system, method, and software program for a fastpath redeployment of an Enterprise Java Bean (EJB). When an EJB is deployed, a copy of it is cached on the server. Thereafter, if the EJB is redeployed, it is compared to the cached copy to determine if the deployment descriptors or remote interfaces have changed. If there has been no change, then the previously deployed EJB is installed on the server, without the need to regenerate and recompile the EJB code.

Fastpath redeployment of EJBs

A method and apparatus for a general container mechanism for storage of object-oriented Java Beans. A repository is created for a persistent collection of items called ManagedBeans. Each ManagedBean contains a structured collection of code and data that makes up a Java Bean. The structured collection consists of items called ManagedBean Elements (MBE) which correspond to different types of code and data. Each ManagedBean Element is a subclass of the generic ManagedBean Element class. Each subclass identifies the different kinds of Bean sub-elements and contains the data contained in the corresponding file, and method that works on this data.

Method and apparatus for a model data structure for accessing and manipulating java beans

A method and apparatus providing a data processing system for managing rules in a program in a Java operating system. The program is morphed such that the program becomes a dippable program. A rule change is identified for the program. A dip is created for the program, wherein the dip incorporates the rule change. The dip is added to the dippable program, wherein the rule change is incorporated into the dippable program. In the instance in which the program is not in a form suitable for morphing, an interface may be added to encapsulate the program and allow the program to be compatible with Java objects.

Method and apparatus for dynamic application and maintenance of programs

A method and apparatus for extending a Java Beans Archive file. A key/value pair is added to the manifest file specification to allow an application to determine information about the sub-element composition of a Java Bean. The key provides a unique integer &ldquo;N&rdquo; which allows the specification of a Java Bean in the archive file. The value pair provides specification for a tag for indicating the type of a specific sub-element file in the archive file.

Method and apparatus for extending a java archive file

A method and apparatus for extending the capability of uniform Resource Locators (URLs) to access Repositories on local and Internet connected remote machines. A general syntax for a uniform resource locator for a local machine has a protocol of 'beans:', followed by an optional entry for a drive letter. The drive letter allows specification of a local device (e.g., A: or C: drive) where a repository is located. In addition, the general syntax contains entries for a file system path, repository name and Java Archive designation. The general syntax for the uniform resource locator for a remote machine has a protocol of 'beans:' followed by entries for host name, file system path, repository name, and the Java Archive designation.

Method and apparatus for utilizing URLs to specify local or remote java

A method and apparatus for using a Digital Signature Algorithm (DSA) for providing licensing of software. Three steps are required to allow setting up a license, issuing a license and for customer update of the license. An initialization step generates a public and private key pair. A license generation step follows the initialization step and involves feeding the private key and data for the license terms through the DSA to create a digital signature. The digital signature hash value is distributed to the customer as a valid license. The customer performs license verification by running the signature, public key and data for the license through the DSA on the customer's machine.

Growing community of inventors

Austin, TX, United States of America

James Irwin Knutson