# 10 Best Computer Science Courses to Take in 2022

Are you looking for the best introductions to computer science? I’ve ranked the top courses available online, following a robust methodology. And they're all free to audit. You can read about it below.

But if you’re in a hurry, here are my top picks. Click on one to skip to the course details:

## What is Computer Science?

The definition of computer science is almost as broad as the definition of physics. So, to say that computer science is the study of computers and computing concepts is just as 'useful' as saying that physics is the study of nature and its phenomena.

Instead, I’ll tell you the main subfields of computer science that most universities include in their syllabus.

- Computer architecture and organization naïvely ponders: ‘How do I design a computer?’
- Programming steps in and questions: ‘But how will the computer understand the human?’
- Operating systems interjects: ‘Hold on, how should the human interact with the computer?’
- Data structures and algorithms chirps in: ‘After you've figured that out, how do we store and compute data efficiently?’
- Networking and communication waits politely before inquiring: ‘So that’s all cool, but how can we make computers talk to each other?’

You get the gist. I’m sure you’ve had one of these intriguing thoughts pop up in your mind before. Luckily, these are the questions that computer science tries to answer.

By studying computer science, you can become a better programmer. Just as a veterinarian is likely to understand animals better than the average pet owner, by studying computer science, you can get a better grasp of the features, abilities, and limitations of these awesome code-running machines that we call ‘computers’.

## Course Ranking Methodology

I followed a three-step process to build this ranking:

**First**, let me introduce myself. I’m part of Class Central, the leading search engine for online courses. I (@elham) built this ranking in collaboration with my friend and colleague @manoel, following the same approach we used with some success in our previous rankings of the best Python courses and best machine learning courses. At this point, I’d say it’s a pretty robust method.

We started building this ranking by looking at our database of 50K+ online courses. We were interested in things like ratings, reviews, and course bookmarks. This allowed us to make an initial selection. So this phase was purely data-driven.

This tentative first step rapidly helped surface some of the best options available out there. Word of mouth is very effective in online learning. Good courses get noticed. And the very best gather a lot of attention, and raving reviews.

That said, reviews don’t always tell the whole story. In fact, some courses are so good at grabbing the spotlight early on that other excellent resources can go unnoticed. So the next step was to bring our personal knowledge of online education into the mix.

**Second**, we used our experience as online learners to evaluate each of our initial picks.

We both come from computer science backgrounds and are prolific online learners, having completed about 45 MOOCs between us. Additionally, Manoel has an online bachelor’s in computer science, and I am currently completing my foundation in computer science.

Manoel gathered the courses while I wrote the article you’re currently reading. Throughout this process, we bounced ideas off each other and made iterative improvements to the ranking until we were both satisfied with the end result.

**Third**, during our research, we came across courses that felt well-made but weren’t well-known. If we adopted a purely data-centric approach, we would have to leave those courses out of the ranking, if only because they had fewer enrollments and ratings.

But no. This ranking is deliberately opinionated and holistic. When we felt confident that a course was worth including, even when the course might not yet have quite as many reviews as some of its competitors, we went with our gut and included it.

We also spiced up the list by including a wide variety of computer science courses that will hopefully cater to the diverse range of learners, whether you’re a true beginner or someone with some foundations in computer science, or an interest in specific topics like math.

After going through this process — combining Class Central data, our experience as lifelong learners, and lots of editing — we arrived at our final ranking. So far, we’ve spent more than 10 hours building this ranking, and we intend to continue updating it in the future.

## Course Ranking Statistics

Here are some aggregate stats about the ranking:

- In total, the courses in this ranking accumulated over 5 million enrollments with 2 courses having over 1 million enrollments each.
- The most popular course in the list has 3.5 million enrollments.
- All of the courses in this ranking are either entirely free, or free to audit.
- With 4 courses each, edX and Coursera are tied for the most represented provider in this ranking.
- Around 480k people are following Computer Science Courses on Class Central.

Without further ado, let’s go through the top picks.

Course instructor Prof. Malan with his students

My first pick has to be CS50's Introduction to Computer Science, offered by Harvard University on edX. Launched on edX in 2012, CS50 is the computer science course on the internet. It is famous for its splendid production quality and its yearly curriculum updates.

