I built my first site nearly 20 years ago and even then I was able to source quite a lot of information online.
Even though most of my learning was a combination of reading IDE manuals (QBasic), downloading manuals and guides on a floppy disk from Internet cafes, and reprinting original books in multiple copies since these were extremely rare to find.
Some engineers here have been coding for 40 years and faced a far more conservative ecosystem while still being able to produce code decades later.
Studying programming now is a no-brainer. Between YouTube and Udemy tutorials, Coursera and FreeCodeCamp training programs, tons of Kindle books, GitHub, and gazillions of bootcamps and private training academies, students can access everything needed at their fingertips. I recalled how learning coding was like before in a video I posted on Linkedin.
Self-Taught Software Developers vs Computer Science Graduates
It’s NOT about the skills.
- It’s about the background.
- The foundational knowledge.
- The conceptualized overview of computer science (and its corresponding areas).
There are tons of universities teaching Computer Science with transparent/public curriculums online, often sharing presentation/slides or recommended reads, too. But I hardly doubt more than 2% of all self-taught programmers have considered going through this process.
That’s not to say that universities have covered everything you need to know.
It’s more about having a common pattern or strategy for solving well-known types of problems, just like design patterns. And a group of people with CS degrees will likely communicate easily, without having to refer to manuals or explain concepts like design patterns, regular expressions, the Big O notation, binary search trees, or anything like it.
You can look it up online, but it may get trickier if it happens all the time.
It’s what everyone says about development — you don’t have to memorize every class or function out there, but if you have to look it up every single time then you’re as good as a freshman.
But, Does Practicing Coding Questions Online Help?
The only time I ever bothered about coding questions were on my university and certification exams.
Online exams are about memorizing syntax curiosities, specific function names, and hardcoded limits. In practice, you really don’t need to be able to quote the entire manual of a programming language back-to-back while building a software application.
Programming is about solving business problems through algorithms. Nothing less, nothing more. Efficient and elegant development add to that by introducing conventions, design patterns, optimal data structures, and algorithms.
And programming is a piece of the puzzle from the entire technical stack. Think about your computer architecture and the installed operating system. The network layer as well. And all utilities, servers, tools, libraries, daemons running atop. While the raw theory doesn’t make a lot of sense in class, it’s paramount when building real-world applications.
The rest is about solving as many problems as possible.
- Build pet projects.
- Contribute to different online applications and platforms.
- Submit the code to open source projects if you are up for it.
- Develop extensions, tools, libraries, plugins or modules for existing applications.
- Play with different frameworks and technologies within your technical stack.
- Solve as many problems as possible.
Continuous Experiential Learning
Professional software development is dependent on experiential learning through different business cases that require software automation. Having learned through practice, you will be able to collaborate with other computer programmers, conduct peer code reviews, focus on security, performance, or stability. You can dabble with design patterns and architectural patterns.
But it all starts from practice and continuous learning by actual programming.
I created a video on the importance of continuous learning for software engineers and IT professionals. Check the video below.
Endless reading and watching training videos without actually writing code is the biggest misuse of time when learning programming.
I’ve trained over 2,000 students since 2006 and I’ve probably met a hundred of those who struggle with simple problems. They keep re-reading the user manuals, the best books in the field, and watching numerous online courses until they become comfortable writing code from scratch.
That doesn’t work in software development. It’s all about solving business problems through simple or more complex algorithms.
It’s about practice – just like Physics or Math. Being a theoretical guru doesn’t mean that you can actually solve problems. Experienced engineers can solve problems based on a pinch of theory and a recollection of similar use-cases that have benefited from a certain solution.
That’s why my advice for new software engineers is usually to start a pet project. It’s easier to learn through an actual problem at hand and slowly build on top of it.
The Easiest Way To Fail
Sure, the initial code base won’t be ideal.
But that would be the case with endless reading, too.
Additional code improvements and optimizations are a result of a malfunction of the application. If you build a project by yourself and use it day-to-day, you’ll easily find loopholes that need a smarter solution. This would isolate a certain problem and thus make it easier to identify a better approach to solving it.
And most of those “readers” and “watchers” are afraid of failing.
The easiest way to fail is not to take action in software programming. Your code would evolve over time. If you’re progressing further, it’s likely that you’ll always be somewhat ashamed by the code you’d written a year or two ago.
And that’s actually a good thing.
Just start small and solve actual problems. Build a small project that works for you. It could be a small contact book or an application that solves your physics homework exams. Once you have the foundation ready, add some UI, refactor the database layer, optimize for performance or include new components.
It’s all about continuous learning – but it will never work without practice.
Instead of worrying about being self-taught, just keep solving business problems via code. Sooner or later, you’ll collaborate with other engineers, have to hack around an existing product with conventions, or participate in an open source project.
Some coding standards will be available. Design patterns will be referred to (and expected). Job interviews will include certain questions you hadn’t thought of initially.
- You may consider a certification program (if available) just to make sure that you’ve covered a broader set of requirements within your programming ecosystem.
- Or review the curriculum of some top Computer Science programs.
- Read open source GitHub projects written in your favorite language. See if you’ll face some challenges understanding coding patterns and paradigms. Just be mindful that large complex projects take a while to understand anyway.
This will all fall into place with time.
Instead of wondering about experienced teams, solve as many problems as possible and challenge yourself.
Even if you meet “coding purists” later, you’ll be able to solve more actual problems thanks to your practical background.
Self-taught developers can learn everything graduates have learned. But for the most part, they haven’t put the time and effort to do it.
Click To Tweet