SkillSurf
SkillSurfRide the Wave
Enterprise Applications

IBM Power Systems (AS/400) Developer Training

Master Legacy RPG/400, Modern ILE RPG, CL Control Programming, and DB2/400 Relational Databases

4.9(1,100 students)
60 Hours
Advanced
IBMAS400IBM iRPGILEDB2CL Programming
IBM Power Systems (AS/400) Developer Training

Enroll in IBM i (AS/400) Developer

Get started with a free demo class.

By submitting, you agree to our privacy policy. We'll never share your details.

Live Online
Classroom
Weekend Batches Available
Lifetime Access to Recordings

Course Overview

This specialized training program delivers end-to-end expertise in developing and optimizing mission-critical business software on IBM Power Systems architectures. Covering the full evolutionary trajectory from the classic legacy AS/400 up to modern IBM i running on high-performance Power10 hardware, this curriculum grounds developers in the platform's unique single-level store and object-based operating philosophy. Participants will learn how to design data models via DB2/400 DDS and SQL schemas, automate administrative and operational tasks with Control Language (CL/400), and write highly performant business rules using RPG/400 and modern Integrated Language Environment (ILE) Free-Form RPG.

Who Should Learn

Software Engineers and Enterprise Developers looking to master core backend billing and banking architectures
Mainframe Developers and Database Administrators intending to support legacy DB2/400 data environments
Modern Web Developers seeking to connect modern API web nodes to core transactional RPG business modules
Technical Support Consultants migrating, maintaining, and debugging classic AS/400 or iSeries application codebases

Prerequisites

  • A solid grasp of relational database fundamentals, structured tables, and fundamental query filters
  • Prior exposure to any procedural or structured programming language (e.g., Java, C, or COBOL)

Learning Outcomes

Navigate the native object-oriented architecture of IBM i using command-line structures and explicit library lists
Create and manipulate Physical Files (PF) and Logical Files (LF) using Data Description Specifications (DDS) and advanced SQL commands
Develop automated operational tasks, override standard file behaviors, and manage runtime error trapping utilizing CL/400 scripting
Write complex business calculation logic using structured RPG/400 operation codes and dynamic local data structures
Build interactive multi-record green-screen user interfaces utilizing explicit Load-All and Page-Load display subfiles
Architect modular, reusable applications leveraging the modern Integrated Language Environment (ILE) binding directories
Implement absolute data consistency using explicit database journaling tracks and built-in Commitment Control boundaries

Course Curriculum

1Module 1: AS/400 Architectural Concepts & Object Navigation
5 topics
  • Historical system evolution: Mapping the path from legacy AS/400 hardware up to modern IBM i on Power10 nodes
  • Exploring unique OS attributes: Understanding single-level store mechanisms and object-centric system boundaries
  • Navigating the platform: Working with User Profiles, Libraries, Object Types, and Member file containers
  • Mastering the Library List concept (`*LIBL`): Customizing system search priorities and resource allocations
  • Introduction to the Application Development Tool Set (ADTS): Utilizing PDM (Program Development Manager) and SEU (Source Entry Utility)
2Module 2: DB2/400 Database Architecture & DDS Data Modeling
5 topics
  • Relational model deployment: Architectural overview of the integrated DB2/400 relational database engine
  • Creating data records: Defining Externally Described Files using Data Description Specifications (DDS)
  • Differentiating internal structural mechanics: Engineering Physical Files (PF) vs. filtered Logical Files (LF)
  • Implementing advanced relationships: Coding Join Logical Files and constructing reusable Field Reference Files
  • Enforcing data safety: Implementing database security restrictions, Referential Integrity, and field validations
3Module 3: Advanced DB2 Data Controls, Logging & SQL Integration
4 topics
  • Setting up system auditing: Configuring local Database Journaling (`STRJRNPF`) and tracking receivers
  • Enforcing transaction atomicity: Implementing multi-row transaction boundaries using Commitment Control methods
  • Injecting standard query operations: Executing INSERT, UPDATE, and DELETE operations via embedded SQL structures
  • Processing datasets sequentially: Declaring, opening, fetching, and closing row cursors within application logic blocks
