Deep Dives
Deep Dives are focused, professional-grade guides for important IBM i, RPGLE, SQL, CL, and operations topics. Use them when you want detailed coverage of a specific concept, production scenario, or interview-heavy topic.
Explore standalone topic guides — no fixed order required.
Every Deep Dive is designed for professional-grade understanding with real-world examples, production considerations, debugging notes, and interview angles.
Unlike the IBM i Fundamentals path, Deep Dives don't need to be read in order. Jump straight to the topic you need -- whether you're debugging a production issue, prepping for an interview, or want a deeper explanation than a regular lesson covers. New Deep Dives are added over time; topics marked “Coming soon” are planned but not published yet.
SQL on IBM i
A professional deep dive into SQL on IBM i, covering Db2 for i architecture, naming conventions, schemas, tables, joins, CTEs, SQLCODE, catalog queries, constraints, indexes, views, optimizer basics, authority, and production practices.
Read the Deep Dive
Embedded SQL in RPGLE
A professional deep dive into embedded SQL in RPGLE -- SQLRPGLE source setup, host variables, indicator variables, singleton SELECT, cursor loops, commitment control, dynamic SQL, and SQLCODE troubleshooting.
Read the Deep Dive
SQL Cursors on IBM i
Declaring, opening, and fetching from SQL cursors in RPGLE -- including scrollable cursors and reliable patterns for checking SQLCODE/SQLSTATE after each fetch.
Stored Procedures on IBM i
How SQL and external (RPGLE/CLLE) stored procedures work on Db2 for i, when to reach for one, and how they fit into a real application.
Database Triggers on IBM i
Before/after triggers on physical files: what they can and can’t safely do, common pitfalls, and how they interact with commitment control.
SQL Error Handling with SQLCODE and SQLSTATE
Reading and responding to SQLCODE/SQLSTATE in SQLRPGLE -- the codes that come up most in practice, and reliable checking patterns that don’t silently swallow errors.
Native I/O vs SQL Decision Guide
A practical decision guide for choosing native RPGLE file I/O versus embedded SQL for a given piece of logic -- performance, readability, and maintenance tradeoffs.
Commitment Control with SQL and RPGLE
Journaling-backed commitment control end to end, from both SQL and native RPGLE -- commit/rollback boundaries, isolation levels, and what happens when a job ends mid-transaction.
SQL Performance Basics on IBM i
The SQL performance fundamentals every IBM i developer should know -- indexes, access plans, and the habits that keep queries fast as data grows.
Service Programs and Binding Directories
Building reusable *SRVPGM modules, exporting procedures with a binder source, and organizing binding directories for a real multi-program application.
Activation Groups
What activation groups actually control (scoping, resource cleanup, RCLACTGRP behavior), and why the wrong choice causes hard-to-diagnose production bugs.
Record Locking in RPGLE
How UPDAT/DLTE locking actually behaves under the hood, diagnosing lock waits and RNX/RNQ escapes, and designing for concurrent access without deadlocking.
Journaling in Real Applications
Beyond "turn on journaling": receiver management, remote journals, and using journal entries for real recovery and auditing scenarios.
Job Log and MSGW Troubleshooting
A practical checklist for reading a job log under pressure, diagnosing a job stuck in MSGW, and the commands that actually help you resolve it.
Subfile Design Patterns
Load-all vs. page-at-a-time subfiles, multi-record-format screens, and structuring RPGLE code so a subfile-heavy program stays maintainable.
Data Queues
Using *DTAQ objects for inter-job communication -- keyed vs. FIFO queues, blocking receives, and where data queues fit versus a database table.
Job Queues and Subsystems
How subsystem descriptions, job queues, and routing entries actually control where and how a submitted job runs, with real troubleshooting scenarios.
Authority and Adopted Authority
Object/data authority in practice, how adopted authority (USRPRF(*OWNER)) actually propagates through a call stack, and where it commonly goes wrong.
IFS for Developers
Working with the Integrated File System from RPGLE and CLLE -- stream file APIs, path handling, and common integration scenarios (CSV/JSON exchange, uploads).
APIs and External Integration on IBM i
Exposing IBM i logic to the outside world and consuming external services from IBM i -- REST basics, common gateway patterns, and where each fits.