Quest: Learn to write adaptable software

When I was about 12 years old, I bought a Java book with my first allowance.

With books and the internet, I taught myself how to code.

Initially I recreated small games, but over time also started creating small utility programs for myself. I programmed by myself for years.

I learned, the need for maintainable code, the hard way.

I was building this game my brother and I came up with.

We imagined it to be a MMO (massive multiplayer online) game.

And it was a massive undertaking...

Trying to build something

so big
after school hours
with limited technical knowledge

was crazy really.

The project kept growing, and there was barely any architecture to speak of.

I didn't even know version control existed!

So the project eventually grew out of control.

I was unable to keep all the pieces in my head at once.
I forgot what I was working on.
I forgot what existed already
the constant stress of "will I be able to get to a working state ever again?"

Eventually, I decided to start from scratch.

So I put all my old code into a package "v1" and created a new package "v2".

And I started from scratch.

I had learned things from my previous failing.

This time was going to be different.

I had new ideas on how to do things better:

design stuff in UML up front
start small, and get that small part to work
make smaller changes (aim for less than one work-evening)
jump from working state to working state
don't get distracted (hard!)
backup the entire project once in a while (tedious!)

After a while I took a break.

The break ended up being a couple of months long.

I paused working on it for a couple of months.

When I picked the project back up...

...it was impossible to get started.

What was I doing when I stopped?
What is finished what is done?
How does this thing work?

So I decided on a rewrite.

I created a package "v3" and started anew.

With new tools, like 'design patterns' and better practices and ...

Every rewrite, I got a bit farther.

But never managed to get something enjoyable to play.

Nothing came close to what I imagined.

There were lots of small success.

But in total, the result was not a success.

I never got to play the game we imagined!

Starting from scratch was fun.

Greenfield projects always seem so much more promising.

But they would slowly but surely, come to a grinding halt.

Sucking the joy and energy out of coding.

Adding more and more friction to the project.

And finally it's easier to throw everything away, rather than continue.

But the lessons I learned, stick with me to this day.

The successes and the failures.

But most of all the experience of

the friction chafing the joy away,
 while the project grinds to a halt.


And the only thing I could think of,
 to ever reach what we imagined,
 the only option I had left...


...was to throw it all away.

This experience forms the foundation for my quest.

My quest for technical excellence

My quest for adaptable software

How do I write software, so that it does not force a rewrite?

How do I write software, so that it continues to be enjoyable?

Topics of interest:

agile methodologies
software crafting (former software craftsmanship)
TDD
clean code
refactoring
continuous deployment
design patterns
software design
software architecture
theory of constraints