Universidad Adventista del Plata
Inherited systems
Two systems, two kinds of inheritance. One is a Progress 4GL desktop application that pays the university’s suppliers. The other is a modern web platform written by other developers. Since September 2026, both are my responsibility.
The problem
Proveedores is the accounts-payable system for two companies: suppliers, invoices, payments with tax withholdings, the purchase VAT book and the files sent to the tax authority and the banks. It is a Progress 4GL Windows client of about 53,000 lines in 77 sources, whose history lives in old RCS version-control files.
VID runs the university’s calls for research protocols: submission, methodological and scientific review, budget and vote. Other developers built it; I took it over as technical owner.
Constraints
- Nothing runs against production: analysis works from source code and schema definitions.
- The new accounts-payable system targets PostgreSQL 18, with a React and Vite front end.
- From June to November, VID only takes bug fixes.
What I built
Code-archaeology tools in Python — 182 lines in all: an extractor for RCS ,v history files, a parser for Progress .df schema definitions and a cross-reference of which program touches which table. Together they processed 1,789 files and 5,774 revisions.
A migration plan in three steps: load the legacy tables one-to-one into a staging schema, transform with SQL, and reconcile the totals against the old system.
A configuration-driven React and Vite prototype — generic list, report and process screens generated from config — shown to the accounting team with mock data two days after kickoff.
For VID: a reproducible local environment, documentation of the inherited codebase, a security review and a matrix tracing 20 user-reported bugs to their root causes.
The hard parts
Read
RCS history
1,789 files, 5,774 revisions
.df schemas
Real tables and fields
4GL sources
77 programs, ~53k lines
Map of tables, programs and history
Move
Staging
Legacy tables loaded one-to-one
Transform
Plain SQL
Reconcile
Totals checked against the old system
PostgreSQL 18
Reading 4GL without running it
With production off-limits, the only reliable sources were the code and the schema. The .df files gave the real tables and fields, the cross-reference showed which programs read and write them, and the revision history showed what changed and when. Seventy-seven opaque sources became a map.
Guarantees first
The rewrite starts from rules the database itself enforces: document numbers that stay correct under concurrent writes, money stored as exact decimals, and journal entries that must balance before they can be saved.
Root causes, not symptoms
Twenty issues reported by VID’s users — around time zones, identity matching and email delivery — each traced to the code responsible and grouped by root cause, so one fix closes several reports.
Result
- Proveedores: analysis complete and a working prototype in front of its users in the first week.
- VID: 20 issues traced to root cause, a documented codebase and a local environment anyone on the team can reproduce.
The code belongs to the client and stays private. Figures are illustrations with sample data; no real records appear on this page.