The Jane Scenario

While thinking about Walking In Space, I was motivated by how teams worked and communicated. But I am a developer and in the back of every developers mind is the thought “If only I could just do it all myself, it would be so much easier”.

At first blush, this is an impractical and unlikely hypothesis. Most useful and comprehensive solutions are the result of teams, not individuals. But after turning it over a bit, I thought that it might be a good place to start. Maybe thinking about an individual building a solution for them self might be a way to reason about what made this hard in a team. At any rate, it was cathartic for me to write it out so here it is.

Jane had a problem

The problem was about information, it was an I.T. type of problem. This problem was very frustrating for Jane, and doing it manually was repetitive and prone to error and Jane had a lot better things to do with her time.

Jane could visualise a solution

Jane had an exceptional imagination and was able to imagine a solution that could solve her problem. She didn’t need to write it down or sketch it because she could see it in her mind, she could see all of the components, she could see all of the internal and external interfaces, she could see how it would look, she could see herself using it and she could see that it would solve her problem adequately.

Jane knew where to start

Jane knew that there was no existing solution to her problem 4 million apps on the various app stores and nobody had solved exactly this thing.

Jane however did know about a particular stack of technologies and abstractions, api’s and languages, that was the right type of stack to build her solution with. This stack already solved some of the key complexity that her solution would need so it felt like a good place to start building. It was also a stack that Jane was comfortable with, she knew about all of it’s interfaces, capabilities and limitations.

Jane could walk the walk

So Jane opened up her laptop, fired up her development tools and started work.

Jane started by configuring and installing the database and the http server. Then she built the execution and bootstrap code for her solution, the part that runs. Then, Jane created the components that were dependent only on the interfaces of her chosen stack, the data access layers and the message handlers.

Then Jane started building the domain elements of her solution, the schemas, models, services and controllers. Then Jane built the User interface for her solution, the app that she would interact with with her eyeballs and fingers.

Finally, after Jane had finished the last bit of styling on the big green button marked ‘Go’, Jane deployed the solution and installed the app onto her phone and opened it up.

When Jane clicked that big green button, the app sprang to life, everything that Jane expected to happen happened, every piece of information Jane needed was in the right place and every action she made was answered by a smooth and correct response.

Jane had achieved it.

Her vision for the final solution and all of the components and interfaces was correct and met her needs adequately.

Her chosen starting point, the stack was the right choice, was intuitive and bug free and all of it’s abstractions were water-tight.

Jane had built her solution, from the least to the most dependent component, from foundation to spire exactly to the plan in her head.

No Waste

She hadn’t tested what wasn’t broken. She hadn’t re-implemented or re-factored. She hadn’t written stubs or test harnesses. Every bit of Jane’s toil and effort had moved her inexorably and directly towards the final, useful solution.

Straight Line

In solution space, Jane had walked a perfectly straight line from the starting point of her stack, radially outwards to the point of her final solution.