Hello friends,
Perhaps this also explains why DBF is often prematurely dismissed as "obsolete," even though it can still be highly performant in a modern architecture—especially when using CDX and clear access interfaces. I’d like to add a practical perspective from my own experience, which only became fully clear to me much later.
In the past—with classic DBF/NTX setups—work was heavily state-dependent:
You’d open a DBF, keep it open, work with fixed work areas, set indexes, and rely on an implicit context. This worked well in desktop environments but had very real technical limitations.
A concrete example from practice:
We had DBFs with many NTX indexes—10, 12, or even 15 were not uncommon. Each index meant a separate file, in addition to the DBF itself. Back then, we quickly hit limits like:
- Maximum number of open files
- Directory limits (e.g., 256 files—no longer an issue today, but a real constraint back then)
- High administrative overhead for opening/closing files
- Increased error-proneness in crashes or interruptions
In multi-user environments, this became critical:
A failed access could leave the DBF and NTX out of sync—reindexing was a daily routine.
What only became clear to me later:
The real problem wasn’t DBF itself, but the access model.
NTX implicitly assumes:
- A running process
- A stable state
- Files kept open for extended periods
But as soon as you move toward services, web applications, and stateless access (open → read → close), this model falls apart.
This is where DBF/CDX makes a crucial technical difference:
- One index file per table
- Multiple indexes as tags
- Fewer open files
- Clearer structure
- Far more tolerant of frequent opening and closing
If you take it a step further and use DBF via a microservice, the picture changes entirely. The client no longer sees any state—only requests and responses. Locking, index selection, and transactions are fully handled by the service.
Pros and Cons from Practice
DBF/NTX
Pros:
- Very simple model
- Fast in single-user operation
- Well-suited for classic desktop applications
- Low barrier to entry
Cons:
- One index = one file
- Many open files for complex tables
- Highly state-dependent
- Prone to errors during crashes
- Poorly suited for web, services, and parallelism
- High maintenance overhead (reindexing)
DBF/CDX
Pros:
- One index file per table
- Multiple indexes as tags
- More robust in multi-user operation
- Better encapsulation
- More service- and web-friendly
- Lower file and lock overhead
Cons:
- Slightly more complex setup
- Less transparent for developers accustomed to NTX
- Clean architecture required to fully leverage advantages
DBF via Microservice (CDX-based)
Pros:
- Clear separation of data and access
- Stateless clients possible
- Full control over locking and transactions
- No DBF dependency in the client
- Excellent performance with controlled data volumes
Cons:
- Higher initial effort
- Requires specialized architecture and operational know-how
- Not an "out-of-the-box" standard like SQL servers
In retrospect, I’d say:
Many problems we once attributed to DBF were actually architecture problems—not format problems.