It provides a succinct but comprehensive overview of what computer science is all about. Whether you are a newbie who has never heard of ‘Hello World!’, or a programmer who knows a thing or two about computers, you’ll come out of this course having learned something new.

### One Thing to Note

Although the course exercises come in two versions, easy and challenging, I found that even the easy exercises can be a bit tricky. If you know nothing about programming, I’d recommend you find someone to study this course with.

Fortunately, CS50 has one of the largest and most active course communities online: check their Discord.

Or if you’re looking for a shorter, more practical course, you might want to have a look at my Python ranking, which includes some gentler on-ramps into the world of programming.

### The Instructor

We can't discuss CS50 without bringing up David J. Malan, the Harvard professor that teaches the course. Rarely has an instructor been so instrumental to the success of a course.

Beyond being an excellent educator, Prof. Malan is a true entertainer, with near-perfect delivery. And when you’re tackling an academic course that may take you dozens of hours to complete, having an instructor capable of capturing the learner’s attention makes a huge difference.

So if despite a sincere desire to learn, you find yourself falling asleep while taking online courses, this might just be the course for you. Prof. Malan’s energy is contagious!

### What You’ll Learn

The course begins with the premise that computer science is, at its core, problem solving. It introduces you to binary, the fundamental language of computers, and explains how sequences of 1s and 0s can somehow represent text, images, videos, and even sounds.

You’ll learn that algorithms are step-by-step instructions designed to solve a problem. The most common type of algorithms you’ll deal with throughout the course are algorithms for sorting and searching, like bubble sort, merge sort, and binary search.

You may wonder, ‘What’s the point of having many different algorithms if they all do the same thing?’. This is when you’ll learn about measuring the efficiency of an algorithm with Big O notation.

The first programming language the course teaches is the beginner-friendly language Scratch. Through block-based coding, you'll use Scratch to illustrate fundamental programming concepts like functions, conditional statements, boolean expressions, loops, and variables.

Later in the course, you’ll notice that these fundamental concepts keep coming up time and again, since they can be found in pretty much every programming language that CS50 will teach you.

The course then removes your training wheels and drags you down into the depths of low-level programming languages. By “low-level”, I don’t mean “less valuable”. In computer science, low-level programming languages are languages that are close to machine code: the closer they are to machine code, the “lower” they are.

Assembly language is as close as we get to binary, and the course will briefly discuss it. But our first deep dive into traditional programming (writing lines of code instead of arranging colorful blocks like with Scratch) will be with C, a low-level programming language where you'll manage memory by hand and implement your first data structures.

You’ll learn that computers store data in sequences of locations in memory, and how computers can locate and access data with addresses and pointers. You’ll also learn about the different ways we can create and store lists of values, like arrays, linked lists, and trees.

You’ll compare the advantages and disadvantages of each data structure. For example, hash tables can be accessed in constant time, but require mitigating the risk of data collision.

You’ll then be brought back up to the surface towards “higher-level” programming, where you’ll be able to comfortably breathe as you begin working with Python, and continue jumping from topic to topic.

You’ll explore SQL, the programming language of many databases. The final weeks of the course culminate in you building and designing an interactive website with HTML, CSS, JavaScript, and a Python framework called Flask.

### How You’ll Learn

The course is ten weeks long, plus an open-ended final project that might take an extra week (or more, if you want to work on something really ambitious).

The course is recorded annually on-campus at Harvard before being launched online the following Spring. While the recording is ongoing, you might be able to join via live stream with a hundred other learners, or if you live near campus, even attend in person — though the pandemic might preclude this for the foreseeable future. Otherwise, you’ll have access to on-demand recordings on edX or via Harvard OCW.

Regarding assessments, you’ll complete ten problem sets, eight labs, and a final end-of-course project that you’ll have to design and come up with yourself or with a team. You’ll be able to code and submit these via a convenient in-browser VS Code-based editor.

**Institution**

Harvard University

**Provider**

edX

**Instructors**

David J. Malan, Brian Yu

**Level**

Beginner

**Workload**

100–200 hours total

**Enrollments**

