NOTE: The following is an OPINION and does not have any bearing on how easy or hard a particular language / application is to use.
Those of you who follow the midrange.com lists probably are aware that I’m not a big fan of application code generators.
This includes (but is not limited to) …
- Case Tools (AS/SET, Synon, etc)
- SQL Pre-processors (RPG SQL, COBOL SQL, etc)
- JSP (to a limited extent)
- Various 3rd party application generators
The reason is simple … the code you write is not the code that executes.
In all the cases, you write in some form intermediary language … which then gets translated into a different language source code which ultimately gets compiled and/or executed.
- AS/SET & Synon translate into RPG (or COBOL).
- EGL gets translated into Java and/or COBOL.
- SQL RPG & COBOL gets translated into RPG & COBOL (but not the SAME code you wrote).
- JSP gets translated into Java.
So what’s the problem with this?
- In most cases, the generated code is extraordinarily complex and convoluted. This makes it very difficult (if not impossible) to debug directly.
- If the code generator changes in a significant way, your application could generate totally different code … which, in a good development organization, would necessitate a full regression test of the application to ensure it still functions the way it did before.
- Often, you are tied to the tool that you used to develop the application … you will need that tool to make any future modifications to the code (assuming the company exists and the tool is still supported).
- Many code generators use their own code repository … which makes it difficult to integrate with change control systems.
- The generated code is often not very modern.
- RD for Power can’t seem to cope with RPG SQL very well (I assume the same is true for COBOL SQL) …
- If generation time errors are encountered during the compile, the errors are not reported correctly.
- If you have a syntax error during the actual compile phase, the line number that RD Power picks up does not correspond to the source code you submitted for compile.
- Although it’s possible to have the source code saved during the generation phase, I’ve had problems with file member locks if I try to RD for Power reference that source member.
Many people will argue that using a code generator is faster & easier than writing an application from scratch thus allowing you to spend more time concentrating on the business logic instead of the language details … which is true … but in order to be able to debug flaws the business logic, you’re going to need to know the generated language.
Another thing to consider: code generators shield you from the real programming language … and your skills in the programming language might (and probably will) suffer. You won’t necessarily always have the code generator available … at which point you’ll have to fall back to your original programming skills, which might have atrophied.
Granted, sometimes there’s no other option …
- You really have no other options if you want to write RPG SQL code. When you compile, I suggest you include *ALL debug views, so you can switch to the list view to see when the SQL CLI is invoked (although you still won’t get a clear idea of what SQL is being executed).
- JSP generates Java … but there’s an option to keep the java source that’s generated, so you can debug it directly. And the generated Java is fairly closely aligned with the JSP itself.
- EGL provides a very robust development environment, including debugger, that allows you to debug the written code instead of the generated code … but you need the tool perform the debugging and (I think) you can’t use a 3rd party JPDA debugger.
Now some might argue that a code ‘wizard’ is a code generator also … but I disagree. Wizards are supposed to give you a good starting point in the specific language … they are, at least in my experience, next to useless when it comes to ongoing maintenance.
What’s the alternative? Well, I would suggest that you invest in a developing a good framework for your system that doesn’t rely on code generators (wherever possible), build it with modern programming techniques, and heavily leverage modularization, so you have a good base to start with.