IBM i Fundamentals

An ordered path through the foundational IBM i concepts every beginner and working developer benefits from knowing.

Browse by category

Showing 288 of 288 lessons

1What is IBM i?Free previewA beginner-friendly introduction to IBM i, the integrated platform that runs on IBM Power Systems.
2Why IBM i Still MattersLog in to accessWhy organizations continue to rely on IBM i for critical systems, and what makes replacing it a slow, deliberate decision.
3IBM i Platform OverviewLog in to accessA high-level map of the major parts of the IBM i platform and how they work together.
4Libraries and ObjectsLog in to accessHow IBM i organizes programs, files, and other objects using libraries, and why the library list matters.
55250 Screen BasicsLog in to accessWhat a 5250 screen is, how people navigate it, and why many IBM i applications still use it.
6Physical Files and Logical FilesLog in to accessHow IBM i stores data in physical files and provides different views of that data through logical files.
7Introduction to RPGLELog in to accessWhat RPGLE is, how it's used to build IBM i business applications, and how it connects to what you've learned so far.
8Introduction to CLLELog in to accessWhat CLLE is, how it's used to control and coordinate IBM i processes, and how it differs from RPGLE.
9Introduction to Db2 for iLog in to accessWhat Db2 for i is, how it relates to physical and logical files, and how applications access the data it stores.
10Job Logs and Spool Files BasicsLog in to accessWhat job logs and spool files are, how they help with troubleshooting, and how they differ from physical and logical files.
11Basic IBM i Development WorkflowLog in to accessA general mental model for how IBM i developers move from source code to a tested, released program.
12Where to Go NextLog in to accessA closing look at what you've learned across the IBM i Fundamentals path, and practical directions for continuing to learn.
13AS/400, iSeries, and IBM i Naming ExplainedLog in to accessWhy the same platform has been called AS/400, iSeries, System i, and IBM i, and how these names relate to each other.
14IBM i Access Client Solutions OverviewLog in to accessWhat IBM i Access Client Solutions (ACS) is, what its main tools do, and how it fits alongside the 5250 interface.
15Signing On, User Profiles, and Current LibraryLog in to accessWhat happens when you sign on to IBM i, what a user profile is, and why your current library affects what you can find.
16Understanding IBM i Command StructureLog in to accessHow IBM i command names follow a verb-plus-object pattern, and how commands and parameters fit together.
17Using F4 Prompt and Command HelpLog in to accessHow to use the F4 prompt to fill in command parameters interactively, and how to use built-in command help.
18Common IBM i Object TypesLog in to accessCommon IBM i object types like *LIB, *FILE, *PGM, *USRPRF, and *OUTQ, and what each one is generally used for.
19Library List Explained in DepthLog in to accessThe parts that make up an IBM i library list, the order IBM i searches them in, and how to view your own library list.
20Source Physical Files and Source MembersLog in to accessWhat a source physical file is, what a source member is, and how RPGLE and CLLE source code is typically organized.
21IFS Basics for IBM i BeginnersLog in to accessWhat the Integrated File System (IFS) is, how its directory structure differs from libraries and objects, and when it is used.
22Native Objects vs Stream FilesLog in to accessThe key differences between a native IBM i object and an IFS stream file, and how to recognize which model applies.
23Object Naming and Qualified Names in PracticeLog in to accessBasic IBM i object naming rules, what a qualified object name is, and why qualifying a library removes ambiguity.
24Working with WRKOBJ, DSPOBJD, and WRKLIBLog in to accessWhat the WRKOBJ, DSPOBJD, and WRKLIB commands are each used for, and which one to reach for depending on the task.
25DDS and SQL: Two Ways to Define Db2 for i DataLog in to accessHow Db2 for i data can be defined using either traditional DDS or modern SQL, and why both approaches still coexist today.
26Physical Files Explained in DepthLog in to accessThe structure of a DDS-defined physical file, including record formats, in more detail than the introductory lesson.
27DDS Field DefinitionsLog in to accessHow to read a simple DDS field definition: field name, data type, and length.
28Keyed Physical FilesLog in to accessWhat makes a physical file keyed, how key fields relate to DDS field definitions, and why keyed access matters.
29Logical Files Explained in DepthLog in to accessWhat logical files can do beyond reordering data: keyed ordering, field selection, and select/omit.
30Access Paths and Why They MatterLog in to accessWhat an access path is, how it supports keyed physical and logical files, and why it is a meaningful design tradeoff.
31SQL Tables vs DDS Physical FilesLog in to accessComparing an SQL-defined table directly against a DDS-defined physical file: key similarities and practical differences.
32Basic SELECT on IBM iLog in to accessWhat a basic SQL SELECT statement does, how to read one, and a common way to run one against Db2 for i data.
33RPGLE Program StructureLog in to accessThe main parts of a simple free-format RPGLE program: control options, declarations, calculations, and program end.
34RPGLE Source Layout and Free Format BasicsLog in to accessThe basic layout rules of free-format RPGLE source: the **free marker, semicolons, comments, and indentation.
35Variables and Data Types in RPGLELog in to accessHow to declare a simple RPGLE variable using dcl-s, and common RPGLE data types like char, packed, int, and ind.
36Constants and Literals in RPGLELog in to accessWhat a literal value is, what an RPGLE constant (dcl-c) is, and why named constants are often better than repeated literals.
37Expressions and Assignment in RPGLELog in to accessHow to read and write RPGLE assignment statements, and common arithmetic and comparison operators used in expressions.
38IF / ELSE in RPGLELog in to accessHow to read and write if / elseif / else blocks in free-format RPGLE using comparison operators.
39SELECT / WHEN / OTHER in RPGLELog in to accessHow to read and write select / when / other blocks in free-format RPGLE, and when they beat a long elseif chain.
40DO Loops and Basic Iteration in RPGLELog in to accessHow to read and write for, dow, and dou loops in free-format RPGLE, and when each one is a natural fit.
41Built-in Functions in RPGLELog in to accessWhat RPGLE built-in functions (BIFs) are, and how to use %TRIM, %LEN, %SUBST, %CHAR, and %DEC.
42Data Structures in RPGLELog in to accessHow to declare an RPGLE data structure with dcl-ds, group related subfields, and why qualified is good practice.
43Arrays in RPGLELog in to accessHow to declare an RPGLE array with dim, access elements by index, and loop through an array.
44Indicators in Modern RPGLELog in to accessWhy numbered indicators (*IN01-*IN99) were historically common, and why modern RPGLE favors named indicator variables.
45Procedures and Subprocedures in RPGLELog in to accessWhy RPGLE programs are broken into subprocedures, and how to write and call a simple one with dcl-proc.
46Parameters and Prototypes in RPGLELog in to accessHow to write a subprocedure that accepts parameters and returns a value using dcl-pi, and what a prototype is for.
47Basic Error Handling in RPGLELog in to accessWhy error handling matters in RPGLE, and how to use monitor / on-error / endmon to catch a runtime error.
48Debugging RPGLE ProgramsLog in to accessBeginner-friendly ways to investigate an RPGLE program: dsply tracing, the ILE source debugger, and job logs.
49When to Use CLLE vs RPGLELog in to accessPractical situations where CLLE is a natural fit for orchestration, compared to where RPGLE is the better tool.
50CLLE Program StructureLog in to accessThe main parts of a simple CLLE program: PGM/ENDPGM boundaries, variable declarations, and commands.
51CL Commands and ParametersLog in to accessHow CL command parameters work as keyword-value pairs inside a CLLE program, using literals or variables.
52Variables in CLLELog in to accessHow to declare a CL variable with DCL, common CL data types, and how to change a value with CHGVAR.
53IF, DO, and Basic Control Flow in CLLELog in to accessHow to read and write IF / THEN / ELSE and DO / ENDDO groups in CLLE, using CL comparison operators.
54Calling RPGLE Programs from CLLELog in to accessHow to use CALL and PARM to run an RPGLE program from a CLLE program and pass values to it.
55MONMSG and Basic Error Handling in CLLELog in to accessWhy error handling matters in CLLE, and how to use MONMSG to catch an error from a command or program call.
56SBMJOB and Batch Job BasicsLog in to accessThe difference between interactive and batch work, and how SBMJOB submits a command to run as a job on a job queue.
57Passing Parameters to CLLE ProgramsLog in to accessHow a CLLE program receives its own parameters using PARM on the PGM statement, matched with DCL.
58Calling RPGLE Programs with Parameters from CLLELog in to accessHow a value can flow both ways between CLLE and a called RPGLE program, and why matching data types matters.
59Working with IBM i Job Attributes in CLLELog in to accessHow to use RTVJOBA to retrieve basic attributes of the job a CLLE program is running in.
60Checking Objects with CHKOBJLog in to accessHow to use CHKOBJ to confirm an object exists before acting on it, combined with MONMSG to handle a missing object.
61Sending and Receiving Messages in CLLELog in to accessWhat a message queue is at a basic level, and how to use SNDPGMMSG to send a message and RCVMSG to receive one.
62Data Areas in CLLELog in to accessWhat a data area is, and how to use RTVDTAARA and CHGDTAARA to read and update one from a CLLE program.
63Using CLLE for Batch Job OrchestrationLog in to accessHow a CLLE program combines checking objects, calling programs, error handling, and SBMJOB into one coordinated sequence.
64Common CLLE Mistakes and Best PracticesLog in to accessCommon beginner mistakes in CLLE programs, such as missing MONMSG, unqualified names, and unclear variable names.
65What is a Display File in IBM i?Log in to accessWhat a display file is, how it relates to 5250 screens, and how it fits alongside physical and logical files.
665250 Screen Design BasicsLog in to accessThe row-and-column grid a 5250 screen is built on, and simple principles for designing a readable, usable screen.
67Display File Record FormatsLog in to accessWhat a record format means for a display file, and how it differs from the single record format a physical file has.
68Input Fields, Output Fields, and Both FieldsLog in to accessThe difference between an input field, an output field, and a both field on a 5250 screen, and why it matters to RPGLE.
69Function Keys and Response IndicatorsLog in to accessHow a display file connects a function key press to a numbered indicator, and how RPGLE reads that indicator.
70Basic Display File DDS KeywordsLog in to accessCommon DDS keywords like TEXT, DSPATR, and COLOR that describe how a display file field looks and behaves.
71RPGLE Program Calling a Display FileLog in to accessHow to declare a display file in free-format RPGLE with dcl-f workstn, and use exfmt to show and read a record format.
72Simple Inquiry Screen FlowLog in to accessA complete, simple RPGLE program that shows an entry screen, processes input, and shows a results screen in a loop.
73Display File Indicators ExplainedLog in to accessThe two directions a display file indicator can flow: conditioning indicators into the screen, response indicators out.
74Function Keys in More DepthLog in to accessCommon function key conventions like F3=Exit, F5=Refresh, and F12=Cancel, and handling several function keys at once.
75Screen Field Validation BasicsLog in to accessBasic DDS validation keywords like CHECK(MF), RANGE, VALUES, and COMP that validate a field before RPGLE sees it.
76Displaying Error Messages on 5250 ScreensLog in to accessHow ERRMSG and ERRMSGID display an error message tied to a field, connecting validation failures to what the user sees.
77Window Records and Simple Popup ScreensLog in to accessWhat a window record is, and how it lets a display file show a small popup screen over the current one.
78READ, WRITE, EXFMT, and Screen FlowLog in to accessHow exfmt combines separate write and read operations, and when using them separately makes more sense.
79Basic Inquiry Screen PatternLog in to accessThe general, reusable pattern behind most simple IBM i inquiry screens, including validation, error messages, and function keys.
80Common Display File Mistakes and Best PracticesLog in to accessCommon beginner mistakes with display files, such as unreset conditioning indicators and reused indicator numbers.
81What is a Subfile in IBM i?Log in to accessWhy subfiles exist: showing a scrollable list of multiple records on one 5250 screen, instead of just one record at a time.
82Subfile Record Format vs Subfile Control Record FormatLog in to accessThe key distinction between a subfile record format (SFL, one repeating row) and its control record format (SFLCTL, the frame).
83SFLDSP, SFLDSPCTL, and SFLCLR ExplainedLog in to accessWhat SFLDSP, SFLDSPCTL, and SFLCLR each control, and how RPGLE uses conditioning indicators to manage a subfile lifecycle.
84Load-All Subfile ConceptLog in to accessThe load-all subfile strategy: loading every record before displaying it once, and how SFLPAG and SFLSIZ relate to it.
85Page-at-a-Time Subfile ConceptLog in to accessThe page-at-a-time subfile strategy at a conceptual level, how it differs from load-all, and the role of RRN.
86Simple Inquiry Subfile PatternLog in to accessA complete, simple RPGLE program that clears, loads, and displays a load-all subfile showing a list of records.
87Function Keys in Subfile ProgramsLog in to accessWhich function keys a load-all subfile handles automatically (Page Up/Down), and how custom function keys still work the same way.
88Common Subfile Mistakes and Best PracticesLog in to accessCommon beginner mistakes with subfiles, such as misplaced fields, forgetting to clear before reload, and premature SFLDSP.
89Understanding RRN in Subfile ProgramsLog in to accessWhat the Relative Record Number (RRN) actually is, and how SFLRCDNBR lets a program reliably identify a subfile row.
90Clearing and Reloading a SubfileLog in to accessWhy a subfile commonly needs to be cleared and reloaded more than once during a program run, such as on a refresh.
91Using SFLEND to Show End of ListLog in to accessWhat SFLEND does: automatically showing More... or Bottom so users know whether more subfile records remain.
92Option Fields in Subfile ScreensLog in to accessWhat an option field is, how it lets a user choose an action per row, and common conventions like 1=Select, 2=Change, 4=Delete.
93Selecting a Row in a SubfileLog in to accessHow to use READC in a loop to find every subfile row a user entered an option value on, and read each one's RRN.
94Basic Update/Delete Subfile PatternLog in to accessThe general, conceptual flow behind a subfile screen that lets a user update or delete records marked with option values.
95Introduction to SFLNXTCHGLog in to accessWhat SFLNXTCHG does at a conceptual level: letting a program mark a subfile row as changed so READC finds it again.
96Debugging Subfile ProgramsLog in to accessBeginner-friendly ways to investigate a subfile program: checking clear/load/display indicators, loading loops, and READC.
97RPGLE File Declarations with dcl-fLog in to accessHow to declare a database file in free-format RPGLE using dcl-f disk, connecting a program to an externally described file.
98Reading Physical Files in RPGLE with READLog in to accessHow to use READ in a loop to process every record in a physical file from beginning to end.
99Understanding %EOF in RPGLE File ProcessingLog in to accessWhat %EOF actually checks, and why it must be tested immediately after each READ for a read loop to work correctly.
100CHAIN for Keyed AccessLog in to accessHow to use CHAIN to look up one specific record in a keyed physical file by its key value.
101Understanding %FOUND after CHAINLog in to accessWhat %FOUND actually checks, and why it must be tested immediately after every CHAIN before using its fields.
102Writing Records with WRITELog in to accessHow to use WRITE to add a new record to a physical file, and how this differs from the WRITE used with display files.
103Updating Records with UPDATELog in to accessHow to use UPDATE to save changes to a record that was already successfully retrieved with CHAIN.
104Deleting Records with DELETELog in to accessHow to use DELETE to remove a record already retrieved with CHAIN, completing the basic native RPGLE file operations.
105SETLL in RPGLELog in to accessHow to use SETLL to position a keyed file at a specific key value, and how this differs from CHAIN.
106READE for Reading Matching KeysLog in to accessHow to use SETLL together with READE to read every record sharing the same key value.
107READP and Reading BackwardLog in to accessWhat READP does at a basic level, and how reading backward through a keyed file differs from reading forward.
108Processing Duplicate Keys in RPGLELog in to accessWhat a duplicate key is, and how to use SETLL and READE together to process every record sharing one key value.
109Basic File Locking Concept in RPGLELog in to accessWhat a record lock is at a beginner level, why IBM i uses them, and how they relate to UPDATE and DELETE.
110Handling File I/O Errors at a Beginner LevelLog in to accessThe beginner-level approach to handling file I/O errors, building on %FOUND, %EOF, and the general error-handling pattern.
111Debugging RPGLE File I/O ProgramsLog in to accessApplying dsply tracing, the ILE source debugger, and job logs specifically to problems in file I/O code.
112Common RPGLE File I/O Mistakes and Best PracticesLog in to accessThe most common beginner mistakes across native RPGLE file I/O, and a simple set of best practices to avoid them.
113What is SQLRPGLE?Log in to accessWhat SQLRPGLE is: free-format RPGLE with embedded SQL statements written directly inside the program.
114Native RPGLE File I/O vs Embedded SQLLog in to accessHow CHAIN, READ, SETLL/READE, WRITE, UPDATE, and DELETE each correspond to an embedded SQL equivalent.
115Basic EXEC SQL Syntax in RPGLELog in to accessThe EXEC SQL / semicolon block structure every embedded SQL statement in RPGLE uses.
116Host Variables in SQLRPGLELog in to accessWhat a host variable is, and how the colon prefix distinguishes it from a table column inside embedded SQL.
117SELECT INTO for Reading One RowLog in to accessUsing embedded SELECT INTO to retrieve one row into host variables, and checking SQLCODE the way %FOUND is checked after CHAIN.
118Using SQL Cursor to Read Multiple RowsLog in to accessDeclaring, opening, fetching from, and closing an SQL cursor to read every matching row, one at a time.
119INSERT with Embedded SQLLog in to accessUsing embedded INSERT to add a new row using host variables, the embedded SQL equivalent of native WRITE.
120UPDATE and DELETE with Embedded SQLLog in to accessUsing embedded UPDATE and DELETE with a WHERE clause, and how this differs from native operations acting on the most recently retrieved record.
121SQLCODE and SQLSTATE Basics in SQLRPGLELog in to accessWhat SQLCODE and SQLSTATE each report after an embedded SQL statement runs, and how they relate to each other.
122Handling No Row Found in SQLRPGLELog in to accessA clean, reliable three-way pattern for handling the SQLCODE = 100 "not found" case, distinguishing it from a genuine error.
123FETCH Loop for Reading Multiple RowsLog in to accessWriting a complete cursor FETCH loop that accumulates counts and totals across every fetched row, not just displays it.
124Basic WHERE Conditions in Embedded SQLLog in to accessWriting WHERE conditions with comparison operators and AND/OR to filter embedded SQL results beyond simple equality.
125ORDER BY and Result OrderingLog in to accessUsing ORDER BY to control query result order, and why this is separate from a physical file's own key or access path.
126Simple JOIN in SQLRPGLELog in to accessWriting a simple two-table JOIN in an embedded SQL cursor, combining CUSTMAST and ORDHIST on a shared customer number.
127NULL Handling Basics in SQLRPGLELog in to accessWhat NULL means in Db2 for i, why it differs from blank or zero, and how to detect it using a null indicator.
128Common SQLRPGLE Mistakes and Best PracticesLog in to accessThe most common beginner mistakes across embedded SQL in RPGLE, and a simple set of best practices to avoid them.
129What is a Printer File in IBM i?Log in to accessWhat a printer file is, how it fits alongside physical, logical, and display files, and what its output becomes.
130Printer File DDS BasicsLog in to accessHow a printer file DDS describes printed report lines, and how this compares to DDS used for physical and display files.
131Report Record FormatsLog in to accessWhy a printer file DDS commonly defines several record formats: heading, detail, and total lines.
132RPGLE Program Writing to a Printer FileLog in to accessDeclaring a printer file with dcl-f, and using WRITE to print a specific record format.
133Report Headings and Detail LinesLog in to accessWriting a complete report loop that prints a heading once and a detail line for every row of underlying data.
134Page Overflow BasicsLog in to accessWhat page overflow is, and how an RPGLE program uses an overflow indicator to reprint a heading on each new page.
135Spool Files and Output QueuesLog in to accessWhat happens to a printer file's output after it is written, and how a spool file relates to an output queue.
136Common Printer File Mistakes and Best PracticesLog in to accessThe most common beginner mistakes across printer files and basic report programs, and a simple set of best practices to avoid them.
137Report Totals and Summary LinesLog in to accessAccumulating a running total across a report's detail lines and printing it once as a summary line at the end.
138Multi-Record Format ReportsLog in to accessDistinguishing a report-level heading, printed once, from a page-level heading, printed again on every page.
139Controlling Page BreaksLog in to accessThe difference between automatic page overflow and a deliberate page break triggered by a control break in the data.
140Working with Spool Files using WRKSPLFLog in to accessWhat WRKSPLF shows, and how to use it to find, view, and manage spool files created by jobs you have run.
141Working with Output Queues using WRKOUTQLog in to accessWhat WRKOUTQ shows, and how its scope, one specific output queue across users, differs from WRKSPLF.
142Printer File Overrides BasicsLog in to accessWhat a printer file override does at a basic level, using a simple OVRPRTF example changing output queue and hold status.
143Debugging Report Output ProblemsLog in to accessA practical checklist for common report problems: missing spool file, wrong output queue, report not printing, blank report, wrong page breaks.
144Printer File vs Display File vs Database FileLog in to accessComparing printer files, display files, and database files: what each is for, and which RPGLE operations pair with each.
145Why Debugging Matters on IBM iLog in to accessWhy debugging is a normal, routine part of IBM i development, not a sign that something has gone wrong.
146STRDBG Basics for RPGLELog in to accessWhat STRDBG does, what a program needs before it can be debugged this way, and what happens once the debugger starts.
147Setting and Using BreakpointsLog in to accessSetting a breakpoint at a specific line, running a program until it stops there, and stepping through its logic.
148Watching Variables During DebugLog in to accessDisplaying a variable's current value while paused in a debug session to confirm or rule out where a calculation goes wrong.
149Understanding Job LogsLog in to accessWhat a job log actually contains, using DSPJOBLOG to view one, and why it is one of the most important IBM i troubleshooting tools.
150Reading IBM i Message IDsLog in to accessThe structure of an IBM i message ID, such as CPF9897 or RNQ1218, and why that structure matters for understanding a message.
151Compile Errors vs Runtime ErrorsLog in to accessDistinguishing a compile error, caught before a program runs, from a runtime error, which only surfaces while it executes.
152Common IBM i Debugging MistakesLog in to accessThe most common beginner mistakes when debugging on IBM i, and a simple set of best practices to avoid them.
153DSPJOB and Job Information BasicsLog in to accessWhat DSPJOB shows, and how to use it to inspect a job's log, call stack, library list, and basic attributes.
154WRKACTJOB Basics for DevelopersLog in to accessUsing WRKACTJOB to find active jobs on the system and read their basic status.
155Finding Program Failures from Error MessagesLog in to accessMoving from an error message in a job log to the specific program and statement that actually failed.
156Understanding Call Stack BasicsLog in to accessWhat a call stack is, and how to use it to see which programs and procedures are currently active in a job.
157Debugging Batch Jobs at a Beginner LevelLog in to accessThe basic practical difference between debugging an interactive job and a batch job, and a simple beginner-level approach.
158Using Job Logs for SQLRPGLE and File I/O IssuesLog in to accessConnecting job log messages to specific SQLRPGLE and native file I/O problems covered earlier in this path.
159Basic Troubleshooting Flow for IBM i DevelopersLog in to accessA simple, ordered troubleshooting flow that connects every debugging tool covered across this lesson group.
160Debugging Checklist for BeginnersLog in to accessA condensed, practical checklist to run through during an actual debugging session, drawing on both Debugging Batches.
161IBM i Jobs ExplainedLog in to accessWhat identifies a job on IBM i (name, user, and job number), and where a job actually runs.
162Interactive Jobs vs Batch JobsLog in to accessComparing interactive and batch jobs: how each is started, and what that difference means in practice.
163Job Queues and Output QueuesLog in to accessDistinguishing a job queue (jobs waiting to run) from an output queue (spool files waiting to print), using WRKJOBQ.
164Subsystems BasicsLog in to accessWhat a subsystem is, and how a job queue connects to it.
165Library List in Real Job ExecutionLog in to accessHow a library list can change during a job with ADDLIBLE/RMVLIBLE, and where a batch job's starting library list comes from.
166Object Locks BasicsLog in to accessWhat an object lock is, how it differs from a record lock, and using WRKOBJLCK to see what is locking an object.
167Authorities and Object Access BasicsLog in to accessWhat an authority is, the difference between public and private authority, and why an authority failure happens.
168Common IBM i Operations Commands for DevelopersLog in to accessA condensed, practical reference for which everyday IBM i operations command to reach for, depending on the question.
169Submitted Jobs and WRKSBMJOBLog in to accessUsing WRKSBMJOB to track a submitted batch job from submission through to completion.
170Job Logs in Batch JobsLog in to accessHow retrieving a batch job's job log differs practically from checking your own current job's log.
171Job Status Values ExplainedLog in to accessA few common IBM i job status values, ACTIVE, JOBQ, OUTQ, and MSGW, and what each generally means.
172Basic Job Scheduling ConceptsLog in to accessThe basic difference between submitting a job to run immediately and scheduling one to run automatically later.
173Handling Object Locks as a DeveloperLog in to accessDeciding what to do once you have confirmed another job is holding an object lock you need released.
174Authority Failures and How to Investigate ThemLog in to accessRecognizing an authority failure in a job log and following a practical process for investigating it.
175Library List Problems in Real ApplicationsLog in to accessRecognizing and diagnosing the two most common library list problems: an object appearing missing, and the wrong version being found.
176Common IBM i Operations Mistakes and Best PracticesLog in to accessThe most common beginner mistakes across IBM i jobs, queues, locks, authorities, and library lists, and best practices to avoid them.
177Mini Project: Customer Inquiry ProgramLog in to accessA complete interactive inquiry program combining a display file, CHAIN, and %FOUND to look up a customer by number.
178Mini Project: Item Master Lookup ProgramLog in to accessA second, independent inquiry program applying the Customer Inquiry Program pattern to a new item master file.
179Mini Project: Simple Order List SubfileLog in to accessA subfile screen listing every order for one customer, combining SETLL/READE with the subfile load-display pattern.
180Mini Project: Batch Report ProgramLog in to accessA printer file report program listing every customer balance with a grand total, designed to run as a batch job.
181Mini Project: CLLE Wrapper to Run a ReportLog in to accessA CLLE program that checks a required file, overrides a printer file to an output queue, and submits a report as a batch job.
182Mini Project: SQLRPGLE Customer LookupLog in to accessThe Customer Inquiry Program rebuilt using embedded SQL instead of native CHAIN, as a direct side-by-side comparison.
183Mini Project: Debugging a Broken File I/O ProgramLog in to accessA deliberately broken payment-processing program, debugged using the job log, STRDBG, breakpoints, and EVAL.
184Mini Project: End-to-End Mini DMS-Style FlowLog in to accessA small order-entry-to-report flow tracing one order through entry, listing, and reporting, connecting several mini projects together.
185Mini Project: Customer Maintenance Add/Change/DeleteLog in to accessA maintenance program letting a user add, change, or delete a customer, extending the read-only Customer Inquiry Program.
186Mini Project: Order Entry SkeletonLog in to accessA proper interactive order entry screen, building the End-to-End Mini DMS-Style Flow's minimal order-writing sketch into a real program.
187Mini Project: Report with CLLE Submit Job FlowLog in to accessExtending the CLLE Wrapper to Run a Report with a genuine submit-job flow, confirming the batch job actually completed.
188Mini Project: Subfile Row Selection with Detail ScreenLog in to accessAdding an option field and a detail screen to the Simple Order List Subfile, letting a user select and drill into one order.
189Mini Project: SQLRPGLE Search ScreenLog in to accessA partial-name search screen using an embedded SQL cursor with a LIKE-based WHERE clause, loading matches into a subfile.
190Mini Project: Printer File Report with TotalsLog in to accessAn order history report printing a subtotal each time the customer changes, combining a control break with a running grand total.
191Mini Project: Troubleshooting Locked Record ScenarioLog in to accessA guided exercise: two users updating the same customer at nearly the same moment, investigated with WRKOBJLCK.
192Mini Project: Batch Job Failure InvestigationLog in to accessA guided exercise: a nightly batch report that fails silently, investigated using WRKSBMJOB and the batch job's own job log.
193IBM i Developer Interview RoadmapLog in to accessA roadmap for using this course's Interview and Professional Readiness lessons, covering what to revise first and how interviews are typically structured.
194RPGLE Basic Interview QuestionsLog in to accessCommon beginner-level RPGLE interview questions about program structure, control flow, and built-in functions, with guidance on how to answer them well.
195RPGLE File I/O Interview ScenariosLog in to accessInterview scenarios covering CHAIN, %FOUND, WRITE, UPDATE, and DELETE, with a focus on explaining common file I/O mistakes clearly.
196CLLE Interview ScenariosLog in to accessInterview scenarios covering when to use CLLE, MONMSG error handling, and batch job orchestration with CHKOBJ, OVRPRTF, and SBMJOB.
197SQLRPGLE Interview ScenariosLog in to accessInterview scenarios covering SELECT INTO, SQLCODE, host variables, and partial-name searches with LIKE.
198Display File and Subfile Interview QuestionsLog in to accessInterview questions covering display file screen flow, subfile loading, clearing, and row selection with READC.
199Debugging Scenario-Based QuestionsLog in to accessPractice structuring clear, ordered answers to common IBM i debugging scenarios, from job log first to STRDBG.
200Real Support Ticket Analysis for BeginnersLog in to accessWalk through six realistic, small IBM i support tickets and practice naming a likely cause and first check for each one.
201Explaining Your IBM i Project ExperienceLog in to accessHow to describe the mini projects from this course clearly and honestly, the way a beginner interview might ask you to.
202RPGLE Scenario-Based Interview PracticeLog in to accessCode-reading style RPGLE interview practice: explaining what a snippet does and spotting a missing %FOUND check.
203SQLRPGLE vs Native I/O Interview DiscussionLog in to accessHow to build a balanced answer for when to use embedded SQL versus native RPGLE file I/O, instead of preferring one universally.
204Debugging Live Issue Interview PracticeLog in to accessPractice narrating your debugging process step by step for live, in-the-moment interview questions.
205IBM i Support Ticket WalkthroughLog in to accessA full start-to-finish walkthrough of one realistic support ticket, from specifics gathered to confirming the fix worked.
206Resume Points for IBM i DevelopersLog in to accessHow to turn course mini projects into specific, honest resume points you can defend if asked a follow-up question.
207Common IBM i Interview MistakesLog in to accessA focused list of the weak-answer patterns that show up across RPGLE, CLLE, SQLRPGLE, subfile, and debugging interview questions.
208Mock IBM i Developer InterviewLog in to accessA capstone mock interview mixing definition questions, code-reading questions, and scenario-based questions in one sitting.
209OPM vs ILE on IBM iLog in to accessThe difference between the Original Program Model and the Integrated Language Environment, and why ILE was introduced.
210What are Modules, Programs, and Service Programs?Log in to accessThe three ILE object types -- module, program, and service program -- and how they relate to one another.
211Creating RPGLE Modules with CRTRPGMODLog in to accessCompiling free-format RPGLE source into a module with CRTRPGMOD, and what that command does and does not produce.
212Binding Modules into Programs with CRTPGMLog in to accessUsing CRTPGM to bind one or more modules into a runnable program, and what binding actually means.
213Prototypes and Procedure Interfaces in ILELog in to accessWhy a prototype is required to call a procedure defined in another module, and how it pairs with a procedure interface.
214Internal Procedures vs Exported ProceduresLog in to accessThe difference between a procedure only callable within its own module and one exported for other modules to call.
215Introduction to Service ProgramsLog in to accessWhat a service program is, why it is useful once several programs share logic, and creating one with CRTSRVPGM.
216Activation Groups BasicsLog in to accessWhat an activation group is at a conceptual level, and why it matters for how programs and service programs behave at runtime.
217Binding Directories BasicsLog in to accessWhat a binding directory is, and how it lets CRTPGM find shared modules and service programs automatically.
218Creating Service Programs with CRTSRVPGMLog in to accessCreating a service program with CRTSRVPGM and binding a program to it with BNDSRVPGM, versus binding a module directly.
219Binder Source IntroductionLog in to accessWhat binder source is, and why EXPORT(*SRCFILE) offers more deliberate control than EXPORT(*ALL).
220Service Program Signatures at a Beginner LevelLog in to accessSignatures as a compatibility fingerprint of a service program's exports, and why they matter to callers.
221Updating Service Programs SafelyLog in to accessA conceptual, safe process for updating a service program without breaking programs that already depend on it.
222Activation Group Problems and Common ConfusionsLog in to accessCommon, realistic activation-group-related symptoms, such as files not staying open between calls, and their likely causes.
223Debugging ILE ProgramsLog in to accessUsing STRDBG against a program built from multiple bound modules, and reading a call stack across module boundaries.
224Common ILE Mistakes and Best PracticesLog in to accessThe most common mistakes beginners make with ILE modules, programs, and service programs, drawn from across both ILE batches.
225Modern IBM i Development OverviewLog in to accessWhat "modern IBM i development" actually means: exposing and integrating existing business logic, not replacing IBM i.
226Why APIs Matter on IBM iLog in to accessWhat an API is in plain terms, and why APIs are the key building block for integrating IBM i with other systems.
227REST API Concepts for IBM i DevelopersLog in to accessCore REST API concepts in plain terms: endpoint, request, response, HTTP method, status code, and payload.
228JSON Basics for RPGLE DevelopersLog in to accessHow to read a simple JSON payload, and how its structure relates to familiar RPGLE fields and records.
229IFS and API Payload FilesLog in to accessWhy the IFS is a common place for request/response payloads, logs, and other integration artifacts on IBM i.
230Calling External APIs from IBM iLog in to accessThe conceptual steps involved when an IBM i program calls an external API: building, sending, and reading a response.
231Exposing IBM i Logic as an APILog in to accessThe high-level pattern for exposing existing RPGLE or SQL logic behind an API endpoint, without rewriting it.
232Common IBM i Integration MistakesLog in to accessThe most common mistakes developers make when first working on IBM i integration, drawn from across this batch.
233HTTP Methods and Status Codes for IBM i DevelopersLog in to accessMapping GET/POST/PUT/PATCH/DELETE and practical status codes (200/201/400/401/403/404/409/500) to familiar IBM i operations.
234API Request and Response Design BasicsLog in to accessHow to design a clean, readable request and response shape for a common IBM i business operation.
235JSON Parsing Concepts in RPGLELog in to accessWhat it means to parse a JSON payload in RPGLE and map its values into familiar data structures, without depending on a specific library.
236API Error Handling BasicsLog in to accessA practical approach for handling API errors: checking status codes first, deciding what to retry, and what to do next.
237Logging Integration Requests and ResponsesLog in to accessWhat is generally useful to log for an API request and response, and what should be deliberately left out, such as sensitive data.
238Securing IBM i APIs at a Beginner LevelLog in to accessWhat authentication, authorization, HTTPS, secrets, and least privilege mean for an IBM i API, at a beginner level.
239Batch vs Real-Time IntegrationLog in to accessHow to decide whether a batch or real-time approach is the better fit for a given IBM i integration scenario.
240Debugging API Integration IssuesLog in to accessA systematic approach for investigating an API integration problem using status codes, logs, job logs, and external responses.
241DDL on IBM i: CREATE TABLE, ALTER TABLE, and DROP TABLELog in to accessCreating, changing, and removing a Db2 for i table with SQL DDL, and how an SQL table relates to a DDS-created physical file.
242SQL Indexes and Views on Db2 for iLog in to accessWhat an SQL index and an SQL view are, and how each relates to access paths and logical files already covered in this course.
243Constraints on IBM i: Primary Key, Foreign Key, Unique, and CheckLog in to accessWhat a database constraint is, and why it is a stronger guarantee than validating the same rule only in application code.
244ACS Run SQL Scripts for IBM i DevelopersLog in to accessWhat ACS Run SQL Scripts is and why it is a practical everyday tool for testing queries and DDL against Db2 for i.
245SQL Stored Procedures on IBM iLog in to accessWhat a SQL stored procedure is, written in SQL PL, and how it compares to the service program procedures covered earlier in this course.
246External Stored Procedures with RPGLELog in to accessHow an external stored procedure lets existing RPGLE logic be called through plain SQL, without rewriting it in SQL PL.
247SQL Triggers on IBM iLog in to accessWhat a SQL trigger is, when it runs automatically using CREATE TRIGGER, and how it compares to native ADDPFTRG triggers.
248User-Defined Functions on IBM iLog in to accessWhat a user-defined function (UDF) is and how to use one inside a SELECT statement, alongside built-in SQL functions.
249SQLCA, SQLCODE, and SQLSTATE in DepthLog in to accessWhat the SQLCA is, and how to read SQLCODE and SQLSTATE values beyond the single case of SQLCODE 100.
250Static SQL vs Dynamic SQL on IBM iLog in to accessThe difference between static SQL, known and checked at compile time, and dynamic SQL, prepared and executed at runtime.
251SQL Precompilation with CRTSQLRPGILog in to accessWhat precompilation does and where CRTSQLRPGI fits between embedded SQL source and a runnable RPGLE program.
252Query Optimization Basics on Db2 for iLog in to accessWhat a query optimizer does conceptually, and how indexes and access paths influence its choice of access plan.
253SQE vs CQE at a Beginner-Friendly LevelLog in to accessWhat SQE and CQE are, why Db2 for i has two query engines, and why this matters when reading performance advice.
254Encoded Vector Indexes IntroductionLog in to accessWhat an Encoded Vector Index (EVI) is, and what kind of grouping or summarizing query pattern it is generally built for.
255DRDA and Distributed Database ConceptsLog in to accessWhat DRDA is and why it matters for querying a Db2 for i database on a different system using ordinary SQL.
256Common Advanced SQL Mistakes on IBM iLog in to accessThe most common mistakes developers make when first working with advanced Db2 for i SQL features, drawn from across both batches.
257User Profiles and Group Profiles on IBM iLog in to accessWhat a user profile and a group profile are, and why group profiles make managing authority for many users practical.
258Object Authority in DepthLog in to accessHow authority applies differently to a library, a file, a program, and a command, building on the authority basics already covered.
259Public Authority and Private Authority in DepthLog in to accessThe difference between public authority and private authority, and why setting public authority deliberately matters.
260Authorization Lists on IBM iLog in to accessWhat an authorization list is and why it simplifies managing authority across many objects at once.
261Special Authorities ExplainedLog in to accessWhat a special authority is, and why granting one, especially *ALLOBJ, deserves caution.
262Adopted Authority BasicsLog in to accessWhat adopted authority is, how USRPRF(*OWNER) changes whose authority applies while a program runs, and why it must be used responsibly.
263Investigating Authority Failures in DepthLog in to accessA more complete authority-failure investigation accounting for group profiles, authorization lists, and adopted authority.
264IBM i Security Best Practices for DevelopersLog in to accessPractical security habits for everyday IBM i development work: least privilege, avoiding *ALLOBJ overuse, and protecting sensitive data.
265QSECURITY System Value ExplainedLog in to accessWhat the QSECURITY system value is and why its level shapes how strictly every other security concept in this course is enforced.
266Auditing Basics and QAUDJRN OverviewLog in to accessWhat QAUDJRN is: the system-wide security audit journal, and how it differs from a single job's own job log.
267Exit Points and Exit Programs OverviewLog in to accessWhat an exit point is, what an exit program is generally expected to do, and how it compares to a database trigger.
268IFS Security BasicsLog in to accessHow IFS authority differs from native object authority, and why securing a database file does not automatically secure related IFS data.
269Digital Certificates and TLS Concepts on IBM iLog in to accessWhat a digital certificate and TLS are, conceptually, and how they relate to the HTTPS already introduced earlier in this course.
270Row and Column Access Control and Field Procedures OverviewLog in to accessWhat RCAC and FIELDPROC each do differently from a plain table constraint, enforcing access and transformation based on who is asking.
271Authority Collection OverviewLog in to accessWhat Authority Collection is, and how it replaces guessing with an observed, evidence-based record of what authority a user or program needs.
272Common IBM i Security Mistakes and Best PracticesLog in to accessThe most common IBM i security mistakes developers make, drawn from across both Security Fundamentals batches.
273What is Journaling on IBM i?Log in to accessWhat journaling is: an ongoing record of changes to a journaled table, independent of the table's own current contents.
274Journal Receivers ExplainedLog in to accessWhat a journal receiver is, how it relates to a journal, and why receivers must be managed over time as they grow.
275Starting Journaling with STRJRNPFLog in to accessThe basic steps involved in starting journaling for a physical file: creating a receiver, a journal, and running STRJRNPF.
276Viewing Journal Entries BasicsLog in to accessWhat a journal entry contains and how to view journal entries for a table using DSPJRN, at a basic level.
277Commitment Control OverviewLog in to accessWhat commitment control is: grouping related changes into a single transaction that succeeds or fails together, and why it depends on journaling.
278STRCMTCTL, COMMIT, and ROLLBACK BasicsLog in to accessUsing STRCMTCTL, COMMIT, and ROLLBACK to group a set of changes into a transaction that succeeds or fails as a whole.
279Journaling for Recovery and AuditingLog in to accessHow journaling supports recovery, restoring a correct state after a failure, and auditing, tracking what changed and by whom, as related but distinct goals.
280Common Journaling and Commitment Control MistakesLog in to accessThe most common mistakes developers make when first working with journaling and commitment control, drawn from across this batch.
281Why Backup and Restore Matter on IBM iLog in to accessWhy understanding save and restore basics matters for a developer, not only for a system administrator.
282SAVOBJ and RSTOBJ BasicsLog in to accessUsing SAVOBJ and RSTOBJ to save and restore a specific object, without needing to save or restore an entire library.
283SAVLIB and RSTLIB BasicsLog in to accessUsing SAVLIB and RSTLIB to save and restore an entire library at once, rather than one object at a time.
284Save Files ExplainedLog in to accessWhat a save file is, and how to create one with CRTSAVF and inspect it with DSPSAVF.
285GO SAVE Options 21, 22, and 23 OverviewLog in to accessWhat GO SAVE options 21, 22, and 23 are for, at an overview level, and how they differ from everyday object and library saves.
286Restoring Objects Safely in Development and TestLog in to accessA safe, deliberate process for restoring objects: confirming the target library, checking authority, and coordinating with other users and jobs.
287Backup vs Journaling vs High AvailabilityLog in to accessHow backup, journaling, and high availability are three distinct, complementary concepts, each answering a different reliability question.
288Common Save/Restore MistakesLog in to accessThe most common mistakes developers make when first working with save and restore, drawn from across this batch.