The Source Code of Science

When you dive deep into STEM fields like astrophysics or chemistry on your own terms, you quickly hit a wall that has nothing to do with math or conceptual complexity. You hit a vocabulary problem.

You are trying to understand the hydrostatic equilibrium of a dying star, how nucleosynthesis forged heavy elements, or why doping a semiconductor crystal lattice alters its electrical conductivity.

The underlying physics is pure logic. It is a system of rules, forces, and base cases. Yet the literature wraps these elegant mechanics in dense, multi-syllabic terminology that brings reading comprehension to a grinding halt.

Every time you have to pause to look up a term like nucleosynthesis, allotrope, or chemiosmosis, you suffer a mental context switch. Your working memory drops the physics model you were holding in your head just to parse a string of letters.

Most people treat scientific jargon as a massive list of arbitrary words to memorize by brute force. As a software engineer, I hate brute force. When a system scales poorly, you do not throw more memory at it; you look for the underlying architecture.

That is why I built [ISV-BRO](http://github.com/leouofa/isv-bro](https://github.com/leouofa/isv-bro), an educational game designed to teach the building blocks of International Scientific Vocabulary (ISV). Instead of memorizing thousands of isolated scientific definitions, the goal is to master the morphological source code that generates them.

Learning any complex domain comes down to bandwidth. In computer science, if your parser is slow, your entire pipeline bottlenecks before execution even begins. The same thing happens when reading scientific texts.

International Scientific Vocabulary isn’t a random collection of complicated words. It is a highly structured, modular language assembled almost entirely from classical Greek and Latin roots, prefixes, and suffixes. Words like photolysis, thermodynamics, and spectroscopy are not monolithic terms. They are compound functions built from small, reusable primitives:

• Photo- (light) + -lysis (loosening, splitting)

• Thermo- (heat) + -dynamics (power, motion)

• Spectro- (image, appearance) + -scopy (viewing, examining)

When you do not know the primitives, every new scientific term is a lookup that interrupts your flow state. When you master the roots and affixes, your brain compiles the meaning at runtime. You can encounter a word you have never seen before in an astrophysics paper and deduce its meaning immediately from its parts.

Returning to the absolute basics of vocabulary removes the friction from high-level STEM learning.

Building ISV-BRO turned a reading obstacle into a hands-on exploration of linguistics. If you enjoy programming languages, human linguistics is the ultimate legacy codebase.

Natural languages often feel messy and full of exceptions, but ISV is uniquely engineered. Scientists across centuries needed a trans-linguistic standard so a researcher in Tokyo, a physicist in Berlin, and a chemist in Sao Paulo could read the same formulas and recognize the same concepts. To achieve this, they treated classical roots like a standard library.

To build a game that teaches this effectively, you cannot just slap flashcards on a screen. You have to model how morphology actually works:

1. Morphemic Tokenization: Breaking complex words down into their smallest meaningful units (prefixes, bound roots, connecting vowels, and suffixes).

2. Semantic Composition: Understanding how meaning shifts when roots combine, much like function composition in software.

3. Etymological Graph Mapping: Seeing how a single root like -graph- or iso- branches across completely different disciplines, connecting chemistry, geology, and astronomy through shared linguistic DNA.

When you have to structure these rules into data models for a game engine, you stop passively reading about linguistics and start reverse-engineering it. You begin to see language not as static text, but as a generative system of combinatorics.

Whenever I hit a friction point in learning, my instinct is to build a tool to solve it. You could argue that spending hours coding a game to learn scientific roots is a detour from just reading the chemistry textbook. In practice, building the tool is the ultimate accelerator.

To teach a machine how to quiz, score, and guide a player through scientific etymology, you have to understand the subject matter at a structural level. You have to curate the roots, verify their meanings, map their combinations, and design progression loops that reinforce retention. By the time the game is playable, the developer has already absorbed the foundational dataset just by architecting the system.

Furthermore, turning a dry academic subject into an interactive loop forces you to strip away academic bloat and focus strictly on signal. What are the highest-leverage roots in science? Which prefixes unlock the most comprehension across physics and biology? Building the tool forces you to find the Pareto frontier of the subject.

I build games as a hobby, separate from my day-to-day work architecting AI systems and full-stack software. Yet nothing sharpens core software engineering instincts quite like game development.

Enterprise software often lets you hide behind layers of abstraction, heavy frameworks, and asynchronous forgiveness. If a web request takes an extra 50 milliseconds, nobody notices. Game development is unforgiving. Every frame is a deadline, state changes are constant, and bad architecture reveals itself immediately in the user experience.

Building a project like ISV-BRO reinforces fundamental engineering disciplines that translate directly back to production software:

• Deterministic State Machines: Games live and die by clean state transitions. Managing player progression, UI states, scoring logic, and feedback loops requires strict, predictable state management without race conditions.

• Data-Driven Design: Hardcoding content into game logic is a trap. Building a vocabulary game forces you to cleanly decouple the linguistic engine (the game mechanics and UI) from the data layer (the roots, definitions, and word combinations). Good data schemas make adding a hundred new Greek roots a zero-code operation.

• Tight Feedback Loops and UX: In enterprise software, we often forget that a human has to sit on the other side of the interface. In a game, if the interaction feels sluggish or the feedback isn’t immediate and rewarding, the player quits in thirty seconds. Designing game juice, clear visual hierarchy, and intuitive progression makes you vastly better at designing responsive, human-centric software interfaces.

Whether you are studying the fusion of elements in the core of a star, decoding the etymology of a twenty-letter scientific word, or architecting a complex software platform, the secret is always the same: respect the base cases.

Advanced concepts are rarely hard because they are mystical; they are hard because our foundation has gaps. When we skip the primitives, everything built on top of them feels fragile and overwhelming.

When you hit a wall in your learning, take a step back. Identify the foundational layer you are missing, open your editor, and build the tool that makes mastering that layer inevitable. You will not only learn the subject faster, you will become a sharper builder in the process.