What do you do when 15 characters just aren't enough?

If you're like me, you've become so used to abbreviating names for fields, data structures, prototypes, and subprocedures to stay within the 15-character limit that it's become part of your programming psyche. But what if there was a way to remove the limit of the length for these objects? As you may have already guessed, that's what this article is all about.

How Many Characters Are Enough?

You may be of the mindset that the 15-character limit should be plenty, but in some circumstances, the ability to extend beyond that limit can be very helpful in creating well-defined, easy-to-understand code. A good example of this might be defining groups of associated prototypes, where a portion of the name is used to identify that grouping.

Removing the 15-character limit can also help you avoid potentially confusing abbreviations. You may alsobe someone who likes to indent field names within the data structure and/or prototype definitions. When you work within the 15-character limit, your indented field names actually have to deal with a smaller limit.

Having said that, it's also important to avoid the temptation to go too far in using long naming techniques. You don't want to run into situations where you can't use the field within your C-specs.

Coding the Definition Specs

Field, data structure, and subprocedure prototype names are all created within your program's definition ("D") specs. Below are examples of some standard D-specs.

       * Standalone field definition
      DstrCstShpToFNme  S             35A  

 * Data Structure definition  
      DdsFltPrmDfnStr   DS                    Qualified Dim(10)
      D FltStr                        35A

      D FltType                        2  0

 * Procedure prototype

      DprcClcOrdShpCh   PR            15  5      
      D parOrdNbr                      9  0

      D parShpDt                        D

In these examples, the standalone field is defined as a 35-character alpha field that will be used to store the customer ship-to first name. The second definition is for a data structure containing two subfields. This data structure is intended to store information used to define filter parameter strings. The final example is a procedure prototype for a procedure that is used to calculate order shipping costs. While these may be clear enough from the 15-character values shown, using abbreviations like these can lead to confusion. Let's look at how we can make these names more clear.

A Total Ellipsis

The key to extending names in your definition specs is the use of the ellipsis. The simple "..." string gives us the ability to create a name longer than 15 characters. In fact, you can string multiple definition lines together using multiple ellipses to create an almost-limitless name.  The remaining definition parameters are then placed on the line immediately after the line containing the ellipsis.

Let's look at our earlier examples, redefined using longer names. First off, our standalone field might be defined as shown here:

       * Standalone field definition
      DstringCustomerShipToFirstName...  

      D                 S             35A    

In this example, our field name is now stringCustomerShipToFirstName instead of strCstShipToFNme.

Below is a modified example of the data structure defined earlier: 

Note that in this example the subfield names are also more descriptive, even though these more-descriptive names are shorter than the 15-character limit. This is done here for consistency purposes.

Finally, let's examine the subprocedure definition.

      * Procedure prototype

      DprocCalcOrdeShipmentCharges…
      D                 PR            15  5      
      D parmOrderNumber…     

      D                                9  0

In this example, both the procedure name and the procedure parameter are defined using long naming techniques. It's actually possible to take this technique and create extremely long names, as shown below:

     DstringSomeLongFieldName...

     DThatsTooLongToFitOnASingle...

     DLineAndNeedsToBeExtendedTo...

     DFourLines...

     D                 S             35A                 

The result of this would be a field named

stringSomeLongFieldNameThatsTooLongToFitOnASingleLineAndNeedsToBeExtendedToFourLines

As a side note, if I ever saw this used in a program, I would hunt down the programmer who coded it. This does, however, help to illustrate how to overcome the 15-character name limit.

Powerful Technique

I think a quote from Ben Parker (yes, Spiderman's uncle) might say it best, "With great power comes great responsibility...." In this case, that great power is the perceived 15-character naming limit in ILE RPG programs. While this technique gives you that power, it's important to use that power responsibly and not create long names just for the sake of creating long names.