Some people say 10X Devs are myth. I disagree with them. Why?
So…
You have heard of 10X Developers.
Have you ever imagined how one can become a 10X Developer?
Normally, we think that a 10X Developer is someone like a Super Man.
He can solve every problem in a couple of minutes. Even hardest concepts like System Design, Toughest Data Structures etc are at his/her finger tips.
But…
Today, we will be talking about some soft skills which are damn easier to learn to become a 10X Developer.
Ready…
Let’s start.
i) Documentation :
Maintaining proper documentation is one of the main qualities of best developers. Sometimes as a developer, you start a project from scratch. It may have both frontend and backend. It may have different modules, components or parts. Parts of your project should be well-documented. Specially APIs need to be well documented. Otherwise any person who will be working in future on your code will need to read the whole code to understand what’s going on in it.
ii) Commenting :
Sometimes, you are writing a function or a class. It’s always good practice to put a comment which briefly describes what this thing is about. Alongside this, you may be doing some mathematical calculation like encoding or decoding, here same convention should be followed.
iii) Clean code :
Clean code is one of the good traits of 10X Developers. If you want to become one, your code should be well-indented, predictable and clean. There are many plugins in code editors like VSCode, Atom, Sublime etc. which you can also use as well. Plus, if you are using camelCase for functions then you should use it for all the functions through out the project.
iv) Folder structure :
Folder structure also matters when you are writing code for a project. There should be separate folders for components, helpers, services, middleware, models, views etc. Some frameworks have their own recommended ways of naming different things. Try to follow those ways, because people working on those frameworks will be familiar with those naming conventions already.
v) Code review :
Code reviews are eternal part of a good tech company. You should always get feedback from your fellows or senior developers. Ask for their perspective about the code you have written. They might come up with better suggestions which may open up new horizons of thinking for you. Based on their response, you should refactor your code a bit.
Conclusion :
Being a 10X Developer is not a myth. It’s a reality. You just need to follow some good practices and force yourself to learn some hard and soft skills.
That’s what you need to be a rockstar developer.
Top comments (41)
The second and third point is contradicting: if you write clean and readable code, you don't need comments everywhere. For clean code, I would recommend the book Clean Code from Robert C. Martin
Good recommendation. Many -- perhaps all -- developers would benefit from reading Clean Code, even if they don't agree with every word.
I tend to agree about comments. Expressive code shouldn't need endless comments. That said, there are times when the code can't tell the full story -- if it's doing something funky, or you want to explain your design decisions. In these cases, comments are definitely needed.
Yeah exactly. There are times when comments are needed. Thanks for the comment.
Totally agree!
The senior devs I've worked with tend to end up removing more comments than they add.
Excessive comments tend to be removed during peer review.
Comments are essential where it's hard to get the intention of the code by reading it, which is sometimes unavoidable but should be the exception not the rule.
Clear code shouldn't need comments. Tricky code does. No use filling your codebase with tricky code.
Yeah. Comments should be removed in peer review. They are just to give understanding of something tricky. Complex code should be avoided if it's not needed.
Comment to document the why of the code, not the what. What it's doing should be immediately apparent, but why the client wants it to do that may be important for future maintainers. The last thing you want is for some new dev to rip out something that makes little sense, only to find themselves hauled into the CTO's office to explain why they've gone against the client's wishes & be embarrassingly made to restore it in an emergency release.
The cleanest code still takes more cognitive energy to understand than plain natural language comments. I don't see the need to strive for less comment. Every function, class, or module should have comments. Especially when today's tooling can easily generate docs out of them.
a good expressive comment at every abstraction level is an indication of a well-thought-out design from the developer. The same indication can be evident from a unit test.
If you need more cognitive energy to understand than it is not the cleanest code in my opinion. Comments are always longer and can quickly become obsolete. Nothing enforces them to stay up to date...if you forget it, it remains there unnoticed.
I disagree. In languages like C/C++ or Rust, how ever clean the code is you still can't comprehend easily the intention until you've read through a few lines into a function.
In Go, every exported function is expected to have an accompanying comment. That's considered good practice.
I think it depends on codebase. If its small then code can speak itself what it is intended for. But if it's larger codebase then there should be comments to briefly explain the intentions of programmer.
Yeah. Both things are necessary i.e expressive comments and cleaner code.
FYI: The author of your linked book is not Martin Fowler ;)
Thanks, I tend to mix them up, but the book is certain :)
Thanks for your comment Gábor Soós. Yeah @blacksonic . I agree that if code is readable and clean then you don't need comments but I think there may be cases at time when you are doing some complex calculation or manipulation, then in larger code bases it may be better to put a proper comment there.
The comments OP talks about in the second point seem to be documentation comments - a totally different beast than the comments clean code advocates warn about.
It refers to comprehensive comments. It doesn't matter whether they are to serve as a basis for documentation or making code clearer to new developer.
It does matter. According to the clean code philosophy, you should avoid writing comments to make the code clearer and instead refactor the code so that one wouldn't need comments to understand it. Documentation comments are for generating API docs, so it makes sense to have them even if you follow clean code principles.
Yeah. It matters but I am in favour of what I said.
It's all great but these tips barely improve your speed to deliver/ship product features which is mostly the metric do recognize a 10x developer. Unless your idea about 10X developer is a developer who make people around him productive which I don't really agree is the case.
Yeah you are absolutely correct. But you know to become a 10X Developer you need to be 10 times more productive in all aspects. And to excel in all aspects you need to be super best in not only your hard skills but also your soft skills. In this article, I have only focused on the soft skills part.
Make sense but I think some points like time management, taking the most effective tasks first and blocking distractions would be more helpful as soft skills in order to be 10X. The points mentioned in this post are more about how to be a better engineer in a quality manner.
Yeah. Agreed. These things are also necessary. Thanks for addition.
I want to apply a caveat for this article: all these skills are considered to be hard. Excerpt code review, which requires both hard and - in a lesser extent - soft skills.
Totally agreed with previous criticism about comments and want to add similar thought about documentation - well written code does not require (significant amount of) documentation (don't mind the top level interface). And with statically typed language you don't need to explicitly document your API in most cases, so documentation won't obsolete and it won't take your 10X expensive time in vain.
I disagree a bit. In my opinion these are soft skills for a coder.
My litmus test for knowing if someone is a 10X developer, as in can replace 10 differently skilled employees, is "can they develop, operate and file support tickets for a cloud app all by themselves?". Usually the answer is no.
Obviously such a person would not be able to monitor an app 24/7 because everyone needs to sleep, and there could be app failures during that time.
No. It means that particular developer is 10 times more productive than others in the same capacity. Yeah, you are right. The ideal man you described can be Hercules not a developer.
Not everyone can be 10 times better than everyone else. That's mathematically impossible.
Yeah there are both kind of views in the developer community about that. Some say it's impossible and some say it's not.
And Obviously Version Control.
Yup. Exactly.
You just described my expectations of a 1X developer.
Your expectations are too high. BTW, I have only focused on soft part, not the hard one. Hard skills might be good understanding of System Design, Computer Architecture, Data Structures and others.
So I'm a 10x? Guess you can't please some managers.
But I can please some devs. :P)
10x is so 2018. 20x is hot right now /s
Yeah. May be 50X in 2021.
This is a huge assumption. You should replace this sentence with a definition.
I have also seen them. So, this isn't an assumption though :P)
What about testing, it should be in the list, right?
Some comments may only be visible to logged-in visitors. Sign in to view all comments.