3.4M

**Certificate**

Free and Paid (see below)

### CS50 Lineup

A lot of people have heard about CS50’s Introduction to Computer Science, but not many realize that there are 10 other courses under the CS50 brand. A few follow-up courses worth mentioning are:

What’s even better: many of these courses offer a free certificate. If you’d like to know more about the CS50 courses, and how to get a free certificate, you can read Manoel's CS50 guide.

### Fun Facts

If you're interested in this course, you can find more information about the course and how to enroll here.

The course instructors, Susan Davidson and Chris Murphy

My second pick would be Computational Thinking for Problem Solving from the University of Pennsylvania on Coursera.

This course focuses on the skills underlying computer science — computational thinking.

Computational thinking is the process of breaking a problem into parts, and then coming up with a resolution method that can be carried out by a computer.

Once you’ve embraced computational thinking, you’ll be in the right mindset to tackle additional computer science courses. So you could see this course as a foundation before the foundation. That said, if your interest lies in problem solving per se rather than CS as a whole, this course should also be a great fit.

You do not need any prior experience with computer science or programming to take this course, although some basic high school mathematics would be useful.

### What You’ll Learn

The course covers four main topics: computational thinking, algorithms, computer architecture, and Python.

First, the course outlines the four pillars of computational thinking. You’ll begin with decomposition, breaking down a complex problem into smaller, simpler problems. Then through pattern recognition, you’ll compare the problem to other similar problems that have been solved previously.

Afterwards, during data representation and abstraction, you’ll simplify the problem even more by identifying what characteristics of the problem are important and filtering out those that are not.

The last pillar of computational thinking, algorithms, forms the second section of the course. The course defines algorithms as a set of step-by-step instructions to solve a problem. With algorithms, you can teach the computer how to solve problems without explicitly telling them precisely how. Instead, your algorithm will be able to handle a number of different cases, as long as these satisfy some preconditions.

You’ll explore a variety of algorithms, like linear and binary search. You’ll learn how to represent algorithms with flowcharts, analyze the complexity of algorithms (Big O), and calculate the number of possible solutions to an optimization problem. Lastly, you’ll compare the benefits and limitations of common algorithmic approaches to problem solving.

The third part of the course gives a brief history of computers, before settling on the computer architecture used by modern computers — the Von Neumann Architecture.

It consists of three fundamental units: the memory, CPU, and I/O. You’ll learn how data and instructions are stored and accessed in computers as bits and bytes, and also how executing code amounts to moving pieces of data in memory and operating on it in the CPU.

In the fourth and final section, the course will instruct you on the basics of Python programming. You’ll explore iterations, classes, and debugging. And you’ll end the course by coding your own Python program, where you’ll get to implement the algorithms you learned previously into code.

### How You’ll Learn

The course is 4 weeks long, with each week having about 18 hours of course material. You’ll learn primarily from video lectures, and after each video there’ll be a short quiz to test your recall. There is supplementary material available on math, for those not-so-confident in their mathematical abilities.

At the end of each week, you’ll be presented with a case study where you’ll see examples of computational thinking used to solve real-life problems. Afterwards, you’ll complete a project where you’ll apply what you’ve learned. Do note that the assessments in this course are for verified learners.

**Institution**

University of Pennsylvania

**Provider**

Coursera

**Instructors**

Susan Davidson and Chris Murphy

**Level**

Beginner

**Workload**

70 hours total

**Enrollments**

74K

**Rating**

4.7 / 5.0 (1K)

**Certificate**

Paid

### Fun Facts

- This course is endorsed by Google, which decided to make it part of its Digital Garage, a collection of courses and resources for learners wanting to gain tech skills.
- Penn’s Prof Susan Davidson, the course instructor, was named a Fellow of the American Association for the Advancement of Science in 2021.
- Prof. Davidson also teaches some of the courses of Penn’s Master of Computer and Information Technology (MCIT), which is offered online through Coursera.

If you're interested in this course, you can find more information about the course and how to enroll here.

Prof. Eric Grimson, course instructor

My third pick for the best computer science course is Introduction to Computer Science and Programming Using Python, offered by MIT on edX.

