If you were to write a new application in RPG, what would it look like?

In this hand-on workshop, Paul takes you through the design and implementation of a modern RPG application. Topics covered include...

• Overview
• A Modern RPG Application
• Messaging
• A Sample Database
• Database Layer
• Tables, Key Constraints, Foreign Key Constraints, Check Constraints, Triggers, Indexes
• Views (and Indexes) and External Views
• Primary, Application and List Views
• Development Environment
• Data Access Layer
• Lists, Get, Add, Update, Delete
• Check Timestamp
• Handling Constraint Errors
• Service Layer
• SL Templates
• Get, Add, Update, Delete
• SL Templates vs DAL Templates
• Business Logic
• Interface and Clients

During the workshop you will learn how to create tables, indexes, views, database handlers and business handlers. You will also examine different interfaces for accessing the application you build.

Still stuck in an RPG/400 world? Well, this exciting Workshop will show you how modern programming practices and tools can transform your old monolithic RPG applications into a modern, highly modularized form that will position your business for the future. Rather than just throw hours of theory at you, this seminar takes a sample application and follows it through the process of converting from RPG/400 or basic RPG IV to full usage of RPG IV and ILE features, modularizing the code, adding DB2 UDB features and even replacing the green-screen with a graphical or browser-based interface.

Who Should Attend
Programmers and Analysts who wish to modernize their existing applications.

Agenda

• Introduction
• Use the Right Tools
• Making Use of RPG IV - Beyond the Basics
• Triggers
• Moving RPG to ILE - the Basics
• Really Moving RPG to ILE - subprocedures
• Referential Integrity
• Externalizing
• Ready for the Web

IBM Rational Developer for i (RDi) provides the modern development environment for RPG and COBOL programmers on i. It is the replacement for the traditional green screen development toolset of PDM, SEU, SDA, RLU and STRDBG and it has a lot to offer in terms of ease of use, extra features and productivity. But, getting to grips with a new development environment can be challenging. This hands-on workshop aims to give you the kick start required to get up to speed with RDi as quickly as possible.

This workshop, through lectures and hand on exercises, takes you through

• Connecting to servers
• Basic day to day use (edit/compile)
• Editor features - what SEU and PDM cannot do for you (color coding, code completion, code comprehension)
• Advanced features (outline view, verifier)
• Customization - (filters, commands, library lists, tweaks)
• Personalization - perspectives and other views
• Debug

The workshop introduces RPG IV and ILE from the point of view of experienced RPG III (RPG/400) programmer.

The workshop covers the following topics

• Background
• Conversion Options
• Format and Limit Changes
• Welcome to Free Form
• Data Types
• Control Options (it was the H Spec)
• Compiler Directives
• Declaring Files
• Declaring Data
• Fields, data structures, arrays, indicators, named constants
• Free Form Code
• Expressions
• Built in Functions
• Dates, Times and Timestamps
• Prototyping
• Subprocedures
• Introduction to ILE

As RPG programmers continue to move to RPG IV and ILE they bring a lot of old RPG III habits with them. Old habits die hard and, even though they may be making use of some of the new language features, are they making full use of what RPG IV and ILE have to offer?

This workshop discusses some of the language features and methodologies programmers should be embracing and some of the more traditional approaches they should be discarding.< /p>

We'll explore some of the following topics:

• Useful Built-in Functions you may have missed
• Is Free Form for you?
• Why numbered indicators should be banned from your code
• How and why to replace Call, Parm, Parm, Parm
• Using subprocedures to structure your code
• What you need to learn about ILE

SQL is being used more and more by the RPG programmer. Not only is SQL replacing DDS for defining databases but it is being used extensively within RPG programs themselves. This workshop introduces SQL for the RPG Programmer with a lot of emphasis on the use of Access Client Solutions. The workshop is designed for experienced RPG IV programmers. You will see how to:

• Get started with SQL
• Use SQL's Data Manipulation (DML)
• Use SQL's Data Definition Language (DDL)
• Use embedded SQL

The workshop covers the following topics

• Overview and Terminology
• SQL and Db2 for it
• Data Manipulation (DML)
  • Retrieving Data (SELECT, FROM, WHERE, ORDER BY)
  • Updating Data (INSERT, UPDATE, DELETE
  • GROUP BY, HAVING, Column Functions
  • Special Operators (BETWEEN, IN, LIKE, IS NULL)
  • SQL Functions
  • Selecting From Multiple Files
  • Sub Queries
• Embedded SQL
  • Why use embedded SQL?
  • Basic Syntax
  • Using host variables
  • Using a SELECT statement
  • Using a Cursor
  • Identifying and handling errors
  • The power of INSERT, UPDATE and DELETE
  • Compile options
  • When to use dynamic SQL
  • Using PREPARE and EXECUTE
  • Performance tips
• Data Definition (DDL) (Create/Drop COLLECTION, TABLE, VIEW)

You have been been getting to grips with SQL and how to use SQL in RPG programs. You know how to make use of powerful SELECT statements and have even used INSERT, UPDATE and DELETE statements to manipulate data in the database.

In this hands-on workshop, Paul helps you to bring your SQL and embedded SQL to the next level. Topics covered include...

• Introduction
• Functions of Note
• Grouping Sets
• Using CASE
• Sub Queries
• Common Table Expressions
• Union
• Identity Columns
• Row Change Timestamp
• The Importance of Views
• Controlling CRTSQLRPGI
• SQLCA and SQLCODE considerations
• Getting data without SELECT
• Multi Row Fetch
• Paging Cursors
• Position To
• Handling NULL
• Dynamic SQL

Through the use of Stored Procedures, Functions and Triggers, SQL (Structured Query Language) provides a means for other languages (and platforms) to take advantage of existing code or to access SQL capabilities from RPG or COBOL applications. Stored procedures provide a means of calling routines that may or may not return a result set. Functions provide a means of writing your own scalar functions. Triggers provide a means of having code execute based on database events.

This seminar shows you how to code and create SQL Stored Procedures, Functions and Triggers that utilize existing code (external) and how and how to code and create SQL Stored Procedures, Functions and Triggers that are written in SQL.

The seminar will cover the following topics:-

• What are Stored Procedures, Functions & Triggers and where and why you might use them
• Common components
• Development tools
• Creating Functions from existing RPG code (programs and subprocedures)
• SQL and sourced function
• Parameter styles
• Overloading functions
• Table Functions
• Stored Procedures
• RPG programs to return one or more result sets
• Returning result sets to the caller or the client
• SQL control statements (how to program in SQL)
• Writing stored procedures using only SQL
• Handling exception/errors in external and SQL routines
• Triggers
• How they are attached to a table
• How they are activated
• Coding External Triggers in RPG
• The benefits of SQL Triggers (and there are benefits) and how to code them

To the traditional RPG developer, the web can appear daunting. What is the easiest way for the RPG developer to get to grips with the way the web works? Use RPG!

Although they may provode a better application solution to web interface,You don't need Java, PHP, Ruby, Node.js or Python, in order to understand what is going on. You already have everything you need in RPG IV and the Apache Server for i.

You will see how to:

• code HLL programs to write data to a web page
• understand and write HTML
• use the CGI APIs
• use the CGIDEV2 APIs

Topics are:-

• Introduction
• Tools and References
• Apache Server on i
• Basic HTML
• The CGI APIs
  (the underlying principle)
• Getting Started with CGIDEV2
• Printing to the Web
• Interacting with a Browser
• HTML Forms
• Maintenance with CGIDEV2
• More on CGIDEV2
• Debugging and other Bits and Pieces
• In Conclusion