The true essence of a software developer’s role combines many different skills, mindsets, and disciplines.
Focussing Beyond the Code
Abstract
As a developer, you will code 20% of your time. You should excel at coding nonetheless, but it won’t be enough to be great.
- Coding is the fundamental component of software engineering, but it is not the actual purpose of it. Software engineering is about writing meaningful lines of code and solving problems with it. (A line of code has no meaning without context).
- Being a good developer means being efficient in coding, but what separates good from great is the ability to see beyond the immediate lines.
- How will it interact with other components? How will it scale? How maintainable is it? These are the questions that a decent software developer constantly grapples with.
The Pursuit of Efficiency
Abstract
Making sure everything around you runs smoothly and has forward momentum.
- Developers should be efficient. Challenges should get resolved promptly, and things are under control moving toward the purpose that the engineer has set.
- This efficiency is set in terms of antifragility — not running around and doing everything as fast as possible.
- You don’t have to make tradeoffs by reducing the buffers that you have and be wary of making changes that reduce your resiliency to unexpected things.
- At its core, efficiency is about progress — momentum, ensuring that the wheels of development are always turning.
- Think of it as adopting a proactive mindset, where doing something – even if it doesn’t solve your problem directly – is better than doing nothing.
- This means breaking a complex problem into smaller, more manageable tasks.
- It means seeking input from a colleague when you’re feeling stuck or temporarily setting aside a challenging task to focus on another aspect of the project.
- The key is to maintain forward momentum with small increments.
The Joy of Tinkering
Abstract
Build projects, try out frameworks, and build stuff on the side. It keeps the spark alive.
- Great developers are passionate.
- Their eyes light up at the mention of a new tool.
- They spend hours diving deep into a challenging problem not just because they have to but because they want to.
- They’re driven by an insatiable curiosity, a hunger to know more, do more, and be more.
- This passion manifests itself in various ways, but one of the most evident is the joy of exploration. Great developers are explorers at heart.
Knowing the Why
Abstract
It’s important to know why your code does what it does, too many abstractions nowadays that rarely someone thinks below the level of their language e.g. JS devs not thinking about the engine that runs their code.
- It’s a valid argument that a developer doesn’t need to be an expert in every layer of the stack.
- One doesn’t need to trace the journey from circuit boards to bits and bytes for every line of code written. But having a foundational understanding and a sense of the bigger picture can be incredibly empowering.
- Knowing the why/how behind the code offers several advantages:
- Problem Solving: When challenges arise, understanding the underlying logic can guide you towards the answer much faster. Even errors will be clearer when you know why they are thrown.
- Informed Decisions: Your knowledge of the underlying systems will influence every decision you make.
- Bridging Gaps: In multidisciplinary teams, grasping the broader landscape can foster better communication and collaboration, bridging the gap between specialists of different domains.
- Innovation: Groundbreaking solutions tend to emerge at the intersection of disciplines. Knowing the why of various layers can spark innovative ideas and approaches.
- It’s more about not just blindly accepting things at face value but delving deeper and expanding one’s horizons.
Thinking in Systems
Abstract
Knowing how your code impacts not only your system but other parts of the business/application/life.
- This is similar to the first part of not just focusing on the code but thinking about systems and their interactions.
- A great developer doesn’t just see the individual pieces; they see the entire puzzle, understanding not only how each piece fits into the current puzzle but also what the puzzle is and if more puzzles need to be interacted with.
- Systems thinking is about recognising that software is made up of numerous components that interact with each other in complex ways.
- It’s not enough to ensure that each component works well separately; it’s crucial to understand how it works as part of the whole and what implications it has on the company.
Recharging Beyond the Pixels
Abstract
Recharging away from your monitor makes you a better programmer.
- Great developers aren’t just masters of their craft but well-rounded individuals who understand the value of experiences beyond the digital realm.
- They recognise that while technology can expand horizons, it can also, paradoxically, become a limiting bubble.
- Constant immersion in the digital world can lead to a narrowed perspective. There’s so much more outside of the tech bubble.
The Art of Approximation
Abstract
Knowing important tech numbers to approximate calculations when making decisions when programming.
- It’s not about knowing everything but about having a mental toolkit of numbers to guide decisions, shape solutions, and prevent costly missteps.
- Being able to approximate calculations on the fly can provide a solid roadmap.
Transferring Knowledge to Other Problems
- Being able to recognise the pattern, adapt, and transfer a mindset is important. Challenges are constant but rarely come in familiar packages.
- The true mark of a developer’s skill is their ability to take their knowledge and mold it to fit the task at hand.
- If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.
- Experience plays a pivotal role in this. With each challenge faced, a developer adds to their repertoire, expanding their understanding and refining their approach. “Every bug you solve today is a skill tomorrow.”
Making Hard Things Easy
- “If you can’t explain it simply, you don’t understand it well enough.”
- In software engineering especially, the pinnacle of understanding isn’t just about mastering the hard things but about making those hard things easy for others.
- It’s a mark of great engineers if they can explain something and be understood not just by their fellow programmers who work in the same field but also by average people.
- Making hard things easy is about levelling the playing field. It’s about recognising that knowledge shouldn’t be a guarded treasure but a shared resource.
- By simplifying concepts by making them accessible, you empower others.
- You give them the tools to rise, to reach your level of understanding, and perhaps even surpass it.
Playing the Long Game
- Deadlines loom, stakeholders press and the allure of quick fixes can be overwhelmingly tempting. But the best developers, the ones who leave a lasting legacy, understand the art of playing the long game.
- They recognise that while today’s solutions (or shortcuts) matter, the vision of tomorrow truly defines success.
- It’s easy to opt for a solution that addresses the problem at hand, but does it stand the test of time? Will it scale? Is it maintainable? Will you even want to touch it later? These are the questions that guide the forward-thinking developer.
Developing a Code Nose
- Bad code comes with telltale signs like convoluted logic, lack of documentation, repetitive patterns etc. Once you know what to look for, it stands out.
- It comes with experience, exposure, and conscious effort. It’s about immersing oneself in various codebases, both good and bad, and analysing them. It’s about seeking feedback, being open to criticism, and continuously learning.
Strong Opinions Loosely Held
- You develop your own touch over the years. Your own conviction that something is better.
- What works for one project or team might not work for another.
- Solutions that are hailed as revolutionary by some might be deemed redundant by others.
- As valuable as strong opinions are, they must be tempered with flexibility.
- The tech world is in constant flux, with new tools, methodologies, and paradigms emerging regularly.
- Clinging rigidly to an opinion, especially in the face of new information or changing circumstances, can be a recipe for stagnation