Abstract: A system and method for system services customization using configured infrastructure properties through a system of property sheets. When a virtual container is configured with an infrastructure service, the preferred embodiment loads the plug of the infrastructure service and invokes the plug, providing it the empty collection of property sheets. The plug responds by populating this collection with corresponding property sheets. A user can then provide unique values for those properties, which are then saved with the other metadata. Each collection contains one or more property sheets and each property sheet contains one or more properties.

Abstract: An analysis tool extracts class data from Java objects originating from multiple vendors having a particular design specification. A database mining tool then creates training data from the extracted class data to create a definition of objects associated with the particular design specification. Various implementations of the defined classes are compared across various performance metrics, which are output for the program designer as a function of vendor. The designer then selects the best design choices based on the best practices of multiple vendors disclosed by the outputs of the analysis tool when implementing a new Java program.

Abstract: A system for the testing of a software component API includes the generation of a wrapper component. The wrapper component is generated by determining the interface of the software component and by mirroring that interface in the public interface of the wrapper. The wrapper methods delegate to the software component API. Test code is included within the wrapper component to permit capture and playback of interaction with the software component API. Test case software accesses the software component API through the wrapper. The wrapper both generates trace data based on the interaction between the test case and the software component and delegates to the software component API.

Abstract: Systems, methods, and structures are discussed that enhance type reconstruction for programs. Whereas previous methods insufficiently provide the set of types necessary for program analysis, the embodiments of the present invention can accept any verifiable bytecode programs and produce a set of types needed for program analysis. The embodiments of the present invention provide a technique called subtype completion that transforms a subtyping system by extending its type hierarchy to a lattice. However, such transformation inserts only a minimal amount of elements so as to enhance the computation of reconstructed types.

Abstract: Methods and apparatus for developing software for a computing device are provided. One method includes accessing input received from an input peripheral, accessing a definition file defining a plurality of tools for code development, providing a development assistance tool on an output peripheral based on conditions and instructions in the definition file that match the input. Another method includes receiving an engine definition file corresponding to a development assistance engine incorporated into the IDE, editing the engine definition file to include programming tools that correspond with the a computer language that is native to the computing device, and saving the edited engine define file for subsequent use by the IDE.

Abstract: A development environment may receive input selecting a Web service implementation. The development environment may also receive input to define a virtual interface of the selected Web service implementation. The development environment may create a virtual interface descriptor file that includes the received input defining the virtual interface. The development environment may generate a Web service description based, at least in part, on the virtual interface descriptor file.

Abstract: A method of dynamically creating an OSGi bundle is provided, including determining a directory for creation of the OSGi bundle, a runtime environment, and an OSGi framework, determining a functionality and a data for the OSGi bundle based on the runtime environment and the OSGi framework, creating a JAR file of the OSGi bundle with the data and the functionality, creating a bundle manifest for the OSGi bundle accordingly, installing and starting the OSGi bundle; and using an activator of the OSGi bundle to any one of initialize services and perform any additional tasks. One of a main OSGi bundle and an application performs the determining, the creating, and the installing and starting. The main OSGi bundle and the application have logic that enables the determining of the functionality and the data offered by the OSGi bundle. An initialization of the services and a performance of the any additional tasks is dependent on the functionality and the data of the OSGi bundle.

Abstract: Various embodiments for remote presentation of an interface of a computing device, such as a PC, are described herein. In particular, in various illustrated embodiments, a local device such as a Digital Media Adapter (DMA), mobile device, cellular telephone, etc. may be used to receive input from a remote control, where the local device provides human perceptible feedback, such as a sound, visual response, etc., responsive to use of the remote control. In some embodiments, the local device may contain a memory or cache for locally storing particular feedback data for human perceptible feedback. In various embodiments, a communication protocol is provided for storing, triggering, deleting, etc. feedback data in the memory or cache. In various embodiments, an article of manufacture, which includes a tangible machine accessible storage medium, stores associated data which, when accessed by a machine, causes the machine to perform the actions described above.

Abstract: Methods and apparatus to implement annotation based thunking are disclosed. An example method comprises locating a parameter of a function, the parameter to be passed as a pointer if a size of the parameter is greater than a threshold and to be passed as data if the size of the parameter is not greater than the threshold, and adding an annotation record for the parameter to a byte code image file containing byte code for the function.

Abstract: An application server system is provided having a core engine connecting one or more protocol providers to one or more applications. In a preferred embodiment, the one or more applications run on a respective one or more virtual machines having their own execution threads. A thread pool may be used to spawn instances of applications or scripts. Preferably, the core engine, the protocol providers, and each of the one or more virtual machines run in separate AppDomains. In another embodiment, a visual designer is provided preferably having XML conversion capability and interactive debug capability.

