Monthly Archives: September 2016

Professionalism

We are not professionals. Doctors, lawyers, civil engineers. They are professionals. In comparison, the development community are a bunch of monkeys. We are banging on keyboards, hoping to knock out the works of Shakespeare.

There isn’t consensus on what the word professionalism even means. But like pornography, we all know it when we see it. Some common themes seem to be:

  • considerable training, over and above most jobs
  • vocational
  • continued training for life
  • entrance exams
  • a code of ethics
  • upholding standards
  • membership of professional bodies
  • working for the public good

In exchange society grants:

  • higher pay
  • protected designation
  • autonomy on deciding what is good practice
  • self-regulation
  • respect
  • higher status

Software development hits some of these highs. We have professional bodies like the IEEE, ACM, BCS but not everyone is required to be a member to call themselves a developer. We do tend to get people who view it as a vocational career and care about the broader implication of their work in the community. But we don’t have a universally recognised code of ethics. We do not weed out bad actors effectively or rank junior to senior members consistently.

How many times have you said no to your boss when you know what they are asking you to do will end badly? Not because you don’t want to do it, or you think it is the wrong business decision, but because your professional opinion about the code tells you it will not work. Business leaders are suppose to make business decisions. If the company really thinks that after careful consideration, getting the new product out before CES is worth so much that they are willing to pay to fix all the bugs afterwards, then it can be ok to rush ahead, move fast and break things, if that’s what it takes to win. But often they haven’t understood the risks, they don’t know how much it will cost and you can see disaster coming.

I’ve asked developers I respect about this issue and most of them have stories of when they have said no. When it was just so clear that this change wasn’t a good idea that their ‘professional pride’ wouldn’t let them stand ideally by and allow it to happen. But for most people these stories are the exception. They happen so rarely that they are stories people tell to prove a point. There are far more stories that people tell of being forced into doing things that they knew would end badly but they did them anyway in order to avoid a fight with their boss. Anyone working as a developer has something to lose by fighting with their boss. A livelihood for their family, stock options, reputation, or just the loss of a comfortable situation. It’s not easy to say no and risk loosing all that. I think part of the reason we don’t push back more often as an industry, is that we aren’t sure ourselves which things we should be taking a stand on.

Compared to other industries, software development has not been around that long. We had a very slow start from Ada Lovelace in the 19th century to teams of developers in the 60s to a recent explosion of millions of developers today. But we still don’t know how to teach it that well. We don’t have an agreed upon practice of how to build software. Or an idea what our place is in the hierarchy of a company. There is a new javascript framework out each week but we still haven’t agreed on the ideal way to test. Unlike some industries we work on the insubstantial, the invisible. You can’t jump up and down on software as you might a bridge to test if it’s strong enough to drive over. People outside of the industry can’t tell how good our software is until it breaks. Most developers find it difficult to judge other’s work objectively. We have a lot to learn, that keeps changing under us, but no where near as much as doctors have to contend with.

So what do we need to do? I think it is going to be a long journey. I cited doctors, lawyers and civil engineers at the start of this post as professionals. They have all been practicing a few thousand years so we have some way to go yet. But there are a few signs that we might be heading in the right direction.

We have a lot of passionate people who consider it a vocation. We have a lot of people who view the public good as one of their main motivations. We have professional bodies who try to raise standards. If you are reading this then you obviously take continued professional development seriously.

So what next? I think if we keep pushing the boundaries of our knowledge of patterns, best practices and hold one another accountable then each day we will be taking a step in the right direction.

I have a friend who told me that when they started medical school they where told that it wasn’t a competition. Other departments grouped students in to top 10% or bottom 10% etc. to award grades. This created a zero sum game where the worse someone else did the better it was for you. Why would you help a fellow student in that situation? But here in medical school, you would fail if you didn’t help each other. There was no way that anyone would get through medical school if they didn’t have the support of other students. The course was designed such that you couldn’t complete it on your own. The advice was clear. Help each other, share knowledge and encouragement. You won’t make it alone. Developers are often quick to criticise each other, to point out the flaws in arguments because we see our profession as so logical and data driven. But that doesn’t mean we can’t help each other. If someone doesn’t know something that you do, great, that’s an opportunity to help someone and increase the total competency level of our profession. It’s also the right thing to do.

As a final note I wanted to mention that there is an argument for defending amateurism. G.K. Chesterton said “If a thing is worth doing, it is worth doing badly.” He was subverting Philip Stanhope, 4th Earl of Chesterfield who wrote “Whatever is worth doing at all, is worth doing well”, but he is often misinterpreted as meaning that any attempt is better than no attempt. In fact he was writing in his book “What’s Wrong with the World” about the importance of amateurs. He said “that the most terribly important things must be left to ordinary men themselves – the mating of the sexes, the rearing of the young, the laws of the state”. Professionals might have many years of experience, they may be able to draw on the research of other professionals in their field. But the amateur does these things out of love, not for money.

