Abl V12 Learning

Progress OpenEdge ABL 12 — v10 to v12 Migration Reference

Version: Progress OpenEdge 12.7 (May 2023)
Language: Advanced Business Language (ABL), also known as Progress 4GL
Scope: v10→v12 migration patterns and new v12 features

TL;DR Checklist

• VAR statement (12.3): VAR INT x = 0. replaces verbose DEFINE VARIABLE
• Compound operators (12.3): Use +=, -=, *=, /= for cleaner code
• Safe navigation (12.5): obj?:Property?:Method() avoids null checks
• CATCH/THROW (12.x): Replace ON ERROR with structured exception handling
• JSON support (11.x+): Use READ-JSON/WRITE-JSON instead of manual parsing
• Generic collections (12.5+): List<T>, SortedSet<T>, HashMap<K,V> replace linked lists
• ENUM type (12.x): Strongly typed named constants for safety
• PACKAGE-PRIVATE (12.2): Package-level encapsulation like Java
• Server-side joins (12.0): FOR EACH...JOIN reduces client round-trips
• INT64 (10.1B): 64-bit integers for large numeric values

When to Use This Skill

This reference is designed for:

• Migration engineers moving legacy ABL v10 codebases to v12
• ABL developers learning new v12 language features
• Code reviewers evaluating v12 patterns vs. v10 anti-patterns
• Architects designing systems with v12 capabilities

When NOT to Use This Skill

• For basic ABL procedural programming — use programming-abl-v10-learning
• For UI/widget programming — use programming-abl-v12-ui
• For OpenEdge server configuration — consult server documentation

Version History: 12.0 – 12.7

Six Major Pillars of Change (v10 → v12)

1. Language Ergonomics

The VAR shorthand, compound operators (+=, -=), and CHAR/INT keyword synonyms reduce boilerplate significantly.

/* v10 — Verbose */
DEFINE VARIABLE x AS INTEGER INITIAL 0.
DEFINE VARIABLE name AS CHARACTER INITIAL "".
ASSIGN x = x + 1.
ASSIGN name = name + " world".

/* v12 — Concise */
VAR INT x = 0.
VAR CHAR name = "".
x += 1.
name += " world".

2. OOP Maturity

Package-level access modifiers, property overriding, generics/collections, and the safe navigation operator (?:) bring ABL's OOP model closer to Java/C#.

3. Error Handling

Structured CATCH/THROW/FINALLY blocks (first available in 10.2B, fully developed by 12.x) replace the legacy ON ERROR + NO-ERROR model.

4. JSON Support

Complete JSON object model (JsonObject, JsonArray, ObjectModelParser) plus READ-JSON/WRITE-JSON on temp-tables and ProDataSets. JSON was completely absent in v10.

5. Generic Collections

Built-in generic collections (List<T>, SortedSet<T>, HashMap<TKey,TValue>) eliminate the need for custom linked-list patterns.

6. Infrastructure

64-bit sequences by default, multi-threaded database server, Docker support, OAuth2/SAML, TLS 1.3.

Quick Reference: What's New in v12

Complete Feature Comparison Table (v10 vs v12)

Version-by-Version Feature Table (v10.0B through v12.7)

Data Types

Full Data Type Table (v10 vs v12)

INT64 — 64-Bit Integer (Added v10.1B)

DEFINE VARIABLE id AS INT64 INITIAL 0.

/* Large values that overflow INTEGER */
id = 9000000000000000000.

/* Use in database fields for large sequences, snowflake IDs, etc. */
TABLE-SCHEMA myTable:
    DEFINE COLUMN myId AS INT64.
END TABLE-SCHEMA.

ENUM Type (New in v12)

The ENUM type provides strongly typed named constants with implicit class backing.

/* Define an enum type */
ENUM OrderStatus:
    PENDING.
    PROCESSING.
    SHIPPED.
    DELIVERED.
    CANCELLED.
END ENUM.

/* Use the enum */
VAR OrderStatus status = OrderStatus:PENDING.

/* Switch is type-safe */
SWITCH status:
    CASE OrderStatus:PENDING:
        DISPLAY "Waiting for processing".
    CASE OrderStatus:SHIPPED:
        DISPLAY "Out for delivery".
    DEFAULT:
        DISPLAY "Unknown status".
