• Guru: Data-Centrism, Step Zero

  September 10, 2018 Ted Holt

  I hear a lot these days about the need for data-centric information systems. That is as it should be. The proper way to support an organization is to remove logic from application programs and put it into the database through such devices as constraints and triggers. However, before many shops can take the first step in that direction, they need to take what I call step zero.

  Step zero in data-centric computing is to remove hard-coded data values from programs and put them into the database. Just as the database manager should enforce business rules (e.g. we don’t ship to …

  Read more

• Guru: Beefing Up The Job Log, Take Two

  August 6, 2018 Ted Holt

  In Tracing Routines Explain Why The Computer Did What It Did, I wrote about the usefulness of writing information about program execution to determine why a program run gave certain results. Today I want to present a simpler method than the tracing routines. The tracing routines are not obsolete, but they are powerful and I have found them at times to be overkill.

  Just a word about terminology. Since I wrote that article five and a half years ago, my reading has led me to a different understanding of the terms tracing and logging. I’ve since decided that …

  Read more

• Guru: Refactoring RPG – Indicators

  July 30, 2018 Ted Holt

  Occasionally I hear someone comment about how terrible indicators are. I don’t think they’re bad. Indicator-laden RPG helped me graduate debt-free with a computer science degree and housed, clothed, and fed my family for several years. I prefer to say that indicators were good for their time, but now we have better programming techniques that I much prefer to use.

  Refactoring code to reduce or even eliminate the use of predefined indicators (not indicator variables) can pay off big in benefits. The fewer indicators a program uses, the easier it tends to be to read, understand, modify, and debug that …

  Read more

• Guru: Serve Web Pages Safely Using A Reverse Proxy

  July 23, 2018 Alan Seiden

  If you are hosting a website or API from your IBM i server, but wish to reduce your worry about allowing access from the Internet, we often recommend a reverse proxy (or “gateway”) server. An industry-standard solution, a reverse proxy server acts as a layer of safety between your production server and your firewall. On IBM i, the IBM HTTP Server (powered by Apache) for i can act as a reverse proxy server, so there’s nothing additional to install.

  While there are several ways to set it up, one approach is to put the reverse proxy or gateway in a …

  Read more

• Guru: Ready or Not! Part 4 of Big Changes in RDi V9.6, PDM Affinity with Object Table

  July 16, 2018 Susan Gantner

  I’m beginning to feel like a broken record — still more new RDi features with V9.6. I’m excited that there are so many great new features to talk about. In this tip, I’ll cover the primary feature added with fix pack update V9.6.0.3 — enhancements to the Object Table for PDM affinity.

  To me, the enhancements to the Object Table view to make it look and feel much more like PDM are the most significant in the release. There are some other smaller — but still very welcome — enhancements as well, which I’ll cover in a later tip.

  Why …

  Read more

• Guru: DB2 For i XML Composition And The IFS

  June 11, 2018 Michael Sansoterra

  Hey, Mike! Regarding Composing An XML Document From Relational Data, Part 1, I have built an XML document using DB2 and i. When I run the query, I get a worthless result set. How do I use the SQL XML functions to get a usable XML file?

  This question comes from reader RA, and he doesn’t exaggerate. The result set from his XML-based query looks like this:

  ....+....1....+....2....+....3....+....4....+
  ************Beginning of data************** 
  
  XMLDATA 
  -------- 
  #CGULIB#
  
    1 RECORD(S) SELECTED.
  
   ************End of Data********************
  

  Notice that DB2 for i does nothing to make the XML attractive to human eyes as the entire XML …

  Read more

• Guru: Refactoring into Routines

  May 7, 2018 Ted Holt

  In RDi and Refactoring, I illustrated the process of refactoring by taking code of a very old style and converting it little by little into something modern. I promised to write more about the subject, and today I fulfill that promise.

  The things I did in that first article — removing indicators, removing the COMP op code, removing GOTO, and renaming variables — are great, but they are not the only refactoring techniques. One of the best ways to refactor is to create new routines or improve existing routines, especially routines that can stand alone.

  To illustrate, I’ll begin …

  Read more

• Guru Odds and Ends: Readers Respond

  April 30, 2018 Ted Holt

  I appreciate the comments and feedback that readers have contributed. Some of you sent it my way via the Contact page at IT Jungle. Others emailed me directly. Yet others left comments at the end of the articles themselves. I am always grateful for your knowledge and wisdom, however I receive it.

  Knowing that you are very busy and don’t have time to revisit the articles we have published, I’ve collected some of that feedback for your edification. Please feel free to add to the body of knowledge.

  ---

  Had to chuckle when I read Sorting Options For CPYTOIMPF, …

  Read more

• Guru: RDi and Refactoring

  April 16, 2018 Ted Holt

  When I first heard the term refactoring, I thought, “So that’s what they call it.” I had been refactoring for years, my only tools being SEU and a compiler listing. I learned a long time ago that refactoring is often necessary to enhance code, especially poorly written code. Another reason I often refactor is to better understand poor code.

  To refactor means to rewrite source code without changing its external behavior. Due to all the “legacy” source code (RPG II, RPG III, fixed-form RPG IV, OCL, etc.) in IBM i shops, the ability to refactor source code is a …

  Read more

• Guru: Dealing With Non-Normalized Data

  April 9, 2018 Jon Paris

  From time to time, many of us have to find solutions for handling our old non-normalized tables in an efficient manner. It would be nice to have the luxury of redesigning and normalizing these databases, but real life is not like that. This is particularly true when the tables in question are part of an application package where you have no control over the file layout.

  I should point out that by “efficient” in this context I don’t necessarily mean processing speed, but rather in terms of the number of lines of code needed to perform the necessary manipulations and/or …

  Read more

Previous Articles Next Articles