This course approaches the field of computer science and programming through Python. The course focuses on breadth rather than depth, giving students background knowledge on the numerous applications of computation.

So this course is similar to our first pick in that it’s a survey course: it covers a lot, but not in great detail. But it’s dissimilar in that it focuses entirely on one programming language, Python, while Harvard’s course involves multiple languages.

Depending on your goals, this focus on Python could be seen as a positive or a negative. For what it’s worth, I believe Python is an excellent first programming language.

Heads up! This course tries to mirror the MIT on-campus experience, so don’t expect it to be a cakewalk. You won’t need any prior experience with computer science or programming to take it, but you’ll need a background in high school mathematics.

### What You’ll Learn

The main topics the course explores are computational thinking, data structures, iteration and recursion, decomposition, abstraction, and algorithms and complexity.

You’ll be given a brief introduction to computation and computational thinking. You’ll learn what computers are, how they work, and what their limitations are.

By understanding that computers only know what you tell them (and what they can infer from what you tell them), you’ll realize that in order for the computer to accomplish a task, they need a ‘recipe’ containing a sequence of instructions they should follow. This is what computer scientists call an algorithm.

Your programming journey begins by learning Python and its basic syntax. With Python, you’ll explore concepts common to most programming languages. These include variables, conditional statements, and control flows.

Furthermore, you’ll be introduced to functions and the role they play in decomposition, abstraction, and recursion, which are concepts fundamental to problem-solving in computer science.

By then, you should be able to code simple programs that can come up with approximate solutions to difficult math equations through a guess-and-check method.

Lastly, you’ll learn about the different ways we can represent information in Python, called data structures. You’ll work with lists, tuples, and dictionaries, and understand when to use one data structure over another.

### How You’ll Learn

The course is 9 weeks long with an expected workload of 14 to 16 hours each week. The main mode of learning is video lectures, and the course includes plenty of activities to put your hard-earned skills into practice. You’ll also have access to a learner’s forum where you can discuss with fellow learners.

There are 3 problem sets containing challenging coding exercises that will help you solidify your knowledge. If you are a verified learner, you’ll have to complete a timed mid-term and final exam in order to receive your certificate.

**Institution**

Massachusetts Institute of Technology

**Provider**

edX

**Instructors**

John Guttag, Eric Grimson, Ana Bell

**Level**

Intermediate

**Workload**

80–140 hours total

**Enrollments**

1.5M

**Certificate**

Paid

### Fun Facts

- This course has over 18k bookmarks and 120 reviews on Class Central.
- It is the first of a two-course XSeries Program on edX. The second is Introduction to Computational Thinking and Data Science, which could make for a good follow-up.
- One of the instructors, Professor John Guttag, leads the Data Driven Inference Group at MIT’s legendary Computer Science and Artificial Intelligence Laboratory (CSAIL).

If you're interested in this course, you can find more information about the course and how to enroll here.

Prof. Scott Rixner, course instructor

Principles of Computing (Part 1), by Rice University on Coursera, is my fourth pick for the best computer science introduction. The course emphasizes doing rather than watching, requiring you to complete many coding assignments.

This course aims to help you step up your programming skills by teaching you computational problem solving, a skill that underlies computer science, and that was also the focus of our second pick. This will involve learning important programming practices and developing a mathematical foundation for problem solving.

To take this course, you’ll need to be comfortable with writing small (100+ lines) programs in Python, as well as have some background in high school mathematics. So this one doesn’t start from scratch, and is therefore geared toward learners that also have some basics down.

If you’re looking for a problem solving course with fewer prerequisites, you might want to have a look at our second pick.

### What You’ll Learn

The course includes refreshers on Python, code testing, probability and randomness, combinatorics, and function growth.

After a brief review of Python, the course will explain how to build tests, and why having tests for your Python programs can be useful.

Many programmers dislike or don’t simply bother to write tests for their code, but as one of the instructors explains, it’s a best practice worth treating as an integral part of the programming process.

Writing tests will help you save time and effort, and serves as a reusable sanity check that your program actually does what it’s supposed to do. For your first mini-project, you’ll recreate the well-known game 2048 in Python.

