In my opinion, there are certain things that you should be doing already when you program in RPG IV. If you're not, make them your resolutions for 2007.
Use Mixed Case
Always use mixed-case letters when programming. When North Americans are taught to read, they are taught to read lowercase letters for a number of reasons, one important reason being that lowercase letters have different patterns, whereas most uppercase letters have similar patterns. This means they look the same to the eye unless the eye pauses and reads the letter. For example, "BOB" is a rectangle, whereas "bob" is not. The longer the word, the easier it is to see what I mean. Look at the word "Chosen" versus "CHOSEN." Which is easier to read? Try reading the following two sentences to get a better idea of what I'm talking about.
The quick brown fox jumps over the lazy dog.
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.
Now apply this thinking to RPG IV programs, especially free-format.
Avoid CALL and CALLB Opcodes
Avoid using the CALL and CALLB opcodes. Using CALL/CALLB means you're really trying to stay in RPG III land. These opcodes were replaced by prototypes nearly 10 years ago. Use a prototyped call so that (a) you have the prototype for use in other programs, and (b) you can define and pass parameters to the called programs much more easily. I haven't used CALL/PARM for years and have never looked back. I'm also aggressively moving away from *ENTRY/PLIST. Instead, I use program entry parameter lists. These are effectively the same as procedure interfaces and prototypes, but they're used for the program.
Use Procedures
Use procedures for most routines. The use of inline code can be problematic. Whenever a group of related instructions exceeds some number of lines (10, 15, 20...whatever you feel comfortable with), consider stuffing that group into a subprocedure. This is similar to what we used to do in RPG III with subroutines, but subprocedures provide more flexibility and power. For example, you can add parameters, call the subprocedure in an expression, and easily modify it by adding new work fields as local variables without impacting the rest of the program.
Convert Subroutines to Procedures
Convert complex subroutines to procedures. As mentioned, subprocedures have long since replaced subroutines. Rather than continue to maintain those lengthy subroutines, port them to subprocedures, move the work fields associated with them to local variables in the new subprocedure, and call it.
Use Multiple Source Members
Design programs so that they use multiple source members, one as the main source member and the others containing the subprocedures used by the main program. It may seem like a lot of work, but the reality is that if you break apart your source members, editing them actually becomes faster. As the different routines are compartmentalized, you can make modifications faster with WDSC or even SEU. In addition, you avoid breaking parts of the application that aren't directly related to the area in which you are working.
Specify the EXPORT Keyword on the P Spec
Form a habit of specifying the EXPORT keyword on the P specification when writing subprocedures. Every subprocedure is a potential candidate for exporting. Specify EXPORT by default whenever you code a new subprocedure; type "P" in column 6, the subprocedure name in columns 7 to 21, "B" in column 24, and then the EXPORT keyword in column 44.
This allows the subprocedure to be called from another module. Without EXPORT, the subprocedure can be called from within the source member/module in which it exists. You'll also eliminate lots of time scratching your head in response to that nasty "Undefined external reference" message.
Use the D Spec to Declare Data
Use only the Definition specification to declare data. There are several places to declare data in RPG IV, and doing so can get quite monotonous; there are Input specifications, Definition specifications, and Calculation specifications. One good thing about /free (free-format) RPG IV is that you can't declare ad hoc fields like you can in fixed-format RPG IV.
The Definition specification allows you to declare standalone fields, data structures, arrays, data structure arrays, nested data structures, named constants, Java objects, parameters lists, and prototypes.
In addition, the LIKE, LIKEDS, and LIKEREC keywords allow you to use reference variables to create new variables based on previously defined variables. This makes things incredibly easy compared to recoding fields of similar data types and lengths. In addition, the LIKEDS keyword enables the use of data structure templates, a technique in which you create a data structure and then declare your own version of that data structure using the LIKEDS keyword whenever you need a set of related work fields. For example, if a subprocedure requires a data structure for its third parameter, the LIKEDS keyword is used to declare that data structure. You populate it and pass it to the subprocedure. This is common practice in most other languages, and it's a very welcome addition to RPG.
Looking Forward to 2007
That's it. I hope you had a safe and happy New Year holiday, and I'm looking forward to the new year and to providing the kind of information you need to get your job done.
Bob Cozzi is host of iSeriesTV.com, an audio and video podcast/netcast Web site dedicated to the iSeries/System i world. Bob is also the author of several books, including The Modern RPG IV Language and RPG TNT: 101 Tips 'n Techniques for RPG IV. He is also the producer of RPG World, an annual conference for RPG IV programmers.
LATEST COMMENTS
MC Press Online