Abstract: A method of code obfuscation includes receiving a code segment. The existing code of the code segment is modified and/or additional code injected to create overlapped code. The overlapped code performs a plurality of semantically different actions depending upon the content of execution. The resulting obfuscated code having overlapped code is then output.

Abstract: Techniques are described for generating and actively verifying a boot code associated with a peripheral device of a computer system to prevent potential security threats the boot code may introduce into the computer system. The techniques for generating boot code entail generating the boot code from a high-level programming language using a verification application program interface (API). The API aids in generating a certificate, which is associated with the boot code in that the certificate describes operation of the boot code. After generating the boot code and associated certificate, the two are loaded onto a memory module of the peripheral device. Once the peripheral device is connected to the computer system, the computer system may retrieve the boot code and certificate. The computer system utilizes techniques to actively verify the boot code by performing a security check on the boot code in accordance with the associated certificate.

Abstract: A method and a system for selecting a desired language for text displays in a Java-Type language is provided. A localization class in the loadable Java program defines the text portions of the displays. At start of the application, the Java virtual machine loads this class and a determination is made, by user input or otherwise, of which of a group of languages available should be used for the text. Based on the determination, the static initializer Java-type code is invoked, and it loads the appropriate language text from a markup language document, preferably an XML document. The appropriate text segments from the markup language document are then used to initialize the variables. The application then can proceed to run as usual. Preferably, after the static initialization, the fields of the localization class are checked to confirm that all fields contain text.

Abstract: A new architecture and method of a cellular phone embedded system consists of an application system interface sector and an execution system interface sector. The application system interface sector includes an application program executed on a cellular phone platform system, and a conversion to a PIFF format is performed by a program compiling software and an MVM application program code. The converted PIFF format is downloaded to the execution system interface sector, so as to enable an internal OS management system to be an open system program sector. The execution system interface sector contains an MVM subsystem, and the converted PIFF format is linked to an MVM system program code (ORGAN.lib) by an MVM internal system program operating platform and the application system interface sector. Moreover, an active fast dynamic address linking and static address linking is used to constitute a new architecture of system platform.

Abstract: Methods and systems for delivering a Java application to a requestor device are described. A request for the Java application is received at a node between the requestor device and a source of the Java application. A request for the Java application is sent to the source. The Java application is received from the source at the Intermediate node, which transforms the Java application according to attributes of the requester device. The transformed Java application is then sent to the requestor device.

Abstract: The present invention uses annotations and SQL to retrieve and/or persist POJO data from/to a database, respectively. Using SQL will enable developers to unleash the full querying power of their chosen Database Management Systems (DBMS) and will remove the requirement that they learn a new query language. A minimal amount of annotations will be associated in the same Java® source file where each class of POJO to be persisted to the database is defined. An enhanced compiler is capable of analyzing the annotated source file and automatically generate the bytecode required to create, deploy, and manage the persistence of POJOs without requiring knowledge of specific details of the persistence to corresponding data entities in the underlining database. Therefore, such an approach decreases the time, knowledge, skill and ultimately cost required to persist POJOs to an underlying database. This description is not intended to be a complete description of, or limit the scope of, the invention.

Abstract: A Web application framework for creating Web-based applications is described. The framework includes an abstract command tag that predefines at least some generic Web application activities. When using the framework, one specifies at least one custom action that is desired to be performed by a Web application under development. In one embodiment, this includes creating a customized command tag that is capable of being embedded within a Web page. The customized command tag includes the ability to conditionally execute the specified custom action based on run-time conditions. The customized command tag is embedded in a Web page of the Web application.

Abstract: Techniques for developing database applications are described herein. According to one embodiment, an object-relational mapping (ORM) query language (OQL) statement is received via a first window which is entered from a user for querying an underlying database, where the OQL statement is written in a customized query language that is incompatible with the underlying database. In response, a SQL statement compatible with the underlying database is dynamically displayed in a second window, where the SQL statement is automatically translated from the OQL statement displayed in the first window. Other methods and apparatuses are also described.

Abstract: The present invention provides users and processes with various features to control the memory usage by a cache and pool dynamically at runtime. The cache and pool can be initialized on demand to remove idle objects of classes from them without the server being restarted. When the cache and pool reach their maximum sizes, idle objects in them may be removed to make room for newly active objects using various strategies in batches, where the schedule (periodicity), size and processing time of each batch can be dynamically adjusted. When a newly created object is being added to a full cache where each object is enrolled in a transaction, one or more active objects may be passivated from the cache based on various criteria to make room for the new instance to be added. Various features of the cache and pool can be defined in a configuration file. This description is not intended to be a complete description of, or limit the scope of, the invention.

