COMMON POWERUp 2026

**update**  Tegratecs apologizes for their speaker representative not being able to make it to the conference.  Rexford is still dealing with 2 significant and separate dental issues that came up over the last two weeks.

Conference attendees are entitled to the presentation PDF and attachments and USB stick (for in person attendance or by request), but since the session was cancelled, COMMON has removed the links from view. So please contact Tegratecs for these resources based on your interest. If you were signed up for this session prior to the cancellation, everything but the actual USB stick contents should still be visible and enabled for download.
------

If you have internal Change Management and/or DevOps functions that need to handle SQL PL Stored Procedures or a dual source model, then this session will be of interest to you.  During this presentation, we’ll delve into programming specifics of how challenges were overcome and show examples.  The presentation will attempt to narrow down the conflicting techniques involved with storing source in the IFS versus native source files, and for pulling (extracting, generating) source from the SQL PL *PGM object. Pulling the source from the object is, at various times, something that is pretty much necessary for SQL PL stored procedures and views.  We’ll cover the different style of source and object handling (and source versus object precedence) probably required for SQL PL stored procedures (*PGMs with CLE attribute) in our custom C/M and DevOps commands.  This turned out to be quite a bit different than what we were doing before when distributing incremental updates to our accounting package or customer environments, because previously (1) source always took precedence over object, (2) source never needed to change during migration and (3) we were able to have a tight source code version level indicator in the object metadata.

Come to the presentation to find out why we thought it easier to store view and procedure source in both the IFS and traditional source files, at least during the first round of production IFS source implementation. Hear also how we managed to keep them synchronized, and similarly, how we kept a pretty tight rein on source and object versioning. Checkout, compilation, staging and promotion via a native CLP or *CMD call will be examined and (hopefully) shown to be enhanced and solved to everyone’s liking during the presentation.

Key CLP source code and SQL queries of SQL meta data will be covered in the presentation PDF or attachments available for download to all conference attendees. Some slides with a lot of code will be given to attendees in printed form. Attendees may want to have the attachments available to peruse (on some sort of device larger than a small smartphone) during the presentation in order to gain the most developer level understanding in the quickest manner and to participate interactively.

