Abl V12 Learning

---




name: abl-v12-learning
compatibility: opencode
completeness: 95
content-types:
- code
- guidance
- examples
- diagrams
description: '"Reference guide for Progress OpenEdge ABL 12.7 (2023) — v10→v12 migration"
  INT64, ENUM, VAR shorthand, CATCH/THROW/FINALLY, JSON support, generic collections,
  safe navigation operator, server-side joins'
license: MIT
maturity: stable
metadata:
  domain: programming
  output-format: code
  related-skills: abl-v10-learning, algorithms
  role: reference
  scope: implementation
  triggers: abl v12, openedge 12, abl 12.7, v10 to v12 migration, abl migration, catch
    throw, jsonobject, read-json
  archetypes:
  - educational
  anti_triggers:
  - brainstorming
  - vague ideation
  response_profile:
    verbosity: medium
    directive_strength: medium
    abstraction_level: tactical
version: "1.0.0"




---




# 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

| Version | Release | Key Theme |
|---------|---------|-----------|
| **12.0** | 2019 | Server-side joins, Docker, 64-bit sequences default, STOP catchable by default |
| **12.1** | 2020 | High availability, performance, security enhancements |
| **12.2** | 2020 | `PACKAGE-PRIVATE`/`PACKAGE-PROTECTED` access, AES-GCM encryption, Docker DB |
| **12.3** | 2021 | `VAR` statement, compound operators (`+=`, `-=`), `CHAR`/`INT` full synonyms |
| **12.4** | 2022 | `VAR` with inline `NEW`, expression initialization, `AGGREGATE` statement |
| **12.5** | 2022 | `List<T>`, safe navigation `?:`, override non-abstract properties, `FINAL` on properties |
| **12.6** | 2023 | `SortedSet<T>`, Java 17 support, TLS 1.3, `LeakCheck` diagnostics |
| **12.7** | May 2023 | `HashMap<K,V>`, `HASH-CODE()`, `.NET 6`, signed archive libraries |

---

## Six Major Pillars of Change (v10 → v12)

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

