Professionalism and Programming
In a world where it’s not inconceivable that everything, including the kitchen sink, might have a piece of software in it it is evermore apparent that this software should be taken seriously. We, as the wranglers of code, need to be aware of the repercussions of our actions as well as the responsibilities we have when we create software. As Uncle Bob says in The Reasonable Expectations of your CTO: “We must act like professionals”. Given a certain amount of responsibility it is amazing how quickly the quality of our code/process increases when there is any level of accountability involved. If you know someone will be looking at your code on a regular basis or come back to you after your released code has failed to hold you accountable you will undoubtedly keep it clean. If we think of ourselves as being part of a group of professionals as opposed to being individuals doing our own dark biding we can increase the overall quality of our code and, consequently, the overall enjoyment of creating that code. The advantages of thinking as a group and acting as professionals are many.
We are social creatures, we are not built to sit alone in our own minds stewing in other-worldly confusion. It is not in this way that we should write code. We should perpetuate and propagate in others our ideas so that they can be shared, mixed, re-mixed, or maybe even completely reshaped. We shouldn’t be afraid to lay our code on the table and point at the weaknesses because by doing so we create a collaboratively successful environment that produces what no individual can hope to accomplish. Our code should not be owned by any individual and should be soft and malleable to accommodate team work and inexpensive revisions. By not being afraid to accept other’s ideas we must always be able to change our code without fear of breaking and cleaning it. At the same time we must also not be afraid to break and clean another person’s code but instead, as professionals, we should see it as our duty to clean it. A professional understanding of and from your colleagues makes this process easy and, most of the time, enjoyable.
Another great benefit of working together is the advantage of accountability. At first this might seem scary because you are not used to other people looking at your code and analyzing it. But once one overcomes this fear the vast improvements become apparent. Not only will you code better because of the expectation that someone whose opinion you respect will be looking at your code but your level of professionalism will rise as well. In this way accountability makes you create a higher bar of quality for yourself as well as those around you. Like a rising tide before you know it you look around and the overall level of quality for the entire group is suddenly much higher.
An incidental but crucial effect that thinking and working as a team has is for the ability to cover for one another. Just because I decide to take a Bahama beach cruise shouldn’t mean that the rest of my team can’t continue forward. Bob uses the analogy of a crew on a ship, imagine being out to sea and one of your fellow sailors fell overboard and was swept away at sea. You better believe the other sailors know how to do that person’s job otherwise the entire crew is dead. As sailors on a code caravel we should be able to jump into any place where we are needed to keep the ship moving forward. This process is important when we apply it to another crucial idea from Bob’s talk: Continuous Aggressive Learning. Most importantly when we can cover for one another we are learning from one another. We don’t use entrenched ways of doing things that we’ve been stuck with for years because we are constantly exposed to new processes and ideas. We are always teaching one another even when we are at the same level of understanding. In this way we increase our combined professionalism by always knowing we can move forward.
The underlying message of Bob’s talk is how to inject professionalism into a field that he observes severely lacks it. It is our responsibility to make sure that the bounty of software we use on a daily basis doesn’t kill us or cause some catastrophe because we are, after all, responsible for the code that we write. Through the application of agile principles he lays out many different places where programmers can improve toward this goal and inject professionalism into their work. I highly recommend watching this talk as Uncle Bob’s delivery is akin to watching classic Simpsons and the message is enlightening, giving us something to aspire to in our professional lives.