Abstract: Java class information is analyzed to determine if the code is standard for its particular class, and thus belongs to impliedly trustworthy software. An analysis tool performs a pre-analysis to train itself on standard class data for standard implementations of the object type and non-standard class data for non-standard implementations of the object type, and then performs a dynamic analysis of a received Java program to determine if its class data matches the criteria for a standard implementation of the object class.

Abstract: Techniques for constructing and using run-time JAVA Archive (JAR) files for JAVA Stored Procedures (JSPs) are provided. JSP methods referenced by an application via a plurality of different JAR files are extracted and packed into a single packed JAR file. When the application tries to execute a JSP, the attempt to process the JSP methods is redirected to a new JSP that calls the single packed JAR file.

Abstract: A method and apparatus for creating a schema definition from a language-specific metamodel of a data structure written in a legacy computer language involves walking through the nodes of the metamodel, and creating corresponding schema element objects in a schema tree that is serialized to create the schema definition. The creation of the schema element objects follows rules, and permits the definition of nested data structures having conjunctive-type and disjunctive-type membership.

Abstract: Under the present invention a definition file and an object file are provided. The definition file includes a defined syntax for managed object descriptions, while the object file contains a description of a particular desired object. When a process is started (or re-started), the files are automatically read and the description in the object file is automatically validated based on the defined syntax in the definition file. Once validated, the description is used to automatically create a managed resource from which a managed object can be created.

Abstract: Run-as credentials delegation using identity assertion is presented. A server receives a request from a client that includes the client's user identifier and password. The server authenticates the client and stores the client's user identifier without the corresponding password in a client credential storage area. The server determines if a run-as command is specified to communicate with a downstream server. If a run-as command is specified, the server retrieves a corresponding run-as identity which identifies whether a client credential type, a server credential type, or a specific identifier credential type should be used in the run-as command. The server retrieves an identified credential corresponding to the identified credential type, and sends the identified credential in an identity assertion token to a downstream server.

Abstract: In accordance with one embodiment of the present invention, there is provided a technique for supporting introspection of generic types while maintaining migration compatibility. According to one aspect of this technique, in response to an invocation of a programmatic method of a reflective proxy, a string representation of a program element that corresponds to the reflective proxy is generated. The string representation contains information that is based on formal type parameters that are associated with the declaration of the generic type that is associated with the program element. According to another aspect, the programmatic method described above differs from another existing programmatic method “toString( )” that generates a string representation that does not indicate generic type-specific information. Thus, programs that depend upon the existing implementation of the “toString( )” method may continue to use it.

Abstract: A method for changing a succession of instruction words including providing a set of machine words, each machine word being associated with an address from a set of addresses, providing a succession of instruction words having address information, the succession of instruction words prescribing a sequence of machine words which are intended to be processed by an arithmetic and logic unit which is coupled to a buffer store, altering the association between at least a portion of the set of machine words and at least a portion of the set of addresses, changing the address information in the succession of instruction words based on the alteration of the association, storing the changed succession of instruction words in a memory, and storing the set of machine words in the memory, so that it is possible to access the machine words using the associated addresses.

Abstract: The present invention provides a method for supporting data driving a software process. The method comprises receiving, from a user, input of a class of an object of a non-primitive data type; and providing to the user a description of the collection of attributes necessary to construct an instance of the object, based only on the class of the object. The step of receiving the class of the object is free of receiving a pre-existing instance of the data type. In further related embodiments, the method further comprises receiving, in a single user step, user input of defining attribute data necessary to create the instance of the object and set it into a desired state; and creating and initializing the instance of the object using the defining attribute data; wherein the defining attribute data does not include a pre-existing instance of the data type.

Abstract: The present invention method and system ensure execution of post processing logic for a subject computer program routine (e.g., JAVA application) without wrapping the routine inside another. The invention system and method include different sets of exit handling steps for different types of exits in the subject routine. In each set of exit handling steps, the post processing logic is executed. Flow of control of the subject routine resumes at the respective exit point.

Abstract: A trusted Java virtual machine provides a method for supporting tamper-resistant applications, ensuring the integrity of an application and its secrets such as keys. The trusted Java virtual machine verifies the integrity of the Java application, prevents debugging of the Java application, and allows the Java application to securely store and retrieve secrets. The trusted Java virtual machine environment comprises a TrustedDictionary, a TrustedBundle, an optional encryption method for encrypting and decrypting byte codes, and an underlying trusted Java virtual machine. The encrypted TrustedDictionary protects data while the TrustedBundle protects programming code, allowing applications to store secret data and secure counters. The application designer can restrict TrustedBundle access to only those interfaces that the application designer explicitly exports. The open source code may optionally be encrypted.

