Lessons learned from my journey as a self-taught developer

The path of the self-taught developer is tough and clouded with uncertainty. There is no straight line from newbie to career programmer. Because of this, I believe all self-taught developers have a unique story to tell.

In this article, I've shared a few stories and lessons learned from my time teaching myself programming. Hopefully reading about my experiences will help you reflect on your past and motivate you moving forward.

Focus on the process

When I first started learning to program, I never had the intention of making a career out of it. I just wanted to make a specific app.

My journey started when I was a senior in college. I just finished Richard Brandon's book, Losing my Virginity and I was probably reading too much TechCrunch. I was pumped up full of entrepreneurial energy. I was constantly reading about how college kids were receiving massive amounts of investment for their mobile app ideas. I thought I could be one of those people.

One day, while walking in-between classes, an app idea hit me. The specifics of the app aren't important. The point is, the idea was unique and had a lot of growth potential (at least in my mind).

I was convinced I found the next big thing. I was consumed by the idea and stopped paying attention to lectures. My excitement for the idea quickly grew to the point where I felt the need to take action.

There was one big problem. My idea was a mobile app and I didn't know anyone who could build mobile apps.

So I thought what the hell. How hard could programming be? I was losing interest in my major and I was spending a lot of time playing Xbox. I could allocate some of my free time towards building this mobile app.

Sometimes being naive helps you take action when you normally wouldn't.

What you had was a college student with no programming, business, or design experience trying to learn Android so he could build a complex app. I guess that's what you get when you mix a big idea with the Silicon Valley hype machine.

I wish I could tell you things went well from here. 😉

I bought a few books on Android development and spent many hours in my room trying to duct-tape this app together. I didn't care how the app worked. I just wanted a finished product, if that meant copying and pasting code from any source I could find.

I thought I could get away with learning very little about programming. I became too focused on the end result. The light at the end of the tunnel kept driving me forward.

Time went on and the app turned into a Frankenstein of copy and pasted code. The app didn't have many features and it barely ran without crashing.

It wasn't until I accidentally got into a Computer Science class did I realize that maybe I should focus more on learning. My inability to program lead me to abandon my initial app idea. I had come to the realization that I wasn't going to make the next big thing, at least not yet.

Luckily, over time I corrected my behavior and took learning more seriously. I started to enjoy programming and eventually started a career as a software developer.

Take Away

Having a big idea is great but beware when the idea becomes all-consuming. It's a powerful force and it consumed me for a long time. It put my focus on the end result rather than the process of getting there.

It's important to remember that learning anything big, like programming, requires many small steps. The only way you are going to learn anything is by focusing on and mastering each individual step.

When you get too focused on the end result, you start taking shortcuts. Shortcuts might lead you to short-term progress but in the long run, your lack of knowledge will always catch up on you. Learning new things is like building a house. You start with the foundation and build up. If the foundation is faulty the whole thing will crumble down sooner or later.

Sometimes building a strong foundation requires you to slow down. There's no shame in going slow. The people who understand the basics the first time will end up going ahead of the people who have to go back and relearn them.

I was a perfect example. From the outside, it might've looked like I was a programming whiz kid. In reality, I couldn't build an app to save my life.

There's an old Chinese proverb that goes:

It is better to take many small steps in the right direction than to make a great leap forward only to stumble backward.

Focus on the process each day and you will surprise yourself with how much progress you make.

Stack Overflow is awesome (and dangerous)

As I was building the app, Stack Overflow became my best friend. Anytime I got stuck I would try to craft together a question to ask the Stack Overflow community. I averaged a few questions a week.

Not only would I post questions, I would treat the answers on Stack Overflow as Gospel. I would spend a crazy amount of time scouring the site to try to find an exact chunk of code that would fix my problem. Once I found the answer, I would copy and paste it right into my codebase and try to make it work. I spent little time trying to understand. I made brute-force trial and error a new art form.

This process went on for a while, until eventually, I wised up and realized the flaws of this approach.

Take Away

Copying and pasting is a terrible way to learn how to code.

Stack Overflow is a blessing and a curse. It's great at helping you solve and fix problems. But it also can become a crutch that you always depend on if you aren't careful.

Sometimes, the website is too good at solving your problems. It creates a false sense of confidence that will only lead to more headaches down the road.

It's impossible to learn anything if the answers are constantly given to you. Make sure you make a few attempts at solving your problem before going to Google.

If you do find yourself copying and pasting code, make sure you spend at least a little time understanding the code block before moving on. There are no short-cuts in the learning process.

Find experienced help

The first thing I did after I decided I wanted to learn programming was buying two Android development books.

At the start, I followed the exercises in the books closely and worked through all the example projects.

I quickly got bored and/or frustrated following the book. I decided to go off on my own and figure out programming myself.

As you've read above, that slowly resulted in disaster.

I would spend many hours a week isolated in my room or at coffee shops. I cut myself off from the world. I felt like there wasn't anyone who could help me because no one I knew had any experience with Android development.

Days turned into weeks and I wasn't making much progress.

At one point I had the bright idea to download a massive C library called FFMPEG. My app needed to edit videos so I thought it was a good idea to utilize the library's robust functionality. It wasn't the smartest move, considering at the time, that I could barely get my Android app working.

I wasted a lot of time trying to read the C code and figure out how I could use it in my app. I became frustrated and eventually abandoned the library.

Luckily, around the same time, I signed up for an Object Oriented Programming class and somehow got in. I was the only non-Computer Science major in the class. I don't know how or why I got selected. I think there was a bug in the enrollment software.

The first assignment was to build a Blackjack program. I'd been teaching myself programming for 5 - 6 months at this point, and I felt confident with my skills.

I finished the assignment and felt good about my work. However, that feeling quickly faded.

