Mainframe Java Virtual Machine Configuration via Initiator Program
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Integrating Java into the mainframe computing environment to create an execution pathway for interfacing with legacy programs is challenging due to environmental differences between operating systems, despite the 'write once, run anywhere' paradigm of Java.
Innovation Solution
A computer-implemented method is provided to create a run-time environment on a mainframe computer by an initiator program, which initiates a configuration program written in a high-level language to specify user-defined parameters for a Java Virtual Machine (JVM), enabling the creation of a JVM and error handling, using the Java Native Interface (JNI) to invoke Java methods and output errors to a data file.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If Java is integrated into the mainframe computing environment, then extended functionality for legacy programs is achieved, but environmental differences between operating systems create integration challenges
Solution Approach 1:
The patent introduces a run-time environment as an intermediary layer between the mainframe operating system and Java programs. This run-time environment includes a Java virtual machine that handles Java execution, while a configuration program written in a high-level language acts as a mediator to bridge the mainframe environment with Java, managing environmental differences and enabling seamless integration without requiring changes to the underlying mainframe system.
Solution Approach 2:
The configuration program allows dynamic specification of user-defined parameters for the Java virtual machine through configuration files. By enabling parameter customization (such as JVM options, classpaths, and runtime settings), the system adapts Java behavior to match mainframe environment requirements, resolving compatibility issues through configurable parameter adjustments rather than structural changes.
2Adaptability or versatility
If a run-time environment is created to support Java execution, then Java integration is enabled, but the complexity of configuring and managing the environment increases
Solution Approach 1:
The run-time environment is designed to be self-configuring through automated program generation. The system automatically generates the configuration program based on the specified parameters, reducing manual configuration effort. The environment also performs self-management by handling Java virtual machine instantiation and execution automatically, minimizing the administrative burden despite the added functionality.
3Productivity
If high-level programming languages are used to minimize duplicative development effort, then cross-platform capability is improved, but environmental differences between operating systems reduce viability
Solution Approach 1:
The configuration program is written in a high-level programming language that provides universal functionality across different mainframe environments. This single program serves multiple purposes: it configures the Java virtual machine, manages the run-time environment, and handles platform-specific adaptations. By making the configuration program multi-functional and environment-agnostic, the system maintains both development efficiency and reliable cross-platform execution.
Data Source
AI summary
A computer-implemented method is provided for creating an execution path for interfacing with legacy programs in a mainframe computing environment. The method includes: creating a run-time environment for programs on a mainframe computer by an initiator program; initiating execution of a configuration program in the run-time environment by the initiator program, where the configuration program is written in the high level programming language; specifying user-defined parameters for a Java Virtual Machine to the configuration program; and creating a Java Virtual Machine in another run-time environment of the mainframe computer, where the JVM is created by the configuration program using the user-defined parameters.