Informix-4GL

Informix-4GL (often written I-4GL) is a fourth-generation programming language released in 1986 for building database applications on top of the Informix database engine. Rather than treating data access, screen handling, and reporting as separate libraries bolted onto a general-purpose language, Informix-4GL folds all three into the language itself: SQL statements are written inline as first-class syntax, screen forms are described declaratively and driven by dedicated INPUT and DISPLAY statements, and a built-in report writer turns query results into formatted output. For roughly a decade it was one of the dominant tools for writing character-based business software on UNIX, and a substantial body of that code is still in production today.

History & Origins

Relational Database Systems (1980)

The language traces back to Relational Database Systems (RDS), founded by Roger Sippl in 1980. The company built a line of relational database products and tools, and in 1986 renamed itself Informix Corporation after its flagship product, going public the same year. Informix-4GL grew out of the company’s earlier character-based tooling (the Informix SQL/ISQL family of form and report utilities), generalizing those capabilities into a full programming language.

The 4GL Project (1985–1986)

Development of Informix-4GL began in 1985, with Chris Maloney as chief architect; Roy Harrington, another key figure of the era, led the closely related Informix Turbo (later OnLine) database engine rather than the 4GL language itself. The language was first released in February 1986. At launch it targeted the UNIX systems common in that era, reportedly including Microsoft Xenix on the IBM PC AT, DEC Ultrix on VAX hardware, the Altos 2086, and several AT&T 3B-series and AT&T Unix PC machines. Over the following years support expanded to commercial UNIX variants such as AIX, HP-UX, IRIX, Solaris, and Tru64, and later to Linux.

Corporate Journey: Informix → IBM → HCL

Informix Corporation grew into a major database vendor through the late 1980s and 1990s. After a turbulent period, IBM acquired Informix’s database business in July 2001 for approximately $1 billion, and the language was rebranded IBM Informix-4GL. IBM treated 4GL as a mature, legacy technology and pointed customers toward graphical successors. In April 2017, IBM delegated active development, sales, and support of the Informix product family — including 4GL — to HCL under a long-term agreement, while IBM retained ownership. HCL has continued to maintain the product, with version 7.51 reported as the current release.

Design Philosophy

Informix-4GL embodies the central premise of the fourth-generation language movement: raise the level of abstraction so that a developer expresses what a business application should do — query this table, present this form, print this report — with far less code than a third-generation language like C or COBOL would require.

Its guiding ideas include:

• SQL as a first-class citizen — SELECT, INSERT, UPDATE, and DELETE are written directly in program source, not passed as strings to a library call.
• Declarative screens — form layouts live in separate specification files, and the language provides high-level statements to bind database columns to screen fields and to drive data entry.
• Reporting as a language construct — a dedicated REPORT block with format sections (page headers, every-row, control breaks, totals) handles pagination and aggregation that would otherwise be tedious to code by hand.
• Database-aware typing — variables can be declared LIKE a table column, so a program’s data structures track the schema and stay consistent with it.

Key Features

Embedded SQL

SQL is part of the language. A program connects to a database with DATABASE and then issues queries whose results flow into program variables or cursors:

MAIN
    DEFINE p_customer RECORD LIKE customer.*

    DATABASE stores

    DECLARE c_list CURSOR FOR
        SELECT * FROM customer WHERE state = "CA"

    FOREACH c_list INTO p_customer.*
        DISPLAY p_customer.fname CLIPPED, " ", p_customer.lname CLIPPED
    END FOREACH
END MAIN

The RECORD LIKE customer.* declaration ties the variable’s structure to the customer table, a hallmark of the language’s database-aware typing.

Screen Forms

User interfaces are character-based forms described in a separate form specification file (.per), then compiled and driven from program logic:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

DATABASE stores
SCREEN
{
    Last name:  [f000             ]
    State:      [f1]
}
ATTRIBUTES
f000 = customer.lname;
f1   = customer.state;
END

OPEN FORM custform FROM "custform"
DISPLAY FORM custform

INPUT BY NAME p_customer.lname, p_customer.state
    AFTER FIELD lname
        IF p_customer.lname IS NULL THEN
            ERROR "Last name is required"
            NEXT FIELD lname
        END IF
END INPUT

The INPUT statement handles field navigation, validation hooks (BEFORE FIELD, AFTER FIELD), and editing keys, freeing the developer from writing a terminal input loop.

The Report Writer

