Like many people, I started my development career from another role. I taught myself coding and then built software to help the business and myself. It was well received, but I did not feel like a "real" developer yet.
This experience convinced me that software was what I
wanted to do, so I looked for a junior developer role. This wasn't easy,
most companies want people who can come in and start being productive
right away, and there were many skills I lacked from not working in
a"true" software development environment. Eventually, I was taken in as a
When handing in my resignation, I was offered a
pay rise to more than I would be getting in the new role. I was
also offered a new position, the position of "Senior" developer.
I had a choice. I could stay, and drive development projects, leading a
team of newly hired junior developers. My career would leap to a role
of seniority and if I was to move on I could say I had been a "senior"
Or, I could move into a new company as a junior developer, where I would be mentored, and surrounded by more senior developers.
I chose to move.
wanted to see how it was"really"done. How developers work together, how
they feed off each other, how they learn. I wanted to learn. I could
not do that if I was the most senior developer.
Staying was never
an option. I'd be a fraud. The title of senior can be extremely
subjective, given for many reasons. Tenure, age, comparative skill, or
Yet I see this often. Developers who have always
been a senior developer don't get to see how it's "really" done, how large software departments work together. You can't always work out the best ways to do things by yourself. You need exposure to different practices, methodologies, cultures, personalities, and skill levels.
Moving to a junior
role was the best thing I ever did for my career. It taught me to
understand the development process from the ground up, filling in many
skills gaps from being self taught. Some of these skills were technical,
some were interpersonal, but the most important, were both.
Now I realise that the maintainability of our code is one of our most important skills. It's often said that we write code once and maintain it ten times. Most importantly, other people maintain it. If your code isn't maintainable, then bugs happen. If your code is not maintainable, it can bring down companies.
developers who have always been senior may not learn the importance of maintainability. They never have the pleasure of being told off by more senior developers for sloppy, non-reusable code. They didn't have the privilege of being humble and being shown how to write code that others can work with. Nobody complains to them about their code because they are always more senior. So they tend to get away with it, and often end up in charge of a hard-to-maintain monolith that nobody wants to work with.
Senior developers should recognise that without exposure to different working dynamics, or other developers who have worked in different environments, they may be missing out.
Management should compliment in-house, home-grown senior developers with senior developers who have experience where they were not the most senior. Well rounded senior developers with a broad range of experience, who are not afraid to speak up when code is not written with others in mind.
If I had stayed as a "senior" developer, I may never have learnt the value of writing code for others. And I may never have realised.
Sunday, April 08, 2018
Monday, March 26, 2018
Classes should only have one reason to change. We should attempt to increase cohesion between things that change for the same reason, and decrease the coupling between things that change for different reasons. Classes should do one thing and one thing well.
Violations of the Single Responsibility Principle can cause code to be difficult to test and maintain, and can make it easier for bugs to manifest.
There are a few symptoms of SRP violations which can give warning signs of these issues.
Obviously large classes and methods do not always point to SRP violations as there may be a requirement for a significant amount of logic. However, it is usually a good sign.
Large methods are more likely to point to an SRP violation than large classes, or at least too much cyclomatic complexity. You'll become aware of this when you attempt to cover the method with test cases, and realise there are excessive test combinations required.
Too many injected dependencies
While this may depend a lot on how you set up your services, lots of injected dependencies may suggest that the class is doing too much, and may be violating SRP.
Too many tests per class
If a class has too many tests, or the tests need to change often, this is an indication that there may be too much complexity, too much setup, and this may point to an SRP violation.
Described with and/or, or encompassing words such as "manager"
This is a sure sign that your class or method is doing more than one thing. For example: a method called CreateOrEditRecord() or a class called "InvoiceHandler" are red flags, and should be investigated.
Logic in Views
Logic in your front end almost always means that you are violating SRP, because a view's responsibility is to render an output. As soon as you have two pieces of logic in a view, it's unlikely they'll be for the same reason, because they'll be for different elements on the page. This immediately makes it impossible to unit test the view.
Also, because of the standalone nature of views, there's a good chance you'll have to violate DRY in another view.
Move that logic up to a model, a controller, a helper, or a service where it can be properly unit tested.