Many people get into the world of development, not through formal training but through enthusiasm. They are self taught ‘hackers’. These are the people who stay up all night to solve that one last problem. Without these people the Open Source community would not exist. Companies have now pilled on because of how popular it has become, but I don’t believe they would have started what we see today as Open Source on their own. With amateurs we get passion in our industry. We get nonconformity. We can avoid gatekeepers and broaden the demographics of developers. Becoming more professional in the work place is surely a good thing, but lets not forget about the amateurs.

The Biggest Reason to Test

There are many reasons to write tests for our software. Validation. Verification. Non-functional requirements testing. Catching mistakes. Identifying edge cases. Documenting defects. Being the first user of our own interface. But I think one reason to test ranks above all the others. Maintainability.

I have seen and heard about many projects that start off promisingly. Features are delivered quickly by a skilled development team. Managers and Executives realise they have a great team that can produce the goods and decide to double down on the product. The team is encouraged to move quicker, to deliver features in shorter and shorter time frames. To take on more ambitious goals. In order to keep up with this ever more demanding pace, the development team cut anything that is not required by the current push for features. This normally includes thorough automated testing.

The problem occurs sometime later, normally about 2 years into the project, when the managers realise it now takes their team much longer to implement new features. They have the same number of developers as before, they are working the same number of hours. So what’s wrong? The code has become so messy and unmaintainable that no one is confident making changes, so everything takes much longer. There is then much handwringing and pointing of fingers as to whose fault this lack of productivity is. Then the project is cancelled.

This is a build up of technical debt. By technical debt I mean: the business owes a debt to the development team. By borrowing from their future selves the business has decided that moving quickly now is worth more than it will cost to pay back the loan later, making more money overall. This is the same calculation businesses make when taking out monetary debt. When the business makes this decision consciously then it is their decision to make, and it will either work out or not as they press up against market forces. But when this decision is taken lightly, with either no thought to the consequences or when non-developers are dismissive of the implications being warned of by the development team, then the whole project can fail.

By building in to your process thorough automated testing with aggressive refactoring you can attempt to hold off this fate. A good suite of automated tests, that can be run easily by the whole development team allows you to add new features and refactor with confidence by showing that your changes didn’t break anything. By being able to run tests quickly and repeatably developers need to keep much less of the program in their heads when making changes, so that they can concentrate on the important changes they are trying to make. I don’t think I can over state this, tests are key to maintainability. If you don’t want your program or your business to be around in a years time, then you can take all the risks you want to move quickly and break things. If you want to maintain a steady pace of development without a gradual slow down, then you need to invest in testing.

Most professional developers now seem to now agree that tests are necessary. But one of the marks of a professional is that we stand up for what we think is in the best interests of our client. We need to do more of this.

HTML programmer is not a career

HTML programmer used to be a job. In the early days of the world wide web there weren’t many people who understood how to make a web site. How to stand up a LAMP server, or even customise a landing page from an ISP. This meant that you could learn a bit of HTML and pick up a few basic design concepts, right click – view source on any pages you liked the look of and copy and paste your way to a new site.

As a software developer you have heard of other people worrying about their jobs being automated. Typist is no longer a job. Taxi drivers are worried about Uber and autonomous vehicles. Factory work is going the way of mining with more and more automation in factories. Not everyone can re-train as a brain surgeon.

But you’re a programmer, so life is good.

Your skills are in demand and you are making a decent wage. More than a lot of people. But if you think you are immune to this problem, you are dead wrong.

Now HTML is just one of the many skills you need to be able to be a full stack developer.

Back-end language, front-end language. Styling, design, test automation, agile, DevOps. A modern language that shows you know what is cool in the industry. A portfolio of open source work to show you give back to the community and are not all about money, and how you work on code all the time even when not at work because you love to code so much.

Designers have 99 designs to contend with, we have Upwork (now including oDesk and Elance), and freelancer.com where anyone can find a coder on short notice.

You are not a commodity and shouldn’t be treated like one. But the world isn’t fair and no one is going to give you more than the market price for your skills.

As a developer  your biggest asset is your ability to learn new things. To solve new problems. To be creative. Progress can be held back but it can not be stopped. You can either find a hole to hide in and ride out your current skills until retirement, or you can keep learning.

As a developer you have a huge advantage over most people when dealing with this problem. Part of your training, either school or on the job, has been to solve problems you’ve never seen before. To learn new things quickly and to apply that knowledge to complex problems. By learning the underlying fundamentals of programming as well as the practical skills to apply that knowledge you have already started to build up the skills you need to achieve bigger and better things. You are in an industry where you can move up the value chain to solving wider business problems and that’s where the money really is.

This is where we can help. DistributedDeveloper can show you the skills you need, the table stakes you need to stay relevant, and the areas where you can gain additional skills to stay ahead of the competition.