In my previous post, I hammered out a plan to follow every day. A crucial part of that plan is having a syllabus to follow. One that will refresh my CS knowledge and prepare me for interviews. I’ve been researching this for quite a while now and have finally decided on a plan to follow. Before I get to my own plan, I’ll talk about a lot of the information I read through to formulate my own syllabus.

Research

First, a List of Suggestions that helped point me towards some of the better existing syllabi out there.

• A discussion from /r/cscareerquestions
• A discussion from /r/learnprogramming
• Another discussion from /r/learnprogramming
• And this Github repo * I was able to pull out links to resources from there that helped a lot.
• Then there was this StackExchange question that was really useful in helping me think about how to build out my own syllabus. Some key points: _ Aside from suggestions, the top comment builds out a common CS track syllabus for you. _ Good in how it breaks it down by year. * It’s a good place to base your syllabus on as an outline, but other sources have already built this out for you.
• Lastly and most important, the /r/learnprogramming wiki - The Gold Standard of a collection of resources.

Second, a piece of advice that I came across that could help you skip the whole “learn from a syllabus” thing and get you a much better chance of landing a job:

• Email a company with an open position that you want to work at, and ask them what you should learn before applying.
  • The idea is from this article’s opening.
  • It may not result in anything, but it could lead to a sort of mentorship. And mentorships can be super valuable. See: Talk Python To Me @ 00:51:43 * Mentorships are important and I may eventually want to seek out someone or a program (paid) that will have a mentor who can answer the professional questions I have about really getting myself to the advanced level.

Lastly, your journey is not done even if you make a self study syllabus and follow it through to the end. There’s a lot more that you need to do and continue doing to separate yourself from the pack. This reddit comment does a great job illustrating the long road ahead.

That said, these were some of the best syllabi that I came across and my thoughts about each.

Teach Yourself Computer Science

• Website
• Trello Board for this from reddit.
• Reviews: _ Hacker News _ It’s strength lies in it’s simplicity and how it tells you exactly what fundamentals you need to learn. _ If you don’t like what it picked, you can swap it out for a different course or book since you know what the topic is supposed to be. _ The only debatable fundamental that it lacks is computer graphics. But that’s ok as it’s easy to redo since I did it in university. _ It’s also good enough that it is used by others who teach in person: https://bradfieldcs.com _ reddit * Good set of comments for how to supplement what this teaches you.
• Why this particular guide looks so attractive to me: _ Both P1xt and OSSU guides are great and in many ways similar, but they are SO BLOATED. _ Teach Yourself Computer Science target audience is self-taught developers, who already know some technologies and tools, but want to learn their underlying foundations and core CS principles which you really should know as a software engineer.

OSSU - Open Source Society University

• Website
• Github
• subreddit
• Reviews: _ reddit 1 _ reddit 2 _ reddit 3 _ Not much to be gleamed from this discussion other than that this is super comprehensive. _ There are spots that it’s missing, but the current version seems to have rectified all of those. _ It’s also gotten more streamlined over time. _ reddit 4 _ reddit 5 _ Same as above. It’s quite well known I think, but also known for being very very in depth. _ reddit 6 _ One of the best parts of this is that it is constantly updated with new versions. _ Hacker News _ Great for theoretical Comp Sci. _ Quora
• Why this particular guide looks so attractive to me: _ If I want a comprehensive education, this is probably one of the best to follow. _ This will be good as something to study long term. * The website has a great breakdown of the duration and effort (in hours) required to get through this.

p1xt-guides

• Github
• P1xt is a compilation of OSSU, Google Interview University, The Odin Project and Free Code Camp.
• The goal of this course is to get you Job Ready. Specifically, this section of their course:
  • This looks like it’s meant to follow up on the Free Code Camp course.
  • This will fill in all the holes and gaps you need to learn to actually be able to work as a developer.
  • It’s also focused on JavaScript and looks quite decent as a guide to follow.