Abstract: A system and method for automatically analyzing virtual machine bytecode of a software application and adding additional bytecode operable to determine information regarding network communication performed by the software application are described. According to one embodiment of the method, program code of a software application may be received, wherein the program code includes bytecode for a virtual machine. The bytecode may be automatically analyzed to detect network communication functionality. The method may operate to automatically add additional bytecode to the bytecode of the software application, where the added bytecode is operable to determine information regarding the network communication.

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: Multiple Shared Rowsets, can access rows of data stored in a Cached Rowset independently. These Shared Rowsets can have their own cursor, sorted order, filtered rows, and pending changes.

Abstract: A method of converting ERP data in a database managed by an ERP application and accessed through an ERP API and ERP Message Agent API (MAAPI) to strongly typed data in Java objects includes steps of reading, parsing, creating, and populating. A XML file containing the definition of the Java objects and their attributes of HyperText Markup Language (HTML) statements which specifies presentation format is read. Each of the declarations and HTML statements are parsed to identify definitions of objects and their attributes. The respective objects are created with their attributes. The objects are populated with data from the ERP data.

Abstract: Examination of a server-side Java bean to automatically generates a JavaScript representation of the methods in the bean. The JavaScript representations of the methods are sent to the Web browser. The browser then creates JavaScript objects that can be called directly from other JavaScript code on the client side, and which communicate with the server-side method.

Abstract: A method and apparatus for transforming JAVA Native Interface function calls to constants, internal just-in-time (JIT) compiler operations or simpler intermediate representation. A compiler generates a plurality of intermediate representations for a plurality of native interface function calls. During inlining of native code, matching is performed on each native function call (against this list) and a list of native interface function calls is generated. For each native interface function call, a (JIT) call transformer attempts to replace the native interface function call with a constant, internal JIT compiler operation or a simpler intermediate representation depending on the type of native interface function call.

Abstract: A system and method for controlling execution of an interpreted language. Statements of the interpreted language to be executed by a script engine are intercepted by a protection module and control is passed to a script helper module that is asociated with the script engine. The script helper module establishes a secure communications channel with an authorization component and passes the statements and an authorization request to the authorization component. The authorization component sends a reply to the script helper module which either permits the script engine to execute the statement or cancels the attempted execution. When the script engine is loaded, a list is updated identifying the script engine. If a script helper module is not present for the loaded script engine, a boot-strap loader is called to load the script helper module. A special information block contains data as to the location of the interception points.

Abstract: A method of instrumenting a method of a class by modifying bytecodes is disclosed. The method comprises: providing an interface, by which the method can be selected; inserting bytecodes that will be executed when the selected method is called; and providing an interface, through the inserted bytecodes can pass information about the method.

Abstract: A method to assist a software developer in optimizing performance of a Java virtual machine (Jvm) is disclosed. The method includes creating a model to predict future usage of heap memory by the Jvm. In response to the time series analysis model having an upward trend of heap memory usage, advising the developer to review a heap dump to determine if a possible memory leak exists. In response to the time series analysis model having a horizontal asymptote at a predicted future time, advising the developer to specify the maximum limit of heap memory as a function of the horizontal asymptote. In response to a heap exhaustion error, which indicates a requested usage of heap memory by the Jvm greater than a maximum limit of heap memory, determining a likely cause of the heap exhaustion error, and advising the developer to take appropriate actions to optimize the Jvm performance.

Abstract: A mobile information device may execute a Java MIDlet or a non-MIDlet application. The mobile information device may further include an object-oriented application program interface that allows one or more object-oriented object classes to allow input and output data to be communicated between Java MIDlets in different MIDlet Suites and between non-MIDlet applications. The application program interface may be used to allow applications to access a universal message handler executing on the mobile information device.

Abstract: Embodiments of the present invention address deficiencies of the art in respect to MIDlet execution in a desktop environment and provide a method, system and computer program product for clip region definition for a MIDlet region space. In one embodiment of the invention, a method for clip region definition for a MIDlet region space can be provided. The method can include extracting a raster image from a MIDlet, computing a clip region from the extracted raster image for the MIDlet, deploying the MIDlet to a desktop environment through an emulator, and applying the clip region to the MIDlet through the emulator to deploy the MIDlet as a widgetized application in the desktop environment.