Then, the course moves on to the role of probability and randomness in computer science. You’ll learn how to identify unreasonable outcomes in probability, along with calculating the expected value of multiple outcomes.

For example, what’s the chance that a die would roll seven sixes out of ten tosses? And if that were to happen, to what extent could we conclude that the die is weighted — that is, that the rolls were unfair?

You’ll also see how we can use Python to simulate the probability of outcomes, a valuable tool used in statistical modeling. And for your second mini-project, you’ll work with probabilities to create an opponent that you can face in a game of Tic-Tac-Toe.

The course also touches on combinatorics, which deals with enumerations, permutations, and combinations. You’ll figure out how to calculate the total number of ways an event can play out.

This helps greatly in calculating the number of steps an algorithm would take, thereby allowing you to estimate the running time of the algorithm, and in turn, determine if the algorithm would be worth implementing. You can see why combinatorics plays a major role in password and computer security. For your third mini-project, you’ll code the familiar dice game Yahtzee.

In the final part of the course, you’ll be taught the importance of counting in solving complex problems. Counting answers the question of how long an algorithm might take to run given a task. Another name for counting you might be more familiar with is “time complexity”.

You’ll also learn about higher-order functions in Python, that is functions that take other functions as algorithms, like the `map`

function. In your last mini-project, you’ll use these concepts to make your own version of Cookie Clicker.

### How You’ll Learn

The course is split into 5 weeks, with each week involving 7 to 10 hours of study. You’ll learn primarily through video lectures and graded assignments, although the course does supply supplemental notes and activities for further reading and practice.

You’ll code and submit the homework and mini-projects on their companion website CodeSkulptor, and in-browser code editor that will preempt the need of setting up a local coding environment.

**Institution**

Rice University

**Provider**

Coursera

**Instructors**

Scott Rixner, Joe Warren, Luay Nakhleh

**Level**

Intermediate

**Workload**

40 hours total

**Enrollments**

30K

**Rating**

4.7 / 5.0 (600)

**Certificate**

Paid

### Fun Facts

- The course has around 15k bookmarks on Class Central.
- This course is the third of seven courses that make up the Fundamentals of Computing Specialization. Upon receiving the specialization certificate, you’ll have completed 20+ projects, including a capstone project.
- If you’re not interested in taking a full specialization after this course, but you’d like to learn more about the course topic, as the course name implies, there’s a follow-up course: Principles of Computing (Part 2).
- Course instructor Prof. Scott Rixner is faculty director of two online degree programs at Rice University. So his dedication to online education extends beyond the scope of his own MOOCs.

Prof. Nick Parlante, course instructor

Computer Science 101 aims to demystify the magic of computers by demonstrating that they work by following a few relatively simple patterns.

This course will help you become familiar with those patterns. It will give insights into how computers work and what their limitations are.

In addition, the course delves into networking and other major topics within CS. No prior knowledge of computer science required!

### What You’ll Learn

The course starts off with the fundamental equation of computers: Computer = Powerful + Stupid. Computers are powerful because they can perform billions of operations per second. But they are stupid because they need someone to tell them what to do. This is where programmers come into play.

This course uses small snippets of JavaScript to introduce you to programming and other computer science concepts. You’ll gain a grasp of programming concepts like variables, loops and iterations, conditional statements, and so on. The course later covers low-level and high-level languages, as well as compilers and interpreters.

The computer is a tool and the programmer wields the tool. Therefore, to program efficiently, it is important to understand how the tool works. The course covers many aspects of said tool, including hardware. You’ll learn about the parts that make up a computer, and look at how computers can represent different information formats.

The main format you’ll work with is images. One of the things you’ll do is “greenscreen” images as well as turn coloured images into grayscale by operating at the individual pixel level.

Another topic the course covers is computer networks, which is how computers communicate with one another. You’ll learn about the different types of networks.

You’ll study what IP addresses are and how they allow computers to locate each other. The course discusses how computers transmit information through data packets, and also the communication protocol the Internet runs on — TCP/IP.

The course also briefly covers a variety of other topics like databases and spreadsheets, computer security, and analog and digital data.

### How You’ll Learn

