Welcome
Developing
Developing EGL applications
Enterprise Generation Language (EGL) is a programming language that you can use to focus on business problems instead of software technologies. Within the Rational® development environment, you can use EGL wizards and other tools to write complex applications with minimal effort.
EGL Programmer's Guide
The EGL Programmer's Guide covers using EGL within the Eclipse Integrated Development Environment (IDE), as well as some of the common programming tasks that EGL developers perform.
Services: a top-level overview
The topics in this section describe service-oriented architecture (SOA) and related technologies, EGL support for SOA, and service-related procedures, with an emphasis on service access. For details about deployment, see “Introduction to EGL generation and deployment” and “Add web-service deployment entries in the EGL deployment descriptor.”
Accessing a service
In EGL, you can access several different types of services. To learn the access procedures, see the links in the following table.
Creating an Interface part from a Service or ExternalType part
You can use a Service or an ExternalType part as a model for a new Interface part.

Overview
Getting started
Installing
Upgrading and migrating
EGL Code Accelerator for IBD
Developing
- Model driven development of EGL code
- Generating source code from UML models
  You can use transformations to create source code from a UML model. First you must create a transformation parameters file and then apply those parameters to a model.
- Generating the EGL Dependency Graph from EGL projects
- Generating Source Code from OpenAPI Documents
- Developing EGL applications
  Enterprise Generation Language (EGL) is a programming language that you can use to focus on business problems instead of software technologies. Within the Rational® development environment, you can use EGL wizards and other tools to write complex applications with minimal effort.
  - How to use this documentation
  - Additional information about EGL
    The most recent EGL documentation is in the IBM Business Developer documentation.
  - EGL Programmer's Guide
    The EGL Programmer's Guide covers using EGL within the Eclipse Integrated Development Environment (IDE), as well as some of the common programming tasks that EGL developers perform.
    - Introduction
      These topics explain the fundamentals of using EGL in the Eclipse IDE, as well as changes to the EGL language and IDE in this version.
    - Contents of an EGL application
      EGL applications contain projects, packages, folders, and files.
    - Properties
      Properties set specific options for parts. In general, you specify the properties when you create the part and then the properties are static. In certain circumstances, however, it is possible to change a property dynamically.
    - Annotating EGL Applications
      EGL developers can annotate their applications to indicate the version, authors as well as a general description.
    - Import and use statements
      Use the EGL import and use statements to expand the visibility of code elements.
    - Working with EGL code
    - Accessing data with EGL code
    - Transfer of control across programs
    - Developing segmented programs in EGL
      Different runtime environments have different considerations for developing segmented programs.
    - Developing EGL programs for the IMS™ environment
    - Developing EGL programs for the CICS® environment
      There are specific design and development considerations when creating EGL programs for CICS® for z/OS® and CICS for VSE.
    - Developing EGL programs for the VSE environment
      IBM Business Developer provides a Generation for VSE feature that you can use to generate EGL as COBOL source for the z/VSE® environment.
    - Developing programs for iSeriesC
      You can deploy EGL-generated COBOL programs targeted for the IBM® i environment.
    - Overview of EGL Logging for Java Application
    - Overview of EGL Rich UI
    - Services: a top-level overview
      The topics in this section describe service-oriented architecture (SOA) and related technologies, EGL support for SOA, and service-related procedures, with an emphasis on service access. For details about deployment, see “Introduction to EGL generation and deployment” and “Add web-service deployment entries in the EGL deployment descriptor.”
      - Service-oriented architecture (SOA)
        Service-oriented architecture (SOA) is a way of organizing software. To learn about SOA, see the following sections:
      - EGL support for SOA
        EGL provides two kinds of support for service-oriented architecture (SOA): service development and service access.
      - EGL Support For REST
      - EGL Support for SSO
        Single Sign-On (SSO) is an authentication process that enables users to access multiple applications with a single set of credentials. This enhances security and user experience by reducing password fatigue and ensuring centralized access control.
      - Creating a service to call a program
        If you have a called program in your project, you can create a Service part to call that program.
      - Spring Framework for EGL REST Services
      - Accessing a service
        In EGL, you can access several different types of services. To learn the access procedures, see the links in the following table.
        Creating an Interface part from a Service or ExternalType part
        You can use a Service or an ExternalType part as a model for a new Interface part.
        Declaring a variable to access a dedicated or local EGL service
        After you code an EGL Service part, you can use that part as the basis of a service-access variable.
        Declaring a variable to access a remote EGL or native service
        When you declare a variable to access a remote EGL service or IBM® i service program, indicate that the binding detail for service access is in the service binding section of the EGL deployment descriptor. You can indicate the relationship of the variable and descriptor by adding the @BindService property to the access variable.
        Binding a service-access variable dynamically
        You can use dynamic binding to either choose a service at run time or change the service to which a variable is bound.
        Creating an Interface part to access a REST service
        You define an EGL Interface part in a file that is made available to the requester of that service. The Interface part can be in the same EGL package or can be imported from a separate package.
        Declaring a variable to access a REST service
        To provide additional details about how to access the REST service, you declare a variable in the requester. That variable is based on the Interface part.
        Creating an Interface part to access a SOAP service
        An EGL Interface part includes one or more function prototypes, each of which identifies an operation that is available in a service.
        Declaring a variable to access a SOAP service
        To provide additional details about how to access the SOAP service, you can create a variable based on the Interface part.
        Invoking a service asynchronously from a Rich UI application
        In Rich UI, the call statement is used to invoke a service asynchronously:
        Invoking a service synchronously from outside of Rich UI
        Service invocation outside of Rich UI is always synchronous, which means that the requester waits for a response from the service.
        Interface part for accessing a third-party REST service
        In EGL, you can use the following Interface part to access a third-party REST service.
        Accessing IBM® i programs as web services: overview
        You can use EGL to expose the logic in an IBM® i called program or service program by way of an EGL external type.
      - Setting preferences for service generation
        You can specify how your services are generated.
      - Creating a WSDL file to preview
        You can create a WSDL file from a Service part to preview the file that will be generated for that part.
    - Generating source code from UML models
      You can use transformations to create source code from a UML model. First you must create a transformation parameters file and then apply those parameters to a model.
    - Building EGL Text User Interface applications
      A Text UI application presents a text-based user interface similar to that of a 5250 or 3270 terminal.
    - Creating reports with EGL
      EGL offers different ways to create reports, using external engines to generate the report contents.
    - Working with web transaction applications in EGL
    - Debugging EGL applications
    - EGL Unit Testing
    - z/OS Connect
  - EGL Generation Guide
    The EGL Generation Guide covers the process of converting EGL code to Java™ or COBOL source code, including the processes and the files involved. This section is intended for a developer who will generate or deploy EGL applications.
  - EGL Language Reference
    The EGL Language Reference covers the fundamental use of the language, including its concepts, syntax, and keywords. This volume is intended for a developer writing EGL applications with some experience in procedural programming.
  - Rational® COBOL Runtime Guide for zSeries®
    This manual provides information about customizing and administering the IBM® Rational® COBOL Runtime.
  - IBM Business Developer EGL Server Guide for IBM® i
    This manual provides information about customizing and administering EGL Server for IBM® i on the host.
  - Generation for VSE Feature Reference
    This reference manual provides z/VSE-specific information about developing and generating EGL programs in the VSE environment.