My whole program was written in one huge method. Just about everyone else in the class was able to pick up on the fact that the program needed to be separated into classes. Not good.

Take Away

Luckily, the classwork and guidance from the teacher allowed me to take a step back from my Android app and reflect on my development abilities. I started to value learning a lot more and reigned back my desires to make a completed app.

If I had spoken to just one experienced developer in those early days, they would've seen what I was doing, set my priorities straight, and talked some sense into me. They would've helped me correct my path when I was going down useless dead ends (like trying to work with FFMPEG).

As I outlined in a previous article, experienced developers are like a compass. They won't get you to your destination but they will make sure you are pointed in the right direction. Their help can often be the difference between success and failure.

In hindsight, there were a lot of ways I could've found help. I could've tried to find a professor/student at the university with Android experience. I also could've tried finding an online Android community.

Instead, I isolated myself.

Isolation is a double-edged sword. On one side, it helps you focus on the task at hand. On the flip side, it removes you from the world starving you of crucial feedback.

Make sure you seek out guidance where ever you can find it. It will save you time and frustration down the road.

Craft your environment

This might be the only thing I felt like I did right when I was teaching myself programming.

Throughout my life, I've been really bad at studying for tests or doing my homework at home. There are just too many distractions at any given moment. I would often try to find refuge in libraries or coffee shops.

Luckily I applied this rule when I was teaching myself programming.

I ended up becoming a regular at a few local coffee shops around town. I preferred coffee shops over other study locations because it provided some variety and it's easy to hide yourself (easy access to caffeine doesn't hurt either). Coffee shops are also nice because you can choose a location where you know you won't bump into people you know.

If I was studying at home, I made sure my door was shut and my roommates knew not to disturb me for a certain period of time.

Regardless of where I was, I would make sure my music was loud enough so I couldn't hear what was going on around me. Upbeat music without lyrics worked best for me.

I can't say I was perfect at finding a distraction-free work environment but I was able to succeed a majority of the time.

Take Away

Having the right work environment is often an under-looked part of learning. Your work environment shouldn't be distracting and should allow for long uninterrupted stretches of focus.

Focus is a foundational component of memory and skill acquisition. When you try to encode new information into your brain, the strength of the encoding is directly linked to the intensity of your focus. When your focus is weak, new information will be less sticky which will result in slower learning and more time studying.

Take any world-class performer and look at how they practice. Do you think they are checking their phone every 5 minutes? Probably not.

The easiest way to increase your focus is by crafting an environment where there are minimal distractions. This can be done in a few ways:

Finding a location where people won't interrupt you

Putting your phone in airplane mode

Using some sort of timed website blocker for social media and news sites

Wearing headphones and listening to non-distracting music (preferably a long playlist so you don't have to constantly switch songs)

Avoiding TV or other highly stimulating surroundings

Having a notebook nearby to write down any tasks or ideas that pop into your head

Only you can decide where and how to craft your environment. But make sure you do because it's worth it.

Get out into the world and meet people

My first programming job was sort of a random occurrence. I just moved to Omaha, Nebraska and I had around a year of self-taught development under my belt.

I only knew very few people in Omaha so I searched Meetup.com to try and find other people interested in Android development. Luckily, at the time there was a Mobile Meetup which covered both iOS and Android development. So I built up the nerve and decided to go to the group.

Going to that first meeting was nerve-racking. I spent around 10 minutes in my car at the venue deciding if I should go in or drive off. I was intimidated. I wasn't confident of my programming skills and I knew everyone at the meeting had much more experience that I did.

I finally said, screw it and went inside. I'm glad I did.

I started to attend regularly. During one Meetup, not too long after I moved to Omaha, I met a recruiter who was looking for an Android contractor. We talked for a while and I got an interview for the job later that week.

Before the interview, I felt confident. During the interview, I was a deer in the headlights. The interviewer was talking about the project I'd be working on and it all went right over my head. I tried to stay engaged but they could tell it was out of my range.

After the interview, they asked me to hang-out for an hour so I could talk to someone else. Knowing I blew it, I walked around downtown trying to clear my head.

I ended up interviewing with someone else, and shortly after, they offered me an internship. The CTO was doing all the Android work at the time and they needed someone to take on the load. I started that day.

I was so shocked that after I signed all the paperwork and got my work laptop running, I went over to the CEO and asked if it was a paid internship or not.

The internship turned into a full-time job and I started my career as a software developer.

Take Away

When you are self-taught, people are not going to come and seek you out. You will need to step out and find the opportunities.

People graduating from four-year universities and code schools have the advantage of leaning on the schools to help them find jobs. Self-taught developers don't have this advantage.

The best way to find a job as a self-taught developer is to go out into the world and meet people. Websites like Meetup.com are great for finding programming specific groups that meet monthly or bi-monthly.

Do what you can to build up the nerve to go to these groups. Be friendly and talk to people about your experiences. Make sure people know of your long-term goal of finding a job.

Put yourself in situations where something positive might happen. You can't win a raffle if you never buy a ticket.

Consider any opportunity that comes your way, because even if it looks like a dead end, it has the potential to lead to something bigger.

The key is to think of job opportunities in the long-term. Internships or part-time jobs might not give you your desired salary upfront but they might open up doors in the future.

Conclusion

As you can see, I made a lot of mistakes in my learning journey.

Learning something new is never a straight road. There will be turns and dips (maybe a few will take you off the road).

I encourage other self-taught developers to share their stories. Not only will they provide valuable insights, they will also help shine a light on the unique paths we've taken.

Hopefully, my story and the lessons I learned will help you moving forward.

Did you enjoy this article? Sign-up for my Self-Taught Developer E-letter. You will receive content like this along with other exclusive tips and tricks.