END SWITCH.

/* Iteration support */
FOREACH s IN OrderStatus:
    DISPLAY s / ENUM-NAME(s).
END.

Variable Declaration

The VAR Statement (New in 12.3)

The VAR statement is a concise alternative to DEFINE VARIABLE.

Basic syntax:

VAR TYPE name [AS subtype] [= expression].

Examples:

/* Basic declarations */
VAR INT count = 0.
VAR CHAR name = "".
VAR DECIMAL price = 99.99.
VAR LOGICAL isActive = TRUE.

/* With expressions */
VAR INT sum = 1 + 2 + 3.
VAR DATE today = TODAY.
VAR INTEGER length = LENGTH("hello").

/* With function calls */
VAR CHAR json = GET-TEMP-JSON().
VAR INTEGER count = GET-RECORD-COUNT().

/* With inline NEW (12.4+) */
VAR Customer customer = NEW Customer().
VAR JsonObject payload = NEW JsonObject().
VAR Progress.Collections.List<STRING> names = NEW Progress.Collections.List<STRING>().

/* Arrays */
VAR INT scores[5].
VAR CHAR items[?].

/* Multiple declarations */
VAR INT x = 0, y = 0, z = 0.

MUST NOT:

• Use VAR for database fields (only variables)
• Use VAR for temp-table definitions (use DEFINE TEMP-TABLE)
• Use VAR to shadow class properties or method parameters

CHAR and INT as Type Keywords (12.3+)

CHAR is now a full synonym for CHARACTER. INT is now a full synonym for INTEGER.

/* v10 */
DEFINE VARIABLE name AS CHARACTER.
DEFINE VARIABLE count AS INTEGER.

/* v12 */
VAR CHARACTER name.
VAR INT count.

/* Also valid (12.3+) */
VAR CHAR name.
VAR INT count.

Compound Operators (12.3+)

Compound assignment operators reduce boilerplate for common operations.

VAR INT x = 0.
VAR CHAR text = "Hello".
VAR DECIMAL total = 100.00.

x += 1.      /* Same as: x = x + 1 */
x -= 5.      /* Same as: x = x - 5 */
x *= 2.      /* Same as: x = x * 2 */
x /= 3.      /* Same as: x = x / 3 */

text += " World".    /* Same as: text = text + " World" */

total += 50.00.      /* Same as: total = total + 50.00 */

Error Handling (v12 Model)

CATCH / THROW / FINALLY

v10 legacy pattern (anti-pattern):

/* v10 — Fragile, hard to trace */
ON ERROR UNDO, ERROR-HANDLER.

PROCESS-ORDER(orderNum IN):
    /* ... logic ... */
    IF NOT AVAILABLE order THEN
        THROW ERROR "Order not found".
    /* ... more logic ... */
END.

ERROR-HANDLER:
    /* Single handler for everything */
    DISPLAY ERROR-TEXT.
    RETURN.

v12 structured pattern:

/* v12 — Structured, explicit, testable */
PROCESS-ORDER(orderNum IN):
    ON ERROR UNDO, THROW.
    
    TRY
        VAR Order order = GET-ORDER(orderNum).
        
        IF order = ? THEN
            THROW NEW OrderNotFoundException("Order not found", orderNum).
            
        UPDATE-ORDER(order).
        COMMIT.
        
    CATCH OrderNotFoundException AS e:
        LOGGER:WARN("Order {1} not found", orderNum).
        RETURN FALSE.
        
    CATCH Progress.Lang.Exception AS e:
        LOGGER:ERROR("Error processing order {1}: {2}", orderNum, e:Message).
        RETURN FALSE.
        
    FINALLY:
        /* Always runs — cleanup here */
        RELEASE-LOCK(orderNum).
    END.
    
    RETURN TRUE.
END.

Key principles:

1. Use ON ERROR UNDO, THROW at procedure/block level
2. Use TRY/CATCH/FINALLY for structured exception handling
3. Define custom exception classes for domain errors
4. Catch specific exceptions before general ones
5. Use FINALLY for cleanup code that must always run

Custom Exception Classes

/* Define a custom exception hierarchy */
CLASS acme.OrderException INHERITS Progress.Lang.Exception:
    CONSTRUCTOR PUBLIC OrderException(message AS STRING):
        SUPER(message).
    END CONSTRUCTOR.
