On Building, Thinking, and Living
A Philosophical Manifesto of a Software Engineer
There are many people who talk about building.
Few think about what building actually is.
This is not a career document. It is an attempt to put into words what remains when you strip away everything incidental.
Ron writes not as a preacher. He writes as a practitioner.
Whoever seeks truth — at least an honest attempt — is in the right place.
Structure Over Surface
Ron does not think in surfaces. He thinks in structures.
Most human labor is surface labor — the visible, the measurable. A dashboard that impresses. A system that works at first glance.
But the first glance is the glance of the buyer, not the glance of the builder.
Antecedents
Plato
The Cave Wall
Build on structures, not shadows.
Bauhaus
Form Follows Function
Ornament without function is a lie.
Clean Architecture
Separation of Concerns
Understand what is before shaping how it appears.
Structure is not the opposite of beauty. Structure is the deepest form of beauty, understood only by those who come close enough to it.
HERE IS WHAT STRUCTURE OVER SURFACE LOOKS LIKE IN PRACTICE →
Case Study · Solo Engineer · Full Stack · Bitcoin2Go
B2GO Dashboard
From Excel Chaos to a Fully Typed Editorial System
Bitcoin2Go was one of Germany's leading crypto media platforms — publishing comparisons and ratings of exchanges, wallets, brokers, DEXs, credit cards, tax tools, and yield products. The editorial team managed all product data, ratings, and rankings in Excel spreadsheets. Every product had 40+ rating fields across 4 scoring axes. Every change meant recalculating scores by hand. Every new category meant duplicating the entire structure. The task: replace the entire workflow from data entry to API delivery.
8 spreadsheets. Manual recalculation. Error-prone.
calculateScores(category, attrs)Features · Usability · Security · FeesOne engine. Configured, not coded.
Scoring rules live as JSONB in the database — not in code. Five attribute types cover every possible rating logic, from simple boolean flags to interpolated formulas.
booleanPoints if property exists
invertedPoints if NOT present
selectPoints mapped to dropdown values
formulaLinear interpolation between anchors
directDirect value with clamping
Five types. Every rating logic covered. Configured in the database, not in code.
TypeScript Config
Type-safe form structure, version-controlled
Database JSONB Rules
Editable point weightings — no deploy required
calculateScores()
Single engine for all 8 categories × 4 axes
PostgreSQL Views
Denormalized — one SELECT returns 100+ fields
REST API
100+ endpoints, one uniform pattern per category
Website
Complete typed product objects, zero N+1
TypeScript Config + Database JSONB
Form structure is type-safe and version-controlled. Point weightings live in the database — editorial staff can adjust scoring without a developer or a deployment.
calculateScores()
A single function that handles all 8 categories × 4 axes. Runs identically client-side (live preview) and server-side (on save). No surprises.
PostgreSQL Views
Each category view joins 5+ tables, computes scores inline, and aggregates pros/cons as JSON arrays. One SELECT returns the complete product object.
REST API → Website
100+ endpoints following one uniform pattern: List, Create, Single, Update, Delete, Score. No exceptions, no special cases.
The cleverness is not in what it does — it's in what it doesn't do. No eight scoring engines. No duplicated schemas. No hardcoded rules. No developer required for editorial changes.
Solo Project — Ron Mujaj
The Engineer
Ron deliberately calls himself an engineer. Not a programmer. This is not a question of title. It is a question of stance.
The Programmer
The Engineer
The difference between a programmer and an engineer is not ability. It is responsibility.
Marcus Aurelius wrote: “What harms the community harms the individual.”
Reputation is what others think of you. Integrity is what you know about yourself.
RESPONSIBILITY IN PRACTICE →
Incentiv Blockchain
Enabling Production-Grade Account Abstraction for a Native AA Layer 1
Incentiv is a Layer 1 blockchain with native Account Abstraction. Smart wallets are the default. But vision means nothing without infrastructure that works in production.
Smart Wallets Default
Every account is a smart contract wallet
Multi-Token Gas
Pay fees in any supported token
Session Keys
No signing per action
Passkey Auth
Biometrics instead of seed phrases
Gasless via Paymasters
Users never see gas
The blockchain team had built on the reference bundler (TypeScript) paired with Hyperledger Besu. It worked in development. It did not work in safe mode.
Before
Reference Bundler + Besu
✗ Safe Mode Impossible- Besu lacks debug_traceCall JS tracer
- Forced --unsafe mode operation
- Vulnerable to griefing attacks
After
Rundler + Geth
✓ Full Safe Mode- Native debug_traceCall support
- 60M+ UserOps processed on-chain
- Production-grade, Rust-built
Safe mode enforces the rules that make bundlers economically viable.
Banned Opcodes
BLOCKHASH, TIMESTAMP, and NUMBER are forbidden during validation — these make results non-deterministic across nodes.
Storage Restrictions
A UserOp may only touch storage slots associated with its own sender — blocking the core griefing vector.
Opcode Tracing
debug_traceCall with a JavaScript tracer must run against the execution client to inspect every opcode touched during simulation.
Reference Bundler vs. Rundler
| Feature | Reference Bundler | Rundler |
|---|---|---|
| Language | TypeScript | Rust |
| Purpose | Spec compliance | Production |
| Throughput | Not optimized | 7.5M gas/s |
| Safe + Geth | ✓ | ✓ |
| Safe + Besu | ✗ | ✗ |
The entire Incentiv blockchain team adopted Rundler + Geth based on this research and testing.
Contributor — Ron Mujaj
Atomic Decomposition
Democritus taught that everything consists of atoms — indivisible particles in various constellations. The principle is mightier than physics: understand the elements, understand the whole.
No project is too large. There are only projects not yet decomposed far enough.
Ron sees the big — and decomposes it. This is not avoidance. It is an epistemological conviction.
THE METHOD IN PRACTICE →
PapaPlay
A Fully On-Chain Casino — From Bet to Payout, Nothing Hidden
On-chain gambling needs trust without regulation. Every bet, payout, and fee must be verifiable on-chain — while protecting liquidity providers with mathematically sound risk management. Most architectures are too simple or too fragile. PapaPlay solves it with four clean layers and no compromises.
Four Layers. Four Responsibilities.
GAME LAYER
Coinflip · Plinko · Slots · LuckyDouble
Place bets, compute RNG, settle outcomes.
RISK MANAGEMENT
HouseRiskManager — Kelly Criterion
Quote max wagers. Reserve exposure. Protect LPs.
LIQUIDITY
HouseVaultV2 (ERC-4626)
LPs deposit USDC. Players win from it. Players lose into it.
ENGAGEMENT
XP · Referrals · Mystery Boxes · Seasons
Fire-and-forget. Never blocks game execution.
Games know nothing about risk. The vault knows nothing about games. The engagement layer is wrapped in try/catch — if it fails, the game still settles.
Two-Step Bet Flow
Batch betting up to 30 bets per transaction — only possible because settlement and claiming are separate concerns.
Approve USDC
permit()
Transfer to Vault
transferIn()
Reserve Exposure
reserveFromWager()
Compute RNG
prevrandao
Settle Outcome
settle()
Claim All
claimAll()
USDC to Player
transfer()
Why two steps? Batch betting. Up to 30 bets in one transaction without gas explosion. Settlement and claiming are separate concerns — so they're separate transactions.
Dynamic Risk Management
The Kelly Engine
Not a fixed-odds system. The house dynamically adjusts based on vault size, concurrent bets, and probability. One bad streak cannot drain the house.
Maximum Wager
$10,101
maxWager = 0.35 × vaultTVL / (1.98 × (1 + activeBets × 0.15))
Concurrent damping means more live bets automatically reduce the max wager — the house never overextends.
The Games
Every game shares the same underlying infrastructure: UUPS upgrades, AccessControl, SafeERC20, referral hooks, XP emission, and mystery box milestones.
Coinflip
Heads / Tails · 50/50
~1.98x
30 flips/tx
LuckyDouble
Two dice · doubles win
~5.56x
30 rolls/tx
Slots
5-reel · 7-symbol grid
0.5x – 50x
10 spins/tx
Plinko
Galton board · 8–16 rows
0.2x – 5.6x
Variable risk
Security + Multi-Chain
Security Features
UUPS Proxy
Universal Upgradeable Proxy Standard
AccessControl
Role-based gate on every privileged call
ReentrancyGuard
Non-reentrant on all state mutations
Gnosis Safe
Multisig treasury — no single point of failure
Fire-and-Forget XP
try/catch wrapper — failures never block games
EIP-2612 Permit
Approve + bet in a single transaction
Multi-Chain
Base
Coinbase L2 · USDC
Incentiv
Native CENT token
Goldsky Indexing Pipeline
Cross-chain leaderboards and XP totals with zero self-hosted infrastructure.
“The craftsman shapes a part. The architect carries the whole.”
Technical Stack
Smart Contract Engineer — Ron Mujaj
Truth
Ron has a tense relationship with untruth. Not morally — practically. Untruth is dysfunctional. It creates friction that leads to failure.
The liar still has a relationship to truth — he knows what is true and says the opposite. The bullshitter has no relationship to truth at all.
Honesty is not a value alongside other values. It is the condition for all other values.
Without honesty, respect is politeness.
Without honesty, reliability is performance.
Without honesty, responsibility is a claim.
The breath before the conclusion
Success and Its Origin
In an age when success is measured in followers and funding, Ron has a different conception of where success begins. It does not begin at the top. It begins at the bottom.
These are not aspirations. They are tools — like a craftsman’s instruments that must be maintained to stay sharp.
THE PRINCIPLES APPLIED →
The Ethics of Work
What is good work? Work that bears — even when no one is looking.
Mastery Without Audience
A sushi chef perfects the same movement for thirty years — not because someone watches, but because the movement deserves it.
Do One Thing Well
No hidden features. No inflated promises. Do one thing. Do it completely.
Ultimate Sophistication
The hardest achievement is not to create complexity. It is to dissolve it.
Technical vanity is betrayal of the craft. Complexity is a burden, not a distinction.
WHAT DOES IT LOOK LIKE WHEN YOU SOLVE A PROBLEM MOST ENGINEERS ABANDONED?
THE PROTOCOL — 5 BLOCKS, ~2.25 SECONDS
5 blocks. Zero oracle. One elegant insight.
The k=4 offset is empirically measured — median commit latency on BSC is under 400ms, P99 is under 1,200ms. k=4 leaves over 600ms of margin. Not guesswork.
Request
User calls flip(). Fee forwards to backend wallet in the same tx. Anchor is set: bSample = current block + 4. The anchor block does not yet exist.
Commit window
Backend generates a fresh secret and ephemeral keypair. Time to commit before the anchor block is mined.
Commit window
Backend submits keccak256(secret) on-chain. The contract enforces: commit must land strictly before B+4.
Commit window
Latest safe block for the commit to land. After this block, no commit is accepted. The window closes.
Anchor
The anchor block is mined. Its hash now exists — but was unknowable at commit time. Entropy crystallised.
Reveal
Backend reveals the secret. Contract verifies the commitment, computes R, and calls back the consumer — all atomically.
B
User calls flip(). Fee forwards to backend wallet in the same tx. Anchor is set: bSample = current block + 4. The anchor block does not yet exist.
B+1
Backend generates a fresh secret and ephemeral keypair. Time to commit before the anchor block is mined.
B+2
Backend submits keccak256(secret) on-chain. The contract enforces: commit must land strictly before B+4.
B+3
Latest safe block for the commit to land. After this block, no commit is accepted. The window closes.
B+4
The anchor block is mined. Its hash now exists — but was unknowable at commit time. Entropy crystallised.
blockhash(B+4) does not exist yet
B+5
Backend reveals the secret. Contract verifies the commitment, computes R, and calls back the consumer — all atomically.
R = keccak256( secret || blockhash(B+4) || requestId )
secret — binds the backend before the reveal
blockhash(B+4) — entropy unknown at commit time
requestId — prevents replay attacks
FOUR COMPONENTS. EACH DOES ONE THING.
Separation of trust by design.
The contract is trustless. The backend is trusted but bounded. The database serves operations, not correctness.
ronVRF Smart Contract
Solidity · BNB Smart Chain
The protocol itself. Immutable and trustless. Manages the commit-reveal state machine, routes fees, verifies commitments, computes randomness, and calls consumer callbacks.
Consumer Contracts
Game1 · NFT Minter · Lottery
Any contract requesting randomness. Implements IRandomnessConsumer and gates fulfillRandom() with require(msg.sender == address(ronVRF)).
Backend Service
TypeScript · Node.js
Listens for RequestCreated events via WebSocket. Generates secrets, submits commits, waits for the anchor block, then reveals. Deterministic, open-source, verifiable.
PostgreSQL
Audit trail · Crash recovery
Persists every request, commit hash, secret, and random output. Crash recovery ensures no pending reveals are lost. Every output is independently verifiable.
EVERY ATTACK CONSIDERED
Security is not claimed. It is argued.
Every viable attack vector is enumerated and addressed. The deterministic backend and closed token economics eliminate the non-reveal risk entirely.
Pre-commit grinding
INFEASIBLECannot compute R without blockhash(B+4), which does not exist at commit time. The entropy source is literally not yet part of the universe.
Front-running the commit
NO ADVANTAGECommitHash is pre-image resistant via keccak256. An observer cannot derive the underlying secret from the on-chain commitment.
Reveal timing manipulation
INFEASIBLEThe anchor block is fixed at request time, not reveal time. A validator cannot alter which block hash is used.
Selective non-reveal
ELIMINATEDThe backend is deterministic and self-funded — users pay gas costs via the flip fee. No private key is held by users. The Discovery Hub lets anyone register a backend and earn 20% of surplus fees.
Fake callback injection
BLOCKEDEvery consumer enforces require(msg.sender == address(ronVRF)). No external address can trigger fulfillRandom().
Chain reorganization
AUTO-RECOVERYShallow reorgs cause safe reverts. Deep reorgs are network-level catastrophes that affect every protocol on the chain.
Validator hash manipulation
INFEASIBLEPractically infeasible without majority collusion — which breaks BSC itself. The attack costs more than the gain.
AGAINST THE INDUSTRY
No oracles. No tokens. No overhead.
The comparison is direct. Every row where ronVRF wins is a deliberate design constraint — not an accident.
| Metric | ronVRF | Chainlink VRF | RANDAO |
|---|---|---|---|
| Oracle dependency | None | Chainlink network | None |
| Latency | ~2.25 seconds | ~24 seconds | >60 seconds |
| Gas cost | O(1) | Medium | O(n) |
| Public audit trail | Yes | No | No |
| Self-funding gas | Yes | No | No |
| External tokens required | None | LINK token | None |
| Deployment complexity | Low | High | Medium |
CLOSED-LOOP TOKEN ECONOMICS
Self-Sustaining by Design
When a user calls flipCoin(), the gas fee covers the backend's commit and reveal transactions. No external funding needed. The system pays for itself.
USER
Pays gas fee via msg.value
BACKEND
Receives fee, pays gas for commit + reveal. Deterministic — no private key exposure.
20%
Backend deployer reward
80%
Returned to consuming smart contracts
RONVRF DISCOVERY HUB
Anyone can deploy their own ronVRF backend and register it on the Discovery Hub. Projects browse available backends, choose one, and start using verifiable randomness — no Chainlink subscription, no LINK tokens, no oracle dependency.
What ronVRF Does Not Claim
A serious project states what it does not achieve. These are the known trade-offs — not omissions.
BSC-specific tuning — k=4 is calibrated for ~450ms blocks. Other chains require recalibration of the anchor offset.
No formal verification — the smart contract has not been machine-verified with tools like Certora. Identified as future work.
“The hardest achievement is not to create complexity. The hardest achievement is to dissolve it.”
~2.25s
Latency
O(1)
Gas Cost
Zero
Oracle Dependencies
100%
Verifiable Outputs
Bachelor Thesis — Ron Mujaj
Main RNG on Incentiv Blockchain
A project is good only when it is good in its depths. What gleams on the surface and rots in the foundation is not work. It is a deception.
Thesis I
Simplicity is not an absence of thinking. It is the result of more thinking than complexity ever demanded.
Thesis II
Every problem can be decomposed. Whoever is overwhelmed by a problem has not yet decomposed it far enough.
Thesis III
The difference between a programmer and an engineer is not ability. It is responsibility.
Thesis IV
Honesty is not a virtue among others. It is the condition under which all other virtues can become real at all.
Thesis V
Technical vanity is betrayal of the craft. Complexity is a burden, not a distinction.
Thesis VI
The invisible parts of work are not less important than the visible ones. They are more important — because no one checks them except the conscience of the builder.
Thesis VII
Character is not the result of success. Success is the result of character.
Thesis VIII
All people are equal in their dignity. No person is equal in their talents. Both are true. To acknowledge both simultaneously is maturity.
Thesis IX
A system that lies about its state is not a system. It is a facade. The same applies to people.
Thesis X
The great emerges from the small. Whoever does not take the small seriously does not understand the great.
Thesis XI
Whoever builds assumes responsibility — not only for what is finished, but for everything that follows from it.
Thesis XII
The question is not whether someone is watching. The question is whether you can answer for what you do before your own conviction.
Thesis XIII
Chapter IX
The Manifesto
Epilogue
Philosophy is not an ending point. It is a movement.
What stands here is not a finished truth. It is a state — a cross-section through a thinking that develops with every built line, every overcome problem, every honest conversation.
Ron is not a philosopher in the academic sense. He is a person who builds, and who while building thinks about building — and eventually begins to think also about thinking.
Marcus Aurelius did not write his Meditations for the public. He wrote them for himself — as a daily exercise in self-clarification. That they are read today was a consequence of the fact that what he wrote was genuine.
Authenticity has a longer half-life than strategy.
Build genuinely.
Think clearly.
Remain responsible.
The rest follows.
“Almost everything — all external expectations, all pride, all fear — falls away at death, and what remains is only that which was truly important.”
— Steve Jobs
“The good you do today will often be forgotten tomorrow. Do good anyway.”
— Marcus Aurelius
“Perfection is not a goal of building. But attention to what still falls short — that is the daily task.”
— Ron