Previously on Learn React from Scratch Series: Learn React: Your First React Component ExplainedPreviously on
Finding the right developer for your team can often be a hard task. Sure, they might show signs of technical chops and pass all the psychometric tests — but how effective are they really as developers?
The effectiveness of a developer in a team and their ability to deliver robust code can’t be judged based on their number of years working alone. This is because someone with five years’ experience may not have gone through the same intensity of developmental pressures and output as someone with two years of experience. A particular senior back end developer may actually have the equivalent of a junior’s front end skills.
So, how can you tell the difference between highly effective developers and those who are just developers? Code knowledge can be upgraded, but the speed of this upgrade is often determined by a set of common traits, regardless of a developer’s current specialization or skill level.
Large Domains of Knowledge
It doesn’t matter where a developer sits on the spectrum of software development — you can judge a developer’s potential effectiveness through their depth and breadth of knowledge domains.
A knowledge domain refers to what a person knows about a particular subject or topic. The wider the knowledge pool and topics, the higher the likelihood they’ll be able to make connections and comparisons between the problem presented and what they know.
This is because creating software is a translation job. When a developer knows more than just how to code, they’re better at both understanding your requirements and creating solutions.
Developers encode the rules and laws of a particular reality and set of expectations into a form that can be translated and interpreted by machines.
Having depth and breadth in multiple knowledge domains outside their main sphere of work means that they have a faceted understanding of multiple realities. It makes them efficient developers because it takes less time for them to figure out how a problem works before translating it into code.
Knowledge domains exist in the theoretical world. Cross-functional skills sit in the practical space of execution. It’s one thing to know, but it’s a completely different set of skills to be able to do something.
When an individual has cross-functional skills, they’re usually a generalist with multiple field experiences — sometimes in code, sometimes outside of it.
An effective front end developer, for example, may have a background in art or design — a cross-functional discipline that’s directly related to the fact that they’re experts in coding. The scope of their experience isn’t limited by just the things they code, but also a practical experience beyond the digital interfaces they work with.
To be cross-functioning means that you’ve had practical experiences in other areas beyond your discipline. This is also a reason why new developers that have switched from a different expertise, or have worked in other industries previously, often excel at turning problems into effective solutions.
Code philosophy is a discipline that not many delve into once they have a working application.
There are two kinds of developers out in the wild. The first kind follows the thinking of ‘if it works, don’t touch it,’ and the second are the ones that are perpetually curious about how and why things work the way they do. Sometimes they’re limited by the time they’re given to work on a code, but they have that desire to know nevertheless.
It’s this curiosity that becomes the main and visible sign of a code philosopher’s mind at work. Their depth of experience may be limited by the number and intensity of projects they’ve worked on, but it’s a skill that’s hard to cultivate if it doesn’t internally exist.
The word philosophy itself comes from the Greeks, and it translates literally to ‘love of wisdom.’ To be a code philosopher means one is continually upgrading their personal skills and spheres of knowledge in order to better understand the tasks they’re performing, with a wider mastery of code beyond just the act of coding itself.
A code philosopher explores paradigms, techniques, data, structures, architectures, and modes of thinking toward a particular problem before they decide on a solution. They’re not the kind to jump right in. Instead, they take a step back and work on seeing the issue for what it really is.
Givers Rather Than Takers
Let’s be honest, a majority of our current knowledge comes from the internet. We rely on the help of others to solve our coding problems. Without these people, we’d remain stuck for a very long time.
Givers are the people that contribute back to the larger communities that have helped them grow as a developer. When givers give, they’re transmuting their knowledge for others to consume — meaning that they have something valuable for someone who may be of lesser skill.
The act of giving doesn’t have to be a grand gesture — it can be as simple as posting a reply on a Reddit thread, pushing a small but public repo that solves a common pain point, or a tweet here and there about things the giver has found interesting on the internet. Often, givers will also help out colleagues offline — maybe a junior in the office, or someone on their own level — to understand something differently.
Many developers tend to be passive lurkers, taking without giving back to the ecosystem. While the ecosystem itself is sustainable without their contribution, the act of giving back makes a developer superior to their taking peers because they’re engaging with others beyond themselves and their immediate codebase.
Givers are more effective developers than takers because they’re skilled enough to transfer their knowledge in a way that another developer can understand. When someone is able to do this, it means that they have a certain level of understanding toward a topic that takers have yet to demonstrate.
Effective developers are good at what they do — but sometimes that’s hard to judge until they start coding and interacting with the rest of the team.
Software and application development is a much wider area than a lot of people realize, spanning across different layers — from infrastructure to what the end-user experiences. Developers tend to specialize in a particular layer with knowledge of others and how they operate. While having one specialty may seem like a good thing, it’s not always the case when it comes down to putting all the parts together.
For cross-functional agile teams, you’re going to need individuals who are solid in their areas but are also chameleons in others. This lets them talk in the same language as others who are not as technically inclined or don’t have an in-depth understanding of their expert domains.
It’s these people that you’d want on your team because they’re highly efficient and effective beyond their coding skills. They’re effective and efficient because they’re your givers — active and aware.
They’re code philosophers, often refusing to accept the status quo of a system. They will question, with judgments made not only against what they’ve done in the past, but also possibilities for the future. Just because something has been done a certain way doesn’t mean that it is the most efficient or effective methodology. They’re your advocates for change and champions for reducing technical debt, turning old problems into new and efficient solutions — something that not all developers are capable of or are internally inspired to do.
Effective and efficient developers are like musicians with the ability to improvise — to listen to a particular set of sounds and replicate it on their instrument of expertise. It’s the trait that marks them as different and superior from someone who can just play based on the available sheet music.