The course is 6 weeks long, with each week taking 4–6 hours to complete. Lessons are provided through video lectures and are supplemented with notes and assessments. However, you’ll need to be a verified learner to access the assessments.

**Institution**

Stanford University

**Provider**

edX

**Instructor**

Nick Parlante

**Level**

Beginner

**Workload**

36 hours total

**Enrollments**

100K

**Certificate**

Paid

### Fun Facts

- The instructor acknowledges Google for supporting his early research into creating the class. I think this goes for all of us!
- This course has 3k bookmarks on Class Central.
- The course instructor Nick Parlante’s current interest is in CodingBat Java, an experimental online code-practice tool.

Dr. Marco Gillies, course instructor

This concise course taught by the University of London on Coursera touches on a few key topics in computer science, but it is mostly interested in helping you build a foundational understanding of hardware. It’s in the title really: by the end of the course, you’ll know how computers work.

And through that understanding, you’ll also form a clearer picture of how computers can be leveraged to help solve everyday problems.

The course is just as suitable for someone wanting to build solid foundations for further study in CS, as it is for someone simply curious about how computers work and wanting to explore some key CS topics but not necessarily a deep dive.

You do not need any prior knowledge of computer science to take this course.

### What You’ll Learn

This course covers computer hardware, abstraction, modularity, computer networks and communication.

The course begins with abstraction — the art of drawing attention to the important details while filtering out the noise. Many disciplines rely on abstraction, and computer science does so heavily, both at the hardware and software levels.

This concept will become apparent when the course starts discussing computer hardware, like memory, CPU, and other devices. You’ll use notional machines as means for capturing these abstractions.

Afterwards, you’ll move on to another key idea: state and modularity. This will help you answer the question, ‘Why does turning off and on my computer fix most problems?’

Using notional machines, you’ll explain how computer applications function by transitioning through different states, and how modularity allows them to interact with other applications. You’ll learn how to debug stuff, a very useful skill indeed.

Moving on, you’ll learn how computers talk to one another over the Internet through networks and communication protocols. You’ll also learn about the kinds of security threats computers (and users) face, and how to protect yourself from malicious actors.

Lastly, you’ll explore basic web development. By applying your new-found knowledge of abstraction, state, and modularity, you’ll be able to clearly understand how websites work.

### How You’ll Learn

The course is 4 weeks long, with 10 hours worth of material per week. It consists of video lectures and quizzes to test your knowledge of the material. You’ll have the chance to share your thoughts in discussion prompts.

**Institution**

University of London

**Provider**

Coursera

**Instructor**

Marco Gillies

**Level**

Beginner

**Workload**

40 hours total

**Enrollments**

25K

**Rating**

4.6 / 5.0 (440)

**Certificate**

Paid

### Fun Facts

Prof. Malan (again!), course instructor

This is another course from the CS50 family. But unlike our first pick, which is the main CS50 course, this course is for those who work with technology everyday but don’t understand how it all works under the hood or how to solve problems when something goes wrong. And it’s also for those who don’t (yet) work with technology — most notably, computers — but would nonetheless like to understand its functioning.

The course aims to fill in the gaps in your knowledge of hardware, internet, multimedia, programming, and web development, preparing you for the technology of today and tomorrow.

This course has no prerequisites.

### What You’ll Learn

The course begins with an introduction to the language of computers, binary. It explains how computers use binary to represent text and other information. Then, you’ll move on to the hardware of the computer: CPU, RAM and Main Memory. You’ll learn about the functions of each of these components.

The course discusses Internet and multimedia, and the technologies underpinning them. It’ll tell you how computers can find and talk with one another. You’ll learn about the common Internet protocol TCP/IP and more.

You’ll learn about the different data representations of multimedia, like audio, images, and video. There are many file formats and compression techniques – the course will give you an overview of some of the main ones.

Next, you’ll be taught how to stay safe on the Internet. You’ll discover several ways to protect your data and privacy. This section will include lessons on cookies, passwords, two-factor authentication, encryption, and more.

