Starting over .. again ..

This is my first Blogger entry.

That sentence alone probably tells you something important.

I’ve been here before.

A Quick Background (So You Know Where I’m Coming From)

I’m the original creator of Crafty Syntax, a system that—years ago—handled over a million users without imploding, without fashionable abstractions, and without most of what modern frameworks now insist is “required.”

Then I disappeared.

For 11 years, I was effectively off the keyboard. Life happened. The industry moved on. The hype cycles came and went.

In August 2025, I sat back down at a computer.

And what I found… was wild.

So now I’m starting over. Again.

This blog exists to document that return.

Not as nostalgia.
Not as a victory lap.
But as a very real rebuild of two living systems:

Crafty Syntax (now moving toward 4.x)
LUPOPEDIA, a federated AI coordination and knowledge architecture built on the same core principles I’ve been refining for over two decades

If you’re expecting “Hello World” posts or gentle tutorials, this probably isn’t for you.

If you care about systems that last, you might want to stick around.

Why I’m Writing Publicly Again

When I came back, I expected new tools.

What I didn’t expect was how much fundamental thinking had been outsourced—to frameworks, to defaults, to dogma.

Modern development feels safe.
It also feels fragile.

I started documenting my reactions, discoveries, and rebuild work over on Patreon—not as marketing, but as engineering notes written in public.

One of those posts, Why Modern Programmers Are Driving This Old-Timer Crazy, turned into something larger than I expected.

It wasn’t just a rant.

It became a live demonstration of everything I’m talking about.

The Short Version of the “Madness”

Here’s the core tension I ran into immediately:

Timezones everywhere
Foreign key constraints everywhere
Validation pushed downward instead of enforced at boundaries
Over-engineering justified as “safety”

Meanwhile, I had already built—and maintained for decades—a system that:

Stored all time as sortable integers (YYYYMMDDHHIISS)
Used one temporal truth
Ran without foreign key constraints
Used orphan rows instead of NULLs
Survived constant schema evolution
Scaled without ceremonial complexity

Coming back and being told this was now “wrong” was… educational.

And irritating.

So I didn’t argue theory.

I built LUPO—a doctrine enforcer that makes databases behave the way Crafty Syntax always has.

No debates. No best-practice bikeshedding. Just enforcement.

Why This Blog Exists (And What It Isn’t)

This Blogger site is not where the deepest technical work lives.

That’s still happening on Patreon, where I can write long, precise, occasionally confrontational posts without pretending they’re tutorials.

This blog is:

A public index
A narrative log
A place to explain why things are being rebuilt the way they are
A bridge for people who don’t want to dive straight into 10,000-word architecture posts

Think of it as the front door, not the engine room.

If You Want the Deep Dive

If you want to see what sparked this restart—and how far it’s already gone—start here:

Why Modern Programmers Are Driving This Old-Timer Crazy
(Linked from LUPOPEDIA / Patreon)

That post covers:

Timestamp insanity
Constraint obsession
Why I don’t trust databases to “parent” developers
How LUPO enforces doctrine automatically
And why simplicity isn’t the same thing as being outdated

It also includes a live, multi-LLM dialog that accidentally proves the entire point.

What Comes Next

Going forward, I’ll be posting here when there’s something worth anchoring publicly:

Major Crafty Syntax milestones
LUPOPEDIA architectural shifts
Clarifications when things get misunderstood elsewhere
Occasional “no, really, stop doing this” essays

No content calendars.
No SEO rituals.
No pretending this is a startup blog.

Just honest documentation of systems being rebuilt to last another 20 years.

If that resonates—you’re in the right place.

— lupopedia
🐺 Counting in Light

Search This Blog

lupopedia