Labels

What Skills Modern IBM i Developers Actually Need — And How Managers Can Help Them Get There

 Today’s Coffee: Starbucks Single-Origin Sumatra Dark Roast—bold, deep, and grounding. It reminds me of the kind of developer we’re trying to build: steady, modern, and strong at the core.

Modern IBM i development is not a language problem.
It’s not a tooling problem.
It’s not even a modernization problem.

It’s a people problem.
And people problems require leadership.

As managers, our job is no longer just scheduling projects and reviewing code—it’s developing craftsmen. Modern IBM i teams need a blend of legendary experience and modern capability. And that only happens when leaders intentionally build the environment, structure, and habits that help developers grow.

Below is the expanded guide—including the technical skills developers need and the leadership responsibilities required to make it possible.

1. Modern RPG Skills — With Managers Creating the Space

Modern RPG means:

But here’s the truth:
Developers won’t adopt modern RPG unless you make time for them to learn it.

Manager Action Steps

  • Dedicate modernization hours weekly (even 1 hour/week compounds).
  • Require new code to use modern conventions—set the expectation.
  • Pair modern-skilled developers with legacy experts intentionally.
  • Celebrate wins publicly (“Sana rewrote this module in free-form—great work”).

Culture follows what you praise.

2. DB2 for i Literacy — The Foundation of Modern IBM i

Your developers must understand:

This used to be “DBA-only” territory.
Not anymore.
Modern RPG developers are data engineers.

Manager Action Steps

  • Bring SQL training into your sprint cycles.
  • Provide real examples: slow queries, missing indexes, bad access paths.
  • Assign “SQL cleanup” or “view consolidation” tasks as learning projects.
  • Stop allowing SELECT * in new code.

Data mastery is a management priority.

3. Git, Branching, and Code Review — Managers Must Enforce It

Modern workflows include:

But Git culture doesn’t grow naturally.
Managers must define it, enforce it, and ensure developers use it consistently.

Manager Action Steps

  • Define a simple branching model (feature / develop / main).
  • Require pull requests for every change—no exceptions.
  • Rotate code review assignments so all devs learn from each other.
  • Make Git training part of onboarding.

Teams only modernize when workflows modernize.

4. VS Code, RDi, and Tooling — You Must Remove Barriers

Tool adoption doesn’t happen because the tool is good.
It happens because leadership eliminates friction.

Manager Action Steps

  • Install VS Code and RDi on every machine with a standard configuration.
  • Create cheat sheets your team can reference.
  • Replace SEU/SDA workflows with modern equivalents, gradually but firmly.
  • Lead by example—use VS Code in demos and reviews.

If the manager uses old tools, the team will too.

5. SQL-First Thinking — Managers Define the Architecture

SQL views, procedures, and table functions simplify the application layer.
But developers won’t use them unless the architecture demands it.

Manager Action Steps

  • Adopt a policy: “Business rules belong in SQL or service programs.”
  • Require new database logic to use views instead of copy/paste joins.
  • Teach the team to think in sets, not loops.

Architecture is not a suggestion—it’s a leadership directive.

6. Integrations, APIs, and Web Workflows

Your IBM i will talk to other systems.
Modern developers need that skill.

Manager Action Steps

  • Build API work into project plans—not as a side task.
  • Give devs exposure to JSON, REST, OAuth.
  • Invite cross-team demos from cloud or web teams.

Modern IBM i work is integration work.

7. Unit Testing and QA — Managers Set the Pace

Developers don’t naturally write tests.
Managers must normalize testing as part of development, not “extra work.”

Manager Action Steps

  • Require unit tests for service programs and SQL logic.
  • Set simple initial targets (10% → 20% → 40% coverage).
  • Use RPGUnit or SQL test harnesses.
  • Include testing in definition of done.

Quality starts at the leadership level.

8. Understanding the Business — The Manager’s Secret Weapon

Modern developers who understand the business build better systems.
But this only happens if managers open the doors.

Manager Action Steps

  • Put developers in meetings with users and analysts.
  • Have devs demo what they built every sprint.
  • Share customer stories, good and bad.

Understanding the business is how developers grow from coders to engineers.

9. Respecting Legendary Code While Moving Forward

Your codebase is legendary.
Not legacy.
It runs your business. It holds decades of value.
Modern developers must learn to respect it and evolve it.

Manager Action Steps

  • Pair juniors with seniors deliberately.
  • Create “code archaeology” sessions.
  • Reward modernization through mentorship, not rewrite crusades.

Legendary code is a mentor, not an obstacle.

10. Damaged Object Recovery — The Skill No One Teaches but Everyone Needs

Modernizing doesn’t mean we stop dealing with foundational system mechanics.
Damaged objects remain part of IBM i life—even in 2025.

Modern developers must know:

  • how to detect object corruption
  • how to rebuild access paths
  • how to restore objects
  • how to coordinate with ops
  • how journaling affects recovery

Manager Action Steps

  • Run hands-on labs: “simulate and fix damaged objects.”
  • Build internal guides: common damage patterns and recovery steps.
  • Let junior developers shadow ops teams when issues arise.
  • Don’t hide incidents—use them as training.

These are battle-tested skills that modern teams must carry forward.

11. The Mindset—The Most Important Skill of All

Modern developers:

  • stay curious
  • learn continuously
  • embrace new tools
  • understand both code and context
  • grow past their own fears

This is not accidental.
It is intentional leadership development.

Manager Action Steps

  • Normalize learning as part of the job.
  • Add growth goals to every performance plan.
  • Celebrate experimentation, not just deliverables.
  • Give your team permission to fail safely.
  • Say it clearly: “Modernization is not optional. But you won’t walk it alone.”

People don’t resist change.
They resist change without support.

Final Sips

Today’s Sumatra Dark Roast reminds me of what strong leadership feels like—steady, bold, unmistakable at the core.

Modern IBM i development is not about abandoning RPG, rewriting everything, or chasing the newest trend. It’s about building developers who can thrive in the next decade—skilled in data, tooling, testing, architecture, recovery, and adaptability.

As managers, our responsibility is simple:

  • Give them the time.
  • Give them the tools.
  • Give them the training.
  • Give them the support.
  • And set the expectations clearly.

Modernization isn’t just code evolution.
It’s skill evolution, team evolution, and culture evolution.

And that starts with leadership.

Labels:

Comments

Post a Comment