You’ll continue with the basics of web development. You’ll learn how web browsers access the web with HTTP requests. Have you ever seen a 404 or 500 error when trying to visit a webpage? You probably have. Well, in this course, you’ll learn what these errors mean. A brief overview on the languages that allow us to build and style web pages, HTML and CSS, is provided.

Last by not least, you’ll discover the basics of programming. You’ll primarily use the block-based language Scratch to explore concepts common to pretty much all programming languages, like variables, expressions, loops, and so on.

Additionally, to demonstrate what an algorithm is (and more specifically the divide-and-conquer paradigm), you’ll watch the instructor tear a phonebook into halves… I had to mention this because it is both very instructive and memorable!

### How You’ll Learn

The course is 6 weeks long, with each week taking 2 to 6 hours to complete, depending on your prior familiarity with the content. Each week contains at least one hour of lecture.

Regarding assessments, you’ll have to complete an assignment for each of the six topics presented in the course to earn a certificate.

**Institution**

Harvard University

**Provider**

edX

**Instructor**

David J. Malan

**Level**

Beginner

**Workload**

36 hours total

**Enrollments**

100K

**Certificate**

Free and Paid (see below)

### Fun Facts

- After taking this course, you’ll be more than ready to tackle CS50, our #1 pick.
- This course has 1.6k bookmarks on Class Central.
- Another fact about David J. Malan, the course instructor: he is an active member of the SIGCSE, the arm of the ACM concerned with computer science education.

Screenshot from the course

For those who have some familiarity with programming and algorithms, and want to further their understanding of problem-solving in computer science, this rigorous but insightful course might be what you’re looking for.

Offered by Udacity, Intro to Theoretical Computer Science explores what makes a problem ‘hard’ to solve, even for a computer. Then, it shows how to reduce and simplify these ‘hard’ problems to make them easier to solve through computation.

### What You’ll Learn

The course covers two main areas of theoretical computer science: complexity theory and computability.

Complexity theory asks how much of its resources, like time or memory, will a computer require to solve a problem. Computability, on the other hand, asks if a computer can solve a problem at all, even when given more time and memory.

The course introduces you to a variety of real-world problems from telecommunication, bioinformatics, and finance. You will recognize what makes a problem challenging, and the value of recognizing such problems. This will prime you for understanding what NP-completeness is. Then, you’ll understand what makes a problem ‘hard’ to solve, and be able to prove it.

The rest of the course discusses what to do with the problem once we’ve proved that it is hard (or even impossible to solve).

One of the ways to overcome this obstacle is to employ efficient, intelligent algorithms. Another way is to accept that the problem may not be perfectly solvable, and instead find an approximate solution. And yet another way is to use randomness and probability to poke around and find a solution.

You’ll be able to describe and use these techniques in practical situations: the course discusses the theory but it’s also hands-on.

Lastly, you’ll move on to problems that no computer can ever solve in theory. You will learn about undecidability and recognize the limits of computability.

### How You’ll Learn

The course is 8 weeks long, with a total 14 hours of video lectures. Some videos have a quiz to help you practice recalling what you’ve learned. There are 7 chapters, and at the end of each chapter you will complete a problem set to put your new-found skills to good use.

Finally, there’s a summative exam at the end of the course.

**Provider**

Udacity

**Instructors**

Sebastian Wernicke, Sean Bennett, Sarah Norell

**Level**

Intermediate

**Workload**

25 hours

**Certificate**

None

### Fun Facts

- This course has 2.2k bookmarks on Class Central.
- One of the course instructors, Sebastian Wernicke, has spoken multiple times at TED.
- To tackle this course, you may want to learn about algorithms first. The instructors recommend another Udacity course on algorithms as a refresher. In addition, good math foundations would be useful too. Check our picks below if needed.

Dr. Sara Santos, course co-instructor

Offered by the University of London, this course introduces you to the mathematics and mathematical thinking computer scientists use in their work. What distinguishes this course from other math courses is its playfulness, with fun and interactive exercises.

More specifically, the course combines elements of algebra, analysis, and geometry — topics carefully picked to serve as the backbone of your computer science education.

The course discusses, among others, number bases, an essential topic to understand binary, and conversion between binary and other bases, such as hexadecimal. It explores numerical progressions, like the well-known Fibonnaci sequence. And it will touch on geometry and function graphing.

