The Latte Factor: Small RPG Improvements That Compound Big Gains

 ☕ Today’s Coffee: Starbucks Café Latte — smooth, balanced, and accessible. Like small improvements in RPG development, it doesn’t shout for attention, but day after day it builds into something transformative.

Why Small Changes Matter

There’s a concept in personal finance called The Latte Factor: skipping small daily purchases (like lattes) can add up to significant savings over time. The same principle applies to RPG development.

You don’t need to wait for a massive rewrite or a modernization budget. Small, consistent improvements in your codebase and practices compound into something powerful:

  • More maintainable programs
  • Fewer bugs in production
  • Faster onboarding for new developers
  • A team culture that values progress, not perfection

Five Small Improvements That Pay Big Dividends

1. Meaningful Naming Conventions

Old RPG programs often rely on cryptic field names like CUSTN1 or FLDA03. Updating names to meaningful identifiers (CustomerName, InvoiceDate) makes the code self-explanatory.

  • Payoff: Cuts onboarding time for juniors and reduces errors.
  • Pro Tip: Copilot and other AI tools follow your patterns — good names mean better AI suggestions.

2. Refactor Fixed to Free-Form

Migrating a single calculation spec or file declaration at a time may seem trivial, but the readability boost is immediate.

  • Before (fixed-form):

         C           ADD   1             COUNT

  • After (free-form):

         Count += 1;

  • Payoff: Reduces training overhead for new hires who’ve never touched column-based code.

3. Introduce SQL Views

Instead of hard-coding join logic in multiple RPG programs, create a SQL view once and let RPG pull from it directly.

  • Payoff: Simplifies RPG logic, improves consistency, and reduces bugs.
  • Example:

         Create View ActiveCustomers as

            Select CustID, CustName, CustCity

              From Customer

             Where Active = 'Y';

4. Modularize Common Routines

Take that copy-pasted date validation logic and move it into a service program.

  • Payoff: Fix once, benefit everywhere.
  • Leadership Angle: Signals to your team that reuse is expected, not optional.

5. Commitment Control by Default

Wrap write/update logic in Commit/Rollback blocks, even for “simple” jobs.

  • Payoff: Reduces risk of data corruption and enforces transactional discipline.
  • Example:

         Exec SQL Set Option Commit = *CS;

          

         Exec SQL

            Update CustFile

               Set CustPhone = :NewPhone

             Where CustID = :CustID;

          

         If SQLCOD = 0;

            Exec SQL Commit;

         Else;

            Exec SQL Rollback;

         EndIf;

Myth-Busting: Stop Waiting for the Big Rewrite

Too many shops say:

“We’ll modernize once we get the budget.”

That’s the biggest myth holding IBM i teams back.

Here’s the truth:

  • You don’t need a 6-figure modernization project to start improving.
  • Legacy code doesn’t mean locked code — you can refactor one calc spec today and it counts.
  • Culture change starts small — a team that improves daily will outpace a team waiting for the mythical “big project.”

The Latte Factor in RPG isn’t about glamour projects. It’s about momentum. Stop waiting for permission — start modernizing now.

Leadership Angle: Teaching Your Team the Latte Factor

Managers often wait for budget, modernization projects, or vendor tools before improving RPG code. That’s a mistake.

When you encourage your team to focus on small improvements:

  • Momentum builds — people feel progress even in legacy environments.
  • Culture shifts — developers start asking “how can I make this better?” instead of “why bother.”
  • Retention improves — developers want to stay in a shop where quality is valued, not ignored.

Like compounding interest, the earlier you start, the more powerful the payoff.

Final Sip

The Starbucks Café Latte isn’t flashy, but it’s steady and satisfying. Small sips over time make a big difference — just like small RPG improvements.

Rename a field. Refactor one calc spec. Add a SQL view. Those are the “lattes” of RPG modernization — affordable, approachable, and powerful in the long run.

☕ Follow The RPG Blend for more modern RPG practices, leadership insights, and a good cup of code.
📂 All code examples live here: The RPG Blend on GitHub
📖 Read the blog: The RPG Blend on Blogger

 

Comments

Post a Comment