Mainframe Code Accelerator Template Generation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Mainframe computer applications written in non-object-oriented languages like COBOL, CICS, DB2, and IMS are challenging to maintain due to non-uniform coding practices, making it difficult to generate and modify code efficiently, especially for input/output and error handling operations.
Innovation Solution
A system and method that generate mainframe computer code templates by identifying and retrieving code segments with metadata, allowing developers to focus on business logic, and using copy books to reduce manual navigation and syntax review.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Manufacturing precision
If developers manually write mainframe code following best practices, then code quality and uniformity improve, but development time and complexity increase
Solution Approach 1:
The system performs preliminary action by pre-generating standardized code templates that incorporate best coding practices, input/output operations, and error handling. Developers can then customize these pre-prepared templates rather than writing code from scratch, achieving uniform code quality while reducing development time.
Solution Approach 2:
The system uses copying by providing standardized code templates that can be replicated and adapted for different scenarios. These templates contain proven, uniform code structures that can be copied and modified, ensuring consistency across the codebase without requiring developers to manually create uniform code each time.
2Adaptability or versatility
If developers manually write all code including routine operations, then code customization improves, but productivity decreases
Solution Approach 1:
The system applies segmentation by dividing code development into two parts: standardized template code for routine operations (input/output, error handling) and custom code for business logic. This allows developers to focus on customization where needed while automatically generating standard code, improving productivity without sacrificing adaptability.
Solution Approach 2:
The system implements universality by creating multi-functional code templates that handle various routine operations (different input/output types, multiple error handling scenarios) in a unified manner. These universal templates can be applied across different parts of the application, reducing repetitive work while maintaining the ability to customize specific behaviors.
3Manufacturing precision
If developers refer to manuals during coding, then coding accuracy improves, but ease of operation deteriorates
Solution Approach 1:
The system acts as an intermediary between developers and coding standards/manuals. Instead of requiring developers to consult manuals directly, the system automatically applies best practices and generates accurate code templates, serving as a mediator that translates coding standards into practical, ready-to-use code without interrupting the development workflow.
4Reliability
If complex mainframe operations are implemented manually, then operational control improves, but device complexity increases
Solution Approach 1:
The system implements self-service by automatically generating code for complex mainframe operations such as input/output handling and error management. The system serves itself by providing the boilerplate code and structural framework, reducing the complexity burden on developers while maintaining reliable operational control through standardized, proven code patterns.
Data Source
AI summary
Methods and systems for generating mainframe computer code are provided. Collections of code segments for implementing common input and output operations and error handling operations are linked to an application development platform. Developers identify attributes of input and output operations. The application development platform may then search the collections to locate appropriate input and output operation and error handling operation code segments and generate a template that includes them. The developer may then add code to implement business logic and generate a mainframe application program.