Reports are written as REPORT routines with declarative FORMAT sections. The runtime handles pagination, control breaks, and aggregation:

REPORT cust_report(r_cust)
    DEFINE r_cust RECORD LIKE customer.*

    FORMAT
        PAGE HEADER
            PRINT COLUMN 1, "Customer Listing"
            SKIP 1 LINE

        ON EVERY ROW
            PRINT r_cust.lname CLIPPED, COLUMN 30, r_cust.state

        ON LAST ROW
            SKIP 1 LINE
            PRINT "Total customers: ", COUNT(*) USING "<<<,<<&"
END REPORT

Data is fed to a report with OUTPUT TO REPORT, and the format sections fire automatically as rows pass through.

Procedural Core and C Interoperability

Beyond data, forms, and reports, the language provides a deliberately compact procedural core: FUNCTION definitions with parameters and return values, control flow (IF/CASE/WHILE/FOR/FOREACH), arrays, and records. For anything outside the 4GL’s scope, it can call C functions, and C programs can in turn call into 4GL — a bridge that let teams drop down to a lower level when needed.

FUNCTION full_name(fname, lname)
    DEFINE fname, lname CHAR(15)
    DEFINE result CHAR(32)

    LET result = fname CLIPPED, " ", lname CLIPPED
    RETURN result
END FUNCTION

Two Compilation Models: C Compiler vs. RDS

A defining technical characteristic of Informix-4GL is that the same source can be built two different ways:

The RDS path, with its interactive debugger and quick turnaround, suited development and iteration; the C Compiler path was often used for production deployment where raw speed mattered.

Common File Types

Evolution

Informix-4GL evolved steadily rather than dramatically — appropriate for a language whose value rested on stability for long-lived business systems. The product line moved through major releases including the 6.x series around 1996 and the 7.x series (7.2 in 1998, then 7.31, 7.32, and 7.50), with HCL continuing the line into the 7.51 range. Throughout, the core language stayed recognizable: a 1986 program’s structure is still legible to a modern Informix-4GL developer.

The most significant strategic shift was not to the language itself but to its front-end story. Character terminals gave way to graphical desktops and, later, the web. In May 1998 Informix partnered with Four Js Development Tools, whose suite offered near-complete 4GL source compatibility; Informix sold this as Informix Dynamic 4GL (D4GL). Four Js subsequently introduced Genero in 2003, an object-based, XML-driven evolution that renders 4GL-style business logic across graphical, web, and mobile clients, and IBM endorsed Genero as a successor path in 2004. This lineage is how a large amount of original 4GL logic survives today: not rewritten, but recompiled and re-presented through Genero or compatible tools.

Current Relevance

Informix-4GL is firmly in the “legacy but living” category. It is no longer a tool anyone reaches for to start a new application, yet a great deal of mission-critical software written in it continues to run, particularly in enterprise back-office, government, and utility systems. That installed base sustains an ecosystem oriented around maintenance and migration:

• HCL Informix 4GL remains officially maintained for customers running on the Informix database.
• Four Js Genero BDL offers a commercial path to modernize 4GL code with graphical and web interfaces while preserving the original business logic.
• Aubit 4GL, an open-source (GPL) compiler aiming at Informix-4GL compatibility, helps keep existing codebases buildable and runnable on modern Linux.
• Querix 4GL is another commercial implementation in the broader “x4GL” family of compatible dialects.

Why It Matters

Informix-4GL is a clear, influential example of the 4GL idea taken seriously and shipped at scale. Several aspects give it lasting significance:

1. It made the database the center of the language. Embedding SQL as syntax, and letting variables be declared LIKE a column, anticipated the tight language-database integration that later tools and ORMs would chase from the opposite direction.
2. It bundled the whole application. Data access, screen forms, and reporting in one language meant a small team could build a complete business system quickly — a productivity argument that still drives low-code and full-stack platforms today.
3. It demonstrated graceful aging. Through the dual C-Compiler/RDS model and the later Genero lineage, 4GL code proved unusually portable across hardware, build strategies, and even presentation layers, which is a large part of why so much of it is still running.
4. It anchored a family of dialects. The x4GL ecosystem — Genero BDL, Aubit 4GL, Querix 4GL — exists specifically because Informix-4GL defined a syntax and model worth staying compatible with for decades.

Informix-4GL stands as a reminder that a focused, domain-specific language built around a clear job — getting data on and off a screen and onto paper — can outlast far flashier general-purpose technologies.