END CLASS.

CLASS acme.OrderNotFoundException INHERITS acme.OrderException:
    DEFINE PRIVATE PROPERTY _orderId AS INTEGER.
    
    CONSTRUCTOR PUBLIC OrderNotFoundException(message AS STRING, orderId AS INTEGER):
        SUPER(message).
        _orderId = orderId.
    END CONSTRUCTOR.
    
    DEFINE PUBLIC PROPERTY OrderId AS INTEGER GET ONLY:
        GET():
            RETURN _orderId.
        END GET.
    END PROPERTY.
END CLASS.

/* Usage */
THROW NEW acme.OrderNotFoundException("Order not found", orderId).

JSON Support (New in 11.x, Enhanced in 12.x)

Reading JSON

/* Parse JSON string to JsonObject */
VAR CHAR jsonStr = ""{\"name\":\"John\",\"age\":30}\"".
VAR JsonObject obj = NEW JsonObject():LOAD-JSON(jsonStr).

/* Access properties */
DISPLAY obj:GetValue("name") AS CHARACTER.
DISPLAY obj:GetValue("age") AS INTEGER.

/* Read nested object */
VAR JsonObject address = obj:GetObject("address").
DISPLAY address:GetValue("city") AS CHARACTER.

Writing JSON

/* Build JsonObject programmatically */
VAR JsonObject user = NEW JsonObject().
user:Put("name", "John").
user:Put("age", 30).
user:Put("active", TRUE).

/* Convert back to string */
VAR CHAR jsonStr = user:GET-JSON().
DISPLAY jsonStr.
/* Output: {"age":30,"name":"John","active":true} */

READ-JSON / WRITE-JSON (11.x+)

DEFINE TEMP-TABLE ttUser
    FIELD id AS INTEGER
    FIELD name AS CHARACTER
    FIELD email AS CHARACTER
    FIELD active AS LOGICAL.

/* Populate temp-table */
CREATE ttUser.
ASSIGN ttUser/id = 1
       ttUser/name = "John"
       ttUser/email = "john@example.com"
       ttUser/active = TRUE.

/* Write temp-table to JSON */
VAR CHAR userJson = "".
WRITE-JSON(ttUser, userJson).

/* Read JSON back into temp-table */
DEFINE TEMP-TABLE ttUser2
    FIELD id AS INTEGER
    FIELD name AS CHARACTER
    FIELD email AS CHARACTER  
    FIELD active AS LOGICAL.

READ-JSON(ttUser2, userJson).
DISPLAY ttUser2/name.

JsonArray

VAR JsonArray arr = NEW JsonArray().
arr:Add("Apple").
arr:Add("Banana").
arr:Add("Cherry").

/* Access by index */
DISPLAY arr:GetValue(0) AS CHARACTER.  /* Apple */

/* Iterate */
FOREACH i FROM 1 TO arr:Count:
    DISPLAY arr:GetValue(i - 1) AS CHARACTER.
END.

/* Convert to JSON string */
VAR CHAR jsonArr = arr:GET-JSON().

Generic Collections (12.5+)

List

VAR Progress.Collections.List<STRING> names = NEW Progress.Collections.List<STRING>().

names:Add("Alice").
names:Add("Bob").
names:Add("Charlie").

/* Access by index (0-based) */
DISPLAY names:Get(0) AS CHARACTER.  /* Alice */

/* Modify */
names:Set(1, "Robert").

/* Remove */
names:Remove("Charlie").

/* Count */
DISPLAY names:Count.  /* 2 */

/* Contains check */
IF names:Contains("Alice") THEN
    DISPLAY "Found Alice".
    
/* Clear */
names:Clear().

SortedSet

VAR Progress.Collections.SortedSet<STRING> uniqueNames = NEW Progress.Collections.SortedSet<STRING>().

uniqueNames:Add("Charlie").
uniqueNames:Add("Alice").
uniqueNames:Add("Bob").
/* Adding duplicate returns FALSE */
uniqueNames:Add("Alice").  /* Returns FALSE, not added */

/* Automatically sorted */
DISPLAY uniqueNames:First() AS CHARACTER.  /* Alice */
DISPLAY uniqueNames:Last() AS CHARACTER.   /* Charlie */

HashMap<TKey, TValue>

VAR Progress.Collections.HashMap<STRING, INTEGER> ages = NEW Progress.Collections.HashMap<STRING, INTEGER>().

ages:Put("Alice", 30).
ages:Put("Bob", 25).
ages:Put("Charlie", 35).

/* Get value */
VAR INT aliceAge = ages:Get("Alice").
DISPLAY aliceAge.  /* 30 */

/* Check if key exists */
IF ages:ContainsKey("Bob") THEN
    DISPLAY "Bob is in the map".

/* Remove entry */
ages:Remove("Charlie").

/* Count */
DISPLAY ages:Count.  /* 2 */

HASH-CODE Function (12.7+)

/* Generate hash code for objects or values */
VAR INT hash1 = HASH-CODE("hello").
VAR INT hash2 = HASH-CODE("hello").
DISPLAY hash1 = hash2.  /* TRUE - same input produces same hash */

/* Multi-argument hash */
VAR INT combined = HASH-CODE("firstName", "lastName", 12345).

/* Useful for custom Equals implementations and hash-based collections */

OOP Features

PACKAGE-PRIVATE / PACKAGE-PROTECTED Access (12.2+)

Package-level access modifiers allow sharing between classes in the same namespace.

/* File: acme/Base.cls */
CLASS acme.Base:
    DEFINE PRIVATE PROPERTY _private AS STRING.
    DEFINE PACKAGE-PRIVATE PROPERTY _packageLevel AS STRING.
    DEFINE PACKAGE-PROTECTED PROPERTY _protected AS STRING.
    DEFINE PUBLIC PROPERTY Public AS STRING.
END CLASS.

/* File: acme/Sibling.cls - Same package */
CLASS acme.Sibling:
    METHOD PUBLIC VOID AccessBase(base AS acme.Base):
        /* base:_private      - ERROR: cannot access */
        base:_packageLevel = "shared".    /* OK: same package */
        base:_protected = "inherited".    /* OK: package-protected */
    END METHOD.
END CLASS.

/* File: other/Outside.cls - Different package */
CLASS other.Outside:
    METHOD PUBLIC VOID AccessBase(base AS acme.Base):
        /* base:_private      - ERROR: cannot access */
        /* base:_packageLevel - ERROR: different package */
        /* base:_protected    - ERROR: different package */
        base:Public = "public".           /* OK: public */
    END METHOD.
END CLASS.

Safe Navigation Operator ?: (12.5+)

Eliminates verbose null checks when accessing nested properties.

/* v10/v11 — Verbose null checking */
VAR Customer cust = GET-CUSTOMER(id).
IF cust <> ? THEN
    IF cust:Address <> ? THEN
        IF cust:Address:City <> ? THEN
            DISPLAY cust:Address:City:Name.
        END.
    END.
END.

/* v12.5+ — Concise safe navigation */
VAR CHAR cityName = GET-CUSTOMER(id)?:Address?:City?:Name ?? "Unknown".
DISPLAY cityName.

Override Non-Abstract Properties (12.5+)

Prior to 12.5, only abstract properties could be overridden. Now any non-final property can be overridden.

/* Base class with concrete property */
CLASS acme.Base:
    DEFINE PUBLIC PROPERTY Value AS STRING GET. SET.
END CLASS.

/* Override with coded getter/setter (12.5+) */
CLASS acme.Derived INHERITS acme.Base:
    DEFINE PRIVATE PROPERTY _value AS STRING.
    
    DEFINE PUBLIC PROPERTY OVERRIDE Value AS STRING GET. SET.
    END PROPERTY.
    
    GET():
        RETURN UPPER(_value).
    END GET.
    
    SET(newValue AS STRING):
        _value = LOWER(newValue).
    END SET.
    
END PROPERTY.
END CLASS.

FINAL Properties (12.5+)

Prevent property overriding in subclasses.

CLASS acme.FinalBase:
    DEFINE FINAL PUBLIC PROPERTY Immutable AS STRING GET. SET.
END CLASS.

CLASS acme.FinalDerived INHERITS acme.FinalBase:
    /* This would cause a compile error:
    DEFINE PUBLIC PROPERTY OVERRIDE Immutable AS STRING... 
    */
END CLASS.

Server-Side Joins (12.0+)

Basic Server-Side Join

/* v10 — Client-side join (slow) */
FOR EACH Customer NO-LOCK:
    FOR EACH Order WHERE Order.CustId = Customer.Id NO-LOCK:
        /* Process each combination */
    END.
END.

/* v12 — Server-side join (fast) */
FOR EACH Customer NO-LOCK
    JOIN Order WHERE Order.CustId = Customer.Id NO-LOCK:
        /* Database performs the join */
    END.
END.

Multiple Table Joins

/* Server-side join up to 10 tables */
FOR EACH Customer NO-LOCK
    JOIN Order WHERE Order.CustId = Customer.Id NO-LOCK
    JOIN OrderItem WHERE OrderItem.OrderId = Order.Id NO-LOCK
    JOIN Product WHERE Product.Id = OrderItem.ProductId NO-LOCK:
        
    DISPLAY Customer.Name,
            Order.OrderDate,
            OrderItem.Quantity,
            Product.Name,
            OrderItem.UnitPrice * OrderItem.Quantity AS Total.
END.

Migration Checklist (v10 → v12)

Language Modernization

• Replace DEFINE VARIABLE x AS INTEGER with VAR INT x
• Replace DEFINE VARIABLE x AS CHARACTER with VAR CHAR x
• Use compound operators: x += 1 instead of x = x + 1
• Use CHAR/INT keywords instead of CHARACTER/INTEGER where appropriate

Error Handling Migration

• Replace ON ERROR blocks with TRY/CATCH/FINALLY
• Create custom exception classes for domain errors
• Remove NO-ERROR flags; use structured error handling
• Add FINALLY blocks for cleanup code

JSON Migration

• Replace manual JSON string parsing with JsonObject:LOAD-JSON()
• Use READ-JSON/WRITE-JSON for temp-table serialization
• Replace SERIALIZE-ROW(..., "XML") with SERIALIZE-ROW(..., "JSON")

Collections Migration

• Replace linked list patterns with List<T>
• Replace sorted array patterns with SortedSet<T>
• Replace custom hash maps with HashMap<TKey, TValue>
• Use HASH-CODE() for custom object hashing

OOP Improvements

• Replace VALID-OBJECT() chains with safe navigation ?:
• Use PACKAGE-PRIVATE for package-level encapsulation
• Consider FINAL on properties that should not be overridden
• Override non-abstract properties where needed (12.5+)

Database Improvements

• Convert client-side nested FOR EACH loops to server-side JOINs
• Review sequence fields for INT64 compatibility
• Consider AGGREGATE statement for server-side aggregations

Related Skills

References

• Progress OpenEdge 12.7 Documentation
• ABL Language Reference
• OpenEdge Developer Studio

Compiled from official Progress OpenEdge 12.7 documentation. Last updated: May 2023

When to Use

Use this skill when:

• Implementing or analyzing algorithms — You need to understand, implement, or optimize algorithms for a specific problem domain
• Comparing algorithmic approaches — You are evaluating different algorithms for correctness, performance, or trade-offs
• Studying computational patterns — You need reference implementations and complexity analysis for standard algorithmic patterns

Core Workflow

1. Understand the Problem — Identify inputs, outputs, constraints, and edge cases. Checkpoint: Clearly define the problem statement and expected behavior.

2. Select Algorithm — Choose the most appropriate algorithm based on constraints (time/space complexity, data size, ordering requirements). Checkpoint: Justify the algorithm choice with complexity analysis.

3. Implement & Test — Write clean, readable code with type hints, docstrings, and edge case handling. Checkpoint: Verify correctness with multiple test cases including edge cases.

4. Analyze & Optimize — Review time/space complexity, identify optimization opportunities, and validate against benchmarks. Checkpoint: Confirm complexity bounds match analysis and all test cases pass.

Constraints

MUST DO

• Include time and space complexity analysis for all algorithms
• Show at least one working example with input/output
• Include diagrams for non-trivial algorithm flows

MUST NOT DO

• Present an algorithm without its complexity bounds
• Use recursive solutions without discussing tail-call or memoization alternatives
• Omit edge case handling in examples