Smoothing the Edges: The BinaryStar Journey from PickBASIC to MongoDB

By the folks at BinaryStar Systems

In the world of legacy systems, you don’t just throw out the old to make room for the new. That may work when you’re replacing a toaster, but not when the system in question has been running your business faithfully for 30 years. You’ve got deeply entrenched business rules, thousands of customer records, maybe even decades of tribal knowledge wrapped up in screens and subroutines that still hum along in PickBASIC. And while humming is nice, the rest of the world has moved on to the cloud, to APIs, to modern frameworks, and to databases like MongoDB.

That’s where our story begins—and where BinaryStar has spent the better part of the last five years carving a path not just for ourselves, but for any organization bold enough to migrate their Pick-based applications into the modern age.

Why Pick? Why Now?

Let’s face it: PickBASIC isn't flashy, but it’s loyal. It’s the kind of technology that “just works”—until the day it doesn’t. Not because it breaks, but because it won’t play nicely with your new partners, analytics tools, or web interfaces. For many of our clients, modernization isn't about abandoning Pick; it’s about preparing their systems to live on in new forms—scalable, accessible, and integrated.

But we learned quickly that you can’t just snap your fingers and transport PickBASIC logic into a Node.js app backed by MongoDB. That’s where the real work begins.

The Early Days: Messy and Manual

At the start, every modernization project felt like whittling a square peg to fit a round hole. PickBASIC is a different animal altogether—full of multivalues, subroutines, tightly interwoven business rules, and decades of "quick fixes" from developers long since retired.

We began by writing our own scripts. Bash. Node. Perl, even. Whatever got the job done. But we soon realized that for modernization to scale—for it to be more science than art—we needed process, tooling, and structure.

Introducing MYRA: Our Compass in the Chaos

That’s when MYRA was born. Short for Modernization Yield & Refactoring Assistant, MYRA became our way of organizing the madness. She’s not just a parser or a translator—she’s a guide. MYRA reads PickBASIC source, identifies structure, teases out embedded business logic, and gives us a roadmap. She recognizes the “unspoken architecture” of a legacy system.

What does MYRA do?

• Tokenizes and classifies PickBASIC logic into meaningful categories.
• Identifies reusable logic blocks (the stuff buried 12 conditionals deep).
• Maps multivalue records to nested MongoDB documents.
• Flags implicit dependencies you didn’t know were there.

But perhaps most importantly, she lets humans stay in control. This isn’t an AI that runs off and rewrites your software. MYRA shows you what’s there—warts and all—and helps you decide how to rebuild it right.

Taking the Rough Edges Off

Once we could see the system clearly, we could smooth it. That meant building specialized tools to:

• Untangle spaghetti logic without breaking it.
• Separate UI from logic (remember those terminal screens baked into your source?).
• Create RESTful interfaces that mirror the shape of your legacy data, while speaking modern API.
• Preserve and modernize dictionary metadata, translating it into schema-aware MongoDB documents.

These tools didn’t exist in the market—not in a form that respected the nuance of Pick. So we built them. Slowly, patiently, with the understanding that this work is more like archeology than demolition. Every variable, every GOSUB, every phantom process had a story. And MYRA helped us listen.

MongoDB: A Natural Partner

MongoDB didn’t come into the picture by accident. We chose it because its document model suits the multivalue mindset. In a way, it honors Pick’s strengths—flexible schemas, nested structures, speedy lookups—but in a modern, scalable, cloud-friendly form.

We built mappers and migrators that knew how to convert Pick records into MongoDB documents that make sense—not just dumps, but meaningful transformations. A CUSTOMER record in Pick might become a JSON document in Mongo with nested invoices, contacts, and preferences. All without losing fidelity.

Our work here made us confident enough to say: You can modernize your data without flattening it. And you can do it with integrity.

Lessons From the Field

If you’ve ever watched a master carpenter work, you know the real skill isn’t in swinging the hammer—it’s in knowing where to tap. The same is true of legacy modernization. Over the years, we’ve learned:

• Don't skip discovery. You might think you know what’s in your codebase. You don’t.
• Code isn't the only asset. Business logic lives in user habits, report structures, and naming conventions.
• Automate where possible. But never fully remove the human from the loop.
• Invest in translation layers. Your modern stack shouldn’t be a total rewrite—it should speak to what came before.

The BinaryStar Approach

We aren’t a tooling company. We’re not a consulting shop that drops a PDF on your desk and walks away. We’re builders. Which means we believe in standing shoulder-to-shoulder with your teams to make the transition real, workable, and maintainable.

BinaryStar’s approach is:

• Code-informed, not code-blind.
• Data-centric, not data-phobic.
• Cloud-savvy, but legacy-respecting.

And most importantly, human. We built these tools for ourselves first—because we needed them. And then we shared them with our partners, because they needed them too.