Welcome to the newest series of the WeAreDevelopers Magazine – Dev Talk Recap. This article recaps an interesting talk by Tobias Modig who gave advice about getting old(er) as a developer and slowing down.
What you will learn:
Thoughts of the speaker and the community concerning age.
Why slowing down will actually improve your development process
About the speaker:
Tobias Modig is currently a software development consultant at Citerus AB in Stockholm. He self describes a passionate software craftsman with a love for open source technology and agile methodologies. Sharing his knowledge is also of high value for him a he recently spoke at WeAreDevelopers Live.
Turning old as a developer is hard. It is hard to stay relevant, hard to keep up with waves of younger newcomers and all these new frameworks.
What is old from a developer's perspective?
At first, Tobias tells a story about his definition of old: About 15 years ago he worked at a big travel company in Stockholm, together with 15 other people. They were all working on a website meant for trip bookings. Tobias remembers two old men in the team who worked on a maintenance system written in Fortran (almost ancient by development standards). But suddenly those men were gone and so was their whole system. They were replaced and, as far as Tobias knows, they both went straight to retirement. He still admires the two for staying with their passion until the bitter end.
So according to Tobias, being old as a developer is correlated to the languages you use and how obsolete the systems you are working on are.
Next, he wants to know a bit about his audience. First, he asks: “Do you consider yourself to be old?” and “What do you consider being old?” The results back each other as over 70% don’t think of themselves as old and almost as many stated that age is mental rather than physical.
Afterward, Tobias reveals 28 years as the average age of developers. Since this sounds very young he started to compare them with those of other professions. Please keep in mind that the following numbers refer mainly to pre-corona surveys. Other jobs that require a high education level, like teachers and doctors, averaged at 42 and 51 years respectively. Project managers are also quite old with 42, which is interesting because they require more or less the same level of education as developers.
When looking at professions without the need for a university degree we see a bit of an age shift with bartenders and dishwashers at 34 years. But nothing as young as the 28-year-old developers. So we are one of the youngest working people in the world and when taking the level of education needed into account we are definitely the youngest.
Tobias asks the audience how many years they will continue their job as a developer. The result matches perfectly with the broader survey. The expected number of years staying active is eight. That’s a problem according to Tobias as the developer tribe is replaced way too often, throwing competence at the scrapyard. People are using the job as a bouncing pad to other professions. Or are they scared away? What makes developers quit? The next poll shows that one reason would be losing the spark. Tobias thinks of this as a sad but also valid explanation because if one does not have a passion for coding he or she shouldn’t do it as a profession. The second (and also most popular) reason for quitting is to be promoted. In combination with losing the spark, it’s comprehensible according to Tobias, but otherwise, it’s no good idea as he personally had a bad experience with it. When he was offered to become head of development at the .net place it flattered him but soon after he realized that it was very boring and a total waste of his experience and expertise. Rather than being involved in the development process itself, Tobias was forced to sit in budget meetings, talking about resources and arguing with the advisory board.
This tells us if you are a good developer, it doesn’t necessarily qualify you to be a good manager or product leader. In fact, the opposite is probably just as common. There is actually a term regarding this:
The Peter Principle
The Peter principle states that a person who is competent at their job will earn promotion to a more senior position which requires different skills. If the promoted person lacks the skills required for their new role, then they will be incompetent at their new level, and so they will not be promoted again.
In other words: people will be promoted until they reach their level of incompetence and there they will stay. This will lead to “The Peter’s Corollary”: In time, every post tends to be occupied by an employee who is incompetent to carry out its duties. According to this, we have companies where more or less everyone is incapable of doing their job. Of course, that’s a bit satirical, but to Tobias, it carries quite a lot of truth as well. There we have the expected developer life circle, where people start at a coding job, move on to team lead, and finally some kind of manager. To Tobias, that’s mostly moving people from being competent to being incompetent. We have known this for more than 50 years now and it’s still one of the most common reasons for developers to quit. There is actually a course on Pluralsight for this kind of career jump. Tobias' solution would be to give the developers a decent salary, reward them frequently and let them do what they are doing best. He also strongly advises coders who think about changing careers to stick with their passion as he knows it is not worth it.
Is it a problem to get old as a developer?
Mark Zuckerberg once said that young people are just smarter. Tobias would say he is wrong as most Nobel Prize winners these days look more like American presidents than developers. Apart from that, people in the tech branch must never forget that they need to stay relevant and confident in what they are doing.
How about the slowness? Tobias would say that slow is good. Don’t think about it as something bad as we actually need to slow down a bit.
Worried that TDD will slow down programmers? Don’t. They probably need slowing down.
Tweet by J.B. Rainsberger
Tobias thinks that too many people mix up rushing with speed. He compares it to Usain Bolt, the fastest man on earth. When he has run 100 meters, he is done. But when developers have run 100 meters there are often many more to run as software development resembles a marathon rather than a sprint. So, we should be less like Usain Bolt and more like Ricardo Abad. The latter is a Spanish ultrarunner who holds the world record for consecutive marathons run on consecutive days (607). And even more impressive: during this, he continued working in a factory for eight hours per day in shifts. According to Tobias, that's the mentality we should have. We are long-distance runners - not sprinters. The right way to develop is to slow down and find a sustainable pace.
Why are we rushing like this? It’s probably ascribable to a combination of things, but one major reason is deadlines for sure. Tobias even compares them to poison as they are mostly random dates that someone estimated a long time ago. Another rushing factor may be the lean and start-up movement. Here we are told that the only thing that matters is to deliver.
What is slowing down? Tobias believes that the cure for all pressure is to slow down. So I want to end this article with some words of him:
Slow down to practice. Take time to improve your skills.
Slow down to tweak the process. Streamline them, eliminate waste, and make sure to have a good outcome.
Slow down to plan ahead. We usually do this the least when we need it the most.
Slow down to refactor. Always leave your ground a little bit cleaner than you found it.
Slow down to build with quality. Build quality software from the beginning because this is the only way to be fast in the long run.