4Module 4: CL/400 Control Language & Automation Programming
5 topics
  • Operational execution: Writing Control Language (CL) scripts to handle job flows and interactive workspaces
  • File-system manipulation: Executing relational data access and program routing inside CL steps
  • Runtime exception isolation: Implementing explicit global and local message trapping (`MONMSG`) controls
  • Manipulating memory blocks: Interfacing with global Data Areas (`*DTAARA`) and processing transient Local Data Areas
  • Overriding system behaviors: Modifying execution pointers using `OVRDBF`, `OVRPRTF`, and scaling Open Query Files (`OPNQRYF`)
5Module 5: Procedural Core Development: RPG/400 Structure
5 topics
  • Structural layout analysis: Deconstructing classic columnar RPG Specifications (H, F, E, I, C, O sheets)
  • Understanding execution flow: The classic implicit RPG Logic Cycle and programmatic indicator states
  • Manipulating memory slots: Building local Data Structures, multi-dimensional lookup tables, and run arrays
  • Writing business algorithms: Utilizing fundamental operation codes (MOVE, Z-ADD, CHAIN, READE, SETLL)
  • Structuring modular systems: Writing internal subroutines and parsing multi-parameter arguments across boundaries
6Module 6: Interactive Display Interfacing: Subfile Engineering
5 topics
  • Designing terminal interfaces: Creating green-screen Workstation Files (DSPF) using data-driven DDS keywords
  • Introduction to multi-row displays: Decoupling subfile control records from operational subfile data sets
  • Coding interface strategies: Implementing high-performance 'Load All' vs. dynamic paging 'Page Load' subfile layouts
  • Handling error displays: Building custom Message Subfiles to route validation issues onto user terminals
  • Processing user entry vectors: Reading selection inputs, updating inline grids, and repainting screen arrays
7Module 7: Modernizing Applications: Integrated Language Environment (ILE)
5 topics
  • Evolutionary architecture: Transitioning away from legacy OPM (Original Program Model) limitations into ILE specs
  • Compiling granular building blocks: Authoring individual Source Modules and compiling them into `*MODULE` assets
  • Packaging logical execution units: Creating static Service Programs (`*SRVPGM`) and structuring clean Prototype definitions
  • Managing compile bindings: Configuring explicit Binding Directories and mapping functional export signatures
  • Exploring advanced ILE properties: Setting up explicit Activation Groups (`*NEW`, `*CALLER`, Named) to control runtime memory isolation
8Module 8: Enterprise Integration Capstone Project
5 topics
  • Project Definition: Scoping a legacy business processing application simulating standard wholesale inventory systems
  • Database Architecture Phase: Building full relational DB2/400 schemas with automatic journaling tracks
  • Control Layer Phase: Scripting multi-stage CL setups to isolate staging regions, perform file overrides, and execute nightly batch queues
  • Core Logic Phase: Architecting modular ILE RPG programs paired with transactional subfile user windows to adjust inventory counts
  • Verification Phase: Replaying transactional logs under Commitment Control boundaries and executing performance validation dumps

Certification

Earn the SkillSurf Certified IBM Power Systems Enterprise Architect credential upon successfully passing the rigorous columnar legacy conversion exam and implementing the multi-layer transactional ILE capstone program.

Frequently Asked Questions

The platform has evolved significantly. AS/400 was the original 1988 minicomputer hardware name. Today, the hardware is part of the high-performance 'IBM Power Systems' family (such as modern Power10 servers), while the underlying object-based operating system is explicitly called 'IBM i'.
OPM is the legacy compilation model where source code compiles directly into a standalone executable program with high execution boundaries. ILE is the modern architecture that allows you to compile source code files into intermediate Modules (`*MODULE`) which can then be bound statically into high-performance Programs or Service Programs, dramatically reducing invocation latency and enabling modular programming across multiple languages.
This course covers both. You will study legacy fixed-format positional layout structure (which is mandatory for modifying and maintaining thousands of active enterprise codebases) and then move cleanly into modern ILE Free-Form RPG syntax patterns used for net-new software development.