By the end of the course, you’ll have acquired the foundation needed to understand the math that underpins other computer science courses, and you’ll be ready to tackle more advanced mathematical topics.

The course assumes you know some high school mathematics as well as basic Python programming.

### What You’ll Learn

The course investigates five main topics: number bases, modular arithmetic, sequences, series, graph sketching and kinematics.

The course begins with the study of number bases. You might know that binary is the number base used by computers. But did you know that computer scientists also use hexadecimals?

You’ll cover the key concepts of place values and number systems, which will involve converting between binary, hexadecimal, and decimal, as well as adding, subtracting, and multiplying them together. Oh, a cool thing that the course teaches you is steganography, the art of hiding messages in images!

Next, you’ll cover modular arithmetic. Have you ever wondered what “modulo 7” means? You’ll learn about the usefulness of congruence and modular arithmetic operations in computer science (psst, it can be used for encryption).

You’ll identify, describe, and compute sequences of numbers and their sums. You’ll study a special family of sequences called progressions, which consists of arithmetic and geometric progressions. You’ll learn how sequences can be used to generate random numbers. Additionally, you’ll be able to tell when a series converges (meets at a point) or diverges (approaches infinity)

Lastly, the course describes how to represent and describe space numerically using coordinates and graphs. You’ll see how graphs can help us visualize and transform functions like straight lines, quadratics, cubics, reciprocals and more. An example of modeling motion will be given: the field of mathematics called kinematics.

### How You’ll Learn

The course is 6 weeks long, with about 40 hours worth of material. Each week comes with one or more quizzes, allowing you to learn by doing. However, you’ll need to pay for the certificate for the course autograder to mark your answers.

**Institutions**

University of London

**Provider**

Coursera

**Instructors**

Matthew Yee-King and Sara Santos

**Level**

Beginner

**Workload**

40 hours total

**Enrollments**

22K

**Rating**

4.1 / 5.0 (200)

**Certificate**

Paid

### Fun Facts

- It is the third and final course of the Introduction to Computer Science and Programming Specialization.
- Dr. Sara Santos enjoys math busking, which seeks to surprise and amuse people on the streets with performances rooted in math.

Laura Broddle, course instructor, teaching Venn diagrams

If you have taken a look at the previous two courses but do not have the mathematical foundations to take them yet, this course can help you with the basics.

This course is a short course on mathematics skills for computer science, offered by the University of Hull on FutureLearn.

Meant for learners starting or considering studying computer science at the university level, this course covers Venn diagrams and set theory, algebra techniques, and vectors and matrices — all fundamentals concepts ubiquitous in computer science.

The course assumes no prior mathematical knowledge. You’re starting from scratch.

### What You’ll Learn

Starting off with Venn diagrams and set theory, you’ll learn how “sets” (bags of objects, if you will) can be formalized and operated on. You’ll learn to reason about computations and objects of computation. Venn diagrams will help you visualize this type of reasoning.

You’ll then move on to algebra and its techniques. You’ll be given an overview of algebra (which could be described as doing math using variables instead of explicit numbers) and its use in algorithms and scientific computation. The course will teach you how to solve linear equations and quadratic equations using algebra.

The course ends with an overview of vectors and matrices. You’ll learn what vectors are, and why they are especially important in graphics programming. You’ll learn how we can represent vectors as matrices, and how to modify, transform, and invert matrices to solve complex problems.

### How You’ll Learn

This course is 3 weeks long, with around 3 hours of material per week. You’ll learn primarily through video material, although there are discussion forums where you can discuss problems with fellow learners.

At the end of each week, there is a quiz that’ll help you strengthen your understanding of mathematical concepts and applications.

**Institution**

University of Hull

**Provider**

FutureLearn

**Instructor**

Laura Broddle

**Level**

Beginner

**Workload**

9 hours total

**Enrollments**

1.2K

**Certificate**

Paid

### Fun Facts

- The course instructor, Laura Broddle, joined the University of Hull in 2015 as a foundation math teaching fellow.
- She also had visited a sister school in Uganda and was rated an outstanding teacher by Ofsted in 2013.