With the rise of the IT industry, more and more people are keen to become a part of it. The most obvious way to achieve this goal is to become a developer; however, it isn’t a trivial task as there are numerous paths you can go down. A more traditional path involves investing N years of your time into higher education — this culminates in the computer science degree, which (hopefully) leads to better employment opportunities.
However, this option isn’t suitable for everyone — and so the path of the self-taught programmer opens up. In this article, we’ll explore how a self-taught programmer comes to be: which education opportunities they can utilize, which problems they may encounter, and whether this path is right for you.
Higher Education vs. Self-Education
We should preface the “Higher education vs. Self-Education” debate with the following disclaimer: Yes, there are always exceptions. Sometimes, universities and colleges fail to provide the necessary knowledge and support; other times, self-taught programmers utilize their discipline, determination, and motivation to become the industry’s most valuable professionals. These are the extremes, but we should primarily focus on the averages to get a better understanding.
We would argue that the distinctive feature of self-taught programmers has to do with education. As the name suggests, they teach the development skills to themselves through various sources: coding bootcamps, online courses, books, etc.
It’s a common misconception that the “self-taught” prefix makes the developer less serious, knowledgeable, or determined. We can disprove this sentiment by remembering the following fact: computer science as an academic field is rather young. The pioneers of the computer science industry weren’t exactly computer scientists, but rather mathematicians and academics from related fields. Of course, adapting to this new field (i.e. becoming self-taught programmers) was significantly easier thanks to their STEM backgrounds — but they had to adapt nevertheless!
Nowadays, the development sphere is much more diversified and democratized, so many of its subfields require no formal education — sometimes, it can even box the student in as many university programs cannot keep up with the speed of innovation.
The Case for Higher Education
It goes without saying that, in certain fields, higher education is a necessity — the foundational knowledge it provides doesn’t change, so the student can understand the technologies behind the computer on a much deeper level. Additionally, many companies list a computer science degree (or an equivalent) in their job postings as a requirement.
In other scenarios, a university degree is a great supplementary factor. A good example is the artificial intelligence field: it is absolutely possible to enter this industry as a self-taught developer. However, extensive mathematical education (e.g. calculus, linear algebra, probability theory, and statistics), especially aided by competent and enthusiastic professors and teaching assistants, can really make the student shine.
Coding Bootcamp as an Alternative
For many aspiring developers, bootcamps seem like a viable option: success stories from bootcamp graduates fuel the hype, while the organizers promise that every graduate will be recruited by Apple/Google/Amazon/<insert your favorite tech company here> the day they finish the program. Is it true? Is it false? Well, it’s not so simple — our article titled “Are Coding Bootcamps Worth Your Time? Yes — with the Right Approach” covers this topic in great detail.
Here’s the key takeaway from this (somewhat) humorous representation: in recent years, bootcamps have positioned themselves as a real alternative to traditional higher education. While higher education institutions focus on foundational knowledge, coding bootcamps focus on the “here and now” of computer science — that is, modern tools that can help the student enter the job market as soon as possible.
The Good: Hands-On Experience
The undeniable advantage that bootcamps can offer is the hands-on experience — lots and lots of it. In essence, coding bootcamps design their teaching programs around providing their students with as much experience as possible; this experience is supposed to showcase how real-world development is organized (i.e. how learning via following along a tutorial is different from learning in a hectic work environment).
College students often get the chance to gain this experience through various internship roles — institutions of higher education establish connections with tech companies and supply their students en masse, all the while vouching for them. Self-taught programmers don’t have this opportunity, so they typically have to pitch themselves to tech companies in order to get an internship role.
The Good: Employment
Similar to universities and colleges, coding bootcamps also connect their graduates with companies; although, in the case of bootcamps, this connection is usually promised to lead to full-on employment rather than simply an internship.
In fact, employment opportunities are one of the main selling points that coding bootcamps advertise. Their pitch can be summarized as “Get an in-demand skill → Use it to get a job → Monetize it even further”
The Good: Clear Learning Process
The learning process itself can often be a challenge: understand, memorize, apply to a real problem to facilitate understanding… This way, people perceive learning as the biggest obstacle, but we often neglect another aspect: not knowing what to learn.
This is a problem that all self-taught developers encounter eventually: the internet is rich with information, but it’s not self-evident which domain of knowledge should be prioritized; beginner self-taught developers typically turn to online communities for their expertise — but often get clashing pieces of advice. Imagine a thread on reddit asking the following question: “Hello r/webdev! I’ve just started learning front-end web development. In a year’s time, which skills should I have under my belt? A framework, perhaps?..”
This thread is likely to get some great answers — but, upon comparing them directly, we might get confused:
- User A will advise the following: “Learn JavaScript in and out! Learn it so well that you can write your own framework! Frameworks that are trendy today aren’t guaranteed to be relevant tomorrow — don’t waste your time on them.”
- User B, on the other hand, will advise the following: “Your goal is to become hireable as fast as possible! To do this, you need to learn a modern front-end framework. Go for React — it’s not going away in the near future.”
Both of these opinions will be stated with confidence and knowledgeability — so which one should the beginning developer choose?
Furthermore, it is also unclear how deep the self-taught programmer should dive into these domains. Let’s take another scenario: you’re entering the field of artificial intelligence, focusing on natural language processing. To outline the learning process, you’re drafting a plan of subjects, topics, and concepts you’ll need to familiarize yourself with.
- Hmm, programming languages… Python or R? Well, all major NLP frameworks are written in Python… But I heard R is optimal for statistics and data mining, so should I learn both of them?
- So, which framework should I pick? Or is it more correct to build a solid theoretical foundation?
- Data, data, data… I’ll probably have to interact with unstructured data. How can I process it? How can I make it structured?
- Data… bases! Which database should I learn? Probably relational ones? This means SQL, right?
- Maths… There’s probably a plethora of subfields I need to brush upon. Calculus? Linear algebra? Probability theory?
Naturally, linguistics is a must as well… how much of this knowledge, though?.. - What about areas only tangentially related to NLP (e.g. statistics)?
Here’s the million-dollar question: with most of these skills seeming equally important, how to decide when to stop learning? A good example is SQL: just how proficient should a data scientist/NLP engineer be with SQL? Average? Semi-pro? Pro?
Therefore, the benefit of well-organized teaching (whether in universities or coding bootcamps) is the authority that can tell you: “Learn skill A and complete 10 assignments — this will be enough.” The keyword is authority: university professors, unlike anonymous online users, really think their pieces of advice through because they have their reputations to lose.
The Good: Financial Aspect
Another point of consideration is student debt — a problem exclusive mostly to American graduates. Although it’s not a factor that would actually prevent the majority of high school students from entering higher education, it does cause additional worries about the future life — “Will I be able to pay this debt off or will it become a burden for 10-20 years of my life?”
The numbers may vary, but the general idea stays the same: any amount of debt can be dangerous. A counterargument may be the following sentiment: “The professionals in the IT field make more money per capita than in many other fields!” While it is true that developer salaries are high, a graduate cannot be guaranteed that their particular salary will be high
For instance, it stops young people from taking entrepreneurial risks — exactly when they’re most likely to take these risks, having (relatively) nothing to lose and (usually) no family to provide for. Last but not least, student loans can’t be claimed in bankruptcy (unless a special case applies).
Importance of the Portfolio
When it comes to employment, the selling point that drives the company’s decision to hire/reject the candidate is the experience. Experience comes in all shapes and sizes, so the society came up with a neat little idea: experience should be provable, i.e. something should demonstrate that you did solve this problem/find yourself in this situation/learn how to avoid this pitfall in the future.
College graduates have it figured out: the trials and tribulations of higher education finally result in the diploma — a testament to the person’s expertise in the field (in theory, at least). For self-taught programmers, the diploma’s equivalent is often their portfolio — a collection of hand-picked projects that prove their mastery of computer science.
Here’s the good news: a great portfolio is worth a thousand resumes. Here’s the bad news: there’s no recipe for the portfolio that is guaranteed to hook the employer. Here’s another good news: we have an extensive guide dedicated to (web) developer portfolios with some great examples.
GitHub as an Interview Tool
For some tech companies, the candidate’s portfolio is the optimal tool for testing their skills: they abandon the usual “whiteboard interview with 100 algorithm questions” routine and choose a different route — they analyze the candidate’s portfolio, pick a project, and ask various questions related to it. This way, the company can gauge the candidate’s knowledgeability without confusing them with abstract questions (e.g. grilling a front-end web developer with time complexity of the merge sort algorithm)
Therefore, your chances of success will increase if you remember this simple truth: you don’t present your projects — your projects present you. Your GitHub account can act as a shield against the skepticism of your prospective employers. They will probably take a close look at your project as a finished product and ask the following questions:
- Is the code well-written and well-documented? (Of course, “well-written” is a subjective quality, but the code at least shouldn’t be plagued with bad practices.)
- Which tools and technologies have been used? Why them? Which design decisions have been made? Why?
- What was this project’s goal? Has the developer succeeded to reach it?
Companies can benefit from this methodology because they can see if the candidate is trying to trick them with a project they copied from the internet. The candidate, on the other hand, gets a chance to shine and showcase just how well they’re suited for the job.
Conclusion
The path of a self-taught programmer is long and full of pitfalls — but with just enough articles from our blog, you’ll feel a bit safer. 🙂 The key is to avoid comparing your experience with that of other developers: your path is unique, so it’s best to appreciate it even when you encounter problems. Good luck!
