A lot has changed over the years, yet some foundational principles hold true. We've organized what we've learned from other great thinkers into sections that we view as pillars of good software systems and teams.
As new technologies come and go, we're constantly examining our assumptions and modifying what we view to be best practice information.
Our aim in putting this resource together is two-fold. Firstly we want to support eager learners, regardless of their experience level. Secondly, we want prospective clients to understand what we value in the software development process.
While it will likely be a while until computers can understand human intention, they are already really good at automating the verification of very specific items. Leveraging this automated verification of known and specific outcomes can free up developer time to do other high value activities.
The act of automating a task has the additional benefit of bringing complexity to the forefront. If you pay attention to those cues, it will make spotting software design flaws much easier. Some of the areas that computers can be leveraged to great effect are listed below:
No matter how much you attempt to avoid failure of your software systems, if it's being used by a meaningful amount of people, your system will fail. No amount of preparation will avoid this. The key is instead focusing on designing your system to be resilient to various sorts of failures.
There are tools and approaches that can help you do the following:
The needs of an organization changes over time as it learns more about how to reach its stated goals. As such, the software that an organization leverages needs to be designed to be easily changed and reflect its new set of discoveries. Unfortunately, complexity increases as functionality increases. An organization's goal should be to make that a linear relationship instead of an exponential one.
Many small details need to be done correctly in concert in order to have the resulting software be adaptable. Below are some principles that can guide you towards creating adaptable software:
There is no "perfect" way to build a system. Building quality software is all about making judgment calls without a full understanding of the consequences. As software systems evolve, so too does the team's understanding of the trade-offs they made along the way. In order for teams of developers to deliver high quality software, those teams must commit to continuous improvement. Doing the following is what is required to continuously improve:
Teams enable individuals to use their different abilities, values, and beliefs to accomplish things they likely aren't able to do by themselves. Given the broad set of differences between individuals, there is a LOT that goes into working effectively as a team. However, making improvements to teamwork can have a profound impact on an organization's ability to deliver quality software quickly. Below are some aspects of teamwork that can be intentionally improved to yield better results:
Often overlooked, fun is a reliable indicator of the health of an organization. While all activities of building software can't be fun all the time, having fun can strengthen relationships (promoting better teamwork), reduce stress (promoting clearer decision-making), and increase motivation/focus (speeding up the process).
Fun is a state of mind that individuals consciously or unconsciously enter based on a unique set of factors. However, there are some underlying shared principles that can be applied to increase the chance of an individual having fun:
Our guide is incomplete, it only represents the thinking and resources that we've been exposed to so far. We do not pretend to know everything. Help us broaden our horizons by contributing to our repository on GitHub.