Several complete programs will be offered to live session attendees on USB stick (that we can't afford to offer unencumbered on Sched). Contact Tegratecs for USB stick if you can't make the live session.

Please feel out a survey if you find any of the downloads useful.

Learning Objectives:

1.  Get to a point where you can weed out the inefficiencies in locating, extracting, editing, compiling or promoting the source and object for your SQL PL Stored Procedures

2. Learn what one ISV and consultancy did to focus C/M and DevOps activities around the object, instead of the source, for SQL PL stored procedures, and to see how one might go about automating ways to help relieve synchronization concerns and reduce manual intervention

Modernizing COBOL applications to RPG IV can be faster and safer with static analysis, automation, and AI —but it still requires solid engineering. This session explains how analysis tools identify data flow, dependencies, and shared logic before conversion begins. We’ll explore how to combine AI automation with proven analysis and programming discipline to transform COBOL business logic into clear, maintainable RPG IV code. Real examples show planning, testing, and incremental rollout techniques that minimize risk. Attendees will learn how to balance automation, analysis, and AI methods for dependable, low-risk modernization on IBM i. A case study using actual COBOL code will be presented.

Learning Objectives:

`-Understand how static analysis clarifies COBOL logic and dependencies before conversion. -Learn how to combine AI automation with static techniques for accurate modernization. -Apply disciplined planning and testing to ensure reliable COBOL-to-RPG transitions.

One of the most important Features in IBM Rational Developer for i is the Outline Feature. When you - like my Team and I - need to work with a lot of large (and very large) and old (and very old) RPG programs the Outline is such a time saver. But I also miss some features which I send IBM in the RDi "wish list" some years ago... The Outline is also the most important reason why we are still using the RDi instead of VS Code with Code4i. While creating our RPG AI Analyzing Tools we did a lot of work with collecting information about the RPG source and then the idea was born to create our own Outline for VS Code and Code4i which should look and behave like the one in RDi but with all the features I miss for years. In this session you will see our new Outline Tool - Codename Morgana - with all the features we implemented in Version 1 and a first look into the next wave of Features we are working on.

Learning Objectives:

You will learn how you will save a lot of time by using the actual version of our new Outline Add On for Visual Studio Code and Code4i - Codename Morgana - and it's Features, like everything you know from the Outline of RDi as well as opening source code of a procedure or a Display File, Database File or even a CALL with one click without knowing in which Serviceprogram it resides or where the source code is saved. When the RPG Compiler can find these things we can too.

The Code for IBM i family of extensions continues to grow with new tools and powerful enhancements. In this session, we will showcase recent improvements, highlight community contributions, and share a glimpse of upcoming features on the roadmap for 2026.

Learning Objectives:

• Share newly released features across all IBM i VS Code extensions • Showcase new tips and tricks to improve the developer experience • Share an overview of upcoming features in the 2026 roadmap

Join me in exploring Project Bob, a new AI-powered software development partner. We’ll look at how Bob supports the entire software development cycle through intelligent modes, tools, commands, and workflows that understand your code, intent, and standards. We’ll also dive into practical demos for IBM i developers, showcasing how Bob can explain, understand, refactor, transform, and test even monolithic or legacy codebases.

Learning Objectives:

• Explore what Bob is and how to use it • See how Bob understands your code, intent, and standards • Explore practical examples of using Bob as an IBM i developer • Learn how Bob excels at modernizing legacy codebases

Modern IBM i environments depend on complex data exchanges across systems. Static analysis—and now AI—can help map these interactions, but AI is not magic. This session focuses on combining automated insight with AI techniques to trace and document system connections, whether through messaging (MQ), APIs, or batch managed file transfer processes. We’ll show how to rebuild missing documentation, identify redundant paths, and improve visibility for modernization planning. Attendees will learn how to apply both practical engineering methods and AI to understand, validate, and improve cross-system integration on IBM i. A case study will also be presented

Learning Objectives:

`-Learn how to identify and map cross-system dependencies using static analysis. -Understand when to use AI assistance and when traditional analysis works better. -Apply hybrid AI/non-AI techniques for documentation, modernization, and reliability.

Dive into VS Code and CODE for IBM i / DB2 extensions with this perfect starter Lab. Many RPG developers are unfamiliar with VS Code, and beginning with this IDE can feel daunting. This lab offers a introduction to both VS Code and the Code for IBM i / DB2 development environment. To Participate the attendee MUST BRING A LAPTOP! The attendee will receive access to an IBM i system to engage in lab tasks. By the end of the lab: The basics of VS Code. Installing and VS Code extensions Navigating the Code for IBM i development environment.

Learning Objectives:

Overview of VS Code Introduction to the VS Code IDE Installing IBM i extensions Connecting to the IBM i system Editing and compiling modules, service programs and creating runnable RPG objects Running and Debugging a program Using SQL DB2 in VS code

More and more companies get into trouble with their old applications and this is not only on IBM i. The reasons are different but at the end they all have the same challenges: They need to get out of that. One way of doing that is using Tools to analyze the old stuff. That is something we all do for decades now but the tools changes or continue to evolve. Right now there are many "Tools" out there and they all claim to use AI and many of them are based purely on AI. All of them promise you, that they will solve all your problems. My team and I have spent a lot of time and energy over the last two years looking at many of these tools (and those that claim to be such) and have done a lot of experimenting and developing in this area ourselves. Many of these tools deliver very questionable results, which sometimes fit perfectly and sometimes don't fit at all. However, our customers and we need to be able to trust the results of such a tool. Is it true or false? Not sometimes yes and sometimes no... In addition, many of these tools incur enormous additional costs, especially if they rely on cloud-based AI models, where you can never be sure what will happen to your company data. I can show you a working solution that is used in production for many months and can use pure local AI Models combined with "self made" development to create results we can trust.

Learning Objectives:

See why it is important to take a close look at how such tools work, understand them, and be able to compare them, as the results and costs of the various tools vary enormously. You need to be able to recognize the advantages and disadvantages of the various tools and decide which one is best suited to your situation and your company. This is not only a question of security, compliance, and valid results, but also of TCO. I will show you examples of some of the above points live so that you can see exactly what I mean. See how you can analyze your old and very old code with the help of a tool that not only uses AI, but only where it makes sense. And it works now—not sometime in the future.

Git has become the standard for version control, but moving traditional IBM i source code into Git requires planning, the right tools, and some trial and error. This session walks through a complete migration experience: from the initial planning phase, through the technical steps of exporting source, to resolving issues with members, naming, syncing, and how AI can help. Along the way, we’ll discuss pitfalls, solutions, and strategies for adoption across development teams. Attendees will gain a clear roadmap for migrating to Git and the confidence to start their own journey.

Learning Objectives:

Identify key planning steps needed before migrating IBM i source code into Git, including repository structure, workflow design, and tool selection. Execute a practical migration process — from exporting IBM i source members to resolving naming and synchronization challenges. Recognize common pitfalls during migration (e.g., member-level management, library mapping, and CCSID issues) and apply effective solutions. Leverage AI-assisted tools to streamline source analysis, refactoring, and ongoing Git synchronization. Develop a strategy for team adoption, including training, workflow standardization, and integration with CI/CD or modern IDEs. Build confidence to begin their own Git journey, using a clear roadmap and lessons learned from real-world implementation.

In this session we will discuss the various ways to implement using REST APIs in your existing applications. What they are, why they exist, and how companies are using them to communicate with each other.

Learning Objectives:

We will take an RPG service program and deploy it as an API using the IBM Integrated Web Services tool (IWS).

Visual Studio Code has quickly become one of the most popular development environments, and with the Code4i extension it’s a powerful option for IBM i developers. In this session, I’ll show you why VS Code is my tool of choice and how Code4i, along with a handful of other must-have extensions, can transform your development workflow. Most of these tools are free, and my entire setup runs for about $20 a month. If the stars align, I’ll also do a live demo of my environment so you can see firsthand how these tools fit together into a cost-effective, productivity-boosting toolkit.

Learning Objectives:

Understand the key features of Visual Studio Code that make it a strong option for IBM i development. Explore the capabilities of the Code4i extension and how it integrates with VS Code. Identify additional extensions that enhance productivity and streamline development. Learn how to build a highly effective development environment at little to no cost.

Tired of typing long CL commands or repeating the same operational tasks? IBM i gives you the power to create your own commands — complete with prompts, keywords, and integrated help — that look and behave just like IBM’s built-in ones. In this session, you’ll learn how to design and build your own custom CL commands (CMD objects) from start to finish. We’ll start with simple examples that wrap CL programs, then move to more advanced topics such as validation programs, command processing programs (CPPs), and creating user help text. Using practical demonstrations, Simon will show how custom commands can simplify operations, enforce standards, and make your IBM i environment more user-friendly. By the end of the session, you’ll be ready to design your own commands to automate your shop’s most common tasks — and make your coworkers think IBM shipped them that way.

Learning Objectives:

After attending this session, participants will be able to: - Understand the structure and components of IBM i command objects (CMDs). - Create custom commands that call CL or RPG programs. - Define command parameters and default values using keywords. - Use command processing programs (CPPs) and validity-check programs (VCPs).

Join me as we explore how to achieve end-to-end automation on IBM i, covering builds, tests, and impact analysis using open source tools (ibmi-ci, Source Orbit, and itest). The session will walk through a practical example of setting up a modern DevOps pipeline in GitHub. Imagine creating a pull request that automatically triggers a build, generates an impact analysis report, runs your test cases, and produces code coverage — with all results sent directly to the pull request for reviewers to see with ease.

Learning Objectives:

• Learn how objects get built from a Git repository • Explore what the modern development life cycle looks like with Git • Learn how to automate your builds, tests and impact analysis with GitHub Actions

Thanks to the Code for IBM i open source extension, VS Code became an IDE of choice for whoever wants to do some development on IBM i. Less expansive (as in "free") and more modern than RDi, it's already a daily driver for IBM i professionals and enthusiasts alike. But what does it have to offer we barely know? What are the less-known features that can make a developer's life easier? The legend tells that it's even possible to work locally on IBM i source code synchronized with Git or to use Visual Explain right from VS Code. But the best is yet to come and see for yourself! Whether you are a seasoned developer or just curious, join me to discover or rediscover the hidden gems that VS Code has to offer. Don't be a stranger and bring your questions along!

Learning Objectives:

`- Learn new ways of using VS Code for developing on IBM i - Hear it from one of the top contributor of the Code for i project - Discover how to use VS Code more efficiently - Live tips & tricks

In this award-winning session, we’ll go beyond the basics of IBM i Access Client Solutions (ACS) to uncover ways to make the tool work harder for you. After reviewing the core functionality, I’ll demonstrate some of the customizations I use every day to boost productivity and streamline my workflow. Whether you’re brand new to ACS or a seasoned user, you’ll walk away with practical tips, tricks, and user-driven ideas you can immediately put into practice.

Learning Objectives:
Understand the core functionality of IBM i Access Client Solutions (ACS). Learn how to apply customizations within ACS to increase efficiency and productivity. Discover creative ways other users enhance ACS and identify techniques you can adapt for your own environment. Walk away with practical tips and tricks you can immediately implement in your daily workflow.

Are you troubled when debugging from VS Code? Do you experience feelings of dread when starting the Debug Service? Have you or your coworkers actually been struggling to debug ILE from VS Code? If the answer is yes, then don't wait another minute. Just register for this webinar and get in touch with the professionals - Debuggerbusters !

Woops, wrong movie! But right topic!

It is time to learn how to properly debug ILE from VS Code - and believe it, it's not that hard once everything is set up correctly! So...who you gonna call? Seb Julliand! Seb has a long history (as in "love and hate relationship") of interfacing the IBM i Debug Service with Code for IBM i and knows quite a bit about it. From the architecture of the debugger to an actual live debugging session, Seb will take you on grand debugging tour:

- Prerequisites
- How it works
- Configure and start the debug service from iNavigator
- Common pitfalls
- How to debug a program call
- How to work with Service Entry Points
- Variables, Breakpoints, Confitions, Watch

Join this session to finally be comfortable when it comes to debbugging from your favorite IDE.

Ain't afraid of no questions!