The Ledger Model
Before building language learning software, I spent years writing wealth management systems. Portfolio positions. Trade transactions. Performance attribution. The whole apparatus of tracking what you own, how you got there, and whether it is working.
When I eventually built a tool to learn Romanian, I reached for the same vocabulary — not as a stylistic choice, but because the underlying structure is genuinely the same. A learner accumulating mastery over thousands of sentences has more in common with a portfolio manager than with a student filling out flashcards.
This is a short explanation of three core terms, and one architectural decision that follows from them.
The Three Terms
Transaction
A transaction is a single recorded attempt. You hear a sentence. You type what you heard. The app evaluates your transcript against the official one and records the outcome — correct or incorrect, your text, the official text, the timestamp, which session it belonged to.
Transactions are immutable. They are never updated, never deleted. Like a trade confirmation or a journal entry in double-entry bookkeeping, the transaction is the atomic unit of truth. Once recorded, it is permanent. The ledger only grows.
Everything else in the system is derived from transactions.
Position
A position is your current standing on a single sentence — computed from its transaction history. The most important field is the streak: how many consecutive correct answers you have given. From the streak, the algorithm derives when the sentence should next be reviewed.
A sentence you have never attempted is an unknown position — like a security you have not yet bought. One you have answered correctly four times in a row is mastered — it will not surface again for six months. One you just failed is due again in five minutes.
Positions are not stored. They are recomputed, on demand, from the transaction log.
Performance
Performance is the aggregate picture: success rate across a session, across a corpus, across all time. How many positions are mastered. How many are unknown. How many are ready for review. Whether accuracy is improving or plateauing.
Performance is always a view over transactions — a summary computed at the moment you ask for it, not a number stored anywhere. Like a portfolio's return: not a field in a database, but a calculation you run against the history.
The Architectural Choice
The decision not to persist positions — to derive them entirely from transactions — was deliberate, and it deserves a brief defense.
In accounting, the ledger is the source of truth. The balance sheet is derived from the ledger. You do not store the balance sheet independently and update it with every transaction, because if the balance sheet and the ledger ever disagree, you have a problem. The ledger wins. The balance sheet is just a view.
The same logic applies here. The transaction log is the ledger. Positions are the balance sheet. Storing positions separately would introduce a second source of truth that could fall out of sync with the transactions that generated it. If the algorithm changes — and it has changed, repeatedly, as the approach was refined over four years — stored positions become stale. They reflect old logic. A recomputation from the raw transaction log always reflects the current algorithm, applied consistently to all history.
The same architecture underlies blockchain. A wallet balance is never stored on-chain — it is derived by replaying every transaction that ever touched that address from the genesis block. The ledger is the truth; the balance is a view. Ethereum and this app made the same choice for the same reason.
There is a cost: computing positions from 100,000 transactions is not instantaneous. The algorithm has to group transactions by sentence, walk each group in chronological order, and compute the streak and review schedule for every position. At scale, this is O(n) on every session load.
The trade-off is accepted. The computation is fast enough in practice, and the benefit — a single authoritative source of truth, algorithm changes that take effect retroactively across all history, no synchronization logic between positions and transactions — is worth it. Premature optimization in the other direction would buy speed at the cost of correctness and simplicity.
LIFO, FIFO, and Fiat
The financial vocabulary extends further. LIFO and FIFO — Last In First Out, First In First Out — are genuine accounting terms for inventory and cost basis calculation, borrowed here to describe two selection strategies for which position to surface next.
LIFO surfaces the sentence you most recently failed — the freshest failure. FIFO surfaces the sentence most overdue for review — the oldest debt. The algorithm alternates between them, weighted, within each session.
The fiat factor — the mechanism that forces exposure to new, unseen sentences regardless of how large the review backlog has grown — takes its name from monetary economics. When a government needs to invest in new infrastructure despite outstanding debt, it does not wait for the books to balance. It coins new money by fiat. The algorithm does the same: it coins new learning exposure by decree, bypassing the review scheduler entirely on a fraction of selections.
If this framing is unfamiliar, the companion essay on spaced repetition explains why that override is necessary — and what happens to learners whose algorithms never question the scheduler.
Why It Matters
The financial vocabulary is not decoration. It reflects a genuine structural parallel: learning a language at scale involves managing a large, heterogeneous inventory of items with different acquisition costs, different decay rates, and a finite budget of daily practice time. The goal is not to review everything — it is to allocate attention where it generates the most return.
A sentence you have answered correctly four times in a row, at a 96% success rate on the fifth attempt, is not a good use of the next five minutes. A sentence you failed this morning, still live in working memory, is. The algorithm is a portfolio manager, not a homework enforcer.
The algorithm, applied
Romanian shareware — free, offline, macOS.
Download Free Read: The Use and Abuse of SRS →