- Source code analysis with code review
  With code review, you can create configurations of coding rules for EGL source code. You can then run the configurations to check the source code for consistency with the rules.
- Responsive Design Support in IBD
  What is Responsive Design? Responsive design is an approach for creation of web pages that automatically scales its content and elements to match the screen size on which it is viewed. So, instead of designing multiple websites for different devices with variable screen sizes, we can design just one website that scales up or down automatically, to match the device it’s being viewed on.
- Containerizing an EGL RUI Application
Samples
Troubleshooting and support
EGL runtime error messages
Reference
Glossary
Using the help
Notices for IBM Business Developer documentation

Creating an Interface part from a Service or ExternalType part

You can use a Service or an ExternalType part as a model for a new Interface part.

In the Project Explorer view, right-click an EGL source file that includes an EGL Service or ExternalType part and then click EGL Services > Extract EGL Interface. The New EGL Interface Part window opens.
In the Source folder field, select a source folder to contain the new file.
In the Package field, select a package to contain the new file.
In the EGL source file name field, type a name for the new file that is to contain the new Interface part. By convention, files that contain interface parts begin with a capital letter I.
In the Functions field, select the functions, or function prototypes in the case of an ExternalType, to include in the new Interface part. Only the functions that are not marked as private are shown in this list. If you are creating the part from an ExternalType part, EGL might show multiple Interfaces on separate tabs. You can change the suggested name for any of these Interfaces.
To select or deselect the functions, use the Select All and Deselect All buttons.
Optional: To overwrite an EGL source file, select the Overwrite existing files check box.
Click Finish.

When you access an EGL or EGL REST-RPC service, which is a non-SOAP service, do not use an Interface part that is derived from a WSDL file. Otherwise, a runtime error might occur.