× The internal search function is temporarily non-functional. The current search engine is no longer viable and we are researching alternatives.
As a stop gap measure, we are using Google's custom search engine service.
If you know of an easy to use, open source, search engine ... please contact support@midrange.com.



Hi,

A while back a few people asked what kind of questions came up in the 268 exam. I have dug out this page and thought It may be beneficial to get it in the archives: http://www-03.ibm.com/certify/tests/obj268.shtml

Although it doesn't go into details about specific questions posed (which would be inappropriate), it does specify the areas for study. I have detailed the test sections below for people without internet access.

----------------------------------------------------------------------------------------------------------

Section 1 - Externally described files in programs (14%)

Use printer files and "O" specs to define output in a program.
Use database file I/O operations in a program.
Use display file I/O operations in a program.
Use externally described database files in a program.
Use externally-described printer files in a program.
Use externally-described display files in a program.
Create DDS externally described files.
Create SQL externally described files.
Use EXTFILE. EXTMBR and OPEN/CLOSE file operations in a program.
When using externally described files, rename fields.
When using externally described files, show how to rename record formats in a program. Create Physical, Logical/View, Printer, and Display externally described files.
Use a field reference file to create an externally described file.

Section 2 - Subfiles (8%)

Code and use subfiles.
Create and maintain subfiles and programs that use those subfiles (DDS and RPG).
Determine the relationship between page size and subfile size.
Determine performance issues dealing with loading subfiles.
Interpret the use of SFLNXTCHG.
Interpret subfile keywords (e.g., SFLCSRRRN, SFLDSP, SFLDSPCTL, SFLDROP, SFLPAG, SFLFOLD, SFLRCDNBR, SFLEND).
Apply appropriate methods for accessing and updating subfile records.

Section 3 - Core RPG (15%)

Recognize appropriate use of RPG creation commands (e.g., CRTxxxPGM, CRTxxxMOD, CRTPGM, CRTBNDxxx). Define basic arrays (e.g., compile time, pre-run time, run time) using D specs. Use basic array handling (e.g., *IN, LOOKUP, SORTA, MOVE and MOVEA, indexing). Code and use figurative constants (e.g., *LOVAL, *HIVAL, *ALL, *BLANKS, *ZEROS, *ON, *OFF).
Code and use job date and system date.
Code and use structured operation codes (e.g., DO DOUxx, DOWxx, IF/ELSE/ELSEIF, SELECT/WHEN, CASxx/EXSR). Code and use structured operation codes with expressions (+, -, * ,/, **, <, >, =, (), and, or, not). Code and use date data types and arithmetic operations, including date operations in expressions.
Code and use SDS.
Code and use *INZSR.
Code and use RPG IV built-in functions.
Use the H-spec keywords.
Use RPG IV OpCodes (e.g., Arithmetic, Date, Message, Array, Declarative, File, Branching, Indicator setting, String handling, Structured programming, compare, initialization, subroutine, data area).
Use the D-spec keywords.

Section 4 - Advanced RPG techniques (25%)

Given an example of a complex logical expression, determine its results.
Given an example of deeply-nested logic within a sample of RPG code, determine the results of running the code.
Use Data Structure arrays.
Code complex D-specs (e.g., OVERLAY, coding fields without attributes, etc.).
Use modern techniques to handle numbered indicators.
Determine appropriate use of system APIs.
Code subprocedures.
Declare and use subprocedures.
Create and use multiple occurrence data structures.
Use externally-described data structures.
Write logic (including I/O operations) without numbered indicators.
Code and use /Free format Calc specifications.
Code and use Short Form expressions (e.g., + =).
Translate operation codes not supported in /Free form (e.g., MOVE, CALL, etc. into /Free form).
Use qualified Data Structures.
Use pointer data types.
Code and use Named Constants.
Prototype program Calls.
Determine appropriate use of passing parameters by value versus by reference.
Prototype System APIs and C functions.
Understand the ability for RPG procedures to call and be called by Java Methods.
Enumerate advantages of Prototypes compared with PARM and PLIST.
Determine appropriate use for prototype keywords, such as CONST, VALUE, and OPTIONS (*NOPASS, *OMIT, *VARSIZE).

Section 5 - RPG performance and exception/error handling (9%)

Given user requirements, design and create physical and logical data relationships.
Diagnose and resolve User Errors.
Diagnose and correct application errors.
Diagnose and correct system errors.
Diagnose and eliminate errors for date data types and arithmetic overflow.
Given a simple performance problem, determine appropriate course of action.
Code and use INFDS, INFSR, SDS, and *PSSR.
Code and use Monitor operation code blocks.

Section 6 - RPG data handling (10%)

Utilize embedded SQL in an RPG program.
Differentiate between different options for communicating between application processes (e.g., data queues, data areas, parameters, user spaces).
Code and use I/O directly to/from Data Structures.
Code and use nested Data Structures.
Determine appropriate use of LIKEREC keyword.
Determine appropriate use of LIKEDS keyword.
Code multiple ways to use partial keys, including KLISTS, key Data Structures, and direct specification of key fields on I/O operations. Demonstrate how to convert character and numeric data fields containing date values into Date data types and vice versa.
Use journaling in Commitment Control for data integrity.

Section 7 - RPG problem solving/problem determination (9%)

Find and interpret messages on message queues and in a job log.
Use STRSRVJOB to debug a program running from another job.
Code a trigger program using RPG.
Define and create unit test scenarios.
Define and create integration test scenarios.
Define and create system test scenarios.
Diagnose and eliminate errors resulting from numerical operations (e.g. divide by zero, decimal data errors, arithmetic overflow).
Diagnose and eliminate level checks.

Section 8 - ILE (11%)

Create and use Binding Directories.
Differentiate bound procedure calls from dynamic program calls.
Differentiate "bind by copy" from "bind by reference."
Determine appropriate use of activation groups.
Create and use Service Programs.
Create and use multi-module programs.
Determine the impact and appropriate use of the DFTACTGRP (Default Activation Group) parameter on the CRTBNDRPG (Create Bound RPG) command. Determine causes of and ways to avoid Signature Violation errors when using Service Programs. Determine appropriate use of the RCLACTGRP (Reclaim Activation Group) command. Determine the appropriate use of the scoping parameters for Override commands and Open commands, such as OPNDBF and OPNQRYF.

----------------------------------------------------------------------------------------------------------

I hope this is of use to somebody. :-)

Cheers

Larry Ducie



As an Amazon Associate we earn from qualifying purchases.

This thread ...

Follow-Ups:

Follow On AppleNews
Return to Archive home page | Return to MIDRANGE.COM home page

This mailing list archive is Copyright 1997-2024 by midrange.com and David Gibbs as a compilation work. Use of the archive is restricted to research of a business or technical nature. Any other uses are prohibited. Full details are available on our policy page. If you have questions about this, please contact [javascript protected email address].

Operating expenses for this site are earned using the Amazon Associate program and Google Adsense.