• Reviews: _ reddit 1 _ FreeCodeCamp forum _ The original creator is no longer maintaining this or answering questions (actively). _ However, he moved it to Github so it could be updated by community. _ reddit 2 _ reddit 3 * The Job Ready JavaScript guide has good reviews.
• Why this particular guide looks so attractive to me: * The JavaScript stuff is what I probably would have done anyway, but this gives me a good structure and guidance.

The Open-Source Computer Science Degree

• Github
• Inspired by The Open-Source Data Science Masters, this project aims to do the same for an undergraduate Computer Science degree.
• The following document outlines free online courses from top schools like Harvard, Stanford and MIT.
• Reviews: _ reddit _ This comment in particular does a good job of expanding on this course and pointing out what it lacks.
• Why this particular guide looks so attractive to me: _ This has listings for all free university courses to follow and the syllabus is pretty much done. _ It’s also broken up into Terms and very much resembles a real CS degree in structure.

Obtaining a Thorough CS Background Online

• Website
• Good for identifying and shoring up gaps in your CS Education.
• Covers both the fundamentals (down to math) and advanced topics.
• Reviews: _ Hacker News _ The reviews are good and the discussion around free CS courses in general is interesting. _ reddit _ It was part of how someone self-educated themselves into a iOS Developer career.
• Why this particular guide looks so attractive to me: _ It’s good in that it picks out the courses for you and tells you how long it will take. _ I also like the breakdown Math, Fundamentals, and Advanced sections. * It also looks thorough enough that I don’t think I’d miss anything following this syllabus.

Coding Interview University

• Github
• This is the guide that the guy who tried to spend 8 months prepping for a Google interview followed.
• Why this particular guide looks so attractive to me: _ While interview heavy, it covers all of the theory I’d probably need in order to ace an interview. _ It will be good as a supplement to an actual syllabus from the above sets.

Getting Into Software Development

• Article
• This route to employability looks to be a good outline to follow in constructing the key points in a syllabus that you would need to become employable:
• Reviews: * reddit
• Why this particular guide looks so attractive to me: _ It’s to the point and covers the keys to Software Development but not necessarily Computer Science. _ So it’s much more practical and short.

The Open-Source Data Science Masters

• Website
• Github
• This is for Data Science masters.
• I’d review this more, but ultimately I don’t think I’ll be pursuing data science as a career focus at the moment.

Awesome Courses

• Github
• This is a listing with summaries of many different free classes (university ones).
• It’s good as it breaks it down into sections of CS Education (so tracks at Columbia).
• However, there’s a lot of redundancy as it doesn’t pick out an ideal course for you. So it’s up to you to trim it down.
• It’s also not a structured syllabus. You’ll have to figure out your own timeline for studying.

Curated Computer Science Curriculum

• Github
• It’s a syllabus for replicating a CS B.S. Degree.
• However, nothing about this really stands out over the other ones listed above.

I Wanted To Learn Computer Science so I Created My Own Degree — Here’s My Curriculum

• Article
• Based off of The Open-Source Computer Science Degree and the Google Guide to Technical Development.
• It’s ok, but it’s in article form so difficult to follow and get an overview of the entire structure at a glance. You have to read it and break it down yourself.
• Not something I’d probably follow as it doesn’t stand out over the above ones.

MindWeb – A Computer Science Bachelor Curriculum

• Website
• Reviews: _ Hacker News _ This is more of a content compilation than an actual structured curriculum.

Lambda School (YC S17) Syllabus

• Bootcamp Website
• Github (syllabus)
• Reviews: _ Hacker News _ Their syllabus is open source for all to see but as I commented in the discussion, it’s laughably sparse. * It could be used as a guide for structuring your own syllabus, but there are better ones above.

A Self-Learning, Modern Computer Science Curriculum

• Website
• Extremely well explained syllabus of a CS degree all the way from the basics of Math and up.
• It feels a bit theory heavy for me.

Google Tech Dev Guide

• Website
• Three paths:
  • Foundations
  • Advanced Learning
  • For Faculty
