Learn Jiu-Jitsu, Program Better

In the beginning of each year we start looking back at what we accomplished in the previous one and what we didn’t. We look back at the resolutions we managed to fulfil and those that we abandoned on the second week.

Last January I sat down and pondered on what I want to accomplish during 2018 in terms of my career. The first thought that came to my mind was “Well, I want to become a better developer!“. Of course, I doubt that there is someone working in software engineering that doesn’t want to get better at their craft.

But what exactly does it mean to become a better software developer? What are the qualities and skills that one needs to develop to get to the next level. Excellent understanding of the fundamentals is something that you can find in any senior engineer. At the same time keeping up with new technologies, trends and proposals is also important. In other words, learning should be a top priority.

However, learning without practice can only take you so far, right? We all know that building something on the side or tackling a challenging problem is one of the best ways to improve. This is what takes you out in uncharted territory and pushes your innovation and creativity.

Okay, we’ve got a general idea of how developers progress in their craft. But when we put the coding aside there are still many activities that are said to be beneficial for our improvement . Teaching and giving talks, writing blog posts, etc. Where do you even start?

So, what makes us better?

Earlier this year I came across this amazing article that focused on the topic of improving as a software engineer. To be more precise — how engineers stop improving. The essence is that once we find an approach that works for us and gets us results we are inclined to stick to it until we reach a state of plateau.

Then since we are so invested and confident in this approach, it’s hard to make the mental switch and change our habits. The author emphasised the effect that this has on organisations and the careers of programmers who fall into the trap.

This article made me reflect on the decisions I’ve taken in my career and even in my hobbies. It’s incredibly easy to find an approach that lets us perform well and stop looking for other alternatives.

Jiu-Jitsu and Programming

When I read that article my mind immediately went to a previous moment in my life which has nothing to do with programming at first. I understood exactly what the author means for I had been in this trap before. Back in the day I used to train Brazilian Jiu-Jitsu which is kind of like wrestling but with the goal of submitting your opponent.

I fell in love with the sport and enjoyed every moment of the tiring and sometimes painful training sessions. However, early in my Jiu-Jitsu journey I was struggling when sparring with stronger guys since they could use their strength to break out of my submissions.

This was frustrating because even if I applied my technique and knowledge correctly some people could just brute force their way out. Leg locks proved to be an effective solution to my problem due to how quick and unexpected they were. Strength didn’t matter that much when it comes to ankles as well.

While drilling different positions and escapes seemed mundane at times, leg locks were cool and sometimes flashy. I was pulling off sneaky submissions all the time and fighting with bigger opponents was no longer such a struggle.

Little did I know that focusing so much on those techniques would do more harm than good for my development.

But once you have a hammer everything starts looking like a nail. When I understood the effectiveness of leg locks I started disregarding other submission or position opportunities and looked to grab the ankle whenever I had the chance. I was fairly successful with this approach and gained a lot of confidence in my game.

However, focusing all of your attention on one skill and disregarding all the rest is like putting all of your Dungeons and Dragons character’s points on Strength and none on Intellect.

When I started sparring better Jiu-Jitsu practitioners who knew how to defend my leg attacks all my plans crumbled. Since my sole focus was attacking the ankle, if I didn’t get it my chances of winning dropped significantly.

In other words, I didn’t do well against better guys. I realised that I had neglected other basic elements of my training, but I had fallen deep into my comfort zone and felt uncomfortable practicing fundamental techniques that I desperately needed to improve myself.

Don’t make the same mistake

Reading the article I mentioned above and realising the past mistakes I have done I knew I had to change my attitude towards improving. While learning the next fancy technologies would definitely bring me short term benefits and a sense of accomplishment, going back and filling in the gaps would be better for me in the long term.

Cool new JavaScript frameworks and libraries were the leg locks of my programming career. I had once again become too focused on learning fancy new technologies and staying at the bleeding edge of trends. I knew every new tool and library but had big gaps in the core knowledge that a developer needs.

At this point I had already gained confidence as a software engineer. I felt that the way I approach problems was correct and changing my mentality was not appealing to me to say the least. After all, what I knew worked. If it ain’t broke don’t fix it right?

Another way to explain this mindset is through the Einstellung Effect. This refers to how we sometimes tend to solve a problem in a specific way, even if alternative and possibly better solutions are available.

Feeling confused is okay

One of the people I look up to in the programming community is MPJ — the creator of Fun Fun Function. From all the valuable lessons in his videos one shined the most and that is that feeling confused is okay.

The feeling of awkwardness when tackling a challenging problem is actually something that we should be aiming for. It means that we have come out of the safe harbour that is our comfort zone and we are actually learning.

When we have used a particular approach or technology for a long time we become comfortable with it and its capabilities. We tend to forget the feeling of awkwardness and confusion the first time we tried to use it.

This makes the transition to something new even harder than before. If we try something new after a long period our ego will try to protect us with everything it’s got.

Looking for comfort in uncomfortable situations

One of the most valuable lessons I’ve learnt from Jiu-Jitsu is not to avoid uncomfortable and awkward situations. One way or another you will be put in a disadvantageous position and you will have to find your way out.

Maybe you can avoid it for some time but at one point it will happen, that’s a given. The only way to prepare yourself for such moments is to intentionally expose yourself to them.

While this may sound like the typical “get out of the comfort zone” advice, I find that there are different ways to look at it. If a particular language is your safe harbour you can still put yourself on your back by putting some constraints on yourself.

You can prohibit yourself from using certain features of the language and try to think of alternative approaches to solving a problem. Maybe you decide not to use classes. Maybe curry all of your functions or put a limit on their length.

An entirely different approach is to give yourself more options rather than limit them. For me this was introducing TypeScript to a side project I had. While I still worked with JavaScript, static types introduced a whole new level to the programming I was used to and I learned an incredible amount just from that.

As a person working daily with React and Redux I felt comfortable in the ecosystem. However introducing type safe actions in my Redux flow and switching to Observables from Sagas and Thunks made me learn a how new way to wrap my normal programming flow.

TL;DR

The thing is that learning something new is hard and uncomfortable. When we switch our environment and try to use other tools sometimes we struggle with basic operations. While I was finding my way with Observables I always had the thought on the back of my mind that I already knew an approach that worked. Why struggle with that? And each time I thought of going back to what I know I remembered how I stagnated because I didn’t look further than leg locks back in the day.

As software developers we have the opportunity to work in an area of never ending learning. We shouldn’t take that gift away from us to keep our ego safe.

Originally published at alexkondov.com.