4 Common Pitfalls to Avoid, 4 80/20 Rules to Embrace
Stephen R. Covey said: If the ladder is not leaning against the right wall, every step we take just gets us to the wrong place faster.
Nothing is more true for becoming proficient at Python and software development.
Let’s pause and reflect and look at the pitfalls you want to avoid and the 80/20 that will make you an effective Pythonista.
We put this together based on common misconceptions talking to hundreds of people in our community and drawing from our own experience.
So grab some coffee and let’s dive in …
Pitfall #1: Tutorial paralysis
Information overload, hoarding and never completing online courses (How large are your Udemy and Coursera libraries?)…
This is a common pain we often hear and it can be crippling, making you feel you’re going in circles.
Even if you do manage to complete some courses, you don’t feel it contributed much in becoming a better programmer.
The reality is that nothing beats actual coding and implementing. The sooner you write code (and fail) the better.
We are so passionate about this common pitfall we could write an entire book about it, but there is more …
Pitfall #2: Improper sequencing
Somewhat related to tutorial paralysis, you not only need to do the right things, you also need to do them in the appropriate order.
Take dev job hunting for example. Some people get overly obsessed over the coding interview and knuckle down on the Cracking the Coding Interview 700 pager, or spend endless hours on algorithm courses.
Don’t get us wrong, data structures and algorithms are important. However, in order to succeed as a software developer there are many more things that matter.
Another example is early optimization. Engineers at heart, we love to endlessly tweak and improve the performance of our solutions, but did we actually ship the code for starters, getting feedback from real users?
Being a developer requires a certain dose of pragmatism and often getting something working is more important than getting it perfect (which by the way does not exist).
Pitfall #3: Obsessing over Pythonic code
This perfectionism is a nice segue into this next pitfall: “My code is not Pythonic (enough)“.
Neither was ours when we started. It only became more idiomatic learning from mistakes, studying more parts of Python’s humongous standard library, and via code review feedback.
Besides, as important as it is to know how to effectively use Python, you should equally invest in learning about software best practices, e.g. use meaningful variable names, proper scoping, writing modular / testable / self-explanatory code, etc.
Again, this comes with experience and working with others as we’ll see next.
Pitfall #4: Going on your own for too long
As Jim Rohn said: success leaves clues. You can save a lot of time engaging with expert Pythonistas.
Imagine the opportunity cost of not doing so. What takes you months to learn on your own, you can now learn in weeks, because other developers have walked the path before you.
We can relate to this. When we started our careers, we hit ceilings (we still do of course), growth stalled, motivation waned.
Once we sought out more expert teams and leaders, we faced new challenges (new levels, new devils), but at least we knew what to work on.
Condensing the accumulated knowledge from good developers/ mentors can reduce to mere weeks what would you have costed you months.
Or it can even make you work on things you had not even envisioned, because sometimes you don’t know what you don’t know (this is huge!)
How to measure this? If you’re comfortable for too long, you’re likely not growing enough! The gym offers great analogies here: muscles won’t grow without (progressive) overload/ stress.
Now that you know what to watch out for, let’s dive into what you should focus on to become a well-rounded Python developer:
80/20 Rule #1: Work on bigger projects
We are all about eating the elephant a Bite at a time (our exercises are called Bites of Py for a reason).
Exercising has a crucial place, specially when you start out grasping the foundations of Python.
But after that the difference between a “scripter” and a real developer is the size of the projects they work on.
Working on bigger projects forces you to solve more difficult problems, you’ll have to move outside of your comfort zone, you’ll move into the realm of software design and you’ll gain a more holistic understanding of what it means to write software.
Which inevitably forces you to learn all the developer tools the typical Python developer uses: the command line, Vim or a powerful IDE, git / Github, pytest (CI), PyPI (packing), Docker, SQL, a web framework (e.g. Flask or Django), etc.
80/20 Rule #2: Build a portfolio
Writing elegant code is one thing. Well, build it and they’ll come, right?
Well not exactly. With so many developers out there, if you want to stand out, you need to get noticed.
And if you’ve not worked as a professional developer, you’re actually in a chicken-and-egg situation: they want experience, but you don’t have any …
So you need to drop the tutorials and start building and shipping code. Push your apps to Github, get code critique, see if you can collaborate on other projects, etc.
The other side is to give back and teach what you’ve learned. Not only is this a major selling point, you’ll also gain a much better understanding of programming concepts and thus perform better in an interview or presentation.
We really believe that being a developer is as much about code / engineering as it is about effective communication!
80/20 Rule #3: Work with experienced developers
Remember what Jim Rohn said? It bears repeating: success leaves clues.
We are really fortunate we have the Internet these days! Anything can be looked up in seconds and you can reach out to experts on the other side of the planet.
Some important lessons we’ve learned as developers (and in life), we can contribute to the lessons learned from people that inspired us (and we never met face to face!)
It’s fascinating actually that you can learn from mistakes others made and generously shared. This is definitely worth paying some tuition for.
You are going to hit roadblocks and ceilings every step along the way. It can be hard and discouraging.
At those moments you can either give up or seek experts asking them for advice and emulate what worked for them.
80/20 Rule #4: Become a content provider
Become an ace at documenting your learning. The reason to do so is 3 fold:
- It’s too easy to forget, you will save a ton of time and therefor become a more efficient developer.
- It increases your writing and communication skills which is super important because of the amount of communication involved (personal and in code) as a developer.
- Becoming a content provider opens up an amount of avenues and opportunities over time you could not even have envisioned (read The Compound Effect book).
Did you know we started PyBites as “just” a Python blog? It was the end of 2016 and there was not a shortage of Python blogs out there.
But we said to ourselves: if it only serves a dozen of people in the first months and it cements our learning, it will be totally worth it!
Then something interesting happened: we discovered that there was a niche in practical problem solving in Python and we jumped on it.
Which led to 60+ blog code challenges, developing a coding platform hosting 300+ exercises, producing 2 #100DaysOfCode courses (@ Talk Python) and developing a coaching program.
We don’t say this to brag, the point is that you have to produce and launch things to the market. Not only as a business, equally so as a developer / professional.
You have to start building your growing asset.
We like what Brian Tracy said in this context: You are the CEO of your own company.
Remember, failure only exists if you tell yourself so. We prefer to believe that if we fail we learn a valuable lesson and we’ll come back stronger!
Conclusion and next step
So to sum it up in one line: start solve bigger problems with Python, build up your portfolio, learn from more experienced developers, and become a content provider.
Doing these 4 things consistently and you will become unstoppable!
We hope these pitfalls and our 80/20 has been insightful for you. If you want to go a bit deeper, exploring how you could apply these principles to your situation, hop on a strategy session with us.
Let us know what your main takeaway has been and what you will change in your approach: