See your own 4GL translated, with an engineer alongside you.
A migration decision should not rest on somebody else's demonstration — nor on an evaluation that stalls because a JDK was the wrong version. We set the environment up with you, translate programs from your own estate, and leave you with a project that builds on your machine and a counted scope you can take to a board. Your source stays on your network throughout, and whatever is generated is yours to keep and run for ever, with no licence from us.
A conversation, not a download queue
Large Informix 4GL estates are a specialist market, and no two have evolved the same way. We would rather spend an hour understanding yours than have you spend a week guessing what the compiler will do with it.
We set it up with you
A JDK, Maven, the project scaffolded around your existing 4GL, and network access to the catalogue your programs declare. A working build on your machine, in a session or two, at no charge — the evaluation should test the compiler, not your patience with an unfamiliar toolchain.
Your own source, not a sample
We translate programs you choose from your estate. The only coverage figure worth anything is the one for your code, and you get it with the counted list of whatever needs a human decision.
Your source stays where it is
The compiler runs on your machine and reads your sources and your catalogue locally. Nothing is uploaded and nothing contacts us. If you would rather we did the run, that is an offer we make — never a condition.
What the evaluation actually looks like.
Three steps, and the first two cost you nothing but the time of the people in the room.
A conversation first. What the estate is, which programs matter, what the deadline is driving this, and what a good answer would have to prove. Half an hour is usually enough to tell whether there is anything here for you, and we will say so if there is not.
Then a setup session. We work through the environment
with you : a JDK, Maven, j4glc project scaffolded around
your existing 4GL, and reachability from that machine to the Informix
instance your programs declare. The output of the session is a minimal
project that builds and runs on your own machine, which is the thing
that makes everything after it self-service.
Then your own programs, against criteria agreed in advance. You choose them — ideally the awkward ones rather than the flattering ones. We translate them alongside you, read the Java together, and go through whatever the compiler marked for a human decision. You end with generated code you can show a Java developer who has never seen 4GL, and a counted scope you can put in front of a board.
One prerequisite for the run : translation reads the catalogue
of the database your program declares. A program that says
DATABASE stores needs that server reachable while it is
translated, since precision and scale are resolved at compile time
exactly as c4gl resolves them. A program that declares no
database translates with no server at all.
We agree what would count as proof before we start.
An evaluation that is not designed is usually an evaluation that fails for the wrong reason. A compiler pointed at three programs chosen at random, on a machine whose JDK is the wrong version, with no agreement about what a good result would look like, produces an outcome nobody can interpret — and the conclusion recorded internally is “we tried it, it did not work”, which is the one answer that helps neither of us.
So the first call ends with a written scenario. It is short, and it says four things :
Which programs
Chosen deliberately, not at random. Two or three that represent the estate : one that is ordinary, one that is awkward, and ideally one nobody wants to touch. Flattering programs prove nothing you can plan from.
What must match, and how exactly
Usually the arithmetic, to the cent, against what the original produces today for the same inputs. Sometimes a report, byte for byte. Naming this in advance is what turns a demonstration into a measurement.
What is out of scope
Constructs the compiler does not yet cover, screens you have already decided to replace, subsystems being retired anyway. Agreeing these up front stops the evaluation being judged on work nobody intends to do.
What the answer will be used for
A scope for a board, a technology choice between routes, or a decision about one subsystem. It changes what we measure, and it decides whether the output is a translated program or a counted queue with a plan behind it.
Then we run it together, and the result means something either way.
The point of writing it down is that both outcomes are useful. If the criteria are met, you have evidence rather than an impression, in a form that can go in front of people who were not in the room. If they are not, you know precisely which construct, which subsystem or which assumption is responsible — and so do we, which is usually the more valuable of the two results and occasionally the reason a feature gets built.
It also protects against the failure mode we see most : a tool used in a way it was not meant to be used, judged on the outcome. That is not a fair test of the compiler and it is not a fair use of your team's week. An hour of design at the start removes most of it.
Two stages, two names : the evaluation, then the assessment.
The evaluation is the guided stage this page describes, and it is free : the environment set up with you, programs you choose translated on your own machine, the criteria agreed in advance and then measured. It exists to answer one question — does this tooling do what the site says, on our code.
The assessment is the commercial stage that follows when the answer is worth acting on : a charged engagement over a representative slice of the estate that produces the full report below, priced in advance — and credited in full against the licence if you proceed. Free proof first, priced scope second, and a distinct name for each, so nobody meets a fee they were not told about.
What you hold at the end : the assessment report.
The evaluation runs as a pipeline over the source you chose — automated inventory, language-feature analysis, translation, compilation, differential execution against your own binaries — and what comes out the other end is a document written to be put in front of a board, not a demo that evaporates when the session ends. It contains :
- An application profile. The estate as measured — programs, modules, lines, call graph, the globals that couple subsystems, and the character encodings actually in use.
- A compatibility matrix. Which language features your source uses, and how each fared — translated, translated with a decision recorded, or counted for intervention.
- The translation results. The programs that translated and compiled automatically, and the generated Java itself, yours to read and keep.
- The intervention list. Every construct that needs a human decision, marked in place and counted per program — the work queue, not an adjective.
- Differential-test results. Output compared against your own 4GL binaries on the criteria we agreed before starting — the arithmetic to the cent, reports byte for byte.
- An effort estimate and a roadmap. The migration sized per wave from your own numbers, a recommended Java / GraalVM split per subsystem, and the commercial estimate beside it.
That is the funnel in one sentence : do not believe the compatibility claims — give the compiler a representative part of your application, and hold the evidence.
Or send us a program, and we will send back the Java.
Some organisations would rather see the output before installing anything, and some cannot get a JDK onto a machine without a change request. Send us a representative program and we will translate it and return the generated Java, with the marker list and our reading of what it means for the rest of your estate.
That is an offer rather than a requirement, and it is the only route where anything of yours reaches us. It is done under whatever confidentiality agreement you use, on programs you choose, and we would still rather you ran it yourself — the answer is more convincing when it comes off your own machine. The competing free tools ask for an upload before they will show you anything. We ask for nothing, and the compiler needs your catalogue locally in any case.
Getting a program through.
What you need on the machine, how much of the estate to expect, and whether it belongs in your build.
What do I need in place?
A JDK 21 or later, and network access from that machine to the Informix instance your 4GL names. Nothing else — no agent, no runtime licence, no infrastructure of ours. If either is awkward to arrange internally, say so on the call : working out how the compiler fits your environment is part of what the setup session is for.
How much of our estate will translate?
That is exactly what the evaluation answers, and it is why we would rather you measured it than took a number from us. Anything the compiler hands to a person is marked in place and counted, and the file translates and compiles around it — so what you get is a figure you can plan against, from your own code, on the first afternoon.
Can we put it in our build?
Yes. j4glc project scaffolds a Maven project around your existing 4GL, after which an ordinary mvn compile re-runs the translation over whatever changed and produces one runnable jar containing every program. The 4GL stays the source ; the build keeps the Java in step.
Your code, the scope and what follows.
Where the source goes, what happens at the end of the trial, and what to do when the estate is larger than one.
Do I have to send you our source code?
No. The compiler runs where your source already is, and we receive nothing unless you choose to send it. If you would prefer us to do the run, we will — on programs you pick, under your confidentiality agreement. And if you want a conversation without sending code at all, the most useful thing to send is the counted list of constructs the compiler marked for a human decision, which it produces for you.
What happens when the trial ends?
The compiler stops translating new 4GL. Everything it has already produced is unaffected : still yours, still running, still needing nothing from us. There is no deactivation, no phone-home, and nothing that reaches into a system you have deployed.
What if we need longer, or the estate is large?
Ask. The licence is a file we issue, so its length and scope are a conversation rather than a product tier, and a serious evaluation of a large estate is a reason to extend it rather than an exception to a rule.
Arrange an evaluation.
Tell us roughly what the estate is and we will suggest a time. The first call is half an hour and costs nothing ; the setup session that follows is ours to run and also costs nothing. Nobody has a line count to hand, so an estimate is fine — separating the live estate from old copies, dead modules and generated code is work we do with you, and it usually makes the number smaller.