```abl
/* 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)

| Category | v10 | v12 | Status |
|----------|-----|-----|--------|
| **INT64 data type** | ❌ Not available | ✅ `DEFINE VARIABLE x AS INT64` | Added in v10.1B |
| **ENUM type** | ❌ Not available | ✅ `ENUM` statement | New in v12+ |
| **VAR shorthand** | ❌ Must use `DEFINE VARIABLE` | ✅ `VAR INT x = 0.` | New in 12.3 |
| **Compound operators** | ❌ `x = x + 1` | ✅ `x += 1` | New in 12.3 |
| **PACKAGE-PRIVATE access** | ❌ Not available | ✅ `PACKAGE-PRIVATE` / `PACKAGE-PROTECTED` | New in 12.2 |
| **Override non-abstract properties** | ❌ Only abstract | ✅ Any non-final property | New in 12.5 |
| **Safe navigation `?:`** | ❌ Must use VALID-OBJECT checks | ✅ `obj?:Property?:Method()` | New in 12.5 |
| **Generic collections** | ❌ Not available | ✅ `List<T>`, `SortedSet<T>`, `HashMap<K,V>` | 12.5–12.7 |
| **CATCH / THROW / FINALLY** | ❌ Not in v10 (added 10.2B) | ✅ Full structured exception handling | Fully mature in v12 |
| **BLOCK-LEVEL ON ERROR UNDO, THROW** | ❌ Not available | ✅ Single directive covers all blocks | New post-v10 |
| **JSON support** | ❌ None | ✅ `JsonObject`, `JsonArray`, `READ-JSON`, `WRITE-JSON` | New in 11.x |
| **SAX callbacks via OO class** | ❌ Procedure-only | ✅ `EVENT-HANDLER-OBJECT` | Improved in v12 |
| **DYNAMIC-INVOKE()** | ⚠️ Limited | ✅ Full class-method dynamic invocation | Improved in v12 |
| **SERIALIZE-ROW() for JSON** | ❌ XML only | ✅ JSON + XML targets | New in v12 |
| **STOP as catchable object** | ⚠️ Required `-catchStop` flag | ✅ Default behavior — CATCH/FINALLY fire | Changed in 12.0 |
| **64-bit sequences** | ⚠️ Optional | ✅ Default for new databases | Changed in 12.0 |
| **Methods as async callbacks** | ❌ Procedures only | ✅ Class methods as `EVENT-HANDLER` | New in 12.3 |
| **Server-side joins** | ❌ Not available | ✅ FOR+NO-LOCK, up to 10 tables | New in 12.0 |
| **`HASH-CODE` function** | ❌ Not available | ✅ `HASH-CODE(arg1, arg2)` | New in 12.7 |
| **`FINAL` on properties** | ❌ Not available | ✅ Prevent subclass override | New in 12.5 |
| **`AGGREGATE` statement** | ❌ Not available | ✅ Server-side aggregation | New in 12.4 |

---

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

| Feature | Introduced | Category |
|---------|-----------|----------|
| `DATETIME` data type | v10.0B | Data Types |
| `DATETIME-TZ` data type | v10.0B | Data Types |
| `BLOB` / `CLOB` field types | v10.0B | Data Types |
| `LONGCHAR` data type | v10.0B | Data Types |
| `INT64` data type | v10.1B | Data Types |
| `CLASS` / `INTERFACE` OOP | v10 | OOP |
| `CATCH` / `THROW` / `FINALLY` | 10.2B | Error Handling |
| JSON (`JsonObject`, `JsonArray`, `READ-JSON`, `WRITE-JSON`) | 11.x | JSON |
| `Progress.IO.MemoryOutputStream` / `MemoryInputStream` | **12.0** | I/O |
| `STOP` catchable by default (no `-catchStop` needed) | **12.0** | Error Handling |
| Indeterminate array resize without data loss | **12.0** | Language |
| 64-bit sequences enabled by default (new DBs) | **12.0** | Database |
| Server-side joins (FOR + NO-LOCK, up to 10 tables) | **12.0** | Database |
| `PACKAGE-PRIVATE` access modifier | **12.2** | OOP |
| `PACKAGE-PROTECTED` access modifier | **12.2** | OOP |
| Methods as socket / SAX callbacks | **12.2** | OOP |
| `require-return-values` compiler option | **12.2** | Compiler |
| AES-GCM encryption in ABL | **12.2** | Security |
| OpenEdge Application Archive (`.oear`) | **12.2** | CI/CD |
| `VAR` statement (shorthand `DEFINE VARIABLE`) | **12.3** | Language |
| `CHAR` and `INT` as full type keywords | **12.3** | Language |
| Compound operators (`+=`, `-=`, `*=`, `/=`) | **12.3** | Language |
| Runtime resize of initialized indeterminate arrays | **12.3** | Language |
| Methods as `RUN ... ASYNC` callbacks | **12.3** | OOP |
| Methods as SAX-READER callbacks | **12.3** | XML |
| `VAR` with expressions and function calls | **12.4** | Language |
| `VAR` with inline `NEW` | **12.4** | Language |
| `AGGREGATE` statement (server-side aggregation) | **12.4** | Database |
| Override non-abstract properties | **12.5** | OOP |
| `FINAL` on properties | **12.5** | OOP |
| Safe navigation operator `?:` | **12.5** | Language |
| `Progress.Collections.List<T>` | **12.5** | Collections |
| Generic type syntax `<T>` | **12.5** | Language |
| `Progress.Collections.SortedSet<T>` | **12.6** | Collections |
| `OpenEdge.Core.Util.LeakCheck` class | **12.6** | Diagnostics |
| Java 17 support | **12.6** | Platform |
| `Progress.Collections.HashMap<TKey, TValue>` | **12.7** | Collections |
| `HASH-CODE` function | **12.7** | Language |
| Signed Archive Libraries (`.apl`) | **12.7** | Deployment |
| `.NET 6` support on Windows | **12.7** | Platform |
| `ABL Type Hierarchy View` in Developer Studio | **12.7** | Tooling |

---

## Data Types

### Full Data Type Table (v10 vs v12)

| Data Type | v10 | v12 | Notes |
|-----------|:---:|:---:|-------|
| `CHARACTER` | ✅ | ✅ | Max 32,767 bytes. Default `""`. Keyword alias `CHAR` (v12.3+). |
| `LONGCHAR` | ✅ | ✅ | Up to 2 GB − 1 byte. Code-page aware. |
| `INTEGER` | ✅ | ✅ | 32-bit signed: −2,147,483,648 to +2,147,483,647. Default `0`. Keyword alias `INT` (v12.3+). |
| `INT64` | ❌ | ✅ | 64-bit signed: −9,223,372,036,854,775,808 to +9,223,372,036,854,775,807. Default `0`. **Added v10.1B.** |
| `DECIMAL` | ✅ | ✅ | Up to 50 significant digits, up to 10 decimal places. Default `0`. |
| `LOGICAL` | ✅ | ✅ | TRUE/FALSE/YES/NO/Unknown(?). Default `NO`. |
| `DATE` | ✅ | ✅ | 1/1/32768 BC to 12/31/32767 AD. Default `?`. |
| `DATETIME` | ✅ | ✅ | DATE + milliseconds from midnight. Local time. Default `?`. **Added v10.0B.** |
| `DATETIME-TZ` | ✅ | ✅ | DATETIME + UTC offset. Stored in UTC. Default `?`. **Added v10.0B.** |
| `RAW` | ✅ | ✅ | Binary, ≤ 32K. |
| `MEMPTR` | ✅ | ✅ | In-memory binary, up to 2 GB − 1 byte. |
| `ROWID` | ✅ | ✅ | Unique database record identifier. Preferred over RECID. |
| `RECID` | ✅ | ✅ | Legacy 32-bit record ID. Use ROWID instead. |
| `HANDLE` | ✅ | ✅ | Pointer to an ABL object/widget. Interchangeable with WIDGET-HANDLE. |
| `WIDGET-HANDLE` | ✅ | ✅ | Alias for HANDLE. |
| `COM-HANDLE` | ✅ | ✅ | ActiveX/COM object reference. |
| `BLOB` | ✅ | ✅ | Binary large object. DB/temp-table fields only. Up to 1 GB. **Added v10.0B.** |
| `CLOB` | ✅ | ✅ | Character large object. DB/temp-table fields only. Up to 1 GB. **Added v10.0B.** |
| `CLASS` | ✅ | ✅ | User-defined class object reference. Default `?`. |
| `ENUM` | ❌ | ✅ | Strongly typed named constants. Implicitly class-based. **New in v12.** |

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

```abl
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.

```abl
/* 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:**
```abl
VAR TYPE name [AS subtype] [= expression].
```

**Examples:**
```abl
/* 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`.

```abl
/* 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.

```abl
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):**
```abl
/* 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:**
```abl
/* 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

```abl
/* 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

```abl
/* 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

```abl
/* 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+)

```abl
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

```abl
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<T>

```abl
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<T>

```abl
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>

```abl
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+)

```abl
/* 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.

```abl
/* 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.

```abl
/* 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.

```abl
/* 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.

```abl
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

```abl
/* 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

```abl
/* 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

| Skill | Purpose |
|-------|--------|
| `programming-abl-v10-learning` | Original ABL v10 procedural programming reference |
| `programming-abl-v12-ui` | UI/widget programming in ABL 12 |

---

## References

- [Progress OpenEdge 12.7 Documentation](https://documentation.progress.com/output/oberon/enusoe1270index/)
- [ABL Language Reference](https://documentation.progress.com/output/oberon/enusoe1270lang/)
- [OpenEdge Developer Studio](https://documentation.progress.com/output/oberon/enusoe1270dds/)

---

*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