Teenage Dreams
2026-09-11
Before the Idea, It Was There.
Johannesburg, circa 1982. Otto Brinkmeier was nineteen years old.
He didn’t know he was looking at the beginning of anything.
There was no PlebWare.
There was no PlebMachine.
There was no grand technological mission.
There wasn’t even a clear career plan.
There was simply a young man, a Commodore VIC-20, some Microsoft BASIC programming, a bunch of friends, music, nightclubs, and an increasingly persistent feeling that computers could do something far more interesting than merely play games.
The strange thing about looking backwards is that sometimes the future was already sitting quietly in the room.
You just didn’t know its name yet.
The Beige Machine That Opened a Door.
The Commodore VIC-20 arrived in my life in 1982.
To most people, it was a little beige home computer.
To me, it was a question.
What can I make this thing do?
That distinction mattered.
I wasn’t satisfied with simply pressing buttons and watching something happen on a screen. I wanted to understand the machinery behind the result.
I wanted to know why.
And, more importantly, I wanted to know whether I could make the computer reach a conclusion that I hadn’t explicitly told it.
That was where Microsoft BASIC became fascinating.
The computer didn’t appear intelligent. It had no artificial intelligence, no internet and no cloud. It didn’t even have remotely enough memory to impress anybody today.
But it had something magical:
It followed logic.
Give it information.
Give that information values.
Tell it how to process those values.
And the machine would give you a result.
For a nineteen-year-old boy, that was intoxicating.
And Then There Was the Bookstore.
Now comes the embarrassing part.
Actually, no.
Let’s call it what it was.
The criminal part.
There was one of the big news-agency bookstores nearby. They sold newspapers, magazines, technical books, programming manuals and all sorts of wonderful things that a curious young computer enthusiast desperately wanted to read.
And I wanted programming books.
Unfortunately, wanting something and being able to afford it were two very different things.
So, on more than one occasion, I did something that I have remembered for roughly half a century.
I tucked a programming book underneath my shirt…
…and walked out.
I was never caught.
Not once.
And perhaps that is what makes the memory uncomfortable.
There was no dramatic police chase. No angry shopkeeper. No punishment. No public humiliation.
Just me walking away with something that wasn’t mine.
At nineteen, I could justify it to myself in all sorts of clever ways. It was a big bookstore. They wouldn’t miss one book. I needed to learn. I didn’t have the money.
None of those arguments changed the basic truth.
It wasn’t mine.
Looking back now, I don’t celebrate that part of the story.
I confess it.
Because there is something else I learned over the decades:
You can fool a shopkeeper. You can fool your friends. You can even fool yourself for a while.
But you cannot fool God.
I know what I did.
God knows what I did.
Somewhere in the strange filing cabinet of my conscience, that little nineteen-year-old thief has been sitting there for decades.
So there it is.
Honest confession.
The programmer who wanted to understand logic didn’t always understand right from wrong.
From BASIC to Bigger Questions.
The programming books opened another door.
I began discovering that BASIC wasn’t merely about making a computer print things on a screen.
You could collect information.
You could assign values.
You could manipulate variables.
You could perform calculations.
You could create rules.
And you could make the computer arrive at a decision.
One particular kind of program fascinated me.
Imagine asking somebody:
What are the ten most important things when buying a new car?
Perhaps the answers might be price, reliability, fuel consumption, performance, comfort, safety, appearance, running costs, space and resale value.
Then the program would ask:
How important is price, from one to ten?
You might answer 9.
Then:
How important is reliability?
Perhaps 10.
And so it would continue.
Each factor received a weight. The program collected those values, processed them, and eventually produced a recommendation.
It wasn’t artificial intelligence. It wasn’t machine learning.
It was a simple programmer’s experiment in weighted decision-making — turning a person’s priorities into numbers and using those numbers to calculate a result.
But to a nineteen-year-old sitting in front of a VIC-20, it felt like magic.
I remember thinking:
Hang on.
A computer can take what I consider important, weigh those things, and help me make a decision?
That idea stayed with me.
The Old Experiment Meets PlebMachine.
Looking at that experiment from 2026 is rather amusing.
Because today I’m working on PlebMachine.
One possibility for a future PlebMachine User Wizard is a recommendation system built around exactly this old principle.
The wizard wouldn’t simply announce:
“This is the software you must use.”
Instead, it could ask questions.
What do you need?
What matters most to you?
How important is simplicity?
How important is privacy?
How important is offline operation?
How much storage do you have?
Do you need collaboration?
Do you need graphics, research tools, writing tools or development tools?
Do you need something lightweight?
The user could assign priorities or importance scores. The system could compare those requirements against available software and calculate which options best fit the user’s stated needs.
That is the connection I want to explore in Python.
The goal isn’t to pretend that a simple weighted algorithm is intelligent. The goal is to resurrect the logic of the old programmer’s experiment and see whether that straightforward idea can become a useful component of a modern PlebMachine workflow.
The language has changed from Microsoft BASIC to Python.
The computer has changed from a VIC-20 to a modern Linux machine.
The problem has changed from choosing a car to helping a user choose software.
But the underlying mechanism is remarkably similar:
Ask. Score. Weight. Calculate. Recommend.
But Computers Weren’t My Whole Life.
There was another side to being nineteen.
There were mates.
There were nightclubs.
There was music.
And there was dancing.
Now, anyone who knows me will probably laugh at that last statement.
I was never naturally a dancer.
Not even remotely.
But I had help.
My best friend Chris Matthews had a sister named Sandra — although most of us called her Sandy.
Sandy knew how to dance.
Rather than simply laughing at the hopeless young man trying to work out what his feet were supposed to be doing, she taught me the foundations.
Feet first.
Then body movement.
Then rhythm.
Then timing.
Eventually I learned to synchronise my feet and body with the music.
And somehow…
I actually became quite good at disco dancing.
Learning to Dance With Rod Stewart.
There is something wonderfully ridiculous about that memory.
While computers were teaching me about variables and logic, Rod Stewart and the dance floor were teaching me about rhythm.
The nightclub lights would flash.
The music would pound.
My mates would be around me.
And somewhere in all of that noise, I was learning something surprisingly useful:
timing matters.
You can’t force rhythm. You have to listen. You have to respond. You have to coordinate different parts of yourself into one movement.
And perhaps, although I certainly didn’t realise it at the time, that isn’t such a bad metaphor for programming either.
A computer program is a collection of separate instructions. Variables. Conditions. Loops. Inputs. Outputs. Each one has its place.
Put them together correctly and the whole thing moves.
Put them together badly and everything falls over.
The dance floor and the VIC-20 were teaching me different versions of the same lesson:
Learn the pieces. Understand the rhythm. Then make them work together.
I Dreamed About Great Things.
The funny thing is that I didn’t know what I wanted to become.
I wasn’t sitting there at nineteen thinking:
“One day I shall create PlebWare.”
Obviously not.
I didn’t even know what PlebWare was.
I didn’t know Linux.
I didn’t know open source.
I didn’t know what self-hosting meant.
I certainly didn’t know that decades later I’d be sitting in Johannesburg writing software designed around ordinary people using Linux computers.
I simply dreamed.
I dreamed that computers could become something important.
Something useful.
Something that could help people.
Something that could take complicated information and make sense of it.
Something that could put power into the hands of the person sitting in front of the keyboard.
I didn’t have the vocabulary for the idea.
But I had the instinct.
The Idea Came Before the Name.
This is why I call this story:
Before the Idea, It Was There.
Because perhaps the idea wasn’t really born when I first started PlebWare.
Perhaps it wasn’t born when I began working on PlebMachine.
Perhaps it wasn’t even born when I started writing serious software.
Maybe it was sitting quietly inside that nineteen-year-old boy.
The boy who looked at a little beige VIC-20 and saw possibility.
The boy who read programming books until the concepts started making sense.
The boy who discovered that variables could represent real-world priorities.
The boy who realised that a computer could help a human make a decision.
The boy who went dancing with his friends and learned rhythm from Sandy.
The boy who dreamed without knowing exactly what he was dreaming about.
And yes…
The boy who sometimes did stupid things and has spent decades remembering them.
That boy didn’t have the answers.
But he was asking the right sort of questions.
The Computer Changed. The Question Didn’t.
Today, I can sit down with Python and recreate the basic decision-making experiment.
The old VIC-20 is gone.
The cassette drives and CRT screens belong to another era.
The programming books have become memories.
The nightclub music has become history.
But the fundamental question remains:
Can technology help an ordinary human being make better decisions?
That question is still alive inside PlebMachine.
And perhaps that is one of the most important things about technology:
The tools change.
The languages change.
The computers change.
The interfaces change.
But sometimes the little idea that started everything simply waits patiently for the technology to catch up.
From a VIC-20 to PlebMachine.
I sometimes look at what PlebMachine is becoming and think about that nineteen-year-old sitting in front of his VIC-20.
He couldn’t possibly have imagined the journey.
From BASIC…
to electronics…
to industrial systems…
to personal computers…
to Linux…
to open-source software…
to PlebWare…
to PlebMachine.
Different machines.
Different decades.
Different languages.
Different problems.
But the same fundamental curiosity.
How does this work?
And then the more important question:
How can I make it work better for people?
Perhaps that is where the real story began.
Not with a company.
Not with a product.
Not with a business plan.
Not even with a particular piece of software.
It began with curiosity.
A keyboard.
A blinking cursor.
A teenager’s imagination.
And a little voice saying:
“I wonder what happens if…“
A Final Word From the Nineteen-Year-Old.
If I could somehow sit across a table from that nineteen-year-old Otto today, I think I’d have quite a conversation with him.
I’d tell him:
You have absolutely no idea where this is going.
I’d tell him that computers will become smaller and faster.
I’d tell him that one day people will carry more computing power in their pockets than he could possibly imagine.
I’d tell him that machines will eventually talk to people.
I’d tell him that programming languages will change.
I’d tell him that Linux will become an important part of his life.
I’d tell him that he’ll spend decades fixing things, learning things, building things and occasionally breaking things.
I’d tell him that he’ll make mistakes.
I’d tell him that some of those mistakes will still bother him fifty years later.
And I’d tell him something else.
Keep asking questions.
Because the questions are going to take you somewhere.
You just don’t know where yet.
The Lesson.
The biggest lesson from that old VIC-20 isn’t really about computers.
It’s about beginnings.
Great ideas rarely arrive wearing a name badge.
They usually arrive disguised as curiosity.
A teenager playing with BASIC doesn’t know he’s learning computational logic.
A boy learning disco steps doesn’t know he’s learning timing and coordination.
A young man reading programming books doesn’t know he’s developing a lifelong obsession.
And sometimes a foolish mistake becomes a reminder that character matters more than cleverness.
We don’t always recognise the foundations while we’re standing on them.
Sometimes we only see them decades later.
Then we look backwards and realise:
Before the idea had a name, it was already there.
Author’s Note.
There is a peculiar privilege in being old enough to remember the beginning.
I don’t remember every technical detail perfectly. I don’t claim that every memory has survived fifty years untouched.
But I remember the feeling.
The feeling that there was something inside these machines worth discovering.
The feeling that a computer could become more than a toy.
And I remember that little BASIC program that asked questions, assigned weights and produced a recommendation.
Perhaps someday I’ll write it again in Python.
And when I do, I’ll probably smile at the absurdity of it.
Because the program will be modern.
The computer will be modern.
The language will be modern.
But somewhere inside it will still be that nineteen-year-old boy sitting in front of a VIC-20, wondering:
“What if the machine could help me think?”