Catching-up A Computer Science Degree:

A guide for career changers (part 1)

Photo by Infralist.com on Unsplash

I became a developer without following the “traditional path” of computer science or engineering degree, but through a mix of self-learning, attending a bootcamp, and then learning on the job for while working as a developer. We are quite many in the same case, and this is perfectly fine, as most of the needed skills are learned by practice. But why tickle our curiosity a bit and check what it takes to know in depth the fundamentals of computing? In this article, I decided to explore and share some of the most meaningful resources I found.

Computer Science studies usually consist in 3 to 5 years of university studies that are split between theoretical courses, workshops, group projects and dissertations. They highly depend on the country and university, but some of the following courses are commonly found:

• History of Computing
• Algorithms & data Structures
• Math & Calculus
• Physics
• Software engineering
• Systems Architecture
• Computer Security
• Management

Sometimes, specialisation courses are part of the package:

• Data science
• Cryptography
• Robotics
• Artificial Intelligence
• Machine Learning.

This list is non-exhaustive, and it can take years to study in detail even one of the subjects. But do we really need this in order to become a kick-ass developer? Some old-school minded would argue that this yes — is the only way, while anti-academics would deny the value of any degree. My opinion is more balanced: it is up to each individual to seek their own path to accomplishment.

But in all cases, we have the luxury to be selective: the big advantage of not being a student anymore is the ability to select subjects that relate the most with our daily job, and start from very practical topics before going deeper in the theory.

What I find personally efficient in terms of learning is is confronting the limits of own practical knowledge: as daily users of computers, softwares, and programming languages, we are bound to very high levels of abstraction. But once we start looking closer, the questions “how does it work?”, “Why is it so?” or “What if I open the hood of my daily tools and look at what is inside?” might arise. Finding the related answers can be passioning, create the “eureka!” effect… and open the doors to even more questions!

Disclaimers:

• I will provide some mind-openers to a handful of the subjects, without intending (or being able) to cover them entirely.
• Working with JavaScript mainly, the resources I share will more often be related to the language.

Now, let’s start with the list:

History of Computing

This is not the most practice-related topic, but definitely the best to mention as a starter, and a necessary general culture component. The good news are that there are nowadays plenty of great resources, that are also free.

One absolutely incredible youtube series I discovered lately is the computer science crash course: 41 short episodes of around 10 minutes that will lead you from the dawn of programmable machines to modern day computing. From hardware and the functioning of CPUs to software and programs, these very condensed 8 hours of content will make you travel trough many levels of abstraction and build up a basic understanding of algorithms, data structures, and logical programming. They will also present some important people that shaped the field of computer science.

A Brief History of the Computer is an e-book available for free and can be seen as an alternative material, completing with more details the concepts explained in the crash course. It also contains links to extensive video materials.

The famous Computerphile channel is more a scattered collection of similar length videos diving into several topics with a relevant expert for each: cryptography, security, gaming, IA and more. The episodes featuring Professor Brailsford are highly focused on historical aspects.

Algorithms

Before becoming a buzz-word of the modern days, algorithms represent the numerous ways to solve a mathematical or computing problem, therefore representing an important part of computer science.

Studying them can surely be helpful in our daily live as developer, as we’ll get to better know solutions to common issues and more generally — develop a logical way of thinking.

The topic is so vast, that I’ll start with providing broad resources:

• A Github repo with JS algorithms
• Algorithms in task section of Rosetta Code
• MIT 6.006 Introduction To Algorithms (recorded course)
• A collection of Algorithms courses by FreeCodeCamp

A couple of very common algorithms implementations:

• Binary Search Algorithm with implementation in Python
• The Coding Train video on A* pathfinding
• Implementing Quicksort in Javascript (video by FCC)

The list will get long very quickly, so I will stop there for now and move next to a notion that is tightly connected to algorithms:

Data Structures

Arrays, Objects, Matrixes, Directed Acyclic Graph, Hash Tables, Binary Trees… there are many structures used across different languages and to make it even better, some have several names. Data structures is a science in itself, and it includes the structures with which you, as a developer work daily, as well as the knowledge of what happens under the hood of high-level languages: memory management, variables storage, garbage collection and many more.

A good understanding of commonly used data structures is a must for every developer, while the ground theoretic knowledge is a plus.

To start with, the above mentioned Crash Course Computer Science provides a good (and very compressed) intro to data structures, and I would also recommend to check this video.

To get a bit deeper, I recommend the following:

• The Data Structures Course from FreeCodeCamp (video) presented by the Google engineer William Fiset — a deep dive into the most common structures for a total of 8 hours of content.
• Build a basic Binary search tree in JavaScript (video) by The Coding Train

Mentioning algorithms and data structures rarely goes without speaking about their efficiency or complexity, which brings me to the next topic.

Complexity: The Big O Notation

The efficiency of an algorithm, or more generally — any computing task is measured by calculating the space and time complexity using Big O Notation. Big O is therefore a very important concept that will be frequently referred to, and it needs to be well understood before studying algorithms extensively.

Luckily, the big picture is quite easy to grasp, thanks to the numerous related resources:

• Understanding big O notation (article)
• Introduction to Big O notation (video)
• Learning Algorithms and Big O by Academind (video)
• Another video about Big O
• Optimising time complexity

This topic is not vast in itself but serves as a tool when studying algorithms, data structures, and performance optimisation.

Photo by Hope House Press — Leather Diary Studio on Unsplash

That’s it for Part 1, I hope you enjoyed it and found some inspiring material. I will be followed by a second part, where I’ll dive into internal mechanics of JavaScript and share some cross-languages understanding resources.