Chapter 16: Where QF Code Is Going

You just finished a book built on a promise: that a language small enough to read cover to cover could still teach you something real. I want to end this book by being honest about what happens to that promise as QF Code keeps growing, because it is going to keep growing, and I don't ever want that growth to break the thing that made your first line of code feel manageable instead of overwhelming.

Simple by Default, Capable Underneath

Here's the principle I keep coming back to, the same one that built the language you just used: a beginner should never have to know about a feature to write their first program, but an advanced feature should still be there, waiting, once they're ready for it. You've already lived this once in this book. attempt and error sat unused for nine chapters before you needed them. const existed lightly in chapter 2 long before its full story in chapter 11. Nothing about those features made chapter 1 harder. Everything QF Code adds from here follows that same rule, or it doesn't belong in the language at all.

A few smaller, honest gaps are already next in line: a proper wait() that doesn't block the way sound() currently does, file reading and writing, real graphics instead of text-only output, a way to react to a single keypress instead of waiting for a whole line. None of these change what you learned in this book. They're additions, not corrections.

A Bigger Idea: Optional Object Orientation

The bigger thing I'm actually pursuing is this: QF Code becoming optionally object-oriented. Not object-oriented by default, that would break everything this book just taught you, but available, on purpose, for a learner who's ready to understand what a class and an object actually are. Most people meet object-oriented programming for the first time by getting thrown into a heavy, industrial language and told to keep up. I'd rather someone meet it here first, in a language that's already earned their trust, one concept at a time, the same way you just met arrays and functions and scope.

An Even Bigger Idea: wrap

The most ambitious piece of this vision is a feature I'm calling wrap. The idea is that QF Code could reach outside itself, inspect a real module built in another language, Python's numpy, JavaScript's chart.js, whatever a learner actually wants to use, and build a structure so QF Code can work with it directly. Imagine wrapping numpy and chart.js into the same small project and having them work together, still inside the same simple language you just spent fourteen chapters learning.

I want to be honest with you about where this actually stands: it's a direction I'm pursuing, not a promise with a date attached. Making it real means QF Code becoming a genuinely more advanced language under the hood, and that only matters if it happens without asking a beginner to carry any of that weight on day one. That tension, simple for a beginner, capable enough to reach into real tools, is the whole design problem, and I'd rather tell you it's unsolved than pretend it's already finished.

QuibbleFox

QF Code lives on a platform called QuibbleFox, and its own origin is a little unexpected: it started because I wanted better practice with my own Ukrainian vocabulary, tailored to how I actually learn, picking up where an app like Duolingo left off. By the time someone asked me to teach them programming, QuibbleFox already existed for Ukrainian and Spanish, and it occurred to me that learning a programming language is, in real ways, just learning another language. Adding QF Code to QuibbleFox became a test of whether that idea held up.

What QuibbleFox can offer that this book can't is personalization, an AI coach that knows what you're actually working on, what's tripping you up, and how you learn best, adjusting as it goes instead of showing every reader the same fixed page. This book was written for anyone who picks it up. QuibbleFox is built for you, specifically, whenever you want to keep going with something that adapts.

The Only Part That Was Ever the Point

None of what's in this chapter is a reason to wait. Everything you built in this book works today, runs today, is yours today. Wherever QF Code goes next, the thing you actually learned, how to think in variables and loops and functions, how to break a problem into pieces small enough to solve, doesn't expire when the language grows around it. That was always the only part that mattered.

---