In 2011, I walked into a job interview for a developer position.
When they asked if I knew Progress, I said yes — thinking they meant PostgreSQL.

They didn’t.
It wasn’t.
And that misunderstanding ended up shaping an entire chapter of my career.

What started as confusion became my primary development environment for years. While the tech world talked about open stacks, huge communities, and fast-moving ecosystems, I stepped into a parallel universe where almost everything revolved around a single platform, a single vendor, and a very particular way of thinking about software.

For a long time, I saw it as a disadvantage. Today, I see it as an uncomfortable but important part of how I grew as an engineer.

The Parallel World

Working with Progress OpenEdge wasn’t just using a different database or language. It meant entering a complete ecosystem — fairly closed, with its own tools, rules, and philosophy.

While the outside world was discussing:

  • REST APIs
  • microservices
  • open-source communities
  • stacks evolving every year

I was working with:

  • ABL
  • AppServers
  • a database tightly coupled to the language
  • and a much smaller, quieter community

The constant feeling was being outside the global tech conversation. Not because we weren’t building real systems — we were — but because we were doing it on an island.

The Frustration (and What Wasn’t Said)

Some things weighed heavily:

  • Documentation that was hard to navigate
  • A small community to learn from
  • Strong vendor lock-in
  • Difficulty translating that experience into the broader job market
  • A pace of evolution that didn’t match what was happening outside

This wasn’t just a technical issue. It was professional.
You felt like you were growing — but along an axis the rest of the industry barely noticed.

For years, I thought the problem was the technology itself.

Eventually, I realized it wasn’t that simple.

The Uncomfortable Part to Admit

ABL had good ideas.

It took me years to say that without resistance.

Statements like:

  • FOR EACH
  • FIND FIRST
  • record buffers
  • the tight integration between business logic and data access

were incredibly comfortable for certain types of applications. For record-oriented business logic, they often felt more natural and expressive than writing raw SQL mixed with another language.

It wasn’t technical incompetence.
It was a different mental model.

The problem wasn’t the paradigm.

The problem was isolation.

It Didn’t Die for Being Useless — It Drifted Away

Over time, I noticed something: many technologies don’t disappear because they’re bad. They fade because they no longer belong to the ecosystem where the industry moves.

Progress OpenEdge became trapped in:

  • a small community
  • strong vendor dependency
  • limited integration with the open world
  • difficulty evolving at the pace of the broader market

That doesn’t invalidate the ideas.
But it does affect survival.

This wasn’t a technical collapse.
It was an ecosystem and cultural mismatch.

The Transition

When I started working with other technologies — Node, cloud platforms, modern architectures — I didn’t stop comparing everything to what I had seen in ABL.

But the tone changed. It wasn’t frustration anymore. It was curiosity:

What if these ideas existed in an open environment?
What if a data-oriented language model wasn’t tied to a single vendor?

I realized something important:
I didn’t want to escape what I had learned. I wanted to reinterpret it.

LiteABL: Not a Replacement, but Closure

Building a PoC runtime inspired by ABL ideas didn’t come from anger or nostalgia. It came from technical curiosity and a personal need for closure.

It’s not a competitor.
It’s not a replacement.
It’s not a commercial product.

It’s a question written in code.

If you’re curious, the experiment lives here:
👉 https://github.com/osgioia/liteabl/

Can we keep the ideas without carrying the closed ecosystem around them?

For me, this project isn’t the beginning of something. It’s the end of something.

Closing a Chapter

Progress was my technical school, even when I wanted to leave it. It forced me to think differently, to understand models that weren’t trendy, to solve problems in a context I didn’t choose but that still shaped me.

Today, I don’t want to stay there.
But I also don’t want to pretend it didn’t matter.

That misunderstanding in a 2011 interview ended up defining years of my professional life. LiteABL isn’t a rebellion against that past. It’s my way of closing the cycle while understanding everything that happened along the way.

Maybe the product is in decline.
But the ideas were never worthless.

And I carried some of them with me.