• Resource Library
• Reviews of original guide years ago: _ reddit _ Hacker News
• Reviews of the recently revamped guide: _ reddit 1 _ reddit 2 * reddit 3
• Overall comments say that: _ It’s a pretty disjointed guide. _ It doesn’t go into any depth on how to learn these topics. _ The syllabus (path) isn’t actually very good. It’s basically saying, “Learn Everything!” _ It’s very biased towards Google’s recruiting methodology as they base it on interview questions. So it leans heavily on certain topics (algorithms for example).
• Oddly enough, a better more structured guide (not without it’s own faults) for doing this same thing is: Google Interview University – Plan for studying to become a Google engineer

Google Interview University – Plan for studying to become a Google engineer

• Github
• Reviews:
  • Hacker News
  • The companion article says the author spent 8 months studying using this. This is the HN Discussion of the article.
  • The creator was not hired by Google but did get hired by Amazon.
• This is a good guide for learning the algorithmic type stuff you need to pass Google style interviews.
• It won’t make you a master programmer or a specialist in any tech stack, but it’s great prep and covers things I think I should be learning anyway.
• I plan to use this to structure the algorithm section of my own syllabus.

Self Syllabus

All of that research was useful and worthwhile, but before I can fill in my own knowledge gaps, I need to:

• identify what I know vs. what I don’t
• identify what I need to learn for my personal goal

Only then will I be able to build an effective syllabus.

Self Reflection

These are the things I’m capable of, but certainly not confident in:

• JavaScript
• Python
• React Native
• Flask

These are the things I know enough about to be dangerous, but wouldn’t pass an interview:

• HTML (the DOM)
• CSS
• SQL
• Java
• Django
• Bottle
• SQLAlchemy
• peewee ORM

And then there is all the general CS theory that I know but am very rusty in:

• general CS theory
• data structures
• algorithms
• Big O
• databases
• networks
• security
• graphics
• visual interfaces
• UI/UX design

If I were being 100% honest with myself, I should do a refresher on everything. Even the CS101 stuff as I wouldn’t be able to pull out the correct definitions off the top of my head anymore.

Identifying a Goal

These are the bare minimum things I need to be confident in to achieve my personal goal - a software engineering job (probably junior frontend webdev):

• JavaScript
• HTML (the DOM)
• CSS
• general CS theory

To put myself above the pack, I should tack on some of the following:

• React / Angular / etc. (something frontend)
• Ruby on Rails / Flask / Express / etc. (something backend)
• data structures
• algorithms
• Big O
• design patterns / software architecture
• testing
• source control
• debugging (tools, methodology, etc.)
• optimization (performance, profiling, minimization, etc.)

Then to really separate myself (specialize myself as frontend or backend), I should attempt to achieve mastery of the above areas and tack on some of the stuff from this list:

• databases
• security
• networks
• UI/UX design
• SASS / LESS / etc.
• PWA (Progressive Web Apps)
• advanced programming topics (threads, async, event driven coding, etc.)
• build tools

Disclaimer: I created these lists based on a compilation of the key focus areas from the syllabi above and from talking to people currently in the industry. Do not take them as definitive lists. These are simply areas that I feel can be accomplished on my own that will help me reach my goal.

Lastly, to really spruce up my resume, I should complete the following tasks during my self study course:

• One good portfolio project. Though the more, the better.
• Updated resume with concrete skill set.

Choose Your Language(s)

You can make this decision using a few different ways:

• Pragmatism
  • What is used in the industry today?
  • What is used in the jobs you want to apply to?
  • What is used in the specialization you want to pursue?
• Popularity
  • What’s trending (Google, StackOverflow)?
  • What do people commonly suggest?
• Desire
  • What do you want to learn? (coolness factor)
  • What is most applicable to your hobbies?
• Ease
  • What are “easy” languages? (syntax, available tooling)
  • What has to most good tutorials?
  • What do you already know?

