We put love into everything we do for our clients, because every project is unique, and every project is special.
We like analogies because they help us communicate complex ideas. Each project we take on is like a new baby to us. We love them all equally. Sometimes they frustrate us, or keep us up at night. But overall, our projects are incredibly rewarding to us. We hope that our software projects will be productive members of your organization for years to come.
It's better to provide a healthy environment and let the baby grow into their future selves than it is to attempt to force the child to be exactly how we think we want them to be. The same is true for software.
The more complex a proposed software project is, the more flexibility we should allow for it to evolve naturally during development. Despite thinking we know what we want, requirements always change - often by a lot. One of the best ways to ensure a software project fails is to attempt to plan every detail up front and stick to the plan.
Instead, the best practice for modern software development is to focus on micro experiments, which grow into tiny prototypes, which evolve into small features, which mature into solid systems.
When we start small, it's easier to catch bugs, protect existing systems, pivot to better approaches, and throw away poopy diapers.
Babies start their development by laying down their neural and circulatory systems first, since everything else depends on these, followed closely by the beginnings of their skeletal system. Of course, all of these happens simultaneously to the development of the placenta, ensuring that the baby can "eat" in order to grow.
We begin new software projects by setting up the core infrastructure around the project to enable faster iterations once we dive into the code. Essentially, this means:
With these basics in place, we now have a well-functioning "software development machine" in place to make writing, testing, and deploying future code as efficient as possible. This infrastructure will change as the project progresses, as well. Nothing is set in stone.
Babies are very fragile, especially before they're born (pre-beta launch). The womb protects them, keeping them isolated and protected from danger while developing core functionalities.
We protect early software by keeping it isolated from existing systems, as well. When it's time to introduce our new baby to existing systems, we do so carefully and with well-defined controls.
It's hard for parents to push their babies into uncomfortable situations.
"What if they get hurt?"... "They're not ready, yet!"
... but this is how they learn and grow!
Even though we want to protect our babies, we also know that before we think our new software projects are ready, we need to get some real-world feedback. If a child never gets feedback from peers, they never learn how to live among people. If they get delayed feedback, they may have already formed poor habits. If our software gets delayed feedback from stakeholders and users, we could wind up implementing the wrong features or creating a system that "nobody wants to play with".
So we should protect them, but also encourage them to explore... how can we balance the two?
With baby gates and bicycle helmets and pureed foods and close supervision!
For software, we ALWAYS write automated tests as we implement new features to make sure that the code we're writing works as we expect NOW, and to ensure that it continues to work as we expect in the future.
At the same time, we're careful not to go overboard on tests... focusing on the big picture and letting the details work themselves out. Unless they're important details. If we find our software getting "hurt" by specific issues in the future, we can always write more tests to cover these new situations.
After a bit, we'll have a very comprehensive automated testing suite that protects the software from unintended side effects of code changes, protecting its long-term stability and ultimately freeing the developers to feel comfortable about making faster changes in the pursuit of new features.
Parents have the ultimate say in how their children are raised.
Our clients have the ultimate say in how their software is developed, and they should be active participants along the way. This is accomplished by:
It can be tempting to put an iPad in front of our babies to keep them quiet, or feed them ice cream and chicken nuggets every night for dinner. But taking shortcuts like these, especially early on, will have adverse effects on who our children grow up to be.
The same is true for writing software. If we take shortcuts now, we'll be left with a mess in the future. Be disciplined. Do the uncomfortable stuff while the project is still small so that it grows straight in the future.
Doing the right thing now always pays for itself later.