tags
Career
Software Development
Projects
id
14
published
Dec 17, 2023
reading_time
category
Programming
Documentation
Career Development
Professional Growth
Skill Development
author
The fastest way to get to the top in any field, whether it is arts,
sports or software development is to study the people that are already
at the top… And do what they are doing that you are not.
If you write code for a living, this means taking a look at Senior
Developers. It means identifying what skills, habits, and traits they
possess that you don’t.
After spending thousands of hours in the last 3 years working with
top-notch Software Engineers worldwide, I found out that there are 12
Senior Developer traits that you can put in place right now to
fast-track your growth to the next level.
Let’s start with number one…
1. Focus
Focus means saying no to some things, so we can do others.
Ideally, saying no to the things that don’t matter. And saying yes to
the stuff that makes a difference. The stuff that moves the boat
faster.
This is really hard for many developers because it goes against our
natural instinct. It means accepting that you can’t do everything. And
that not every opportunity is created equal.
You can’t learn every new framework out there. You can’t read every
newsletter. You can’t attend every conference. And you don’t have to.
Your time is limited. So is your energy.
Being a Senior Developer means picking your battles.
“People think focus means saying yes to the thing you've got to focus on. But that's not what it means at all. It means saying no to the hundred other good ideas that there are.” - Steve Jobs
Funny enough, the better you can pick, the faster you will progress.
Senior Developers have the same 24 hours in the day that you have. But
they get more done.
How?
By doing less.
When a new thing comes your way, ask yourself "Does this really
matter?" Or is it just another trend? Chances are it is just another
distraction disguised as an opportunity.
Senior Developers say more no’s than yeses. They finish more projects
than they start. And they master the framework they already work with,
before learning a new one. If you want to get to Senior faster, the
first trait you need to develop is focus.
2. Second Order Thinking
One thing that screams "Junior dev" is the attitude of "let’s build
it and we will find out". Juniors have a bias for coding first and
thinking second.
That can be a good attitude if you are just starting out, but when
you are working on production-ready software, some technical decisions
you won’t be able to change. Or change easily.
For example, you choose Vue as a front-end framework.
Then, requirements change. You start thinking React would be a better
option. Sure, you can switch to React. But it will be neither easy nor
cheap.
Senior Developers know it is easy to get high on your own supply. But
if you fall in love with the frameworks and libraries you know best,
you will start making poor technical decisions.
They think twice about the consequences of their choices. This can
mean asking the “five whys” when trying to understand a problem.
Or thinking about the possible drawbacks their solution could have.
For example, now that we have added Redux, global state might be a
bit easier to manage. But we will have to onboard new developers on
Redux. The learning curve is high.
And, guess what, our JavaScript bundle will get bigger which is not good for performance.
Considering second-order circumstances will make you a much better developer. It will also help you during technical interviews.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
3. Pragmatism
When Junior Developers read a book on best practices, they jump and
try to apply them to every line of code in any release. They follow them
religiously.
If you can't make technical decisions by yourself, it is much easier
to stick to predefined rules. But software development is not a
religion.
A good example is Testing.
When a Junior dev reads about TDD (Test Driven Development), they
will start trying to test everything. Aiming for full code coverage.
When in fact, complete code coverage gives diminishing results and will
turn out to be a waste of time.
Senior Devs know how to balance best practices and time to market. When to take shortcuts and when not to.
Hacking things quickly will generate bugs and technical debt. Always
sticking by the rules when the context of your code changes will result
in bad decisions.
You need a balance.
Be open to reconsidering your technical choices based on circumstances.
4. Nothing To Prove
Because of lack of confidence, Junior devs find themselves constantly
trying to prove themselves to others. Same with Senior developers who
are insecure about their value and skills.
They base their confidence on the validation they receive from others.
This is a losing game.
They will try to show how much they know in a certain technical
discussion, talking over others, or pushing code late at night or over
the weekend.
In reality, all these behaviors create a toxic team environment and
backfire. In the best case, they will make you look less Senior than you
actually are.
The Cheetah doesn’t have to prove itself in the race, it only runs to hunt.
There are two ways to deal with this.
The first one is to stop spending so much on external validation.
Because the truth is you don’t need to prove yourself to anyone. Only to
yourself.
The second is making peace with the negative voices in your head.
You can be your worst critic. Perfectionism, fear of failure, and a
mistaken idea of what a "real" developer is are destroying your
self-esteem. That’s why no matter how hard you work you always feel like
falling short.
It’s time to get out of your head.
Focus on mastering your craft and the rest will follow. You will
instantly become more confident in yourself and your skills. And you
will stop trying to prove yourself to strangers.
5. Master The Fundamentals
Whenever I bump into a LinkedIn profile of a developer and they
describe themselves as a "React" developer, or an "Angular" developer, I
know they are not Senior. They might be Senior in that framework, but
not Senior overall.
A Framework developer will never be a Senior Developer.
Frameworks don’t make you Senior because frameworks are only the
icing on the cake. Not the cake itself. The tip of the iceberg, versus
its bottom.
I would even speculate that behind the current epidemic of Impostor
Syndrome among software developers, even Senior ones is not a lack of
talent or lack of hard work.
It is weak fundamentals.
This is also why topics like debugging or performance optimization
are a guessing game for most developers. They are not used to digging
below the surface of the libraries and tools they are working with.
To become a Senior Developer you must not only understand the “What” but also the “Why” behind things.
A Senior developer would, for example, not only be able to build a
React application. But they would also understand why React has been
built in a certain way. And how it blends with the language it’s been
written in (JavaScript/TypeScript) and the platform it runs on (the Web
Browser).
The good news is that once you get the fundamentals handled, the level of everything will rise.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
6. Deliver End-to-end
The #1 reason why companies avoid Junior developers is that they need
a lot of external help to get things done. External help means you will
be bothering a Senior developer to get your stuff done.
Junior developers are considered “expensive” because they can’t deliver independently.
Instead, Senior developers can deliver end-to-end. Give them a bunch
of requirements and they will figure out the rest. This doesn’t mean
they are lone wolves, they are usually great at working in a team.
It doesn't mean Senior devs hack things quickly just to push them forward.
That’s not a “real” Senior.
And it doesn’t mean that they know every part of the software development lifecycle in depth.
But, Senior developers understand all the major pieces across the
software development life cycle. And can contribute to each of them
(frontend, backend, deployment).
If you are a Junior/Mid developer looking to level up, end-to-end delivery is one trait you need to put your eyes on.
7. Mental Models
One of the main things that sets Senior devs apart from more Junior ones is the amount of complexity they can handle.
Seniors can understand more complex codebases and requirements.
They can understand second-order circumstances. How changes in the codebase will affect performance, costs, and even the team.
And they do that not because they memorise every implementation detail. That's impossible because human memory is very limited.
They do that because they abstract the complexity of the code into mental models. These are simple ways of representing reality.
How can developers build quality Mental Models?
By looking behind frameworks and libraries and learning the design
patterns behind them. There is a lot of noise out there depending on
your tech stack. Things like SOLID principles, or MVC…
But I think the best way to start is by picking whatever framework you are working with and trying to look beyond the code.
Start asking yourself, why did the creators of the framework build it
this way? Is it built on new concepts or is it just an implementation
of age-old principles (which is usually the case)?
By answering these questions you will build your mental models on
software development, and be able to handle more complexity. That’s one
of the most effective ways to fast-track your growth to Senior
Developer.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
8. Senior Developers Control The Story
One thing Senior Developers can do extremely well is lead technical
discussions and influence other people around them. Be it business
stakeholders, product managers or fellow developers, Senior devs know
how to guide them in the right direction.
They do this using a mix of assertiveness, technical expertise, and communication skills.
Senior developers are also able to set strong boundaries.
They can disagree without getting emotional. They can stand up for
themselves (and others) during meetings. They negotiate their salary
aggressively.
And they tell their own story.
Senior Developers know how and when to draft a line in the sand and say "enough is enough".
If another developer starts blaming others during a code review,
Seniors know how to stop them. If higher management tries to get into a
developer’s work and micromanage, Seniors know how to push them back
without damaging the relationship.
There is no step-by-step guide on how to become more assertive as a developer.
It takes repetition and practice. The first step is to stop saying
“Yes” all the time. And to start trying to get your way in salary
negotiations.
9. Long Term Thinking
Junior developers think for “now”. They think short term. That is
true for their code when they take shortcuts. A Junior Developer will
extend a piece of code without thinking about refactoring it properly or
simply ignore testing and performance.
But Juniors also think short term about their careers.
This can mean job hopping too much or burning bridges. It can mean neglect.
Like not improving your skills or the way you sell yourself because
right now your job is stable. Just to regret it six months later after
getting laid off.
Part of becoming a more Senior developer is starting to think long-term.
The first way to do that is by changing your mindset. Most short-term
thinking that Junior devs have is not caused by laziness but by
self-doubt.
Deep inside they are still thinking whether being a developer is the
right thing for them. Or whether they picked the right career.
These doubts stop them from committing long-term.
Good things take time, Senior developers know this and adjust their thinking accordingly.
And now with AI threatening the end of software development, this
short-term thinking is more frequent than ever. Why commit to something
anyway if it is going to be gone soon?
Trust me on this, it is only when I made a full commitment to my career as a developer that things started to take off.
I said, “this is it”.
I stopped looking outside. I told myself: this is my job now and it will be my job for the next decade so let me do it well.
I started investing in my skills because now I know they will pay off.
Even if you are not going to write code for the next 20 years, having
a long-term mindset will bring you great benefits. Senior developers
got to Senior level because they committed to their craft. If you aspire
to get there, you should do the same.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
10. Excellence Is A Habit
I think it was Kent Beck who said the famous phrase "I am not a great
programmer, just a good programmer with great habits". Habits are
important because they stand the test of time.
Because any kind of knowledge you have about a JavaScript framework
will sooner or later become obsolete. Technology changes. But your
habits will stay with you forever.
The good news is that humans are creatures of habit.
It is not easy to set new routines in our brains.
But once we interiorise them as habits, we have an easy time
following through. The best way to take advantage of this is to get
whatever goal you have and break it into daily actions. Then turn those
actions into habits through repetition.
For example, if you want to get better at testing, write one unit test every day.
If you want to be more prepared in the daily meeting, and think
clearly, keep a journal. If you want to find a new developer job, and
you have to send 100 applications, send 10 applications every day.
Set up new habits and your progress towards the Senior level will be constant and steady.
11. Protect Your Most Important Asset
Being a Senior Developer means thinking long-term not only about your code and technical decisions but also about your health.
Because health is wealth.
I talk about this again and again in my videos.
Developer jobs are extremely sedentary. You spend most of your day
sitting in a chair in front of a computer. That is very bad for your
health.
Then, there is all the trash food, like chips, soda, and candy in the
office. This means unless you make a conscious effort, it will be hard
for you to stay healthy and in shape.
But if you want to have a long and productive career writing
software, and you don’t want to end up with back problems, diabetes, or
even something worse, you need to start taking care of your health.
If you want the golden eggs, don't kill the goose. If you want more productivity, take care of yourself first.
This doesn’t mean you have to start hitting the gym 5 times a week.
Or go on some crazy diet. But do sports at least 2 to 3 times a week.
You can hit the gym, go for a run, or do a team sport. Right now I am
doing
On the diet side, cut on sugar and refined carbs. Don’t overdo it with the meat either.
Consider your mental health as well.
Ignore advice like “eat, sleep code, repeat” and build a life outside of work.
Start a new hobby. Reach out to a friend. Take breaks.
In the short run, you might progress a bit slower. But in the long run, you will be able to stay in the game for a longer time.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
12. Close The Circle
Finally, Senior Devs understand how karma works. They know that no
matter how hard they work, or how smart they are, dozens of people
helped them on their way to the top.
This doesn’t take away their merit but acknowledges other people as well.
So they close the circle.
They help other developers out. And they do it without expectations.
Not because it might get you a promotion. Or status, or admiration. They do it because it is the right thing to do.
Even Kobe Bryant found the time to mentor young kids and get them into
basketball. You can also find the time to help a fresh developer out.
Helping someone who is just starting out will give you back part of
the spark. The passion and curiosity that a beginner feels when they see
things for the first time is so contagious.
Another thing you can turn into a daily habit!
Okay, this is it. Put in place these 12 traits and you will fast-track your growth to a Senior level and beyond.
Moving forward, here are 2 things I want you to do:
1. What are some traits you’ve seen in Senior Developers that
you think we should add to the list? Comment below, and I will try to
answer all your comments!
2. If you are an ambitious developer trying to level up and you are searching for a community of like-minded people, click here to join our free community for JavaScript developers looking to fast-track to Senior level.
#Career#Software Development#Projects
T
Tentang Tim Editorial
Profil penulis belum tersedia. Konten dikurasi oleh tim editorial kami.
Komentar
Bagian komentar akan diaktifkan segera