There are other approaches to making this decision, but those are the most pertinent questions in my opinion. While I would love to learn Haxe, Kotlin, Swift, Lua, C#, Godot Engine, Unity, and many many other things, I need to be more pragmatic about my decisions. There’s always time for learning tech to pursue my hobbies (gamedev, self hosting) after I get a stable job. In the meantime, I need to focus on what will get me to my current goal. No distractions!

So what languages and frameworks will I be learning?

1. JavaScript - This will be the primary language I attempt to “master” for interviews.
2. Ruby or Python - I need to have a working knowledge of backend code and while I know enough Python, a lot of the jobs I’ve been looking at are using Ruby & RoR. So I may have to switch tracks and learn those instead.
3. React - Given my knowledge of React Native, this should be easy to learn given I learn enough about HTML and the DOM. Once I’m comfortable, I’ll start diving into the most common modules (redux, flux, etc.). This would give me a good leg up in my job search.
4. RoR or Django - Certainly not as in-depth as React, but I need to learn more than what I can accomplish in Flask. Enough to be capable so I’m not restricted purely to the frontend.

Building My Syllabus

The hard decision making is out of the way. Now it’s time to use the resources to build a syllabus that will cover all of those areas of study in a semi-logical progression. In particular, these are the resources that I leveraged the most heavily:

• /r/learnprogramming
• Teach Yourself Computer Science
• OSSU - Open Source Society University
• p1xt-guides
• The Open-Source Computer Science Degree
• Coding Interview University
• Obtaining a Thorough CS Background Online
• Getting Into Software Development

Disclaimer: I will be leveraging free resources heavily in my own syllabus.

Phase 1

I will also be intentionally leaving things out that may seem essential in Phase 1 as I plan to get myself into application ready state as soon as possible.

• Do the equivalent of CS101 using JavaScript.
  • Stanford’s CS101 uses JavaScript so this is a good candidate to follow.
  • Harvard’s CS50x is a good alternative choice, but it covers many other languages in addition to JavaScript. I won’t use it, but it’s good to point out that there are many other courses like this and others (MIT, etc.).
• Achieve baseline “mastery” of JavaScript, HTML (the DOM), and CSS.
  • JavaScript Basics:
  • Modern JavaScript Explained For Dinosaurs is a good article that will help me get reaquainted with the current JavaScript world.
  • Udacity’s Intro to JavaScript could be a good start for the basics.
  • Udacity’s Object-Oriented JavaScript to follow-up.
  • Udacity’s JavaScript Design Patterns to advance.
  • Udacity’s JavaScript Testing to finish off the series.
  • JavaScript Advanced:
  • You Don’t Know JS is one of the best series for really learning in-depth JavaScript. Based on how the book series is described, you’ll want to understand basic JS first, hence why I will be doing those Udacity courses first.
  • Eloquent JavaScript is also highly recommended, but the main problem is that it starts of with simple concepts but ramps up very fast. I won’t be using this unless I feel unsatisfied with You Don’t Know JS.
  • HTML & CSS:
  • Udacity’s HTML and CSS Syntax could be a good start for the basics.
  • DOM Enlightenment for diving deeper into the DOM. I don’t expect to study this in-depth, but I will at least skim through it and read the parts that I feel are harder to understand.
  • Udacity’s Web Development would be a good follow-up to connect my JavaScript studies to HTML & CSS.
• Final Project: Create a portfolio project demonstrating a combination of what I’ve learned.
  • Good clean code.
  • Functionally interesting.
  • Follows best practices.
  • Well tested.

Phase 2: TBD

TODO: This article is running long, so I’ll save the next phases for a future article. I’ll update this with a link to it when I’m done so you can continue reading. For now, a better use of my time will be to just start studying. If you want to get a head start on the next phase, I will probably use parts of the JavaScript Path in Phase 2 to really flesh out my “mastery” of JavaScript. It should help a lot with using JavaScript to learn all of the more advanced topics and frameworks such as React.

Copyright © 2011-2020 Ho Yin Cheng