Abstract: An object-oriented program development tool supports the specification and implementation program aspects. Cross-cutting concerns can be identified, and key points in a program augmented with arbitrary functionality. Classes and individual objects can be associated with different advices. Interceptors can be added dynamically on a per-instance and/or a per-class basis.

Abstract: A mapping engine, capable of receiving descriptions of manageable software objects in a first language, for generating management information in a second language. The mapping engine is further capable of generating a set of mapping metadata, corresponding to the management information as generated. The mapping engine may be further responsive to user input. In another embodiment, a metadata compiler is provided, capable of receiving management information in a second language, and corresponding mapping metadata, for generating compiled metadata, applicable when using said management information in a first language. The metadata compiler may be used in connection with the above first aspect.

Abstract: A cursored collection can be used to allow a user to view subsets of a data result set, thereby conserving system resources. A persistence manager can execute SQL statements on a database, receive a result set from the database, and populate a set of EJBs with the result set. This can be a full result set, or a subset of the full result set. A bean manager can allow the user to access all the EJBs or a subset of the EJBs. The bean manager can also provide the user with a list of EJBs and let the client select the EJBs to access. The client can then iterate through the result set, either by viewing different subsets or selecting different EJBs from the list. This iterative process can continue until all the results have been viewed or the client does not wish to access any more results from the set.

Abstract: The present invention is a method for enabling a trusted dialog for collection of sensitive data, including the steps of: storing a personal security token specified by a user; receiving an input dialog request from an application; determining whether the application is a signed application; and, if a determination is made that the application is a signed application, accessing the personal security token and allowing the input dialog to be displayed with the personal security token and signed application identification.

Abstract: A Java application is started, the started Java application instructs a Flash bridge section 16 to start a Flash file via an application managing section 15, and the Flash bridge section 16 transmits interaction information for causing the Flash file and the Java application to interact with each other while designating an application for the interaction to the application managing section 15.

Abstract: In a processor system comprising of a processor having an instruction decoder 22, a general register 61 composed of a plurality of register areas and at least one ALU 60, and a Java accelerator 30 for converting a Java bytecode sequence to a native instruction sequence for the processor and supplying the native instruction sequence to the instruction decoder. The Java accelerator 30 is composed of a bytecode translator 40 for converting the Java bytecode sequence to the native instruction sequence for the processor and a register status control unit 50 for mapping a Java operand stack to any of the register areas of the general register and detecting a bytecode redundant for the processor. When a redundant bytecode is detected by the register status control unit 50, the supply of the native instruction from the bytecode translator 40 to the instruction decoder 22 is inhibited.

Abstract: The present invention is to provide a method for enabling BD-J to effectively obtain context of the corresponding Xlet while playing BD-J title, which comprises the steps of setting up source file attribute of each class by adding an Xlet context ID as an unique code to the class when loading all classes into a cache of the BD-J; looking up back onto a call stack to search for Xlet class of the current BD-J title when searching for Xlet context; and then obtaining the Xlet context through the Xlet context ID according to the source file attribute. Thus, the method of the present invention enables BD-J to normally play the BD-J title in the BD-ROM and, at the same time, effectively improves the playing performance.

Abstract: A portable executable (PE) is invoked through a platform-independent interface by processing an export table in the PE to obtain the function names used in the PE. A resources table in the PE is processed to obtain a user interface used in the PE. A platform-independent user interface is generated based on the user interface used in the PE. At least one of the functions used in the PE is invoked through the platform-independent user interface.

Abstract: Described is a system and method of regenerating stack unwind data in the presence of exceptions. The system is directed to generating metadata for use during stack unwinding. The system includes procedures, a first plurality of metadata, and an unwind rewriter. Each metadata is associated with a corresponding procedure in the procedures. The unwind rewriter generates new metadata from the first plurality of metadata in response to a modification of the sequence of binary instructions within a procedure, such that the new metadata accurately represents the modified sequence of binary instructions. The method regenerates metadata in response to a binary modification to a procedure by receiving a first group of metadata associated with the unmodified procedure, parsing the first group of metadata, and generating a second group of metadata that accurately represents the binary modification to the procedure.

Abstract: The present invention relates to a method for identifying subject-executed code and subject-granted access rights within a program, the method further comprising the steps of: constructing a static model of a program, and determining a set of access rights that are associated with each subject object that is comprised within the program. The method further comprises the steps of annotating the invocation graph with the set of access right data to generate a subject-rights analysis, wherein each node comprised within the invocation graph is mapped to a set of access rights that represent subject-granted access rights under which a method that corresponds to a respective node will be executed, and utilizing the subject-rights analysis to perform a subject-rights analysis of the program.