These sessions relate to RPG IV and ILE.

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

In this session, Paul takes you through the design and implementation of a modern RPG application - with lots and lots of code examples. 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

One of the key questions is - how easy is it to integrate Watson into my existing RPG applications?

In this session we look at some of the way that RPG can connect with Watson (using the translation API) - and just how simple it is.

As well as looking at different methodologies, we will also discuss the advantages, and disadvantages, of the different approaches.

In this session, Paul discusses the what and why of standards and guidelines for modern RPG development. Topics include:-

  • Make Use of the Tools
  • RPG is FREE
  • Modern RPG Programs and Subprocedures
  • What's in a Name?
  • Comments
  • Structuring Code
  • Use Templates and Qualified Data Structures
  • Qualify Wherever Possible
  • Strings
  • Subroutines
  • Out With The Old
  • Embedded SQL
  • Global Definitions
  • Parameters, Prototyping and Procedure Interfaces
  • The Integrated Language Environment
  • Roll Your Own

This session covers tricks and techniques for the RPG IV programmer.

Come to this session and learn some of the things that you may not have known about...

  • The Control Option
  • Compiler Directives
  • Declaratives
  • Sorting Arrays
  • Using dynamic memory allocation
  • Using integers
  • Using indicators
  • Triggers
  • Constraints
  • Record Locking techniques
  • Other bits and pieces

Many RPG programmers have used interactive SQL as a tool to quickly browse data or to create test data scenarios, but have stopped short of embedding it into their RPG programs. Come to this session to learn why, when and how you may want to use SQL in conjunction with RPG. We will cover the basics of embedding SQL into RPG, including using SQL cursors, and a few tips on getting good performance from your SQL applications.

This session looks at:-

  • Why use embedded SQL?
  • Basic Syntax
  • Using host variables
  • Using a SELECT statement
  • Using a Cursor
  • Multi Row Fetch
  • Identifying and handling errors
  • The power of INSERT, UPDATE and DELETE
  • Compile options
  • When and how to use dynamic SQL
  • Using PREPARE and EXECUTE
  • Performance tips

You have been using embedded SQL in RPG. You have mastered the syntax, tried a few selects, declared a cursor, performed an update - you may even have tried some dynamic SQL!

Time to take it to the next stage and see what you can do with embedded SQL - beyond the basics

Topics covered in this session include:-

  • Discussion of the key points in writing powerful embedded SQL
  • What tools should you use to write and test SQL prior to embedding it?
  • Controlling CRTSQLRPGI
  • SQLCA and SQLCODE considerations
  • Getting data without SELECT - GET DIAGNOSTICS and VALUES INTO
  • Talking to Watson with Embedded SQL
  • Accessing SQL Functions
  • Identity Columns
  • Mastering Multi Row Fetch
  • SQL Exception Handler
  • Dynamic SQL with SQL Descriptors
  • Handling NULL

In this session, Paul offers a practical guide to handling some of the more esoteric problems in RPG programs (whether using native I/O and Embedded SQL) such as...

  • Messaging in a multi client environment
  • Trigger Failures
  • Nulls
  • Constraint Violations
  • Commitment Control
  • And other bits and pieces...

What are pointers? What are User Spaces? What can you do with them? This session guides the programmer through the implementation of pointers in RPG IV, how they extend the capabilities of the language, their importance in an ILE environment and how they are used with APIs - especially those dealing with User Spaces!

By the end of this session, attendees will be able to:

  • Understand the benefits of pointers and the benefits of User Spaces in RPG IV
  • Understand how to implement and use pointers and User Spaces in RPG IV

Learn all about the various options for error handling in RPG IV.

This session explains:

  • What is Exception Error Handling
  • Trapping operation errors
  • Monitor Groups
  • Program and File Information Data Structures
  • ILE Error Handling Options

Commitment control has always been available on the system but is very rarely used. But that doesn't mean that you shouldn't be using it.

Commitment control is an application decision as opposed to a programming decision. As companies look at modernizing their applications commitment control is a feature they should be considering.

This session looks at:-

  • What is Commitment Control?
  • When is Commitment Control useful?
  • Requirements for Commitment Control.
  • How to code and implement Commitment Control in RPG programs.
  • How journaling is used for Commitment Control.
  • Commitment Control and Activation Groups.
  • Commitment Control and the world of SQL.

There is a LOT> that you can declare in RPG! And there is a lot of versatility in the way you can define it!

A myriad of declaritave keywords can cut down on your coding requirements

This session looks at permutation and combination of declaring...

  • Files
  • Stand alone fields
  • Named constants
  • Arrays
  • Data structures
    • Qualified
    • Template
    • Arrays
    • Nested
    • Special structures
  • Pointers and based data
  • Prototypes and Procedure Interfaces

Multiple examples of definitions (and how they are used) are provided

This session takes a small sample RPG IV application and examines the issues involved in integrating it into an ILE application.

This includes decisions on Dynamic Binding, Static Binding, Bind by Copy or Reference, structure of Service Programs, Binder Language, Binding Directories and Activation Groups.

By the end of this session, attendees will be able to:

  • Understand the benefits of ILE
  • Understand the decision process in using the components of ILE

Although it is very rare that the implementation of any two ILE projects are exactly the same, there are a lot of ground rules that are required in all implementations.

This session discusses some of the considerations for a successful ILE implementation including how to control and manage the development environment, development tools to use, design considerations (Activation Groups, Binding Directories, using Service Programs) and documenting procedures.

Prerequisite: Attendees must have a basic understanding of the components of ILE.

One of the major considerations for the ongoing modernization of applications is how to make functionality accessible to multiple interfaces. But no matter how the application interfaces may change (green screen, web, client server, mobile phones etc.) or how data may arrive on the system (FTP, EDI, XML etc.) you can be sure that all of the data is going to end up in a database.

Externalized database processing provides a means of encapsulating database access. This session discusses why you may want to externalize database processing in RPG IV and how to do it.

System APIs can be challenging and, at some stage, nearly every programmer is confronted with using them. But once you get to grips with interpreting the documentation, you will find that the system APIs offer a host of opportunities

This sessions explains how to get to grips with System APIs and expand the possibilities of what the system has to offer your applications.

Topics include:-

  • Finding APIs
  • Type of API
  • Parameters
  • Documentation of an API
  • Prototyping and Using a simple API
  • Pointers and User Spaces
  • List APIs
  • The UNIX Type APIs

Although it has been around for a number of years Asynchronous JavaScript and XML (AJAX) has suddenly become a hot topic. What is all the fuss about? What relevance does AJAX have for the RPG programmer?

AJAX provides a means of having a web page communicate with a server, either synchronously or asynchronously. Combined with CGI programming techniques (CGIDEV2 is used in the presentation), you now have a means of dealing interactively with a web page i.e. changing the contents of a web page without having to re-write the whole page.

And best of all, it is already installed on every PC, all you have to do is use it!.

In this session you will learn:-

  • The background to AJAX
  • How it works
  • Examples of how to use it
[an error occurred while processing this directive]

How is it possible for an RPG program to be called from a web browser? How can an RPG program output to a web page? What is a HTTP server? What is CGI? This session explains how it works with easy to understand examples.

In this session, learn:

  • How to configure a HTTP Server
  • The basics of CGI
  • The CGI APIs