The secret to a successful career as a developer.
I hate teaching. But I love mentoring. WAT? Yes, you read that correctly. I hate teaching, teaching requires patience, and I’m inpatient. Mentoring is about guidance and advice, and that’s easy. At least to me. It’s rare, though, to be mentoring someone and not have to do some teaching along the way too.
Because I like mentoring, I’ve had a number of experience teaching someone new to development, or new to Ruby in particular, certain aspects of development. Some have been good experiences, and others not so much. Out of those experiences, I’ve been able to single out a trait that is common between the different experiences and how its presence or absence in the person can shape the development of the person and their progress.
I have mentored people with 10 years of experience in software development, and people with less than 1 year of experience. People with a computer science/engineering background and people with no science background whatsoever. Experience did not matter. A scientific background did not make a difference. The one trait that had a direct effect, in my opinion, is the person’s attention to detail (as you may have guessed from the title of the post, or have you? 🤔).
Before I go any further, I have to preface the rest of the post with the disclaimer that I am by no means saying that this is the one and only important trait, nor that there aren’t any other significant aspects that will affect someone’s progress as an engineer, yada yada yada… It is, however, a significant differentiator that will set someone up for easier and greater success compared to someone else with the same attributes and qualifications. That said, I will always make a bet on someone who’s demonstrated themselves to be very skilled at attention to detail, regardless of their technical background, whereas I will most likely bet against someone who’s very skilled technically but has demonstrated over a period of time a lack of attention to detail.
Now that the first disclaimer is out of the way, some of you will be thinking something along the lines of “Hey Youssef, isn’t attention to detail necessary for success for any career and any field?” and you’d be right. Yes it is. At least mostly, you’d be surprised at how many people in certain careers get to be successful and be at the top of their field without any thought for detail. That said, the last time attention to detail was mentioned in CS class, bootcamp, talk, or anywhere else was my talk at Galvanize earlier this year, and before that was never. For something that is so obvious and so common sense, how come we don’t hear about it? Is it because we assume that everyone posses this skill or gets taught to develop it in school? My experience says otherwise.
A tiny experiment that I run sometimes is show developers this snippet of code and ask them what the result of the code should be:
def my_method
my_var = 10
while my_var > 0
puts my_var
end
I give them some time to guess, but not too much time. I haven’t had anyone guess the right answer yet. I don’t give out the answer, but instead I show this next snippet of code and ask the same question:
def my_method
my_var = 10
while my_var > 0
puts my_var
end
And I wait about a minute to see if anyone would get it immediately. The slide I show has syntax highlighting and whitespacing is prominent. The devil is in the detail, and the detail is staring everyone in the face. I don’t expect someone with only a few weeks working with Ruby to be as quick as someone who’s been doing it for years in identifying subtle elements of code such as a closing end but I do expect anyone to notice the mismatched indentation and have that trigger the wheels to starting turning in their head. With this experiment, I get to see how someone with limited experience reacts vs someone with extensive experience. When I get people with what I deem enough experience, yet unable to figure out the output of this snippet of code, it makes me question how much they are paying attention to detail.
A couple of slides in a presentation by no means are a great indicator by themselves. This type of attribute in a person is something you need to pay attention to on a continuous basis. Pull requests and code reviews are a great way to keep track of such a thing. So when I see code delivered that looks like this:
foo = 'foo'
bar = 'bar'
baz = 'baz'
then my radar is activated, and a yellow flag is raised. Now I’m paying closer attention to every line of code, and every subsequent commit or PR. The spacing between bar and the = sign is odd. It could be the result of a find/replace all (it’s natural to miss the alignment getting messed up in that case), or the product of carelessness, and that’s worrisome.
My course of action is usually to mention it casually, and see if it reoccurs or not. If it does, I mention the importance of paying attention to everything regarding the code and that the details matter. The hope is that with practice, the developer starts having less and less issues with this kind of stuff. But don’t be fooled by a good PR or two right after the comment. It’s normal to have the critique be fresh in your mind and pay more attention then, but the true indication of progress is if the new behavior is sustained for a longer period of time.
So far I’ve talked about mostly “whitespace” in code. Whether the developer pays attention to indentation, spacing and alignment of assignments, etc. Why is that so important to me? It is important because it is an indication, to me, whether the developer is spending the necessary time to address every single aspect of the coding experience. Are they thinking of every edge case? Do they take pride in the code they are producing? Do they “finish” the job to the last inch or mm, or is it just about delivering something that “works” in order to move a task to the done column? Which brings us to the most important aspect of it all, everything we’ve talked about so far culminates in this crucial part, the definition of done.
For many developers, the definition of done is fleeting. What does it mean for a task to be done? In my first job, one of the Sr. Consultants came up with the term “done done”. He felt the need to have a specific term to signify that the development of a feature or fixing of a bug is actually done. 100% done. Not “works for me” done, or “I did the bare minimum” done. Done done. Let’s take an example to illustrate this, examples always help me illustrate a point better.
Say a developer is tasked to build the sign up/in portion of a new app. They were not given too many instructions, it’s a common feature after all, so it should be straight forward. The developer does a bit of research and lands on Devise and decides to go with it. In our case, we are talking about a Jr. developer that just graduated and this is their first crack at a real production app. Devise is a good choice in this case, you don’t want a Jr. developer trying to figure out all of the intricacies of security.
When “done”, the developer demos the feature to everyone, and goes through the process of signing up as a new user and then logging in, logging out, resetting the password. Seems like a complete job, right? That would be a big fat NO!
See, the developer only demoed the happy path. What happens if the email used has already been taken? What happens if the user does not provide a password? Or the password and confirmation do not match? Are there any limitations on the password (length, characters allowed, etc)? Devise handles all of these cases, if the developer read through the entire documentation of Devise they would know that, and they probably didn’t have to do much work to get it working. But the moment they don’t demo it, it raises a flag for me: did they even test all of this functionality before claiming to be “done”?
At this point someone asks: “Is this pushed to staging for us to QA?” and the developer happily responds with a “Yes, I pushed the branch to a PR app on Heroku”. Great, but the moment someone tries to access the PR app, they get a server error. See, our Jr. developer forgot to migrate the db with all of the changes they made locally. Rookie mistake, we’ll use this as a teachable moment. We’ve all made those mistakes before, it’s not a big deal.
Now we’re 2 sprints later, and the developer is no longer building common functionality that would have a gem ready to drop in for it. We are also seeing an increased rate of bugs being reported by the rest of the team, related to areas of the app that the Jr. developer touched. It turns out there’s a systemic issue of this particular developer not paying close attention to detail. They are not pushing the app to a staging environment and testing it there. They are not trying to break the app in order to identify edge cases and bugs preemptively. Most of their work is just the bare minimum in order to move the task to the done column. It’s easy at this point to chalk it up to lack of experience, but after having someone mention it on numerous occasions, the expected outcome is to see some sort of improvement and course correction.
In the example above I used the case of a Jr. developer. Would you believe me if I said that I’ve seen the same behavior with developers with over 10 years of experience? I firmly believe that this kind of behavior is not limited to experience, but character. Do you or do you not pay attention to detail? It’s all cute and whatnot when it’s about whitespace and alignment, it’s a problem when the team cannot rely on you to complete a task in the “done done” definition of complete. And the signs are there all along, from the tiniest piece of code or element related to it, to writing an entire feature, and everything in between.
In my book, the biggest indicator of how much someone pays attention to detail is the number of times it is required of me to repeat the same comments. Do I need to tell you to pay attention to whitespace in every PR, or are you set after the first or second?
That is why, ladies and gents and everyone else, I say attention to detail is the secret to success as a developer. If you pay attention to detail your are more likely to be trusted by the team you work with because they wouldn’t have to fret the code you deliver. The trust of your team will lead to the trust of your managers, and so on and so forth. Once you have the trust of the people around you, they will do what they can to help you succeed.
Set yourself up for success, and pay extreme attention to detail!