Maybe you’re going through Boot Camp, or you’re participating in the 100 Days Of Code Challenge — where you learn a new concept or write a bit of code each day for 100 days. Whatever it is you’re doing, you’ve finally arrived at the point where you can call yourself a self-taught developer.

But the question then becomes — now what?

There will always be someone out there better than you, who knows more and can code more effectively than you.

At what point can you upgrade yourself and begin to say that you’re a real developer? It’s hard — especially if you’re coming from the self-taught track. Those coming from a computer science degree track will always have an edge over you. This is because they have something you don’t: at least three years of intensive study of the inner workings of computer programs.

It ranges from algorithms to thinking theories that may make them, by design, a better developer than you.

But the mark of an effective and efficient developer isn’t based on a degree alone, nor can it be judged based on the number of years in the game. Every developer will experience different levels of work pressures that determine the speed and quality of their output. Code intuition is built through experience, namely past failures — because when things go well, we don’t really learn.

It’s when we have to fix things that the real code lessons are taught.

Here are nine things you should consider doing to expand your mind and experiences and upgrade your practical skills beyond coding tutorials.

1. Make Something

As a developer, you’re in the business of creating code — so the best way to practice your craft is to do the things that you’ll be repeatedly doing. However, there are different kinds of doing — the kind where you must follow along vs. the kind where you’re able to use the creativity of your own mind.

The latter is the kind of creating you should task yourself with.

This is because when you’re able to code something from scratch, with minimal help from the great knowledge pool known as Stack Overflow and the internet, you’re skilled enough to put pieces of knowledge together rather than spending half your time looking for answers.

Once you’ve reached this level, it’ll let you focus on the product and its architecture rather than trying to find the bricks to build it with.

2. Learn a New Framework or Library

A developer’s world is always on the move, and so knowing how to code in a particular language is no longer enough. You also need to learn different frameworks and libraries, understanding enough to properly conform to their rules and requirements, syntax strangeness, and any oddities that will eventually make sense in the long run.

Learning a new framework or library also signifies to potential developers that you’re able to pick up new ideas quickly — especially code organizational strategies — because that’s what frameworks and libraries essentially are.

Frameworks and libraries exist to make life easier for developers by turning raw code into a structured methodology of creating applications based on certain sets of requirements. It also helps you keep everything in check and on the same page, especially once the application has grown to a certain size and has multiple people working on it.

3. Dig Into Computer Science Topics

If you’re self-taught, you’re most likely handicapped against those with computer science knowledge. The difference between you and graduates with degrees is that they know the underlying computational-based ideologies that aren’t taught in your usual tutorial or self-taught track.

Most of the time, self-taught developers jump right into the code without knowing topics like recursion, functional and object-oriented programming, and algorithms.

While we may have a working program, the robustness and potential conciseness of the code is lost due to a lack of this foundational ‘meta’ knowledge.

4. Learn How to Think

Regardless of what track you choose, learning how to think is a vital component in becoming a fully-fledged and highly effective developer. We’re not talking about your standard thinking — but rather, ways of looking at a particular problem and then coming up with a solution.

There are different levels of thinking, from the code level to the architectural to the conceptual. Different paradigms, methodologies, frameworks, and libraries all have their own special way that enforces a certain way of thinking on a problem at a particular level.

So expand your mind and educate yourself in as many of these things as possible. Try to get to a point where you can make compartmentalizations and connections between the different parts of a problem to a particular solution — resulting in creative code that’s highly robust and resilient to change.

5. Go Shopping

Ecommerce makes up the majority of major software development. If it's not about analyzing the data gained, it’s about how to implement a particular shopping experience.

There’s a reason why Shopify is so big — it’s because they’ve mastered the flow of end to end fulfillment. You can learn a lot from Shopify and translate their ideas onto your applications and solutions. The free account helps with mocking transactions and integrations.

But Shopify isn’t the only shopping site available. Take a step back and look at Amazon’s flow. What strategies does the shopping giant have? What patterns can you see that are replicated in other places? What other techniques can you see?

Consumers are more likely to buy when they encounter a similar pattern. This is because they already know how to make a purchase. Figure out what these patterns are and they can help you with future ecommerce related implementations.

6. Invest in a Hobby

Hobbies expand our domain’s edge by making us experts in a completely different field. This is necessary, especially when it comes to solutions that require thinking beyond the norm.

In most university degrees, there’s often a component that enforces a requirement of general study in order to give students different perspectives beyond their core course requirements.

The same can be done through hobbies, where you explore alternative methodologies of doing something. It can also give you an edge over other candidates when it comes to job applications if your hobby happens to match up with the industry that your potential company exists in.

For example, someone who has a strong interest in health and wellness will often fare better in companies that deal with the healthcare sector. This is because the candidate is already predisposed to certain ideas and topics that someone jumping in cold may not have.

7. Dive Outside Your Comfort Zone

When it comes to application development, we often fall into the trappings of picking the easiest route in order to deliver on time. However, the result may not always be the best solution.

As this habit of taking the easy path sets in, we need to give ourselves some friction in order to grow as developers.

And to get this friction, we need to dive outside our comfort zone — meaning putting ourselves in knowledge spaces that we’re resistant towards. There may be a certain paradigm or methodology you’ve been putting off, or maybe you’ve put off learning a “competitor’s” framework or library.

But seeing how other people are doing it may just give you the enlightenment you need to move forward.

Code creation is part creativity and part knowledge industry. One can’t exist without the other to truly thrive.

8. Aspire Toward Your Dream Job

When was the last time you looked at an advert for your dream job?

Employers often list the things they look for in a candidate, especially when it comes to different combinations of technologies.

There’s a high chance that you won’t be able to tick all the boxes, but ticking more boxes than others gives you a better chance at actually getting where you want to be.

The job calls for React but you’re an Angular developer? Then it’s time to go and play in the sandbox and verse yourself up with it. Does the job call for some weird acronym you’ve never heard off? Looks like it’s time to Google things up.

When you look at potential jobs — not just at the current level you’re at, but at the seniority level you aspire to be — it gives you a blueprint of what you need to learn and level up.

9. Master the art of testing

Testing isn’t often a thing that’s on the self-taught radar. Learning how to test with frameworks and libraries will enable you to think differently and hone into the way you create your code.

The way testing works is that it flips your normal, from beginning to end, and it takes the code development process and turns it on its side. You start off by knowing exactly what shape your data needs to be and test against inputs and expected outputs.

This turns the process of creating code and essentially stabbing at the dark into a process of test-driven development — where the shape of things is architectured into the way you perform your code creation processes. It’ll also put you in front of other potential candidates when it comes to job applicants. Because chances are, they haven’t looked into testing at all.

Final Words

There’s no linear path toward upgrading your skills as a developer, but there are recipes and different combinations that essentially work on expanding your current knowledge domains and experiences with code.

The thing with the self-taught path is that it’s slightly harder because there’s often a lack of guidance. But if you’ve made it this far in your journey, walking onwards is only a matter of consistently making the steps.

It doesn’t matter what direction you go in. As long as you’re learning, you’re essentially making progress in some way.

So keep learning and never stop learning, because that’s your ultimate leverage point in a field that’s all about what you know and how much you know.

Share this post