These terms are frequently used interchangeably, even among experienced developers. But while they may sound similar and occasionally overlap in practice, they address distinctly different problems and serve separate architectural goals. Understanding this distinction is not just an academic exercise. It directly impacts how you build scalable, efficient systems.

Whether you’re developing a high-traffic web server, training complex machine learning models, or optimising application performance, a solid grasp of these concepts can mean the difference between a solution that merely functions and one that scales elegantly under real-world conditions.

This article provides a comprehensive breakdown of both concepts through visual analogies, practical examples, and technical implementations. By the end, you will be equipped to confidently apply these principles in your software projects.

Here’s what we’ll cover:

1. Understanding the Fundamental Concepts

   • The Kitchen Analogy

2. What Concurrency Looks Like in Practice

   • Python Example: Implementing Concurrency with asyncio

3. What Parallelism Looks Like in Practice

   • Python Example: Implementing Parallelism with multiprocessing

4. Concurrency vs. Parallelism: A Detailed Comparison

   • When to Use Each

5. Real-World Applications and Use Cases

   • Concurrency in Production Systems

   • Parallelism in Production Systems

   • Hybrid Approaches

6. Choosing the Right Approach for Your Problem

   • Common Pitfall to Avoid

7. Why This Distinction Matters in Practice

8. Common Misconceptions and Clarifications

9. Practical Implementation Strategies

   • When Implementing Concurrency

   • When Implementing Parallelism

10. Tools and Technologies by Language

11. Further Learning Resources

12. Conclusion

Understanding the Fundamental Concepts

Before diving into implementations, let’s establish some clear definitions:

Concurrency refers to the ability of a system to manage multiple tasks within overlapping time periods. It does not necessarily mean these tasks execute at the exact same instant. Rather, concurrency is about structuring a program to handle multiple operations by interleaving their execution, often on a single processor core.

Parallelism, by contrast, involves the simultaneous execution of multiple tasks. This typically requires multiple CPU cores or processors working in tandem, with each handling a separate portion of the workload at the same time.

The Kitchen Analogy

Consider the process of cooking as a helpful mental model:

A concurrent kitchen employs a single chef who rapidly switches between preparing multiple dishes. The chef might chop vegetables for one dish, then stir a sauce for another, then return to the first dish to continue preparation. From an observer's perspective, it appears that multiple dishes are being prepared "at once," but in reality, the chef is performing one action at a time in rapid succession.

A parallel kitchen has multiple chefs, each working on different dishes simultaneously. One chef prepares the appetiser while another works on the main course, and a third handles dessert. True simultaneous work is happening across multiple workers.

Same kitchen, different strategies, different outcomes.

What Concurrency Looks Like in Practice

Concurrency is fundamentally about task scheduling, coordination, and resource management. It enables a program to handle multiple operations by strategically interleaving their execution, whether on a single core or across multiple threads.

A practical example: when you stream a video on YouTube while your device downloads a file in the background and your messaging app checks for new messages, your CPU is rapidly context-switching between these tasks. Each task gets a slice of processing time, creating the illusion of simultaneous execution even on a single-core processor.

Python Example: Implementing Concurrency with asyncio

To examine concurrency in more detail, we’ll create a simple application which gets data on various APIs asynchronously. This is an example of how Python’s library, asyncio, lets us spawn multiple network operations without blocking so we can effectively use the waiting time.

In this implementation, we’ll be simulating API calls to a weather service, a news service, and a user profile database. Pay attention to the fact that all three requests begin nearly at the same time, yet the program doesn’t wait until one of them is completed before it begins the next one.

import asyncio

async def fetch_data_from_api(api_name, delay):
    print(f"Starting request to {api_name}...")
    await asyncio.sleep(delay)  # Simulates network I/O wait
    print(f"Received response from {api_name}")
    return f"Data from {api_name}"

async def fetch_user_profile(user_id):
    print(f"Fetching profile for user {user_id}...")
    await asyncio.sleep(1.5)
    print(f"Profile loaded for user {user_id}")
    return {"user_id": user_id, "name": "John Doe"}

async def main():
    # All tasks start and are managed concurrently
    results = await asyncio.gather(
        fetch_data_from_api("Weather API", 2),
        fetch_data_from_api("News API", 1),
        fetch_user_profile(12345)
    )
    print("\nAll operations completed!")
    print("Results:", results)

asyncio.run(main())

What happens during execution:

1. All three async functions are initiated at approximately the same time.

2. The event loop manages their execution, switching between tasks when one is waiting (during await statements).

3. While one task waits for simulated I/O, the event loop allows other tasks to make progress.

4. The task with the shortest delay completes first, even though all were started together.

5. No task blocks the others, resulting in efficient use of the single thread.

Key insight: Concurrency optimises responsiveness and resource utilisation. It doesn’t inherently make individual tasks complete faster. Instead, it allows multiple tasks to make progress during the same time period, particularly when those tasks involve waiting for external resources.

What Parallelism Looks Like in Practice

Parallelism concerns itself with genuine simultaneous execution. This approach leverages multiple CPU cores or processors to divide work and execute portions concurrently in real time.

Parallelism shines when dealing with CPU-intensive operations such as mathematical computations, image processing, video rendering, or training deep learning models.

Python Example: Implementing Parallelism with multiprocessing

To better understand parallel execution, we’re going to make a program that carries out intensive calculations in a set of cores of CPUs. The given example relies on Python and the multiprocessing module to create different processes that are executed on different processor cores.

To work with a sufficiently complex example, we’ll compute the sum of the squares of millions of numbers. In contrast to the concurrent code sample, where we were waiting to receive I/O, we are actually doing some CPU-intensive work. You’ll notice the reduction in the time taken to execute the work when it’s shared by a number of cores.

from multiprocessing import Process, current_process
import time

def compute_heavy_task(task_name, iterations):
    """Simulates a CPU-intensive operation"""
    process_name = current_process().name
    print(f"{task_name} started on {process_name}")

    # Simulate CPU-bound work
    result = 0
    for i in range(iterations):
        result += i ** 2

    time.sleep(1)  # Additional simulated work
    print(f"{task_name} completed on {process_name}. Result: {result}")
    return result

if __name__ == "__main__":
    start_time = time.time()

    # Create separate processes for each task
    p1 = Process(target=compute_heavy_task, args=("Task 1", 10000000))
    p2 = Process(target=compute_heavy_task, args=("Task 2", 10000000))
    p3 = Process(target=compute_heavy_task, args=("Task 3", 10000000))

    # Start all processes (they run on separate CPU cores)
    p1.start()
    p2.start()
    p3.start()

    # Wait for all processes to complete
    p1.join()
    p2.join()
    p3.join()

    end_time = time.time()
    print(f"\nAll tasks completed in {end_time - start_time:.2f} seconds")

What happens during execution:

1. Three separate processes are spawned, each allocated to available CPU cores.

2. Each process runs independently with its own memory space and Python interpreter.

3. All three CPU-intensive calculations execute truly simultaneously across multiple cores.

4. The total runtime is determined by the longest-running task, not the cumulative sum of all tasks.

5. On a multi-core system, this completes approximately three times faster than sequential execution.

Key insight: Parallelism achieves actual speedup by distributing computational workload across multiple processors. This directly reduces total execution time for CPU-bound operations.

Concurrency vs. Parallelism: A Detailed Comparison

When to Use Each:

Use concurrency when you want to handle more tasks effectively within the same time period, particularly when those tasks spend time waiting for external resources.

Use parallelism when you want to complete tasks faster by leveraging multiple processors to divide the computational workload.

Real-World Applications and Use Cases

Concurrency in Production Systems

1. Web Servers and APIs

Modern web frameworks like Node.js, Django with async views, and FastAPI handle thousands of simultaneous client connections. Each request may involve database queries, external API calls, or file operations. Concurrency allows the server to handle new requests while waiting for I/O operations from previous requests to complete.

2. Real-Time Communication

Chat applications, collaborative editing tools, and live streaming platforms manage multiple simultaneous connections. Messages must be received, processed, and broadcast to multiple clients concurrently without blocking any single connection.

3. Mobile Applications

Mobile apps perform background synchronization, push notification handling, and data caching while maintaining a responsive user interface. The UI thread remains free while background operations proceed concurrently.

4. Microservices Orchestration

Service meshes coordinate multiple API calls to different microservices, aggregating results efficiently without waiting for each call to complete sequentially.

Parallelism in Production Systems

1. Machine Learning and AI

Training neural networks involves massive matrix computations that can be distributed across multiple GPU cores or even multiple machines. Frameworks like TensorFlow and PyTorch automatically parallelise operations across available hardware.

2. Big Data Processing

Distributed computing frameworks such as Apache Spark, Hadoop, and Dask divide large datasets across cluster nodes. Each node processes its portion of the data in parallel, enabling analysis of petabyte-scale datasets.

3. Media Processing

Video transcoding, image batch processing, and audio rendering leverage multiple CPU cores or GPUs. Each frame or segment can be processed independently in parallel.

4. Scientific Computing

Computational physics simulations, genome sequencing, and climate modelling require enormous computational resources. Parallelism across supercomputer clusters enables these calculations to complete in reasonable time frames.

5. Financial Modelling

Risk analysis and portfolio optimisation involve running thousands of scenarios. Parallel processing allows these computations to execute simultaneously, providing results quickly enough for real-time decision making.

Hybrid Approaches

In practice, sophisticated systems frequently combine both paradigms. Consider a modern web application:

1. The web server handles client requests concurrently (handling multiple users simultaneously).

2. Each request may trigger parallel data processing tasks (such as image resizing across multiple cores).

3. The database connection pool manages concurrent query execution.

4. Background job workers process tasks in parallel (such as sending emails or generating reports).

This layered approach leverages the strengths of both concurrency and parallelism to create systems that are both responsive and computationally efficient.

Choosing the Right Approach for Your Problem

Understanding which paradigm to apply requires analysing the nature of your workload:

Common Pitfall to Avoid

A frequent mistake is attempting to use threading for CPU-bound tasks in languages with a Global Interpreter Lock (like Python's CPython) and expecting parallel speedups. In such cases, threads provide concurrency but not true parallelism.

The GIL ensures only one thread executes Python bytecode at a time, leading to context-switching overhead without genuine parallel execution. For CPU-bound work in Python, multiprocessing or C extensions are necessary for true parallelism.

Why This Distinction Matters in Practice

Grasping the difference between concurrency and parallelism extends beyond writing faster code. It fundamentally influences how you architect systems and make technological decisions:

First of all, choosing the appropriate execution model for each component of your system leads to cleaner, more maintainable code. You avoid over-engineering solutions or applying the wrong tool to a problem.

Understanding these concepts also prevents wasteful patterns such as spawning unnecessary processes for I/O-bound work or using single-threaded approaches for parallelizable computations. This directly translates to reduced infrastructure costs.

Systems designed with proper concurrency models also scale horizontally more effectively. Those leveraging parallelism appropriately utilise hardware resources fully as you scale vertically.

In addition, you’ll get some key performance optimisations by choosing the right approach. When profiling reveals bottlenecks, knowing whether to optimise for concurrency or parallelism guides your refactoring efforts in the right direction.

Beyond this, in cloud environments where you pay for compute resources, efficient use of concurrency and parallelism directly affects operational costs. An efficiently concurrent system might handle 10x the load on the same hardware compared to a poorly designed synchronous alternative.

And these concepts are fundamental to backend engineering, distributed systems, DevOps, machine learning engineering, and systems programming. They appear frequently in technical interviews and are essential for senior engineering roles.

Common Misconceptions and Clarifications

"Using threads automatically gives me parallelism."

In reality, threads enable concurrency but do not guarantee parallel execution. In systems with a Global Interpreter Lock (like CPython) or on single-core machines, threads run concurrently but not in parallel. True parallelism requires multiple CPU cores and mechanisms that avoid locking constraints.

"Parallelism is always faster than sequential execution."

In fact, parallelism introduces overhead, including process creation, inter-process communication, and data synchronisation costs. For small tasks or I/O-bound operations, this overhead can outweigh benefits. Parallelism shows gains when the computational work justifies the overhead.

"Concurrency and parallelism are mutually exclusive."

As you’ve learned, modern high-performance systems routinely combine both. A web server can handle requests concurrently, with each request triggering parallel processing. Understanding how to layer these approaches is key to building sophisticated systems.

"More threads or processes always mean better performance."

Beyond a certain point, adding more threads or processes leads to diminishing returns and even performance degradation due to increased context switching and resource contention. The optimal number depends on workload characteristics and available hardware.

“Async/await makes my code run faster."

Async/await improves efficiency for I/O-bound operations by reducing idle time, but it does not speed up CPU-bound computations. It changes how waiting is handled, not how quickly individual operations execute.

Practical Implementation Strategies

How to Implement Concurrency

To introduce concurrency into your programs, first you’ll need to find where time is wasted. Blocking operations that are held waiting on external resources are the best candidates to be put under concurrent execution.

Say you’re building a web scraper to fetch a bunch of data on a variety of sites. Every single HTTP request is most likely waiting until the server gets a response back. Other requests might be underway in your program instead of waiting around during this waiting period. These wait points are identifiable by profiling your application and searching the operations with network calls, file I/O, or database queries.

After you’ve discovered these wait points, the next big step will be to select the concurrency primitive. In Python, I/O-bound operations perform very well using the patterns of async/await with the support of the asyncio framework. It also comes with a minimal cost.

Take a situation when you have to retrieve user data in a REST API and query a database at the same time. With asyncio, you can write code that initiates both tasks almost simultaneously, and then have the event loop alternate between them during periods of waiting.

Here's a practical example:

import asyncio
import aiohttp

async def fetch_user_api(user_id):
    async with aiohttp.ClientSession() as session:
        async with session.get(f'https://api.example.com/users/{user_id}') as response:
            return await response.json()

async def query_database(user_id):
    # Simulating database query
    await asyncio.sleep(0.5)
    return {'preferences': 'theme:dark', 'notifications': True}

async def get_complete_user_data(user_id):
    api_data, db_data = await asyncio.gather(
        fetch_user_api(user_id),
        query_database(user_id)
    )
    return {**api_data, **db_data}

This gives a thorough look at how concurrency works in practice.

When Implementing Parallelism

Before committing parallelism into your system, you’ll need to profile the system and make sure that what causes your bottleneck is CPU-bound computation. Many developers think that their code requires parallelism when it should actually employ concurrency.

You can use profiling tools such as Python cProfile or line profilers to determine where time is being used or wasted in your program. When the time spent in computational loops is as large as compared to waiting in I/O, then parallelism can be beneficial.

To take an example, when processing images, the execution time in pixel manipulation algorithms consumes 90% of the execution time. This is a good sign that parallelism would be useful.

Deciding how to partition the work between multiple processors is sometimes a complex issue that you should consider carefully (in terms of dividing tasks into independent points). These chunks should be able to be processed individually without needing to communicate with each other on a regular basis.

Imagine that you have to examine the log files of several servers. Processing each file may happen on a different core, and the results will get added at the final stage.

Here's how you might structure this:

from multiprocessing import Pool
import re

def analyze_log_file(filepath):
    error_count = 0
    with open(filepath, 'r') as f:
        for line in f:
            if re.search(r'ERROR|CRITICAL', line):
                error_count += 1
    return filepath, error_count

if __name__ == '__main__':
    log_files = ['server1.log', 'server2.log', 'server3.log', 'server4.log']

    with Pool(processes=4) as pool:
        results = pool.map(analyze_log_file, log_files)

    for filepath, count in results:
        print(f'{filepath}: {count} errors found')

In this example, each log file is processed entirely on one core without needing to communicate with other processes until the final result aggregation.

Tools and Technologies by Language

Various programming languages offer different methods of achieving concurrency and parallelism with their own advantages and disadvantages. And when you understand the available tools in your language of choice, you’ll be able to make a wise architectural choice.

Python

Python has a concurrent and parallel environment. For concurrent programming, the asyncio library offers a more modern syntax of async/await that’s ideal in I/O-bound tasks such as web scraping or API communication.

The threading module allows shared memory execution, but is restricted on CPU-bound tasks by the Global Interpreter Lock. The concurrent futures module is a high-level interface to concurrent task execution, which can be useful when you want to parallelize I/O operations without having to write the low-level code of asynchronous operations.

Sometimes you’ll need actual parallelism because your job requires a lot of CPU time. Multiprocessing starts individual Python processes, which don’t use the GIL at all.

In the case of data science and machine learning processes, distributed parallelism is offered in libraries such as joblib, ray, and dask and can run on your laptop up to a cluster of computers.

JavaScript and Node.js

The event loop architecture had concurrency as its foundation in JavaScript and Node.js. Asynchronous programming is now intuitive with native syntax and Promises being used as the standard model of dealing with I/O operations (like HTTP requests or file system access).

JavaScript is single-threaded, and Node.js is designed to execute single-thread programs that make good use of I/O bound concurrent tasks, such as web servers, which support thousands of parallel connections.

In cases of actual parallelism (for example, image processing or cryptographic tasks), worker threads enable you to execute JavaScript on multiple cores. The child processes module can launch individual instances of Node.js, and the cluster module allows you to launch a pool of workers to accept incoming connections and make the most of all CPU cores in a web server.

Java

Java has mature and battle-tested concurrency and parallelism support. CompletableFuture offers a fluent interface to asynchronous operations, so it’s easier to sequence dependent asynchronous tasks together without any callback hell.

The ExecutorService model also provides detailed management of thread pools and task scheduling, which is necessary in developing high performance server programs. Parallelism Java thread pools are effective at handling worker threads to execute CPU-bound tasks, whereas ForkJoinPool uses work-stealing algorithms that are useful in divide-and-conquer problems.

Java 8 offers parallel streams, which allow you to process collections in parallel with a minimal amount of code rewrites – but you have to pay close attention to when they actually will or will not improve performance.

Go

Go introduced concurrency as a first-class language: goroutines and channels. Goroutines are lightweight threads controlled by the Go runtime, which means that you can run thousands or even millions of operations concurrently with minimal overhead.

The philosophy of communication in Channels offers a secure means of communication between goroutines, and it includes the expression "do not communicate by sharing memory; share memory by communicating." Such a design makes concurrent programming more user-friendly and error-free.

In parallelism, Go automatically allocates goroutines to multiple CPU cores according to the GOMAXPROCS environment variable, and parallel execution is achieved automatically. This renders Go especially effective in the construction of parallel systems such as web servers, network tools, and distributed systems.

Rust

Rust provides concurrent and parallel programming with memory safety without performance degradation. The ownership system of the language eliminates all forms of data races at compile-time, which means that the entire category of concurrency bugs found in other languages doesn’t exist.

In the case of async operations, you can apply the syntax of Rust to operations of an asynchronous type with runtime libraries such as tokio or async-std and achieves similar performance to C++ without sacrificing safety.

The Rayon library makes parallelism of data exceedingly easy. At times, you can parallelise a calculation by substituting .iter() with .par_iter(). Rust thread pools and channels give you low-level control where necessary, and the type system keeps the threads safe, making sure that problems don’t arise in your code.

Conclusion

Concurrency and parallelism represent fundamental pillars of modern computing architecture. They are not interchangeable buzzwords, but are rather distinct paradigms that address different challenges:

Concurrency focuses on program structure and efficient task coordination. It allows systems to handle multiple operations within overlapping time periods, maximizing resource utilization and responsiveness.

Parallelism focuses on computational throughput and execution speed. It divides work across multiple processors to complete tasks faster through simultaneous execution.

The most powerful systems strategically combine both approaches, applying each where it provides the greatest benefit.

The next time you face a performance challenge, ask yourself these critical questions:

1. Is my bottleneck caused by waiting (I/O-bound) or by computation (CPU-bound)?

2. Am I trying to handle more tasks simultaneously or complete tasks faster?

3. Do I need better resource utilisation or raw computational throughput?

Your answers will guide you toward the right solution. Understanding when to apply concurrency, when to leverage parallelism, and when to combine them is what separates adequate solutions from exceptional ones. This knowledge empowers you to build systems that are not only fast but also efficient, scalable, and economically viable.

Master these concepts, and you will find yourself equipped to tackle increasingly complex engineering challenges with confidence and precision.

Further Learning Resources

• "Go Concurrency Patterns" by Rob Pike (Google Tech Talk)

• "Concurrency is not Parallelism" by Rob Pike

• Python AsyncIO Official Documentation

• Real Python: Concurrency and Parallelism in Python

• Java Concurrency in Practice by Brian Goetz

• Apache Spark Documentation for Big Data Parallelism

All of these are possible because of something called Unicode.

Unicode is a powerful system that lets computers understand and show text in nearly any language, including fun stuff like emojis. 😃

In this article, we’ll break down what Unicode is, why it matters, and how it powers global communication.

Table of Contents

• The Problem Before Unicode

• What Is Unicode?

• How Does Unicode Work

  • What Are Unicode Encodings?

  • Code Points, Characters, and Glyphs

• Unicode in Programming

• Why Unicode Matters

• Conclusion

The Problem Before Unicode

Let’s rewind to the early days of computers when each country had its own way of showing text. These systems were called character encodings.

For example, English text used ASCII, while others used ISO-8859, Shift-JIS, and more.

But here’s the problem: the same number could mean different things in different systems.

For example, the number 0x41 meant the letter A in one system, but in another, it might mean something else entirely.

This caused chaos when sharing documents between systems. Special characters would turn into random symbols, and non-English languages were often unreadable.

It was clear that the world needed one universal system. Something that could handle all languages and symbols in a single, consistent way.

That’s where Unicode comes in.

What Is Unicode?

Unicode is a standard system that assigns a unique number, called a code point, to every character. It includes letters, numbers, emojis, symbols, and even invisible control characters.

Think of it like giving every character in every language its own ID number.

For example:

• The capital letter A is given the code U+0041

• The Greek letter Ω is U+03A9

• The emoji 😀 is U+1F600

This means no matter what device, app, or country you’re in, the same code will always mean the same character.

How Does Unicode Work?

At its core, Unicode assigns a code point to each character.

Code points look like this: U+XXXX, where XXXX is a number written in hexadecimal (a base-16 system computers use).

But computers don’t store code points directly. They store bytes, the 1s and 0s under the hood. So Unicode needs a way to turn those code points into bytes. This is called encoding.

What Are Unicode Encodings?

Unicode gives every character a unique code point, but computers don’t store “U+1F600” directly – they store bytes. To convert these code points into bytes that computers can save or transmit, we need encodings.

There are three main ways to turn Unicode code points into bytes:

1. UTF-8 (Most common)

• Uses 1 to 4 bytes.

• Great for English and most symbols.

• Saves space.

• Works on the web and most systems.

2. UTF-16

• Uses 2 or 4 bytes.

• Used in Windows, Java, and some older systems.

3. UTF-32

• Uses 4 bytes for everything.

• Easy to work with, but uses more memory.

If you’re storing or sending text, the encoding decides how many bytes are used. Choosing UTF‑8 can save space, especially for English-heavy data. When you see garbled text or � symbols, it’s usually a mismatch between encoding and decoding.

Web servers, databases, and APIs often require you to specify the encoding to ensure multilingual text displays correctly. In short, knowing the difference between UTF‑8, UTF‑16, and UTF‑32 helps you prevent bugs, save storage, and build apps that handle text from any language reliably.

So, UTF-8 is often the best choice. It’s efficient, and it works nearly everywhere.

Code Points, Characters, and Glyphs

Let’s break down the main parts of Unicode:

Code Point:

This is the number assigned to a character. For example:

• U+0041 is the code point for A

• U+20AC is for the Euro sign €

• U+1F600 is for the smiley face 😀

Character:

The actual letter or symbol we see. For example, “A”, “Ω”, or “😎”.

Glyph:

This is the visual design of a character. For example, “A” in Arial looks different from “A” in Times New Roman, but the character is the same.

Unicode in Programming

Modern programming languages have embraced Unicode, making it easier than ever to build applications that support global audiences.

Whether you’re writing a command-line tool or building a web app, Unicode ensures your text renders correctly, no matter the language.

Take Python, for instance. It natively supports Unicode strings:

print("Welcome 😊")  # This works because Python uses Unicode under the hood

You can even mix languages and emojis in the same output without a problem:

print("こんにちは, friend! 🚀")

In JavaScript, Unicode enables developers to use characters from virtually any script:

console.log("नमस्ते");  // Prints “Namaste” in Hindi
console.log("مرحبا بالعالم");  // Arabic: "Hello, world"

Or even create multilingual UIs:

document.getElementById("greeting").textContent = "Bonjour, мир!";

Before Unicode, developers had to juggle different encodings like ASCII, which often led to corrupted text when files moved between systems. Now, thanks to Unicode, most languages, including Java, C#, Ruby, Go, and Rust, handle international text gracefully by default.

This shift means developers can write apps that support global users from day one. Whether you’re building a chat app, an international e-commerce site, or a multilingual blog – with Unicode, your code speaks every language.

Why Unicode Matters

Before Unicode, digital communication across languages was chaotic.

Different systems used different character sets, leading to garbled text, random boxes, or strings of question marks whenever someone typed in a non-Latin-based language. Unicode changed all of that.

With Unicode, you can now mix languages like Chinese and English in the same document without a problem. Whether you’re copying text between applications or transferring data across platforms, it just works.

This consistency has been a game-changer for building multilingual websites and applications. Developers no longer need to worry about separate encodings for different regions. A single, unified standard handles it all.

Unicode isn’t something most users think about, but it’s embedded in almost everything.

It powers the text you see on websites and in your email, your smartphone’s keyboard, and even the way you chat in online games. Social media posts, search queries, and programming languages, all rely on Unicode.

Behind the scenes, the Unicode Consortium, made up of industry giants like Google, Apple, and Microsoft, regularly updates the standard. They decide which new characters and emojis make it into our digital vocabulary.

That’s why your favourite facepalm emoji or regional script exists. Someone proposed it, and Unicode made it happen.

Unicode isn’t just a technical convenience. It plays a direct role in how people engage with content.

Pages with broken symbols or unreadable characters had significantly lower engagement rates compared to cleanly rendered ones. It was a clear signal that readability isn’t just about aesthetics – it affects how long people stay and interact with your content.

That’s why even small encoding errors can have a real impact, especially on multilingual platforms or international blogs. Unicode silently keeps everything running smoothly.

Conclusion

Unicode is one of the unsung heroes of our digital world. Without it, the internet would still be a confusing mix of broken characters and language barriers. Because of Unicode, we can type “Hello 😊”, mix multiple languages in a single message, or build global apps that just work.

So the next time you post an emoji, read a message in a different script, or switch languages on your keyboard, take a moment to appreciate the invisible infrastructure behind it all. That’s Unicode, working quietly to make sure we stay connected, no matter what language we speak.

Join my newsletter for a summary of my articles every Friday. You can also connect with me on Linkedin.

It doesn't have anything to do with the platform, of course, but rather what it represents: tackling problems for hours on end, usually to find a solution that is even harder to understand.

But what is more challenging is finding a roadmap to solve those problems with very little knowledge of data structures and algorithms. This handbook is more or less based on the Blind 75 list that's included in neetcode.io's practice problems. This is an amazing resource that offers an organized study roadmap for solving LeetCode problems.

In fact, why not take a more structured and calmer approach? We can treat learning about the topics on the list like taking a brief walk in nature – a sort of meditation, if you will.

That said, this handbook is not about specific problems. Rather it’s about understanding the concepts behind them in a casual manner. It is also language agnostic – sometimes you’ll see TypeScript, sometimes Python, and sometimes JavaScript.

This handbook also requires you to be patient, to relax, to take a step back and pay attention. The mid-quality GIFs used in the handbook (maybe ironically!) intend to encourage this. They are not videos, so you can wait for it to come to a moment that you didn't understand or missed instead of hastily rewinding it back or rushing to a certain point in the future.

Solving hundreds of LeetCode problems may be the gate to go through to get an interview at big tech companies…but learning the topics that the problems are about is not under anyone's monopoly.

With that said, let's start the first chapter.

Table of Contents

1. Prerequisites

2. Chapter One: Arrays & Hashing

   • Dynamic Arrays

   • Hash Tables

   • Prefix Sums

3. Chapter Two: Two Pointers

   • Palindrome example

   • Squares of a sorted array example

4. Chapter Three: Sliding Window

   • Fixed window size

   • Dynamic window size

5. Chapter Four: Stack

6. Chapter Five: Binary Search

7. Chapter Six: Linked Lists

   • Singly linked lists

   • Doubly linked lists

   • Circular linked lists

8. Interlude: Fast & Slow Pointers

   • Finding the middle node of a linked list

9. Chapter Seven: Trees

   • Binary trees, binary search trees (BSTs)

     • Inserting into a binary search tree

       • Recursive solution

       • Iterative solution

     • Deleting from a binary search tree

     • Traversals

       • Depth-First Search (DFS)

         • Preorder traversal

         • Inorder traversal

         • Postorder traversal

       • Breadth-First Search (BFS)

10. Chapter Eight: Heap / Priority Queue

    • Heap properties

    • Heaps with arrays

    • Inserting/removing elements

    • Heapsort

11. Chapter Nine: Backtracking

    • Subsets

12. Chapter Ten: Tries

13. Chapter Eleven: Graphs

    • Representing graphs

      • Edge List

      • Adjacency Matrix

      • Adjacency List

    • Traversals

      • Breadth-First Search

      • Depth-First Search

14. Chapter Twelve: Dynamic Programming

15. Chapter Thirteen: Intervals

16. Chapter Fourteen: Bit Manipulation

    • Bitwise operators

      • AND (&)

      • OR (|)

      • XOR (^)

      • NOT (~)

      • Left shift (zero fill) (<<)

      • Right shift (sign preserving) (>>)

      • Right shift (unsigned) (>>>)

    • Getting a bit

    • Setting a bit

17. Conclusion

18. Resources & Credits

Prerequisites

Before diving in, some familiarity with TypeScript/JavaScript and Python may be helpful, as these are the languages I use for the examples. Also, a basic understanding of Big O notation is useful as we go over time and space complexities.

Even though we don't go through the mathematics behind the concepts, some basic mathematical knowledge can also help. That said, it's definitely not necessary to enjoy or learn something useful from this handbook.

Chapter One: Arrays & Hashing

Let's very briefly get to know our topics for this chapter: dynamic arrays, hash tables, and prefix sums.

Dynamic Arrays

Dynamic arrays are, well, dynamic. They're flexible and can change their size during execution.

Python's list type is a dynamic array. We can create an items list, for example:

items = [3, 5]

The length of items is 2, as you can see, but its capacity is greater than or equal to its length. In fact, capacity refers to the total size, whereas length is the actual size.

Since dynamic arrays are still arrays, they need a contiguous block of memory.

We can easily add an item to items:

items.append(7)

And add some more:

items.append(9)
items.append(11)
items.append(13)

All the while, the length and capacity of items keep growing dynamically.

Time and space complexity

Accessing an element is \(O(1)\) as we have random access.

Inserting a new element or deleting an element is \(O(n)\) (think about having to shift all the elements before inserting or after deleting an item). But, in order to not be too pessimistic, we can look at amortized analysis – in that case, inserting/deleting at the end of the array becomes \(O(1)\).

Space complexity is \(O(n)\), as the need for space will grow proportionately as the input increases.

If you need more info about time and space complexity, you can refer to this guide.

Hash Tables

A hash table maps keys to values, implementing an associative array.

Python's dict is one example:

number_of_petals = {
    'Euphorbia': 2, 
    'Trillium': 3, 
    'Columbine': 5,
}

Also JavaScript's "object"s:

let numberOfMoons = {
  'Earth': 1,
  'Mars': 2,
  'Jupiter': 95,
  'Saturn': 146,
  'Uranus': 27,
  'Neptune': 14,
};

There are two important ingredients for a hash table:

• an array of "buckets" to store the data

• a hash function to map the data to a specific index in the array

Hashes are usually large integers, so to find an index, we can take the result of the hash modulo the array's length.

Note: The hash function that's mapping the elements to buckets is not the hash() used in the visual (it's just a Python function to calculate the hash value of an object). The hash function in this case is the modulo ( % ) operation.

Here, with the hash value of each item's key, we calculate the remainder when it's divided by the length of the array to find which "bucket" it should go to.

The ratio of the number of elements to the number of buckets is called the load factor, and the higher it gets, the more collisions (when elements have to be inserted at the same place in the array) occur.

There are some collusion resolution tactics like linear probing (probing through the array until finding an empty bucket) and chaining (chaining multiple elements as linked lists), but we'll not go into those for now.

Time and space complexity

The average case for searching, inserting, and deleting operations are \(O(1)\) as we use keys to look up the values.

Space complexity is \(O(n)\) as it grows linearly with the amount of elements.

Prefix Sums

A prefix sum is the sequence of numbers we get after adding the sums of running totals of another sequence. It's also called the cumulative sum.

The first element of the resulting array is the first element of the input array. That's fine. We start at the second item, and add the previous numbers each time as we go. That is:

$$result[i] = \begin{cases} nums[0] & \text{if } i \text{ is zero} \\ result[i - 1] + nums[i] & \text{if } i \geq 1 \end{cases}$$

In code, we can implement that easily:

def runningSum(nums):
    result = [nums[0]]

    for i in range(1, len(nums)):
        result.append(result[i - 1] + nums[i])

    return result

Time and space complexity

Time complexity for a prefix sum is \(O(n)\) because we're iterating over each of the elements in the array.

The space complexity is also \(O(n)\) because the need for external space grows as the length of the original array grows.

Chapter Two: Two Pointers

One of the techniques of iterating through an array is the two pointers technique, and it is as simple as it sounds: we just keep two pointers, one starting from the left, and the other from the right, gradually getting closer to each other.

Palindrome example

A very basic example can be the one where we check if a string is a palindrome or not. A palindrome is a string that reads the same forwards and backwards.

In an imaginary world where all the inputs always consist of lowercase English letters, we can do it like this:

// s consists of lowercase English letters
function isPalindrome(s: string) {
  let left = 0;
  let right = s.length - 1;

  while (left <= right) {
    if (s[left++] !== s[right--]) {
      return false;
    }
  }

  return true;
}

We initialize two pointers: left and right. left points to the start of the array, while the right points to the last element. As we loop while left is less than right, we check if they are equal. If not, we return false immediately. Otherwise, our left pointer is increased – that is, it's moved to the right one step, and our right pointer is decreased, meaning that it's moved to the left one step. When they eventually overlap, the loop terminates, and we return true.

Let's say our string is 'racecar', which is a palindrome. It will go like this:

Squares of a sorted array example

Another example where we can use the two pointers technique is the problem Squares of a Sorted Array.

The description says:

Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.

For example, if the input is [-4, -1, 0, 3, 10], the output should be [0, 1, 9, 16, 100].

Now obviously, we can just square each one, and then sort the array with a built-in sort method, and be done with it. But a sorting operation is never better than \(O(n \ log \ n)\) runtime, so we can do it using two pointers in just \(O(n)\) time:

function sortedSquares(nums: number[]): number[] {
  let left = 0;
  let right = nums.length - 1;
  let result = [];

  while (left <= right) {
    if (Math.abs(nums[left]) > Math.abs(nums[right])) {
      result.push(nums[left++] ** 2);
    } else {
      result.push(nums[right--] ** 2);
    }
  }

  return result.reverse();
}

We compare the absolute value of the items that left and right are pointing to, and push the square of the greater one to our result array. And we return the reversed version of it.

Note: The reason we return the reversed result is that the array is initially already sorted, and we get the largest absolute value first. The reason that works is related to how two pointers work: as we start from both ends, we initially start with the smallest and largest values in the array.

Because we only make one pass through the array while comparing, and then later reversing, it ends up being \(O(n)\), a better runtime than \(O(n \ log \ n)\).

Chapter Three: Sliding Window

Now that we're familiar with the Two Pointers technique, we can add another one to our toolbox: the Sliding Window. It's usually used for operations done on the subsets of a given data. It also comes in two flavors: fixed window size and dynamic window size.

Fixed window size

If we have a size constraint in a given problem – say, we need to check a \(k\)-sized subarray – sliding window is an appropriate technique to use.

For example, getting the maximum subarray (of size \(k\)) sum of a given array can be done like this:

Note that the window size is \(k\), and it doesn't change throughout the operation – hence, fixed size.

A very cool thing to notice here is that with each slide, what happens to our sum is that we add the right element, and decrease the left element.

Let's look at an example for getting the maximum sum of subarray with given size k:

function maxSubarray(numbers: number[], k: number) {
  if (numbers.length < k) {
    return 0;
  }

  let currentSum = 0;

  // Initial sum of the first window 
  for (let i = 0; i < k; i++) {
    currentSum += numbers[i];
  }

  let maxSum = currentSum;

  let left = 0;
  let right = k;

  while (right < numbers.length) {
    currentSum = currentSum - numbers[left++] + numbers[right++];
    maxSum = Math.max(maxSum, currentSum);
  }

  return maxSum;
}

Note: Updating the pointers can be done outside the brackets as well, like this:

while (right < numbers.length) {
  currentSum = currentSum - numbers[left] + numbers[right];
  maxSum = Math.max(maxSum, currentSum);
  left++;
  right++;
}

Since the postfix operator returns the value first, they can be used inside the brackets to be slightly more concise.

Here, we first get the initial sum of our window using the for loop, and set it as the maximum sum.

Then we initialize two pointers: left that points to the left end of the window, and right that points to the right end of the window. As we loop, we update our currentSum, decreasing the left value, and adding the right value. When our current sum is more than the maximum sum, maxSum variable is updated as well.

Dynamic window size

As opposed to the fixed window size version, the size of the window changes dynamically this time.

For example, let's take a brief look at the problem Best Time to Buy and Sell Stock. We need to choose a day to buy a stock, and sell it in the future. The numbers in the array are prices, and we need to buy the stock at as low a price as we can, and sell it as high as we can.

We can initialize left and right pointers again, but this time, we'll update them depending on a condition. When the left item is less than the one on the right, that means it's good – we can buy and sell at those prices, so we get their difference and update our maxDiff variable that holds the maximum difference between the two.

If, however, the left one is greater than the right one, we update our left pointer to be where the right is at. In both cases, we'll continue updating right until we reach the end of the array.

With the blue arrow indicating the left pointer, and the red the right one, the process looks like this:

The solution looks like this:

function maxProfit(prices: number[]): number {
  let left = 0;
  let right = left + 1;
  let maxDiff = 0;

  while (right < prices.length) {
    if (prices[left] < prices[right]) {
      let diff = prices[right] - prices[left];
      maxDiff = Math.max(maxDiff, diff);
    } else {
      left = right;
    }

    right++;
  }

  return maxDiff;
}

Note: This one is also called fast/catch-up version of dynamic sliding window, because the left pointer jumps to catch up with the right pointer in the else block.

Time and space complexity

Both examples have the same time and space complexity: The time complexity is \(O(n)\) because in the worst case we iterate through all the elements in the array. The space complexity is \(O(1)\) as we don't need additional space.

Chapter Four: Stack

A stack data type is perhaps one of the most well-known ones. A stack of books might be a good example to visualize, but insertion and deletion can only happen from the one end. A stack operates through the last-in first-out (LIFO) principle: the last item to go in is the first to go out.

Usually we'll have methods for pushing an element onto the stack, and popping an element from the stack.

For example, let's say we're looking for valid parentheses in a given string, and the operation we'll do goes like this.

As we iterate over the characters in the string, we push the character onto the stack. If we pushed a closing parenthesis (one of ), }, or ]), then, if the previous pushed element is its opening pair, we'll pop that pair from the stack.

If, at the end, the stack is empty, the string consists of valid parentheses.

A stack can be implemented as an array or a linked list. But using linked lists is more common because with arrays, we have a potential stack overflow when we predefine a maximum stack size. On the other hand, linked lists are not static when it comes to memory, so they are a good candidate to implement stacks.

Linked lists are also efficient because we are using one end of the stack for insertion and deletion, and doing these are constant time operations.

Let's look at one easy stack implementation in Python.

Now, we can use a list, but a list in Python is implemented as a dynamic array underneath, so at one point, pushing an item can be an \(O(n)\) operation if the list needs to be copied into another memory location. For that reason, we'll use a deque, which is implemented as a doubly-linked list, so that we know push and pop operations will be \(O(1)\).

from collections import deque

class Stack:
    def __init__(self):
        self._stack = deque()

    def push(self, item):
        self._stack.append(item)

    def pop(self):
        return self._stack.pop()

    def peek(self):
        return self._stack[-1]

    def is_empty(self):
        return not bool(len(self._stack))

    def size(self):
        return len(self._stack)

In addition to push and pop, we'll also usually have functions like peek to get the topmost item in the stack, is_empty to check if the stack is empty, and size to get the size of the stack.

We can also do it using JavaScript. Now, we can do it using an array, but we want to use a linked list instead. Since we don't have a robust built-in library like Python this time, we'll implement a very simple version of it ourselves. Even though we haven't seen linked lists so far, the basic idea is that we have nodes, each of which has a data value, and a next pointer pointing to the next node.

Let's create a simple node first:

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

We can write our stack now:

class Stack {
  constructor() {
    this.top = null;
    this.length = 0;
  }

  push(item) {
    const node = new Node(item);
    node.next = this.top;
    this.top = node;
    this.length++;
  }

  pop() {
    if (this.isEmpty()) { return null; }

    const data = this.top.data;
    this.top = this.top.next;
    this.length--;

    return data;
  }

  peek() {
    if (this.isEmpty()) { return null; }

    return this.top.data;
  }

  isEmpty() {
    return this.size() === 0;
  }

  size() {
    return this.length;
  }
}

Now, let’s use it:

let myStack = new Stack();

myStack.push(5);
myStack.push(17);
myStack.push(55345);
myStack.push(0);
myStack.push(103)

console.log(myStack.size()) // 5
console.log(myStack.peek()) // 103

myStack.pop()

console.log(myStack.size()) // 4
console.log(myStack.peek()) // 0

Time and space complexity

Each method we defined for our stack has \(O(1)\) time complexity, and it would be the same if we were to use an array as well. However, as mentioned above, arrays have limitations in that having to allocate a predefined stack size can lead to a stack overflow. And if we were to use a dynamic array, the whole array might need to be copied to go into another memory location after a certain size is reached, leading to \(O(n)\) time. So, linked lists are ideal to implement a stack data type.

If the space complexity is linear – \(O(n)\)– the stack will grow linearly with the number of items in it.

Chapter Five: Binary Search

Binary search is one of the most well-known algorithms. It's also a divide-and-conquer algorithm, where we break the problem into smaller components.

The crux of binary search is to find a target element in a given sorted array. We have two pointers: high to point to the largest element, and low to point to the smallest element. We first initialize them for the whole array itself, with high being the last index and low being the first index.

Then, we calculate the midpoint. If the target is greater than the midpoint, then we adjust our low pointer to point to the mid + 1, otherwise if the target is less than the midpoint, we adjust high to be mid - 1. With each iteration, we eliminate half the array until the midpoint equals the target or the low pointer passes high.

If we find the index of the target, we can return it as soon as we find it. Otherwise, we can just return -1 to indicate that the target doesn't exist in the array.

For example, if we have a nums array [-1, 0, 3, 5, 9, 12] and our target is 9, the operation looks like this:

We can write it in TypeScript like this:

function search(nums: number[], target: number): number {
  let high = nums.length - 1;
  let low = 0;

  while (high >= low) {
    let mid = Math.floor((high + low) / 2);

    if (target > nums[mid]) {
      low = mid + 1;
    } else if (target < nums[mid]) {
      high = mid - 1;
    } else {
      return mid;
    }
  }

  return -1;
}

Time and space complexity

The time complexity of a binary search algorithm is \(O(log \ n)\) in the worst case. (For example, if the target is not in the array, we'll be halving the array until there is one element left.) The space complexity is \(O(1)\) as we don't need extra space.

Chapter Six: Linked Lists

A linked list is a linear data structure that you're likely to be familiar with. It is also a data structure that can grow and shrink dynamically – so unlike arrays, there's no need to allocate memory beforehand.

An important part of a linked list is the head pointer that points to the beginning of the list. There may or may not be a tail pointer that also points to the end of the list.

The core ingredient of a linked list is a simple node, which consists of two parts: data and the next pointer. So, it is an important idea to remember: a node only knows about its data and its neighbor.

The very last node in the linked list points to null to indicate it's the end of the list.

But there are different types of linked lists that differ from each other slightly, so let's briefly take a look at them.

Singly linked lists

The core idea with singly linked lists is that each node, along with the data it has, has a pointer that points only to the next node:

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

And here is an example where we have three nodes, holding the values 1, 2, and 3 consecutively:

Here is a simple implementation of a singly linked list in JavaScript:

class SinglyLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  // Add value to the end of the list
  append(value) {
    let node = new Node(value);
    // If the list is empty
    if (this.head === null) {
      this.head = node;
      this.tail = this.head;
    } else {
      this.tail.next = node;
      this.tail = node;
    }

    this.length++;
    return this;
  }

  // Add value to the beginning of the list
  prepend(value) {
    let node = new Node(value);
    // If the list is empty
    if (this.head === null) {
      this.head = node;
      this.tail = this.head;
    } else {
      node.next = this.head;
      this.head = node;
    }

    this.length++;
    return this;
  }

  remove(value) {
    // If the list is empty, return null
    if (this.head === null) { 
      return null; 
    }

    // If it is the first element
    if (this.head.data === value) {
      this.head = this.head.next;
      this.length--;
      // If it is the only element 
      // (we don't have anything after removing it)
      if (this.head === null) {
        this.tail = null;
      } 
      return;
    }

    let currentNode = this.head;

    while (currentNode.next) {
      if (currentNode.next.data === value) {
        currentNode.next = currentNode.next.next;
        // If it is the last element, update tail
        if (currentNode.next === null) {
          this.tail = currentNode;
        } 
        this.length--;
        return;
      }
      currentNode = currentNode.next;
    }
  }

  search(value) {
    let currentNode = this.head;

    while (currentNode) {
      if (currentNode.data === value) {
        return currentNode;
      }
      currentNode = currentNode.next;
    }

    // If the value does not exist, return null
    return null;
  }

  printList() {
    let values = [];
    let currentNode = this.head;
    while (currentNode) {
      values.push(currentNode.data);
      currentNode = currentNode.next;
    }

    console.log(values);
  }
}

Note: We'll keep a tail pointer in all these examples for convenience. It doesn't hurt to have a tail pointer.

We can now use it:

const mySinglyLinkedList = new SinglyLinkedList();

mySinglyLinkedList.prepend(3);
mySinglyLinkedList.prepend(143);
mySinglyLinkedList.prepend(5);

mySinglyLinkedList.printList(); // [ 5, 143, 3 ]

mySinglyLinkedList.append(21);
mySinglyLinkedList.printList(); // [ 5, 143, 3, 21 ]

console.log(mySinglyLinkedList.search(143));
// Node {
//   data: 143,
//   next: Node { data: 3, next: Node { data: 21, next: null } }
// }

mySinglyLinkedList.remove(143);
mySinglyLinkedList.printList(); // [ 5, 3, 21 ]

console.log(mySinglyLinkedList.search(143)); // null

Doubly linked lists

Doubly linked lists differ from the "singly" ones in that each node also has another pointer that points to the previous element.

So, this time, a single node will look different:

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
    this.previous = null;
  }
}

Here is the same example as above, but as a doubly linked list:

A simple implementation might look like this:

class DoublyLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  // Add value to the end of the list
  append(value) {
    let node = new Node(value);
    // If the list is empty
    if (this.head === null) {
      this.head = node;
      this.tail = this.head;
    } else {
      node.previous = this.tail;
      this.tail.next = node;
      this.tail = node;
    }

    this.length++;
    return this;
  }

  // Add value to the beginning of the list
  prepend(value) {
    let node = new Node(value);
    // If the list is empty
    if (this.head === null) {
      this.head = node;
      this.tail = this.head;
    } else {
      this.head.previous = node;
      node.next = this.head;
      this.head = node;
    }

    this.length++;
    return this;
  }

  remove(value) {
    // If the list is empty, return null
    if (this.head === null) { 
      return null;
    }

    let currentNode = this.head;

    // If it is the first element
    if (currentNode.data === value) {
      this.head = currentNode.next;
      // If the removed element is not the only one,
      // make the previous pointer of the new head null
      if (this.head) {
        this.head.previous = null;
      // If the removed element was the only element,
      // point the tail to null as well
      } else {
        this.tail = null;
      }
      this.length--;
      return;
    }

    while (currentNode) {
      if (currentNode.data === value) {
        if (currentNode.previous) {
          currentNode.previous.next = currentNode.next;
        }
        if (currentNode.next) {
          currentNode.next.previous = currentNode.previous;
        // If it's the last element in the list, update tail
        // to point to the previous node
        } else {
          this.tail = currentNode.previous;
        }

        this.length--;
        return;
      }

      currentNode = currentNode.next;
    }
  }

  search(value) {
    let currentNode = this.head;
    while (currentNode) {
      if (currentNode.data === value) {
        return currentNode;
      }
      currentNode = currentNode.next;
    }

    // If the value does not exist, return null
    return null;
  }

  printList() {
    let values = [];
    let currentNode = this.head;

    while (currentNode) {
      values.push(currentNode.data);
      currentNode = currentNode.next;
    }

    console.log(values);
  }
}

Circular linked lists

With circular linked lists, we have the last node also pointing to the first element, creating circularity.

We'll only look at the singly circular linked list for simplicity's sake, so our node will look the same as in the first example:

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

The same example, in a circular linked list fashion:

Here is a simple implementation:

class CircularLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  // Add value to the "end" of the list
  append(value) {
    let node = new Node(value);
    // If the list is empty
    if (this.head === null) {
      this.head = node;
      this.tail = node;
      // As the only node in the list, it should point to itself
      node.next = node;
    } else {
      // As the "last" node, it should point to the head (this.tail.next)
      node.next = this.tail.next;
      this.tail.next = node;
      this.tail = node;
    }

    this.length++;
    return this;
  }

  // Add value to the beginning of the list
  prepend(value) {
    let node = new Node(value);
    node.next = this.head;
    // Update last node's next pointer to point to the new node
    this.tail.next = node;
    this.head = node;
    this.length++;
    return this;
  }  

  remove(value) {
    // If the list is empty, return null
    if (this.head === null) { 
      return null; 
    }

    // If it is the first element
    if (this.head.data === value) {
      // If it's the only element
      if (this.head.next === this.head) {
        this.head = null;
        this.tail = null;
        return;
      }
      this.head = this.head.next;
      this.tail.next = this.head;
      this.length--;
      return;
    }

    let currentNode = this.head;
    let prevNode = null;

    // Iterate until you find the value or
    // you don't find it after traversing the whole list
    while (currentNode.data !== value || prevNode === null) {
      if (currentNode.next === this.head) { 
        break; 
      }
      prevNode = currentNode;
      currentNode = currentNode.next;
    }

    if (currentNode.data === value) {
      // If there is a previous node before the element to be removed,
      // update the previous node's next pointer to point to
      // the one after the element to be removed
      // (unlink it)
      if (prevNode) {
        prevNode.next = currentNode.next;
        // If the element to be removed is the last one,
        // update tail to be the previous node
        if (this.tail === currentNode) {
          this.tail = prevNode;
        }
      // If the element to be removed is the first one in the list
      } else {
        // If it's the only one in the list
        if (this.head.next === this.head) {
          this.head = null;
          this.tail = null;
        } else {
          this.head = this.head.next;
          this.tail.next = this.head;
        }
      }
    }
  }

  printList() {
    let nodes = [];
    let currentNode = this.head;
    if (this.head === null) { 
      console.log(nodes); 
      return;
    }

    // Traverse the list once to add the values, 
    // don't go in circles
    do {
      nodes.push(currentNode.data);
      currentNode = currentNode.next;
    } while (currentNode !== this.head);

    console.log(nodes);
  }
}

Time and space complexity

With linked lists, the time complexity for accessing an element is in the worst case \(O(n)\). Prepending and appending an element depends on whether we have a tail pointer. If we have it, then both operations are \(O(1)\), as we only need to arrange pointers. But if we don't have a tail pointer, appending an element requires traversing the whole list, so it is an \(O(n)\) operation. Removing an element is similar – in the worst case, it is \(O(n)\).

If the space complexity is linear – \(O(n)\)– then the amount of data to store grows linearly with the number of nodes in the list.

Interlude: Fast & Slow Pointers

Let's take a quick look at a technique that comes in handy when it comes to working with linked lists.

We can keep two pointers while traversing a linked list: fast and slow. While the fast one increases by two steps, the slow pointer will increase by just one step.

Finding the middle node of a linked list

When the fast pointer reaches the end of the list, the slow pointer will be at the "middle" node.

Let's see how it might work:

let slow = head;
let fast = head;

while (fast !== null && fast.next !== null) {
  slow = slow.next;
  fast = fast.next.next;
}

We can think of a list like [1, 2, 3, 4, 5] (where each value is a node in the linked list).

Both fast and slow start pointing to the head, that is, 1.

Then, we update the slow pointer one step, which will be 2. And, fast will be at 3.

When we update slow again, it will be at 3. When the fast pointer increases, it will be two steps ahead, and its next pointer will point to the null value, at which point our loop will stop iterating.

slow will end up pointing to the node with the value 3, which is the middle node.

With an even number of nodes, there are two candidates for the middle node. For example, with a list like [1, 2, 3, 4], our current implementation will find the middle as 3. This technique is also useful to detect cycles in a linked list.

Chapter Seven: Trees

Let’s take a look at a non-linear data structure that is pretty familiar to many developers: trees.

Whether familiarity breeds contempt or not is arguable, so let's start with the simplest component of a tree: a node.

Trees, like linked lists, are made up of nodes. The simplest version of a tree is just the root node which doesn't have any edges (links) pointing to it; that is, it has no parent nodes. It is the starting point, in a way.

A tree can only have one root node, and when you think about it, if there are \(n\) nodes in a tree, that means there are \(n - 1\) edges (links) because there is no edge (link) pointing to the root node.

If you've looked at a tree long enough, you might've had a moment of epiphany: a tree has smaller trees within itself. A branch may as well be a trunk, having other branches for the little tree it constitutes.

The tree data structure is like this, it is recursive: a child node can be the root of a subtree.

Two terms that are important when it comes to a tree node are depth and height.

The depth of a node is how far away it is from the root node (how many edges (links) does it take to travel from the root node to it), and the height of a node is how far away it is from its furthest leaf node (which is a node that has no children).

Note: The height of the root node is the same as the height of the whole tree.

A balanced tree is one where the heights of the left and right subtrees of every node differ by at most 1.

Binary trees, binary search trees (BSTs)

A binary tree is a tree where each node has at most two children. That is, a node can have a left child node and a right child node, and no more.

The maximum number of nodes in a binary tree is \(2^h - 1\) where \(h\) is the height of the tree. This is where the binary of the binary tree makes sense: on each level, the number of nodes grows proportionately to the exponents of \(2\).

For example, the number of nodes on the first level (the 0th level) is \(2^0 = 1\), which is just the root node. The second level has at most 2 nodes: \(2^1 = 2\) (remember that we're counting from \(0\), so the second level is \(1\)).

A binary search tree is a binary tree where the values smaller than the node go to its left and those greater than it go to its right:

$$\text{left children } \lt \text{ node } \lt \text{ right children}$$

Here is an example:

We can define a tree node like this:

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;

  constructor(val: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val;
    this.left = (left === undefined ? null : left);
    this.right = (right === undefined ? null : right);
  }
}

Inserting into a binary search tree

If we want to insert a new node into a binary search tree, we need to insert it into its proper place to keep the properties of a BST intact.

Recursive solution:

function insertIntoBST(root: TreeNode | null, val: number) {
  if (root === null) {
    return new TreeNode(val);
  }

  if (val < root.val) {
    root.left = insertIntoBST(root.left, val);
  } else {
    root.right = insertIntoBST(root.right, val);
  }

  return root;
}

Here, we traverse the tree until we find a space (a null position) for our value that is waiting to be a TreeNode. We start with the root node. If the value of the node-to-be-inserted is less than the value of the root node, we go left (passing root.left as the root argument to the function). Otherwise, we go right (passing root.right as the root argument).

Time and space complexity

The time complexity is \(O(h)\) where \(h\) is the height of the tree. On each level in the tree, we either go left or right, so we don't necessarily visit every single node. The space complexity is also \(O(h)\) because we use recursion, creating a new stack frame for each function call.

Note that if the tree is unbalanced, the time and space complexity can be said to be \(O(n)\).

Iterative solution:

We can also do it iteratively, using pointers only:

function insertIntoBST(root: TreeNode | null, val: number) {
  if (root === null) {
    return new TreeNode(val);
  }

  let prevNode: TreeNode | null = null;
  let currentNode: TreeNode | null = root;

  while (currentNode !== null) {
    prevNode = currentNode;
    if (val < currentNode.val) {
      currentNode = currentNode.left;
    } else {
      currentNode = currentNode.right;
    }
  }

  if (prevNode) {
    if (val < prevNode.val) {
      prevNode.left = new TreeNode(val);
    } else {
      prevNode.right = new TreeNode(val);
    }
  }

  return root;
}

Here, we do the same thing: iterating until we find the correct place, but also keeping track of the parent node. Then, we insert the node as either the left or the right child of the parent, depending on its value.

Time and space complexity

The time complexity is again \(O(h)\) (or if the tree is unbalanced, \(O(n)\)) for the same reason as in the recursive solution. But the space complexity is constant – \(O(1)\) – as we only use pointers.

Deleting from a binary search tree

The challenging thing when deleting a node from a BST is keeping the BST as a BST. All smaller values should still go to the root node's left subtree, and all those that are larger should go to the root node's right subtree.

Let's take a look at how we might do it in JavaScript:

function deleteNode(root: TreeNode | null, key: number) {
  if (root === null) {
    return root;
  }

  if (key < root.val) {
    root.left = deleteNode(root.left, key);
  } else if (key > root.val) {
    root.right = deleteNode(root.right, key);
  } else {
    // Node-to-be-deleted has no children
    if (root.left === null && root.right === null) {
      return null;
    } 

    // If either the left or the right child exists,
    // return the one that exists as the new child 
    // of the parent node (of the node-to-be-deleted)
    if (root.left === null || root.right === null) {
      return root.left ? root.left : root.right;
    }

    // If both children exist, traverse the left subtree, get its maximum value...
    let currentNode = root.left;

    while (currentNode.right !== null) {
      currentNode = currentNode.right;
    }

    // ...replace it with the node-to-be-deleted
    root.val = currentNode.val;
    // ...then apply the recursion to the left subtree to get rid of the duplicate value
    root.left = deleteNode(root.left, root.val);
  }

  return root;
}

We traverse the tree until we find the node to be deleted. Once we find it, there are several things to do.

In the case where it doesn't have any child nodes, we can return null and be done with it.

If it has one child node, we can return the one that exists using the ternary operation (return root.left ? root.left : root.right).

Note: In this case, we're essentially making the root of the subtree the child of the parent node.

For example, in the image, if the node-to-be-deleted is 10 (it has only right child node with the value 14), we make 14 the right child of 8. It doesn't break our BST, because those that are larger than 8 continue to be in the right subtree of 8:

Otherwise, if both the left and right children of the node-to-be-deleted exist, we need to do something different.

In this case, we'll replace the node-to-be-deleted with the largest value in the left subtree.

But, after replacing, we'll have two nodes of the same value in both places, so we need to apply deleteNode itself to the subtree that we've taken our replacement node from.

This is all done to keep the BST as BST. It might be a bit difficult to wrap your head around at first, but NeetCode has a detailed explanation of this problem.

Note that we can also use the smallest value in the right subtree as well. In that case, our code would look like this:

let currentNode = root.right;

while (currentNode.left !== null) {
  currentNode = currentNode.left;
}

root.val = currentNode.val;
root.right = deleteNode(root.right, root.val);

Time and space complexity

Similar to inserting into a BST, both the time and space complexity of deleting from a BST will be \(O(h)\) where \(h\) is the height of the tree.

Traversals

We'll take a brief look at two of the most famous ways to traverse a tree where the order in which we visit the nodes matters: depth-first search and breadth-first search.

1. Depth-First Search (DFS)

In a depth-first search, we traverse through a branch until we get to a leaf node. Then, we backtrack and do the same thing with another branch.

There are three common ways to do a depth-first search:

• preorder traversal

• inorder traversal

• postorder traversal

Preorder traversal:

It goes like this: We first visit the node, then go on to its left subtree, then the right subtree.

node ➞ left subtree ➞ right subtree

We can do a preorder walk recursively:

function preorderWalk(node) {
  if (node === null) {
    return;
  }

  console.log(node.val);
  preorderWalk(node.left);
  preorderWalk(node.right);
}

Inorder traversal:

It goes like this: we first visit the left subtree, then the node, then the right subtree.

left subtree ➞ node ➞ right subtree

Note: The inorder traversal gives us the sorted values.

We can do an inorder walk recursively as well:

function inorderWalk(node) {
  if (node === null) {
    return;
  }

  inorderWalk(node.left);
  console.log(node.val);
  inorderWalk(node.right);
}

Postorder traversal:

It goes like this: we first visit the left subtree, then the right subtree, and finally the node.

left subtree ➞ right subtree ➞ node

We can do a postorder walk recursively:

function postorderWalk(node) {
  if (node === null) {
    return;
  }

  postorderWalk(node.left);
  postorderWalk(node.right);
  console.log(node.val);
}

2. Breadth-First Search (BFS)

In breadth-first search, we visit the nodes level by level, that is, visiting every child of a node first before moving on.

A queue is used when implementing a BFS. Since we don't have edges connecting all the children on one level together, it makes sense to keep them in a queue and visit each one when their time comes. When a node is added to the queue and has not been visited yet, it's called a discovered node.

A simple BFS operation looks like this (which is repeated until the queue is empty):

• visit node

• enqueue left child

• enqueue right child

Note that the breadth-first search is also known as level-order traversal.

A simple example of a level-order traversal in JavaScript might look like this:

function levelOrderWalk(root) {
  if (root === null) {
    return;
  }

  let queue = [];
  queue.push(root);

  while (queue.length > 0) {
    let currentNode = queue[0];

    console.log(currentNode.val);

    if (currentNode.left !== null) {
      queue.push(currentNode.left);
    }

    if (currentNode.right !== null) {
      queue.push(currentNode.right);
    }

    // Remove the current node
    queue.shift();
  }
}

This example is based on Vaidehi Joshi's GitHub Gist.

Chapter Eight: Heap / Priority Queue

It’s now time to take a look at a data structure called a heap, which is a great way to implement an abstract data type called a priority queue. They're so interrelated that priority queues are sometimes referred to as heaps – because heaps are a very efficient way to create a priority queue.

Heap properties

The kind of heap we're interested in is also called a binary heap because it's just a binary tree that has specific properties.

One of them is that it must be a complete binary tree, meaning that all the levels must be filled, and all nodes in the last level should be as far left as possible.

For example, when it comes to shape, this is a complete binary tree:

But heaps must also be either a max heap or a min heap – all the parent nodes must be either greater than or equal to the values of their children (if it's a max heap) or less than or equal to the values of their children (if it's a min heap).

A max heap might look like this:

Note: A left child doesn't have to be less than the right child at all, as in a binary search tree. Also, we can always have duplicate values in a heap.

A min heap, on the other hand, has the values of parent nodes less than those of their children:

Note: When we have a max heap, the root node will have the maximum value. And, if we have a min heap instead, the root node will have the minimum value.

Heaps with arrays

We can create a heap using an array. Since the root node is the most interesting element with either a maximum or minimum value, it'll be the first element in our array, residing at the 0th index.

What's nice about using an array is that, given a parent node's index \(i\), its left child will be at the index \(2i + 1\), and its right child will be at the index \(2i + 2\).

Given that, any child node's parent will be at the index \(\lfloor{\frac{(n - 1)}{2}}\rfloor\).

Note: \(\lfloor\) and \(\rfloor\)indicate the floor function.

One question we might ask at this moment is that why should we use an array at all?

The answer lies in the word queue of a priority queue. Since a queue is mainly concerned with the first element (following the FIFO principle), an array can be an ideal choice. In a priority queue, each element has a priority, and the value with the highest priority is dequeued first.

Inserting/removing elements

Let's take a look at how we can add an element to a heap.

We know that we have to add the new element to the bottom leftmost place, but once we do that, it might violate the max heap or the min heap property. Then, how can we avoid violating the heap-order property?

We'll heapify, of course!

Let's say that we want to add a node with the value 20:

So, heapify is the swapping of nodes until we know that the heap-order property is maintained.

A similar thing happens when we need to remove an element. But since we're mainly concerned with the maximum or the minimum element, we just need to remove the root node. So, how are we going to do that?

We start off by swapping the last element (the bottom leftmost one) with the root. Now we can easily remove the "root," which resides as a leaf node. But we still need to maintain the heap-order property, so we need to heapify again.

Heapsort

Even better thing is that if we have a heap, and continually heapify it, we can sort an array.

Let's build a max heap first:

function buildMaxHeap(arr: number[]) {
  /*
  Index of the last internal node 
  (i.e., the parent of the last leaf node, 
   or, the last non-leaf node).
  The last leaf node will reside at index arr.length - 1,
  so, we're getting its parent using the formula mentioned above.
  */
  let i = Math.floor((arr.length - 1) / 2);

  while (i >= 0) {
    heapify(arr, i, arr.length);
    i--;
  }

  return arr;
}

Then, the heapify function:

function heapify(arr: number[], i: number, maxLength: number) {
  while (i < maxLength) {
    let index = i;
    let leftChildIdx = 2 * i + 1;
    let rightChildIdx = leftChildIdx + 1;

    if (leftChildIdx < maxLength && arr[leftChildIdx] > arr[index]) {
      index = leftChildIdx;
    }

    if (rightChildIdx < maxLength && arr[rightChildIdx] > arr[index]) {
      index = rightChildIdx;
    }

    if (index === i) { return; }

    // Swap
    [arr[i], arr[index]] = [arr[index], arr[i]];

    i = index;
  }
}

With a given index i, we get its left and right children indices, and if the indices are within bounds, we check if they are out of order. In that case, we make the index the index of the child, and swap the two nodes. Then, we continue with that new index, assigning it to i.

Now, heapify is nice and all, but how can we actually use it for sorting?

function heapSort(arr: number[]) {
  buildMaxHeap(arr);

  let lastElementIdx = arr.length - 1;

  while (lastElementIdx > 0) {
    [arr[0], arr[lastElementIdx]] = [arr[lastElementIdx], arr[0]];

    heapify(arr, 0, lastElementIdx);
    lastElementIdx--;
  }

  return arr;
}

Note that our max heap [42, 19, 36, 17, 3, 25, 1, 2] won't change when used in the buildMaxHeap function, as it's already a max heap! But if it were to have 17 as the right child of 42, then 17 would have 25 as a child, which breaks the heap-order property. So, using buildMaxHeap with this broken version will correctly swap the 17 and 25, making it a max heap:

buildMaxHeap([42, 36, 17, 19, 3, 25, 1, 2]);

// -> [42, 36, 25, 19, 3, 17, 1, 2]

In heapSort, with our newly built max heap, we'll start with swapping the first and last nodes. Then, we'll keep heapifying until we get all the elements in their place. If we use it with our very own max heap, we can see that it returns the sorted array:

heapSort([42, 19, 36, 17, 3, 25, 1, 2]);
// -> [1, 2, 3, 17, 19, 25, 36, 42]

The examples are adapted from Vaidehi Joshi's article.

Time and space complexity

Heap sort, as a nice sorting algorithm it is, runs in \(O(n \ log \ n)\) time.

In this example, building the max heap starts from the last non-leaf node and goes up to the root node, each time calling heapify. The heapify function has a time complexity of \(O(log \ n)\) as we're working with a binary tree, and in the worst case, we get to do it for all the levels. Since we do it \(n / 2\) times, overall, buildMaxHeap has \(O(n \ log \ n)\) time complexity.

We're swapping the first and last elements, and heapifying as we go through each element, so this is also overall an \(O(n \ log \ n)\) operation — which makes the time complexity of heapSort \(O(n \ log \ n)\).

Note: Building the max heap can be improved to have \(O(n)\) runtime.

Since there is no use of auxiliary space, the space complexity is constant, \(O(1)\).

Chapter Nine: Backtracking

Let's start with admitting this one fact: backtracking is hard. Or rather, understanding it the first time is hard. Or, it's one of those concepts that you think you grasped it, only to realize later that you actually didn't.

We'll focus on one problem of finding the subsets of an array, but before that, let's imagine that we're walking along a path.

Then, we reach a fork. We pick one of the paths, and walk.

Then, we reach another fork in the path. We pick one of the paths again, and go on walking, then we reach a dead end. So, we backtrack to the last point we had a fork, then go through the other path that we didn't choose the first time.

Then we reach another dead end. So, we backtrack once more and realize that there are no other paths we can go from there. So we backtrack again, and explore the other path we didn't choose the first time we came to this point.

We reach yet another dead end, so we backtrack. We see that there are no more paths to explore, so we backtrack once more.

Now, we're at our starting point. There are no more paths left to explore, so we can stop walking.

It was a nice but tiring walk, and it went like this:

Now, let's take a look at a LeetCode problem.

Subsets

The description for Subsets says:

Given an integer array nums of unique elements, return all possible subsets (the power set).

The solution set must not contain duplicate subsets. Return the solution in any order.

For example:

Input: nums = [1, 2, 3]
Output: [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]

Or:

Input: nums = [0]
Output: [[], [0]]

Before diving into the solution code, let's take a look at how backtracking will work in this case. Let's call the nums array items instead:

For each item in items, we have initially two choices: to include the item, or not to include it.

For each level \(n\) in this decision tree, we have the option to include the next item in items. We have \(2^n\) possible subsets in total.

Let's simplify the example a bit, and say that items is now ['a', 'b'] (We'll ignore the problem specifics for now).

In this case, we can use backtracking like this:

function subsets(items: string[]) {
  let result: string[][] = [];
  let currentSubset: string[] = [];

  function backtrack(idx: number) {
    if (idx >= items.length) {
      result.push([...currentSubset]);
      return;
    }

    currentSubset.push(items[idx]);
    backtrack(idx + 1);

    currentSubset.pop();
    backtrack(idx + 1);
  }

  backtrack(0);

  return result;
}

console.log(subsets(['a', 'b']));
// -> [['a', 'b'], ['a'], ['b'], []]

Well, it looks simple at first glance, but what's going on?

One thing to notice is that we pop from the currentSubset, then call backtrack. In our example of walking, that's the part we go back to our previous point, and continue our walk.

In the first animation, we indicated a dead end with a cross mark, and in this case, a dead end is the base case we reach.

It might still be tough to understand, so let's add some helpful console.logs, and see the output:

function subsets(items: string[]) {
  let result: string[][] = [];
  let currentSubset: string[] = [];

  function backtrack(idx: number) {
    console.log(`======= this is backtrack(${arguments[0]}) =======`)
    if (idx >= items.length) {
      console.log(`idx is ${idx}, currentSubset is [${currentSubset}], adding it to result...`);
      result.push([...currentSubset]);
      console.log(`backtrack(${arguments[0]}) is returning...\n`)
      return;
    }

    currentSubset.push(items[idx]);
    console.log(`added ${items[idx]} to currentSubset, inside backtrack(${arguments[0]})`);
    console.log(`calling backtrack(${idx + 1})...`)
    backtrack(idx + 1);

    let item = currentSubset.pop();
    console.log(`popped ${item} from currentSubset, inside backtrack(${arguments[0]})`);
    console.log(`calling backtrack(${idx + 1})...`)
    backtrack(idx + 1);

    console.log(`******* done with backtrack(${arguments[0]}) *******\n`);
  }

  backtrack(0);

  return result;
}

console.log(subsets(['a', 'b']));

The output looks like this:

======= this is backtrack(0) =======
added a to currentSubset, inside backtrack(0)
calling backtrack(1)...
======= this is backtrack(1) =======
added b to currentSubset, inside backtrack(1)
calling backtrack(2)...
======= this is backtrack(2) =======
idx is 2, currentSubset is [a,b], adding it to result...
backtrack(2) is returning...

popped b from currentSubset, inside backtrack(1)
calling backtrack(2)...
======= this is backtrack(2) =======
idx is 2, currentSubset is [a], adding it to result...
backtrack(2) is returning...

******* done with backtrack(1) *******

popped a from currentSubset, inside backtrack(0)
calling backtrack(1)...
======= this is backtrack(1) =======
added b to currentSubset, inside backtrack(1)
calling backtrack(2)...
======= this is backtrack(2) =======
idx is 2, currentSubset is [b], adding it to result...
backtrack(2) is returning...

popped b from currentSubset, inside backtrack(1)
calling backtrack(2)...
======= this is backtrack(2) =======
idx is 2, currentSubset is [], adding it to result...
backtrack(2) is returning...

******* done with backtrack(1) *******

******* done with backtrack(0) *******

[ [ 'a', 'b' ], [ 'a' ], [ 'b' ], [] ]

If you noticed, Add 'a'? and Go ahead? arrows on the first level are calls to backtrack(0).

Add 'b'? and Go ahead? arrows on the second level are calls to backtrack(1).

backtrack(2) calls are when we reach the "dead ends". In those cases, we add currentSubset to the result. We always reach the base case in a backtrack(2) call because it's only when the idx equals items.length.

Note: We modified the function in the above examples to work with strings, but in the actual solution we'll only deal with numbers, so in TypeScript, result and currentSubset will look like this:

let result: number[][] = [];
let currentSubset: number[] = [];

Also, the function parameter and return types are different:

function subsets(nums: number[]): number[][] { ... }

Otherwise, everything stays the same.

Time and space complexity

A subset is, in the worst case, length \(n\) which is the length of our input. We'll have \(2^n\) subsets and since we also use a spread operator in our example to copy currentSubset, the time complexity will be \(O(n \cdot 2^n)\). The space complexity is – I think – \(O(n \cdot 2^n)\) as well because of the recursive call stack (which is of depth n), and the space needed for result (which is in the worst case \(2^n\)).

Chapter Ten: Tries

The trie data structure gets its name from the word retrieval – and it's usually pronounced as "try," so that we don't get confused with another familiar and friendly data structure, "tree."

But a trie is still a tree (or tree-like) data structure whose nodes usually store individual letters. So, by traversing the nodes in a trie, we can retrieve strings.

Tries are useful for applications such as autocompletion and spellchecking – and the larger our trie is, the less work we have to do for inserting a new value.

Note: Using arrays is not very memory-efficient, but for now, we'll stick to the array implementation.

First, let's see what a trie looks like:

In this trie, we can retrieve the strings "sea" and "see" – but not "sew", for example.

There is a lot going on, but we can try to understand it piece by piece.

Let's look at a trie node.

We'll create a TrieNode class that has children, which is an array of length 26 (so that each index corresponds to a letter in the English alphabet), and a flag variable isEndOfWord to indicate whether that node represents the last character of a word:

class TrieNode {
  children: (TrieNode | null)[];
  isEndOfWord: boolean;

  constructor() {
    this.children = Array.from({ length: 26 }, () => null);
    this.isEndOfWord = false;
  }
}

We're initializing children with null values. As we add a character to our trie, the index that corresponds to that character will be filled.

Note: We're not storing the actual character itself in this implementation – it's implicit in the usage of indices.

In a trie, we start with an empty root node.

class Trie {
  root: TrieNode;

  constructor() {
    this.root = new TrieNode();
  }
  // ...
}

To insert a word, we're going to loop through each character, and initialize a new TrieNode to the corresponding index.

insert(word: string) {
  let currentNode = this.root;
  for (const char of word) {
    let idx = char.charCodeAt(0) - 'a'.charCodeAt(0);
    if (currentNode.children[idx] === null) {
      currentNode.children[idx] = new TrieNode();
    }
    currentNode = currentNode.children[idx];
  }

  currentNode.isEndOfWord = true;
}

Once we reach the node that indicates the last character of the word we inserted, we also mark the isEndOfWord variable as true.

Note: word is going to be lowercase in these examples – otherwise, we have to convert it, such as:

word = word.toLowerCase();

For searching a word's existence in the trie, we'll do a similar thing. We'll look at the nodes for each character, and if we reach the last one that has isEndOfWord marked as true. That means we've found the word:

search(word: string) {
  let currentNode = this.root;
  for (const char of word) {
    let idx = char.charCodeAt(0) - 'a'.charCodeAt(0);
    if (currentNode.children[idx] === null) {
      return false;
    }      
    currentNode = currentNode.children[idx];
  }

  return currentNode.isEndOfWord;
}

Note: If we find the word we're looking for, then it's called a search hit. Otherwise, we have a search miss and the word doesn't exist in our trie.

Removing a word is a bit more challenging. Let's say that we want to remove the word "see." But, there is also another word "sea," with the same prefix ('s' and 'e'). So, we should remove only the nodes that we're allowed to.

For this reason, we'll define a recursive function. Once we reach the last character of the word we want to remove, we'll back up and remove the characters we can remove:

const removeRecursively = (node: TrieNode | null, word: string, depth: number) => {
  if (node === null) {
    return null;
  }

  if (depth === word.length) {
    if (node.isEndOfWord) {
      node.isEndOfWord = false;
    }
    if (node.children.every(child => child === null)) {
      node = null;
    }

    return node;
  }

  let idx = word[depth].charCodeAt(0) - 'a'.charCodeAt(0);
  node.children[idx] = removeRecursively(node.children[idx], word, depth + 1);

  if (node.children.every(child => child === null) && !node.isEndOfWord) {
    node = null;
  }

  return node;
}

depth indicates the index of the word, or the depth of the trie we reach.

Once depth is equal to the word's length (one past the last character), we check if it's the end of the word. If that's the case, we'll mark it as false now, because that word won't exist from here on. Then, we can only mark the node as null if it doesn't have any children (in other words, if all of them are null). We'll apply this logic to each child node recursively until the word is removed as far as it can be removed.

Here is the final example implementation of a trie:

class TrieNode {
  children: (TrieNode | null)[];
  isEndOfWord: boolean;

  constructor() {
    this.children = Array.from({ length: 26 }, () => null);
    this.isEndOfWord = false;
  }
}

class Trie {
  root: TrieNode;

  constructor() {
    this.root = new TrieNode();
  }

  insert(word: string) {
    let currentNode = this.root;
    for (const char of word) {
      let idx = char.charCodeAt(0) - 'a'.charCodeAt(0);
      if (currentNode.children[idx] === null) {
        currentNode.children[idx] = new TrieNode();
      }
      currentNode = currentNode.children[idx];
    }

    currentNode.isEndOfWord = true;
  }

  search(word: string) {
    let currentNode = this.root;
    for (const char of word) {
      let idx = char.charCodeAt(0) - 'a'.charCodeAt(0);
      if (currentNode.children[idx] === null) {
        return false;
      }      
      currentNode = currentNode.children[idx];
    }

    return currentNode.isEndOfWord;
  }

  remove(word: string) {
    const removeRecursively = (node: TrieNode | null, word: string, depth: number) => {
      if (node === null) {
        return null;
      }

      if (depth === word.length) {
        if (node.isEndOfWord) {
          node.isEndOfWord = false;
        }
        if (node.children.every(child => child === null)) {
          node = null;
        }

        return node;
      }

      let idx = word[depth].charCodeAt(0) - 'a'.charCodeAt(0);
      node.children[idx] = removeRecursively(node.children[idx], word, depth + 1);

      if (node.children.every(child => child === null) && !node.isEndOfWord) {
        node = null;
      }

      return node;
    }

    removeRecursively(this.root, word, 0);
  }
}

let t = new Trie();

t.insert('sea');
t.insert('see');

console.log(t.search('sea')); // true
console.log(t.search('see')); // true

console.log(t.search('hey')); // false
console.log(t.search('sew')); // false

t.remove('see');

console.log(t.search('see')); // false 
console.log(t.search('sea')); // true

Time and space complexity

The time complexity of creating a trie is going to be \(O(m * n)\) where \(m\) is the longest word and \(n\) is the total number of words. Inserting, searching, and deleting a word is \(O(a * n)\) where \(a\) is the length of the word and \(n\) is the total number of words.

When it comes to space complexity, in the worst case, each node can have children for all the characters in the alphabet we're representing. But, the size of the alphabet is constant, so the growth of storage needs will be proportionate to the number of nodes we have, which is \(O(n)\) where \(n\) is the number of nodes.

Chapter Eleven: Graphs

A graph is probably the data structure that everyone is familiar with, regardless of their profession or interests.

Graph theory is a very broad topic, but we'll simply look at some of the main ingredients of what makes a graph and how to represent it, as well as basic graph traversals.

In a graph, there are two main components: vertices (or nodes) and edges that connect those vertices.

Note: Here, we're going to use "vertex" and "node" interchangeably. The terms "adjacent vertices" and "neighbors" are used interchangeably as well.

A graph can be directed or undirected. With a directed edge, we have an origin and a destination vertex. On the other hand, an undirected edge is bidirectional, origin and destination are not fixed.

Note: There might also be mixed graphs that have both directed and undirected edges.

A graph can also be weighted or unweighted, each edge can have different weights, usually representing the cost of going from one vertex to the other.

We can define a graph like this:

$$G = (V, \ E)$$

\(V\) is a set of vertices, and \(E\) is a set of edges.

For example, if we have a directed graph like this:

Then, we have the vertices:

$$V = \{A, \ B, \ C, \ D\}$$

And, the edges are:

$$E = \{(A, \ B), \ (A, \ C), \ (C, \ B), \ (C, \ D)\, \ (D, \ C)\}$$

If we have an undirected graph such as this one:

We have the same vertices:

$$V = \{A, \ B, \ C, \ D\}$$

But our edges can look like this:

$$E = \{\{B, \ A\}, \{A, \ C\}, \{C, \ B\}, \{D, \ C\}\}$$

Note: We use parentheses when it comes to directed edges, but curly braces with undirected edges as there is no direction from one vertex to the other.

When two vertices share an edge, they are adjacent to each other. The degree of a vertex is the number of adjacent vertices to it. We can also define the degree as the number of edges coming out of the vertex. For example, in the above image, the vertex A has a degree of 2.

A simple path is the one that we don't repeat any vertices while traversing the graph.

An example might look like this:

A cycle is a simple path, except that we end up at the vertex we started with:

Representing graphs

When it comes to representing graphs, there are several ways to do it, and we'll look at three of them: an edge list, an adjacency matrix, and an adjacency list.

Edge List

We can simply put all the edges in an array:

[ [A, B], [A, C], [B, C], [C, D] ]

But to find an edge in an edge list, we'll have to iterate through them, so it will have \(O(E)\) time complexity, where in the worst case, we'll search the whole list to find an edge. Similarly, it needs \(O(E)\) amount of space to represent all the edges.

Adjacency Matrix

The adjacency matrix for our example might look like this:

$$\left\lceil\begin{matrix}& A & B & C & D \\A & 0 & 1 & 1 & 0 \\B & 1 & 0 & 1 & 0 \\C & 1 & 1 & 0 & 1 \\D & 0 & 0 & 1 & 0\end{matrix}\right\rceil$$

Each row is for a vertex, and the matching column shows the relationship between those vertices. For example, the vertex A doesn't have an edge pointing to D, so the cell that matches A and D is 0. On the other hand, A is connected to B and C, so those cells have the value 1.

Note: If the graph is weighted, we can simply put the weight instead of 1, and when there is no edge, the value can stay 0.

An adjacency matrix will have 0s in the "main diagonal," showing that there are no self-loops.

Let's try implementing it in TypeScript.

We'll start with a minimal graph vertex:

class GraphVertex {
  value: string | number;

  constructor(value: string | number) {
    this.value = value;
  }
}

Now we can define our graph. We'll make it really simple with three properties to hold: matrix to represent the graph as an adjacency matrix, vertices to hold vertices, and isDirected to indicate whether our graph is directed:

class Graph {
  matrix: number[][];
  vertices: GraphVertex[];
  isDirected: boolean;

  constructor(vertices: GraphVertex[], isDirected = true) {
    this.vertices = vertices;
    this.isDirected = isDirected;
    // ...
  }

  // ...
}

Initializing our adjacency matrix might look like this:

this.matrix = Array.from({ length: vertices.length }, () => {
  return Array.from({ length: vertices.length }, () => 0)
});

We'll have an array with the length of vertices. Each item in the array is an array with the length of vertices as well, but filled with zeroes.

In our example with four vertices, the initial adjacency matrix looks like this:

[ [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0] ]

Then, adding an edge is just marking the corresponding value as 1, so that we can represent a connection between two vertices:

this.matrix[this.vertices.indexOf(v1)][this.vertices.indexOf(v2)] = 1;

Note: This implementation assumes that all vertices are distinct.

If we have an undirected graph, we can have it both ways:

if (!this.isDirected) {
  this.matrix[this.vertices.indexOf(v2)][this.vertices.indexOf(v1)] = 1;
}

Removing an edge, in this case, will be just resetting the value to 0:

this.matrix[this.vertices.indexOf(v1)][this.vertices.indexOf(v2)] = 0;

And, checking for the existence of an edge is simply checking whether the corresponding value is 0 or not:

this.matrix[this.vertices.indexOf(v1)][this.vertices.indexOf(v2)] !== 0;

And, here is the whole example with additional methods for adding and removing an edge, checking if there is an edge between two vertices, and checking if a specific vertex is in the graph:

class Graph {
  matrix: number[][];
  vertices: GraphVertex[];
  isDirected: boolean;

  constructor(vertices: GraphVertex[], isDirected = true) {
    this.vertices = vertices;
    this.matrix = Array.from({ length: vertices.length }, () => {
      return Array.from({ length: vertices.length }, () => 0)
    });
    this.isDirected = isDirected;
  }

  addEdge(v1: GraphVertex, v2: GraphVertex) {
    this._checkVertexIsInGraph(v1);
    this._checkVertexIsInGraph(v2);

    this.matrix[this.vertices.indexOf(v1)][this.vertices.indexOf(v2)] = 1;

    if (!this.isDirected) {
      this.matrix[this.vertices.indexOf(v2)][this.vertices.indexOf(v1)] = 1;
    }
  }

  /* 
  For a weighted graph:

  addEdge(v1: GraphVertex, v2: GraphVertex, weight: number) {
    this._checkVertexIsInGraph(v1);
    this._checkVertexIsInGraph(v2);

    this.matrix[this.vertices.indexOf(v1)][this.vertices.indexOf(v2)] = weight;
    if (!this.isDirected) {
      this.matrix[this.vertices.indexOf(v2)][this.vertices.indexOf(v1)] = weight;
    }
  }
  */

  removeEdge(v1: GraphVertex, v2: GraphVertex) {
    this._checkVertexIsInGraph(v1);
    this._checkVertexIsInGraph(v2);

    this.matrix[this.vertices.indexOf(v1)][this.vertices.indexOf(v2)] = 0;

    if (!this.isDirected) {
      this.matrix[this.vertices.indexOf(v2)][this.vertices.indexOf(v1)] = 0;
    }
  }

  hasEdge(v1: GraphVertex, v2: GraphVertex) {
    this._checkVertexIsInGraph(v1);
    this._checkVertexIsInGraph(v2);

    return this.matrix[this.vertices.indexOf(v1)][this.vertices.indexOf(v2)] !== 0;
  }

  getAdjacencyMatrix() {
    return this.matrix;
  }

  _checkVertexIsInGraph(v: GraphVertex) {
    if (!this.vertices.includes(v)) {
      throw new Error('Vertex doesn\'t exist');
    }
  }
}


let a = new GraphVertex('A');
let b = new GraphVertex('B');
let c = new GraphVertex('C');
let d = new GraphVertex('D');

let graph = new Graph([a, b, c, d], false);

graph.addEdge(a, b);
graph.addEdge(a, c);
graph.addEdge(b, c);
graph.addEdge(c, d);

console.log(graph.getAdjacencyMatrix());
// -> [ [0, 1, 1, 0], [1, 0, 1, 0], [1, 1, 0, 1], [0, 0, 1, 0] ]

Operations on an adjacency matrix have \(O(1)\) time complexity. But our storage needs will be \(O(V^2)\) where \(V\) is the number of vertices.

Adjacency List

In an adjacency list, usually a hashmap or an array of linked lists is used. For example:

let graph = {
  'A': ['B', 'C'],
  'B': ['A', 'C'],
  'C': ['A', 'B', 'D'],
  'D': ['C']
}

Let's see how we can modify our code above to use an adjacency list instead.

Instead of having a matrix which is an array of arrays, we can have a Map that maps the vertices to an array of their neighbors.

We can initialize it as a map that has the vertices as keys, each of which has a value of an empty array for now:

this.list = new Map<GraphVertex, GraphVertex[]>();
for (const v of vertices) {
  this.list.set(v, []);
}

Adding an edge will be just pushing to the array of corresponding vertex:

this.list.get(v1)!.push(v2);

If our graph is undirected, we can do it both ways here as well:

if (!this.isDirected) {
  this.list.get(v2)!.push(v1);
}

Removing an edge will be deleting that vertex from the array:

this.list.set(v1, this.list.get(v1)!.filter(v => v !== v2));

Checking if an edge exists is just checking the existence of that vertex in the array:

this.list.get(v1)!.includes(v2);

Note: We're using a non-null assertion operator as we’re using TypeScript in these examples. As we'll see below, we first check if the vertex is in the graph. And since we're adding all the vertices in the graph as keys to this.list, we're sure that getting that vertex from the list is not undefined. But TypeScript will warn us because if a key is not found in a Map object, it could potentially return undefined.

Here is our graph:

class Graph {
  list: Map<GraphVertex, GraphVertex[]>;
  vertices: GraphVertex[];
  isDirected: boolean;

  constructor(vertices: GraphVertex[], isDirected = true) {
    this.vertices = vertices;
    this.list = new Map();
    for (const v of vertices) {
      this.list.set(v, []);
    }
    this.isDirected = isDirected;
  }

  addEdge(v1: GraphVertex, v2: GraphVertex) {
    this._checkVertexIsInGraph(v1);
    this._checkVertexIsInGraph(v2);

    this.list.get(v1)!.push(v2);

    if (!this.isDirected) {
      this.list.get(v2)!.push(v1);
    }
  }

  removeEdge(v1: GraphVertex, v2: GraphVertex) {
    this._checkVertexIsInGraph(v1);
    this._checkVertexIsInGraph(v2);

    this.list.set(v1, this.list.get(v1)!.filter(v => v !== v2));

    if (!this.isDirected) {
      this.list.set(v2, this.list.get(v2)!.filter(v => v !== v1));
    }
  }

  hasEdge(v1: GraphVertex, v2: GraphVertex) {
    this._checkVertexIsInGraph(v1);
    this._checkVertexIsInGraph(v2);

    return this.list.get(v1)!.includes(v2);
  }

  getAdjacencyList() {
    return this.list;
  }

  _checkVertexIsInGraph(v: GraphVertex) {
    if (!this.vertices.includes(v)) {
      throw new Error('Vertex doesn\'t exist');
    }
  }
}


let a = new GraphVertex('A');
let b = new GraphVertex('B');
let c = new GraphVertex('C');
let d = new GraphVertex('D');

let graph = new Graph([a, b, c, d], false);

graph.addEdge(a, b);
graph.addEdge(a, c);
graph.addEdge(b, c);
graph.addEdge(c, d);

console.log(graph.getAdjacencyList());

/* Output:

Map (4) {
  GraphVertex: { "value": "A" } => [
    GraphVertex: { "value": "B" }, 
    GraphVertex: { "value": "C" }
  ], 
  GraphVertex: { "value": "B" } => [
    GraphVertex: { "value": "A" }, 
    GraphVertex: { "value": "C" }
  ], 
  GraphVertex: { "value": "C" } => [
    GraphVertex: { "value": "A" }, 
    GraphVertex: { "value": "B" }, 
    GraphVertex: { "value": "D" }
  ], 
  GraphVertex: { "value": "D" } => [
    GraphVertex: { "value": "C" }
  ]
} 

*/

Getting the neighbors of a vertex is \(O(1)\) because we're just looking up a key in a map. But finding a particular edge can be \(O(d)\) where \(d\) is the number of degrees of the vertex, because we might need to traverse all the neighbors to find it. And, it could be \(V - 1\) where \(V\) is the number of vertices in the graph. It's the case when that vertex has all the other vertices as its neighbors.

The space complexity can be \(O(V + E)\) where \(V\) is the number of vertices and \(E\) is the number of edges.

Traversals

Continuing with the adjacency list representation, let's now take a look at two (very familiar) ways to traverse a graph: breadth-first search and depth-first search.

But first, we'll modify our graph a little bit. We'll add a new vertex 'E' and update some edges:

let a = new GraphVertex('A');
let b = new GraphVertex('B');
let c = new GraphVertex('C');
let d = new GraphVertex('D');
let e = new GraphVertex('E');


let graph = new Graph([a, b, c, d, e], false);

graph.addEdge(a, b);
graph.addEdge(a, c);
graph.addEdge(b, d);
graph.addEdge(c, e);

The important idea to remember is that there is no hierarchy of vertices, so we don't have a root node.

For a breadth-first or depth-first search, we can use an arbitrary node as a starting point.

Breadth-First Search

With our new graph, a breadth-first search traversal looks like this:

When it comes to breadth-first search, usually a queue is used, and the idea is simple: given a current node, we'll add the adjacent nodes first, marking them as visited as we go.

Inside the Graph class, we can implement a bfs method that does just that:

bfs(startNode: GraphVertex) {
  const visited = new Set();
  const queue = [startNode];
  visited.add(startNode);

  while (queue.length > 0) {
    const currentNode = queue.shift();
    // console.log(currentNode);
    this.list.get(currentNode as GraphVertex)!.forEach((node) => {
      if (!visited.has(node)) {
        visited.add(node);
        queue.push(node);
      }
    });
  }
}

If we call the bfs method with a as the starting vertex (graph.bfs(a)), and log currentNode to console each time we go, it's as we expected:

GraphVertex { value: 'A' }
GraphVertex { value: 'B' }
GraphVertex { value: 'C' }
GraphVertex { value: 'D' }
GraphVertex { value: 'E' }

With the adjacency list, using a BFS has \(O(V + E)\) time complexity (sum of the vertices and edges) as we're traversing the whole graph.

Depth-First Search

With the same modified graph, a depth-first search looks like this:

With depth-first search there is usually recursion involved as we're traversing through a path until we have visited all the nodes in that path. Once we hit a dead end, we'll backtrack and continue exploring until we have visited all the vertices in the graph.

Again, inside the Graph class, we can add a dfs method:

dfs(startNode: GraphVertex, visited = new Set()) {
  visited.add(startNode);
  // console.log(startNode);
  this.list.get(startNode)!.forEach((node) => {
    if (!visited.has(node)) {
      this.dfs(node, visited);
    }
  });
}

Starting with a node, we check how deep we can go from there. Once we reach a dead end (when the dfs inside forEach returns), we continue checking other neighbors (with forEach) until none is left. We essentially do the same thing until all the vertices are visited.

Logging the output matches our expectation:

GraphVertex { value: 'A' }
GraphVertex { value: 'B' }
GraphVertex { value: 'D' }
GraphVertex { value: 'C' }
GraphVertex { value: 'E' }

The time complexity for a depth-first search traversal of a graph is the similar to BFS, \(O(V + E)\).

Chapter Twelve: Dynamic Programming

Dynamic programming (DP) is one of those concepts that is a bit intimidating when you hear it for the first time. But the crux of it is simply breaking problems down into smaller parts and solving them. It’s also about storing those solutions so that we don't have to compute them again.

Breaking problems down into subproblems is nothing new – that's pretty much what problem-solving is all about. What dynamic programming is also specifically concerned with are overlapping subproblems that are repeating – we want to calculate solutions to those subproblems so that we won't be calculating them again each time. Put another way, we want to remember the past so that we won't be condemned to repeat it.

For example, calculating 1 + 1 + 1 + 1 + 1 is very easy if we have already calculated 1 + 1 + 1 + 1. We can just remember the previous solution, and use it:

Calculating the Fibonacci sequence is one of the well-known examples when it comes to dynamic programming. Because we have to calculate the same functions each time for a new number, it lends itself to DP very well.

For example, to calculate fib(4) we need to calculate fib(3) and fib(2). But calculating fib(3) also involves calculating fib(2), so we'll be doing the same calculation, again.

A classic, good old recursive Fibonacci function might look like this:

function fib(n: number): number {
  if (n === 0 || n === 1) {
    return n;
  }

  return fib(n - 1) + fib(n - 2);
}

Though the issue we have just mentioned remains: we'll keep calculating the same values:

But, we want to do better.

Memoization is remembering the problems we have solved before so that we don't have to solve them again and waste our time. We can reuse the solution to the subproblem we've already memoized. So, we can keep a cache to store those solutions and use them:

function fib(n: number, cache: Map<number, number>): number {
  if (cache.has(n)) {
    return cache.get(n)!;
  }

  if (n === 0 || n === 1) {
    return n;
  }

  const result = fib(n - 1, cache) + fib(n - 2, cache);
  cache.set(n, result);

  return result;
}

For example, we can initially pass an empty Map as the argument for cache, and print the first 15 Fibonacci numbers:

let m = new Map<number, number>();

for (let i = 0; i < 15; i++) {
  console.log(fib(i, m));
}

/*
  0
  1
  1
  2
  3
  5
  8
  13
  21
  34
  55 
  89
  144
  233
  377 
 */

There are two different approaches with dynamic programming: top-down and bottom-up.

Top-down is like what it sounds: starting with a large problem, breaking it down to smaller components, memoizing them. It's what we just did with the fib example.

Bottom-up is also like what it sounds: starting with the smallest subproblem, finding out a solution, and working our way up to the larger problem itself. It also has an advantage: with the bottom-up approach, we don't need to store every previous value – we can only keep the two elements at the bottom so that we can use them to build up to our target.

With the bottom-up approach, our fib function can look like this:

function fib(n: number) {
  let dp = [0, 1];
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }

  return dp[n];
}

Just note that we are keeping an array whose size will grow linearly as the input increases. So, we can do better with constant space complexity, not using an array at all:

function fib(n: number) {
  if (n === 0 || n === 1) {
    return n;
  }

  let a = 0;
  let b = 1;

  for (let i = 2; i <= n; i++) {
    let tmp = a + b;
    a = b;
    b = tmp;
  }

  return b;
}

Time and space complexity

The time complexities for both the top-down and bottom-up approaches in the Fibonacci example are \(O(n)\) as we solve each subproblem, each of which is of constant time.

Note: The time complexity of the recursive Fibonacci function that doesn't use DP is exponential (in fact, \(O(\phi^{n})\) – yes the golden ratio as its base).

But when it comes to space complexity, the bottom-up approach (the second version) is \(O(1)\).

Note: The first version we've used for the bottom-up approach has \(O(n)\) time complexity as we store the values in an array.

The top-down approach has \(O(n)\) space complexity because we store a Map whose size will grow linearly as n increases.

Chapter Thirteen: Intervals

An interval simply has a start and an end. The easiest way to think about intervals is as time frames.

With intervals, the usual concern is whether they overlap or not.

For example, if we have an interval [1, 3] and another [2, 5], they are clearly overlapping, so they can be merged together to create a new interval [1, 5]:

In order for two intervals not to overlap:

• the start of one should be strictly larger than the end of the other

newInterval[0] > interval[1]

Or:

• the end of the one should be strictly smaller than the start of the other

newInterval[1] < interval[0]

If both of these are false, they are overlapping.

If they are overlapping, the new (merged) interval will have the minimum value from both intervals as its start, and the maximum as its end:

[
  min(newInterval[0], interval[0]),
  max(newInterval[1], interval[1])
]

Chapter Fourteen: Bit Manipulation

A bitwise operation operates on a bit string, a bit array, or a binary numeral (considered as a bit string) at the level of its individual bits.

Let's first represent a number in binary (base 2). We can use toString method on a number, and specify the radix:

const n = 17;

console.log(n.toString(2)); // 10001

We can also parse an integer giving it a base:

console.log(parseInt(10001, 2)); // 17

Note: We can also represent a binary number with the prefix 0b:

console.log(0b10001); // 17
console.log(0b101); // 5

For example, these are the same number:

0b1 === 0b00000001 // true

All bitwise operations are performed on 32-bit binary numbers in JavaScript. That is, before a bitwise operation is performed, JavaScript converts numbers to 32-bit signed integers.

So, for example, 17 won't be simply 10001 but 00000000 00000000 00000000 00010001.

After the bitwise operation is performed, the result is converted back to 64-bit JavaScript numbers.

Bitwise operators

AND (&)

If two bits are 1, the result is 1, otherwise 0.

The GIFs below show the numbers as 8-bit strings, but when doing bitwise operations, remember they are converted to 32-bit numbers.

const x1 = 0b10001;
const x2 = 0b101;

const result = x1 & x2; // 1 (0b1)

OR (|)

If either of the bits is 1, the result is 1, otherwise 0.

const x1 = 0b10001;
const x2 = 0b101;

const result = x1 | x2; // 21 (0b10101)

XOR (^)

If the bits are different (one is 1 and the other is 0), the result is 1, otherwise 0.

const x1 = 0b10001;
const x2 = 0b101;

const result = x1 ^ x2; // 20 (0b10100)

NOT (~)

Flips the bits (1 becomes 0, 0 becomes 1).

const n = 17;

const result = ~n; // -18

Note: Bitwise NOTing any 32-bit integer x yields -(x + 1).

If we use a helper function to see the binary representations, it is as we expected:

console.log(createBinaryString(n));
// -> 00000000 00000000 00000000 00010001

console.log(createBinaryString(result));
// -> 11111111 11111111 11111111 11101110

The leftmost bit indicates the signal – whether the number is negative or positive.

Remember that we said JavaScript uses 32-bit signed integers for bitwise operations. The leftmost bit is 1 for negative numbers and 0 for positive numbers. Also, the operator operates on the operands' bit representations in two's complement. The operator is applied to each bit, and the result is constructed bitwise.

Note: Two's complement allows us to get a number with an inverse signal. One way to do it is to invert the bits of the number in the positive representation and add 1 to it:

function twosComplement(n) {
  return ~n + 0b1;
}

Left shift (zero fill) (<<)

Shifts the given number of bits to the left, adding zero bits shifted in from the right.

const n = 17;
const result = n << 1; // 34


console.log(createBinaryString(17));
// -> 00000000 00000000 00000000 00010001

console.log(createBinaryString(34));
// -> 00000000 00000000 00000000 00100010

Note that the 32nd bit (the leftmost one) is discarded.

Right shift (sign preserving) (>>)

Shifts the given number of bits to the right, preserving the sign when adding bits from the left.

const n = 17;
const result = n >> 1; // 8


console.log(createBinaryString(17));
// -> 00000000 00000000 00000000 00010001

console.log(createBinaryString(8));
// -> 00000000 00000000 00000000 00001000

const n = -17;
const result = n >> 1; // -9

console.log(createBinaryString(-17));
// -> 11111111 11111111 11111111 11101111

console.log(createBinaryString(-9));
// -> 11111111 11111111 11111111 11110111

Right shift (unsigned) (>>>)

Shifts the given number of bits to the right, adding 0s when adding bits in from the left, no matter what the sign is.

const n = 17;
const result = n >>> 1; // 8


console.log(createBinaryString(17));
// -> 00000000 00000000 00000000 00010001

console.log(createBinaryString(8));
// -> 00000000 00000000 00000000 00001000

const n = -17;
const result = n >>> 1; // 2147483639

console.log(createBinaryString(-17));
// -> 11111111 11111111 11111111 11101111

console.log(createBinaryString(2147483639));
// -> 01111111 11111111 11111111 11110111

Getting a bit

To get a specific bit, we first need to create a bitmask. We can do this by shifting 1 to the left by the index of the bit we want to get. The result is the AND of the binary number and the bitmask.

But using JavaScript, we can also do an unsigned right shift by the index to put the bit in the first place (so that we don't get the actual value that is in that position, but whether it is a 1 or a 0):

function getBit(number, idx) {
  const bitMask = 1 << idx;
  const result = number & bitMask;

  return result >>> idx;
}

For example, let's try 13, which is 1101 in binary:

const binaryNumber = 0b1101;

console.log('Bit at position 0:', getBit(binaryNumber, 0));
console.log('Bit at position 1:', getBit(binaryNumber, 1));
console.log('Bit at position 2:', getBit(binaryNumber, 2));
console.log('Bit at position 3:', getBit(binaryNumber, 3));

/*
Output:

Bit at position 0: 1
Bit at position 1: 0
Bit at position 2: 1
Bit at position 3: 1
*/

Setting a bit

If we want to turn a bit to 1 (in other words, to "set a bit"), we can do a similar thing.

First, we can create a bitmask again by shifting 1 to the left by the index of the bit we want to set to 1. The result is the OR of the number and the bitmask:

function setBit(number, idx) {
  const bitMask = 1 << idx;
  return number | bitMask;    
}

Remember that in our example 13 was 1101 in binary, let's say we want to set the 0 at index 1:

const binaryNumber = 0b1101;
const newBinaryNumber = setBit(binaryNumber, 1);

console.log(createBinaryString(newBinaryNumber));
// -> 00000000 00000000 00000000 00001111

console.log('Bit at position 1:', getBit(newBinaryNumber, 1));
// -> Bit at position 1: 1

Conclusion

With some detours here and there, we took a look at fourteen (or fifteen, if you count our interlude) different concepts, from arrays and hashing to bit manipulation.

Although I have to say that eventually, with time, it’s easy to forget all that we learned. But, that's not a problem in itself, because as you might have realized, if there is one idea that should stick with you with this handbook, it’s that problems are best solved when they are broken into smaller parts. And, as with anything else, writing or talking to yourself (see duck debugging) works miracles.

Now, it's time to take a deep breath.

It was a delightful adventure to explore data structures and algorithms, and hopefully you found some value in it.

Have a beautiful journey ahead, and until then, happy coding.

Resources & Credits

This handbook was mainly inspired by the amazing BaseCS series by Vaidehi Joshi, which is an incredible resource for learning basic computer science concepts.

The visualization idea was inspired by Lydia Hallie's JavaScript Visualized series.

Of course, you can also check out NeetCode's courses which can be incredibly helpful for a serious study.

There are many other resources to check out if you want to go further, here are some of the ones I used in our exploration:

• brilliant.org

• leetcodethehardway.com

• MDN Web Docs

• baeldung.com/cs

• The Absolute Essentials for Bit Manipulation in JavaScript by Lucas F. Costa

• Heap & HeapSort - Noriko Tomuro

• Heaps - Professor Reva Freedman

• "Using collections.deque to Create a Python Stack" - Jim Anderson

We just published a course on the freeCodeCamp.org YouTube channel that will teach you all about the essential programming concepts required for Cambridge A-Level Computer Science, with a focus on VB.NET implementation. This comprehensive course, developed by Moarz, provides clear and practical explanations of key topics such as Object-Oriented Programming (OOP), algorithms, and Abstract Data Types (ADTs). Whether you're preparing for an exam or looking to deepen your understanding of computer science fundamentals, this course offers valuable insights and hands-on coding demonstrations.

The course begins with an introduction to Object-Oriented Programming, covering fundamental principles such as classes, objects, inheritance, and polymorphism. These concepts are essential for writing modular and reusable code, which is a key skill in both academic and professional settings.

Next, the course covers algorithms, including essential searching and sorting techniques. Understanding algorithms is important for writing efficient code, and this section explains the logic behind popular methods such as bubble sort, quicksort, and binary search. By implementing these algorithms in VB.NET, learners can develop a solid grasp of computational thinking and problem-solving strategies.

The final section explores Abstract Data Types (ADTs), a core concept in computer science that involves data structures like linked lists and binary trees. ADTs help organize and manage data efficiently, making them essential for building complex software systems. The course breaks down these structures in an easy-to-understand way, demonstrating their real-world applications.

By the end of this course, you'll have a strong understanding of programming concepts that are critical for Cambridge A-Level Computer Science and beyond. Watch the full course on the freeCodeCamp.org YouTube channel (3-hour watch).

We first built the list in 2020 using a data-driven approach that we have used each year, including 2025. You can find the methodology below.

Methodology

First, we identified the leading world university rankings. Since we were interested in computer science specifically, he looked at their latest computer science rankings.

For the 2025 update, Suparn, my colleague used the same sources and methodology to find the top 60 universities offering online computer science courses.

Here are the rankings used:

• QS: World University Ranking 2025 — Computer Science & IT

• Times Higher Education: World University Ranking 2025 — Computer Science

Then, we crawled and scraped each ranking.

Now that we had some data, we used Jupyter with Python to process it. We combined the two rankings into one by averaging the position of each university in each ranking. Then, we filtered out the universities that didn’t offer online courses, and limited the list to the top 60 institutions — the cream of the crop.

Combined ranking: top 10 universities for studying computer science in 2024

As you can see above, we found that the top three institutions are #1 MIT,  #2 Oxford , and #3 Stanford.

Finally, we used the Class Central database, with its 250K online courses, to find all the computer science courses offered by the universities in the ranking.

The end result is a list of 1000+ online courses offered by the 60 best universities in the world for studying computer science in 2025.

Stats

• Enrollments range from 10 to over 13 million, with 14 courses exceeding 1 million enrollments

• Altogether, they have over 81M enrollments, with an average of 222K enrollments

• 921 courses are in English, 114 Chinese, 5 Spanish, and 3 French

• Together, they account for more than 78K reviews at Class Central, with an average of 216 reviews

• Average rating: 4.37 out of 5.0

• All these courses are free or can be audited for free

• 104 courses are beginner level, 111 are intermediate level, and 49 are advanced level.

More Courses

The full list is split into subjects. With over 1000 courses to pick from, I hope you find something you like. But if these aren’t enough, check out Class Central’s catalog of 250K online courses or our thematic collections:

• 2000+ Free Developer and IT Certifications

• Harvard Computer Science Courses with Free Certificate

• 40+ Free Certificates from Wolfram U

• 800+ Free Certificates: Master Tech & Soft Skills with CodeSignal Learn

• 10,000+ Free Courses from Tech Giants: Learn from Google, Microsoft, Amazon, and More

• 8000+ OpenCourseWare Courses from Top Institutions.

Computer Science (727)

• Harvard CS50 – Full Computer Science University Course from Harvard University ★★★★★(1012)

• CS50's Introduction to Computer Science from Harvard University ★★★★★(204)

• Artificial Intelligence from Massachusetts Institute of Technology ★★★★★(182)

• Introduction to Electrical Engineering and Computer Science I from Massachusetts Institute of Technology ★★★★★(58)

• Advanced Algorithms - COMPSCI 224 from Harvard University ★★★★★(35)

• Introduction to Artificial Intelligence from Stanford University ★★★★☆(31)

• Machine Learning with Python: from Linear Models to Deep Learning. from Massachusetts Institute of Technology ★★★☆☆(30)

• CS50's Introduction to Artificial Intelligence with Python from Harvard University ★★★★★(29)

• Data Structures & Algorithms I: ArrayLists, LinkedLists, Stacks and Queues from Georgia Institute of Technology ★★★★★(28)

• Introduction to Algorithms from Massachusetts Institute of Technology ★★★★★(25)

• CS50’s Computer Science for Business from Harvard University ★★★★★(21)

• Intro to Machine Learning from Stanford University ★★★★☆(20)

• Automata Theory from Stanford University ★★★★☆(20)

• Introduction to Deep Learning from Massachusetts Institute of Technology ★★★★★(20)

• Computer Science 101 from Stanford University ★★★★☆(19)

• Cryptocurrency Engineering and Design from Massachusetts Institute of Technology ★★★★★(19)

• Human-Computer Interaction I: Fundamentals & Design Principles from Georgia Institute of Technology ★★★★★(15)

• How to Code: Simple Data from The University of British Columbia ★★★★☆(15)

• Design of Computer Programs from Stanford University ★★★★☆(14)

• Unix Tools: Data, Software and Production Engineering from Delft University of Technology ★★★★★(13)

• AI for Clinical Trials and Precision Medicine - Ruishan Liu from Stanford University ★★★★★(11)

• Learning from Data (Introductory Machine Learning course) from California Institute of Technology ★★★★★(10)

• CS50's Computer Science for Lawyers from Harvard University ★★★★★(8)

• Information and Communication Technology (ICT) Accessibility from Georgia Institute of Technology ★★★★☆(8)

• Reinforcement Learning from Brown University ★★★☆☆(8)

• Machine Learning Fundamentals from University of California, San Diego ★★★★☆(8)

• Introduction to Computer Science and Programming in Python from Massachusetts Institute of Technology ★★★★★(8)

• Machine Learning from Georgia Institute of Technology ★★★★☆(7)

• Introduction to Computer Vision from Georgia Institute of Technology ★★★★★(7)

• Data Structures & Algorithms II: Binary Trees, Heaps, SkipLists and HashMaps from Georgia Institute of Technology ★★★★★(7)

• Performance Engineering of Software Systems from Massachusetts Institute of Technology ★★★★★(7)

• Convolutional Neural Networks for Visual Recognition from Stanford University ★★★★☆(7)

• Advanced Operating Systems from Georgia Institute of Technology ★★★★★(6)

• Introduction to Computer Architecture from Carnegie Mellon University ★★★★★(6)

• Computer Networking from Georgia Institute of Technology ★★★★☆(6)

• Data Structures & Algorithms III: AVL and 2-4 Trees, Divide and Conquer Algorithms from Georgia Institute of Technology ★★★★★(6)

• Machine Learning for Healthcare from Massachusetts Institute of Technology ★★★★★(6)

• MIT 6.824 Distributed Systems - Spring 2020 from Massachusetts Institute of Technology ★★★★★(6)

• Data Structures: An Active Learning Approach from University of California, San Diego ★★★★★(5)

• How to Code: Complex Data from The University of British Columbia ★★★★★(5)

• Data Structures & Algorithms IV: Pattern Matching, Dijkstra’s, MST, and Dynamic Programming Algorithms from Georgia Institute of Technology ★★★★★(5)

• Distributed Systems from University of Cambridge ★★★★★(5)

• Electrical and Computer Engineering - Systems Programming and Concurrency from University of Waterloo ★★★★☆(5)

• Human-Computer Interaction II: Cognition, Context & Culture from Georgia Institute of Technology ★★★★★(4)

• 6.S191: Introduction to Deep Learning from Massachusetts Institute of Technology ★★★★☆(4)

• Introduction to Computational Thinking and Data Science from Massachusetts Institute of Technology ★★★★★(4)

• AI and Education Summit: Transforming Learning and Workforce Readiness from Stanford University ★★★★★(4)

• Software Architecture & Design from Georgia Institute of Technology ★★★★★(3)

• Language, Proof and Logic from Stanford University ★★★★☆(3)

• Machine Learning: Unsupervised Learning from Brown University ★★★☆☆(3)

• Algorithmic Design and Techniques from University of California, San Diego ★★★★☆(3)

• Using Electronic Health Records for Better Care from Stanford University ★★★★★(3)

• Design & AI - Envisioning AI-Augmented Products from Stanford University ★★★★★(3)

• Stanford Seminar - Security and the Software Defined Network from Stanford University ★★★★☆(3)

• Stanford Seminar - Self-Driving Cars for Everyone from Stanford University ★★★★★(3)

• Stanford Seminar - Practical Blockchain Applications - Steven Pu from Stanford University ★★★★★(3)

• Stanford Webinar - IOT: From Smart Sensors to Smart Networks from Stanford University ★★★★★(3)

• Stanford Seminar - Gender Disparities in Software Engineering from Stanford University ★★★★☆(3)

• Introduction to Operating Systems from Georgia Institute of Technology ★★★★★(2)

• Human-Computer Interaction IV: Evaluation, Agile Methods & Beyond from Georgia Institute of Technology ★★★★★(2)

• Deep Learning for Natural Language Processing from University of Oxford ★★★★★(2)

• Software Engineering: Introduction from The University of British Columbia ★★★☆☆(2)

• Knowledge-Based AI: Cognitive Systems from Georgia Institute of Technology ★★★☆☆(2)

• The Quantum Internet and Quantum Computers: How Will They Change the World? from Delft University of Technology ★★★☆☆(2)

• 6.S094: Deep Learning for Self-Driving Cars from Massachusetts Institute of Technology ★★★★☆(2)

• Introduction to Algorithms (SMA 5503) from Massachusetts Institute of Technology ★★★★★(2)

• Introduction to Computer Science and Programming (Fall 2008) from Massachusetts Institute of Technology ★★★★★(2)

• Stanford - Human-Computer Interaction Seminar Series from Stanford University ★★★★★(2)

• How to Compute with Schrödinger's Cat - An Introduction to Quantum Computing from Stanford University ★★★★☆(2)

• Web3 Considered - Possible Futures for Decentralization and Digital Ownership from Stanford University ★★★★☆(2)

• Race, Technology, and Algorithmic Bias - Vision and Justice from Harvard University ★★★★★(2)

• Deep Learning Lecture Series from University College London ★★★★★(2)

• Towards Unsupervised Biomedical Image Segmentation Using Hyperbolic Representations - Jeffrey Gu from Stanford University ★★★★☆(2)

• Creating Human-Computer Partnerships - Stanford Seminar from Stanford University ★★★★★(2)

• Stanford Seminar - Decision Transformer: Reinforcement Learning via Sequence Modeling from Stanford University ★★★★★(2)

• Computability, Complexity & Algorithms from Georgia Institute of Technology ★★★★★(1)

• High Performance Computer Architecture from Georgia Institute of Technology ★★★★★(1)

• Health Informatics: A Current and Historical Perspective from Georgia Institute of Technology ★★★★★(1)

• Human-Computer Interaction III: Ethics, Needfinding & Prototyping from Georgia Institute of Technology ★★★★★(1)

• Compilers from Stanford University ★★★★★(1)

• Introduction to Graduate Algorithms from Georgia Institute of Technology ★★★★★(1)

• Software Construction: Object-Oriented Design from The University of British Columbia ★★☆☆☆(1)

• Introduction to Scientific Machine Learning from Purdue University ★★★★☆(1)

• Software Construction: Data Abstraction from The University of British Columbia ★★★☆☆(1)

• Machine Learning for Semiconductor Quantum Devices from Delft University of Technology ★★★★☆(1)

• Data Structures and Algorithm Design Part II | 数据结构与算法设计(下) from Tsinghua University ★★★★★(1)

• Introduction to Computational Science and Engineering from Massachusetts Institute of Technology ★★★★☆(1)

• Nature, in Code: Biology in JavaScript from École Polytechnique Fédérale de Lausanne ★★★☆☆(1)

• Introduction to Algorithms from Massachusetts Institute of Technology ★★★★☆(1)

• Mathematics for Computer Science from Massachusetts Institute of Technology ★★★★☆(1)

• Design and Analysis of Algorithms from Massachusetts Institute of Technology ★★★★★(1)

• Introduction to Computer Science and Programming (Spring 2011) from Massachusetts Institute of Technology ★★★★★(1)

• Boltzmann Law: Physics to Computing from Purdue University ★★★★☆(1)

• Deep Learning for Computer Vision from University of Michigan ★★★★★(1)

• Quantum Computer Systems Design III: Working with Noisy Systems from The University of Chicago ★★★★☆(1)

• Understanding the World Through Data from Massachusetts Institute of Technology ★★★★☆(1)

• Learning and Memory from Yale University ★★★★★(1)

• Beyond Cryptocurrency: Blockchain for the Real World from Stanford University ★★★★☆(1)

• Dive Into the World of Blockchain: Principles, Mechanics, and Tokens from University of Toronto ★★★☆☆(1)

• Rethinking the AI-UX Boundary for Designing Human-AI Experiences from Stanford University ★★★★★(1)

• How ChatGPT and Generative AI Will Shape the Future of Work from Stanford University ★☆☆☆☆(1)

• Stanford Seminar - How Not to Generate Random Numbers from Stanford University ★★★★★(1)

• Stanford Seminar - Building the Smartest and Open Virtual Assistant to Protect Privacy - Monica Lam from Stanford University ★★★★★(1)

• Tuning GPT-3 on a Single GPU via Zero-Shot Hyperparameter Transfer from Massachusetts Institute of Technology ★★★★★(1)

• MIT: Recurrent Neural Networks from Alexander Amini ★★★★★(1)

• Wireless Above 100GHz from New York University (NYU) ★★★☆☆(1)

• Generalization and Personalization in Federated Learning - Karan Singhal from Stanford University ★★★★★(1)

• MedAI- Graph-Based Modeling in Computational Pathology - Siyi Tang from Stanford University ★★★★★(1)

• Synthetic Data Sets for the Financial Industry from Stanford University ★★★★☆(1)

• Learning Controllers - From Engineering to AGI from Massachusetts Institute of Technology ★★★★☆(1)

• Stanford Seminar - Google's Multilingual Neural Machine Translation System from Stanford University ★★★★★(1)

• Deep Generative Modeling from Alexander Amini ★★★★★(1)

• Regulatory Evaluation of Image Processing Software Devices from Yale University ★★★★★(1)

• Edge Computing in Autonomous Vehicles - Panel Discussion from Stanford University ★★★★☆(1)

• Finding Fairness - Incorporating Societal Values in Computer Algorithms from Harvard University ★★★☆☆(1)

• Exploring the Implications of Machine Learning for Cognitive Disabilities from Stanford University ★★★★★(1)

• AI in Molecular Imaging from Yale University ★★★★★(1)

• Stanford Seminar - Toward Scalable Autonomy - Aleksandra Faust from Stanford University ★★★★☆(1)

• Pioneering the Science of Information - IBM's Role in Shaping Information Technology from University of Melbourne ★★★★★(1)

• The Soul of a New Machine - Rethinking the Computer from Stanford University ★★★★☆(1)

• Data Compression I - Lecture 2: Prefix Free Codes from Stanford University ★★★★★(1)

• Feedback Control from Pixels from Massachusetts Institute of Technology ★★★☆☆(1)

• Visualization for Machine Learning - Google Brain from Alexander Amini ★★★★★(1)

• The Information Age and The Age of Creation from Stanford University ★★★★★(1)

• Algorithms: Design and Analysis, Part 1 from Stanford University

• Cyber-Physical Systems Design & Analysis from Georgia Institute of Technology

• Artificial Intelligence from Georgia Institute of Technology

• Introduction to Quantum Computing from The University of British Columbia

• Human-Computer Interaction from Georgia Institute of Technology

• Hacker Tools from Massachusetts Institute of Technology

• High Performance Computing from Georgia Institute of Technology

• Programming & Data Structures from Columbia University

• AI for Teacher Assistance from Georgia Institute of Technology

• Algorithms: Design and Analysis, Part 2 from Stanford University

• Introduction to Blockchain Technology and Applications from University College London

• Machine Learning and AI with Python from Harvard University

• AI skills: Introduction to Unsupervised, Deep and Reinforcement Learning from Delft University of Technology

• Health Informatics: Data and Interoperability Standards from Georgia Institute of Technology

• Development and Applications of Germanium Quantum Technologies from Delft University of Technology

• Ethics in AI Design from Delft University of Technology

• Computer Applications of Artificial Intelligence and e-Construction from Purdue University

• AI skills for Engineers: Supervised Machine Learning from Delft University of Technology

• AI at the Edge on Arm: Understanding and Deploying LLMs for Mobile Devices from Arm Education

• Compilers: Theory and Practice from Georgia Institute of Technology

• Image Processing and Analysis for Life Scientists from École Polytechnique Fédérale de Lausanne

• Assessment Design with AI from Georgia Institute of Technology

• Introduction to Deep Learning from Purdue University

• Chatbots for Instruction from Georgia Institute of Technology

• Complex Problem Structuring: a Socio-Technical Perspective from Delft University of Technology

• Machine Learning from Georgia Institute of Technology

• Health Informatics: The Cutting Edge from Georgia Institute of Technology

• Computer Graphics II: Rendering from University of California, San Diego

• Computer Graphics from University of California, San Diego

• IoT Systems and Industrial Applications with Design Thinking from École Polytechnique Fédérale de Lausanne

• Introduction to Quantum Computing for Everyone from The University of Chicago

• Statistical Machine Learning from Carnegie Mellon University

• Fundamentals of Quantum Information from Delft University of Technology

• Applied Quantum Computing I: Fundamentals from Purdue University

• Accessible Gamification from Georgia Institute of Technology

• Applied Quantum Computing III: Algorithm and Software from Purdue University

• Data Structures Fundamentals from University of California, San Diego

• Computer Vision for Embedded Systems from Purdue University

• Graph Algorithms from University of California, San Diego

• Self-Driving Cars with Duckietown from ETH Zurich

• Machine Learning Use Cases in Finance from Université de Montréal

• Quantum Detectors and Sensors from Purdue University

• Fundamentals of TinyML from Harvard University

• Introduction to Quantum Computing for Everyone 2 from The University of Chicago

• Applications of Machine Learning in Plant Science from Cornell University

• Deep Learning Essentials from Université de Montréal

• Deploying TinyML from Harvard University

• Applied Quantum Computing II: Hardware from Purdue University

• MLOps for Scaling TinyML from Harvard University

• AI in Healthcare. Hype or Help? from KU Leuven University

• Quantum Communication and the Quantum Network Explorer from Delft University of Technology

• Quantum-safe Digital Infrastructures: Technical Challenges and Solutions from Delft University of Technology

• Applications of TinyML from Harvard University

• Quantum Computer Systems Design I: Intro to Quantum Computation and Programming from The University of Chicago

• Introduction à l'éthique de l’IA from Université de Montréal

• Bias and Discrimination in AI from Université de Montréal

• Explore Trading and Lending in Decentralized Finance from University of Toronto

• Quantum Computer Systems Design II: Principles of Quantum Architecture from The University of Chicago

• Data Structures and Algorithm Design Part I | 数据结构与算法设计(上) from Tsinghua University

• Quantum-safe Digital infrastructures: Challenges and Solutions for Governance from Delft University of Technology

• AI in Practice: Preparing for AI from Delft University of Technology

• LAFF-On Programming for High Performance from The University of Texas at Austin

• Modern Distributed Systems from Delft University of Technology

• GT - Refresher - Advanced OS from Georgia Institute of Technology

• Biais et discrimination en IA from Université de Montréal

• Techniques d’intelligence artificielle : des fondements aux applications from Université de Montréal

• The Society of Mind from Massachusetts Institute of Technology

• Introduction à l'apprentissage profond from Université de Montréal

• Advanced Data Structures from Massachusetts Institute of Technology

• NP-Complete Problems from University of California, San Diego

• String Processing and Pattern Matching Algorithms from University of California, San Diego

• Blockchain Technology and the Future of FinTech from University of Toronto

• Quantum Hardware and its Applications with Quantum Inspire from Delft University of Technology

• 计算几何 | Computational Geometry from Tsinghua University

• LAFF – On Programming for Correctness from The University of Texas at Austin

• L'essentiel de l'apprentissage profond from Université de Montréal

• Vision artificielle et exploitation intelligente des ressources naturelles from Université de Montréal

• Les coulisses des systèmes de recommandation from Université de Montréal

• Cryptocurrency Engineering and Design - Spring 2018 from Massachusetts Institute of Technology

• AI to Understand and Connect People from KU Leuven University

• AI in Practice: Applying AI from Delft University of Technology

• Big Data Machine Learning | 大数据机器学习 from Tsinghua University

• Introduction to Computers - Stanford University from Stanford University

• Navigating complex health data challenges from University of Cambridge

• Recommender Systems: Behind the Screen from Université de Montréal

• Navigating Decentralized Derivatives and Governance in Blockchain from University of Toronto

• How You Can Use ChatGPT to Increase Your Creative Output from Stanford University

• Optimization: principles and algorithms - Network and discrete optimization from École Polytechnique Fédérale de Lausanne

• Stanford CS229 - Machine Learning Full Course Taught by Andrew Ng - Autumn 2018 from Stanford University

• Deep Learning in Life Sciences - Spring 2021 from Massachusetts Institute of Technology

• 算法基础 | Fundamental Algorithms from Peking University

• Optimization: principles and algorithms - Unconstrained nonlinear optimization from École Polytechnique Fédérale de Lausanne

• Introduction to Computational Thinking from Massachusetts Institute of Technology

• Artificial Intelligence - Principles and Techniques - Autumn 2019 from Stanford University

• Introduction to EECS I from Massachusetts Institute of Technology

• The Battlecode Programming Competition from Massachusetts Institute of Technology

• Geometric Folding Algorithms: Linkages, Origami, Polyhedra from Massachusetts Institute of Technology

• AI and Law: Implications for Society and Legal Systems from Stanford University

• Artificial Intelligence for Business Leaders from Stanford University

• Programming for the Puzzled (January IAP 2018) from Massachusetts Institute of Technology

• Stanford Seminar - Software-Defined Networking at the Crossroads from Stanford University

• Information Technology as an Integrating Force in Manufacturing from Massachusetts Institute of Technology

• Multicore Programming Primer from Massachusetts Institute of Technology

• 理论计算机科学基础 | Introduction to Theoretical Computer Science from Peking University

• Artificial Intelligence - Current and Future Paradigms and Implications from Stanford University

• Theory of Computation, Fall 2020 from Massachusetts Institute of Technology

• Cryptocurrencies and Blockchains - The Science Behind the Technology from Stanford University

• Introduction to CS and Programming using Python from Massachusetts Institute of Technology

• Stanford Seminar - Deep Learning for Medical Diagnoses from Stanford University

• Stanford Seminar - Transformers in Language: The Development of GPT Models Including GPT-3 from Stanford University

• Introduction to the Theory of Computing - Stanford from Stanford University

• Stanford Seminar - The FATE of AI Ethics, Anna Bethke from Stanford University

• Stanford Seminar - Designing Assistive Technologies for Agency from Stanford University

• Algorithmic Lower Bounds: Fun with Hardness Proofs from Massachusetts Institute of Technology

• Software-Centric Visible Light Communication for the Internet of Things from Stanford University

• How to Use ChatGPT to Increase Your Creative Output - Part Two from Stanford University

• MIT Introduction to Deep Learning from Alexander Amini

• Stanford CS330: Deep Multi-Task and Meta Learning from Stanford University

• Machine Learning Course from California Institute of Technology

• Using Data for Increased Realism with Haptic Modeling and Devices from Stanford University

• Stanford Seminar - Deep Learning in Speech Recognition from Stanford University

• The Future of Blockchain and Cryptocurrencies - Dan Boneh from Stanford University

• AI in the Workplace: Rethinking Skill Development from Stanford University

• AI Bias and Fairness from Alexander Amini

• Stanford Seminar - Natural Language Processing for Conversational Interfaces from Stanford University

• Stanford Seminar - Bugs in Crypto Implementations from Stanford University

• The Artful Design of Interactive AI Systems from Stanford University

• Artificial Intelligence Planning from University of Edinburgh

• Deep Generative Modeling from Alexander Amini

• MIT: Reinforcement Learning from Alexander Amini

• How AI Is Turning Your Smartphone Into the Swiss Army Knife of Clinical Diagnostics from Yale University

• Stanford CS234: Reinforcement Learning - Winter 2019 from Stanford University

• Stanford Seminar - Representation Learning for Autonomous Robots, Anima Anandkumar from Stanford University

• Stanford Seminar - Creating Interfaces with Rich Physical Properties Through Digital Fabrication from Stanford University

• How Machine Learning is Changing Software from Stanford University

• AI in Healthcare from Alexander Amini

• Machine Learning with Graphs - Fall 2019 from Stanford University

• Stanford Seminar - Enabling NLP, Machine Learning, and Few-Shot Learning Using Associative Processing from Stanford University

• Smart Physical Systems from the Standpoint of an AI Company from Stanford University

• Stanford Seminar - Can the Brain Do Back-Propagation? from Stanford University

• Frontiers of Medical AI - Therapeutics and Workflows from Stanford University

• Agentic AI: A Progression of Language Model Usage from Stanford University

• Data Augmentation for Image-Based Reinforcement Learning from Massachusetts Institute of Technology

• MIT EI Seminar - Phillip Isola - Emergent Intelligence- Getting More Out of Agents Than You Bake In from Massachusetts Institute of Technology

• MIT 6.S191 - Automatic Speech Recognition from Alexander Amini

• Theory of Computation from Massachusetts Institute of Technology

• 算法设计与分析(高级) | Advanced Design and Analysis of Algorithms from Peking University

• Deep Maths - Machine Learning and Mathematics from University of Oxford

• Forecasting and Aligning AI - Jacob Steinhardt from Stanford University

• Deep Learning for Symbolic Mathematics - Guillaume Lample & Francois Charton from Stanford University

• Stanford Seminar - Neural Networks on Chip Design from the User Perspective from Stanford University

• Solana Larsen- Who Has Power Over AI? from Stanford University

• Stanford Seminar - Rebooting the Internet from Stanford University

• Federated Learning in Medicine - Breaking Down Silos to Advance Medical Research from Stanford University

• Large Language Models - Will They Keep Getting Bigger? from Massachusetts Institute of Technology

• Jacob Andreas - Natural Language Explanations of Deep Networks from Massachusetts Institute of Technology

• Diverse Data and Efficient Algorithms for Robot Learning from Massachusetts Institute of Technology

• Towards AI for 3D Content Creation from Alexander Amini

• 6.036 Introduction to Machine Learning from Massachusetts Institute of Technology

• The Creativity Code - Marcus du Sautoy from University of Oxford

• Stanford Seminar - Training Classifiers with Natural Language Explanations from Stanford University

• Stanford Seminar - New Golden Age for Computer Architecture - John Hennessy from Stanford University

• Stanford Seminar - Applying Theory to Practice and Practice to Theory from Stanford University

• Weakly-Supervised, Large-Scale Computational Pathology for Diagnosis and Prognosis - Max Lu from Stanford University

• Federated Hyperparameter Tuning - Challenges, Baselines, and Connections from Stanford University

• Stanford Seminar - What's Next for Blockchain in China? from Stanford University

• Artificial Intelligence - The Future of Medicine and Health Care Is Here from Stanford University

• Neurosymbolic AI from Alexander Amini

• Beyond Deep Learning - Learning+Reasoning from Alexander Amini

• Sequence Modeling with Neural Networks from Alexander Amini

• Stanford Seminar - Lenia- Biology of Artificial Life, Bert Wang-Chak Chan from Stanford University

• Stanford Seminar - Scalable Intelligent Systems Build and Deploy by 2025 from Stanford University

• Stanford Seminar - Erudite: Prototype System for Computational Intelligence from Stanford University

• Stanford Seminar - Safe Passwords Made Easy to Use from Stanford University

• Computational Memory - A Stepping-Stone to Non-Von Neumann Computing? from Stanford University

• Stanford Seminar - The Quest for Low Storage Latency Changes Everything from Stanford University

• Stanford Seminar - The REX Neo Architecture - An Energy Efficient New Processor Architecture from Stanford University

• Stanford Seminar - Citadel of One- Individuality and the Rise of the Machines, Suzanne Sadedin from Stanford University

• Dynamic Code Optimization and the NVIDIA Denver Processor from Stanford University

• Stanford Seminar - Instruction Sets Should Be Free- The Case for RISC-V from Stanford University

• Multimodal Opportunistic Risk Assessment for Ischemic Heart Disease - Juan Manuel from Stanford University

• Rethinking Architecture Design for Data Heterogeneity in FL - Liangqiong Qu from Stanford University

• Few-Shot Chest X-Ray Diagnosis Using Clinical and Literature Images from Stanford University

• Data-Efficient AI for Accelerating MRI Acquisition from Stanford University

• Hacking AI - Security & Privacy of Machine Learning Models from Stanford University

• Stanford CS229 - Machine Learning - Summer 2019 - Kernel Methods & Support Vector Machine from Stanford University

• Create a Better User Experience Through AI - Michael Bernstein from Stanford University

• NVIDIA GPU Computing - A Journey from PC Gaming to Deep Learning from Stanford University

• AI Transforms Health Care - The Future of Medicine and Health Care from Stanford University

• Computer Science and IT at the University of Melbourne - Faculty of Engineering and IT Overview from University of Melbourne

• CS50 2012 - Week 3 Continued: Search Algorithms and Sorting Techniques from Harvard University

• EI Seminar - Recent Papers in Embodied Intelligence from Massachusetts Institute of Technology

• Computational Principles Underlying the Learning of Sensorimotor Repertoires from Massachusetts Institute of Technology

• Intuitive Reasoning as Unsupervised Neural Generation from Massachusetts Institute of Technology

• The Lottery Ticket Hypothesis - Michael Carbin from Massachusetts Institute of Technology

• Recurrent Neural Networks and Transformers from Alexander Amini

• MIT: Introduction to Deep Learning from Alexander Amini

• Introduction to Deep Learning from Alexander Amini

• Advanced Topics in Cryptography from Massachusetts Institute of Technology

• Stanford Seminar - Failures & Where to Find Them: Considering Safety as a Function of Structure from Stanford University

• Denoising Diffusion Models for Denoising Diffusion MRI - Tiange Xiang from Stanford University

• Real-Time Seizure Detection Using EEG - Hyewon Jeong from Stanford University

• Deep Learning Methods for Electrocardiograms and Echocardiograms from Stanford University

• Towards Generalist Imaging Using Multimodal Self-Supervised Learning - Mars Huang from Stanford University

• The New Role of Physics Simulation in AI from Stanford University

• Stanford Seminar - Human-AI Interaction Under Societal Disagreement from Stanford University

• Inequality in Healthcare: Using AI and Data Science to Reduce Disparities from Stanford University

• Stanford Seminar - Taraxa.io: A Globalized Blockchain Protocol Startup from Stanford University

• Cybersecurity in the Modern Era - Zero Knowledge Proofs Explained from Stanford University

• Generative AI for Multimodal Biomedicine from Stanford University

• Building Embodied Autonomous Agents from Massachusetts Institute of Technology

• Machine Learning for Scent from Alexander Amini

• Introduction to Deep Learning from Alexander Amini

• Convolutional Neural Networks from Alexander Amini

• Convolutional Neural Networks from Alexander Amini

• Introduction to Deep Learning - MIT 2018 from Alexander Amini

• Improved Ultrasound Image Formation - Domain Adaptation With No Data from Yale University

• ChatGPT pour tous from Université de Montréal

• Stanford Seminar - Leela: A Semantic Intelligent Agent from Stanford University

• Stanford Seminar - An Architect's Point of View on Emerging Technologies from Stanford University

• Stanford Seminar - Dialog Markets from Stanford University

• Stanford Seminar - Time Traveling Hardware and Software Systems from Stanford University

• Stanford Seminar - Concepts and Questions as Programs from Stanford University

• Voices in the Code - A Story About People, Their Values, and the Algorithm They Made from Stanford University

• Against Ethical Robots with Ron Chrisley from Stanford University

• Stanford Seminar - Is Google Search Dying? from Stanford University

• The Race for Technological Supremacy - Emerging Technologies and Global Implications from Stanford University

• Stanford Seminar - Fastai: A Layered API for Deep Learning from Stanford University

• Deep Learning - Class Introduction and Logistics - Lecture 1 from Stanford University

• How is AI Evolving? A Look at the Startup Landscape in the U.S. and Asia from Stanford University

• Entrepreneurial Lessons from Self-Driving Cars from Stanford University

• Stanford Seminar - Transformers United: Neuroscience-Inspired Artificial Intelligence from Stanford University

• Overview of Transformers - Stanford CS25: Lecture 1 from Stanford University

• Language Models as Temporary Training Wheels to Facilitate Learning from Stanford University

• Can You Trust a Computer Algorithm - How and Why from University of Melbourne

• Recent Papers in Embodied Intelligence I from Massachusetts Institute of Technology

• Deep Learning New Frontiers from Alexander Amini

• Deep Learning Limitations and New Frontiers from Alexander Amini

• Computer Vision Meets Social Networks from Alexander Amini

• MIT: Deep Reinforcement Learning from Alexander Amini

• MIT 6.S191 - Deep Learning Limitations and New Frontiers from Alexander Amini

• Modeling Prior Information to Guide Image Reconstruction in Radiation Therapy from Yale University

• Ideas for a Complex World - Anna Seigal from University of Oxford

• GGP Course Videos from Stanford University

• Stanford Seminar - Persistent and Unforgeable Watermarks for Deep Neural Networks from Stanford University

• Stanford Seminar - MIPS Open, Wave Computing from Stanford University

• Stanford Seminar - Efficient and Resilient Systems in the Cognitive Era from Stanford University

• Stanford Seminar - Distributed Perception and Learning Between Robots and the Cloud from Stanford University

• Stanford Seminar: Computational Ecosystems from Stanford University

• Stanford Seminar - HPC Opportunities in Deep Learning - Greg Diamos, Baidu from Stanford University

• Stanford Seminar - Mostly Missless Memory in the Mill CPU from Stanford University

• GANs in Medical Image Synthesis, Translation, and Augmentation - Jason Jeong from Stanford University

• Self-Training - Weak Supervision Using Untrained Neural Nets for MR Reconstruction - Beliz Gunel from Stanford University

• Segmentation and Quantification of Breast Arterial Calcifications - Xiaoyuan Guo from Stanford University

• How Can You Trust Machine Learning? from Stanford University

• Learning to See the Physical World from Stanford University

• Optimizing the Internet from Stanford University

• Lessons From Evaluating and Debugging Healthcare AI in Deployment from Stanford University

• How Can You Trust Machine Learning? from Stanford University

• Safety and Liveness of Robot Behaviors from Stanford University

• Stanford Seminar - Microprocessors from Stanford University

• Deep Learning Full-Cycle Projects - Lecture 3 from Stanford University

• Deep Learning Intuition - Lecture 2 from Stanford University

• Stanford Seminar - Virtual Human Agent for Smart City from Stanford University

• Leveraging Social Theories to Enhance Human-AI Interaction from Stanford University

• Twintrees, Baxter Permutations, and Floorplans in Computer Science - Lecture 2022 from Stanford University

• The State of Design Knowledge in Human-AI Interaction from Stanford University

• SleepFM - Multi-modal Representation Learning for Sleep Across Brain Activity, ECG and Respiratory Signals from Stanford University

• AI's Global Impact on Democracy and Governance from Stanford University

• AI's Role in Improving Health Care Services in Our Communities from Stanford University

• Learn About: Google's AI-Powered Learning Tool - HAI Seminar from Stanford University

• Accounting for Human Engagement Behavior to Enhance AI-Assisted Decision Making from Stanford University

• The Task Specification Problem from Massachusetts Institute of Technology

• Generalizable Autonomy for Robot Manipulation from Alexander Amini

• MIT 6.S191 - Recurrent Neural Networks from Alexander Amini

• Reinforcement Learning from Alexander Amini

• Convolutional Neural Networks from Alexander Amini

• Deep Generative Modeling from Alexander Amini

• Biologically Inspired Neural Networks from Alexander Amini

• Deep Generative Modeling from Alexander Amini

• Reinforcement Learning from Alexander Amini

• 计算机文化基础 from Tsinghua University

• AI and Industrial Innovation from Tsinghua University

• Apprivoiser l’apprentissage automatique from Université de Montréal

• Stanford Seminar - SMILE- Synchronized, Multi-sensory Integrated Learning Environment from Stanford University

• Instruction Execution on the Mill CPU from Stanford University

• Opioid Use Disorder Prediction Using AI and Existing Risk Models from Stanford University

• Explaining Model Decisions and Fixing Them Through Human Feedback from Stanford University

• Fairness in Representation Learning - Natalie Dullerud from Stanford University

• Generative Models With Domain Knowledge for Weakly Supervised Clustering from Stanford University

• Domain Adaptation with Invariant Representation Learning - What Transformations to Learn? from Stanford University

• Optimizing for Interpretability in Deep Neural Networks - Mike Wu from Stanford University

• Adversarial Debiasing With Partial Learning - Medical Image Studies from Stanford University

• MedAI - Training Medical Image Segmentation Models with Less Labeled Data - Sarah Hooper from Stanford University

• Observational Supervision for Medical Image Classification from Stanford University

• Multimodal Medical Research of Vision and Language - Jean-Benoit Delbrouck from Stanford University

• Style Transfer Augmentations for Computational Pathology - Rikiya Yamashita from Stanford University

• Learning the Structure of EHR with Graph Convolutional Transformer - Edward Choi from Stanford University

• Why Would We Want a Multi-Agent System Unstable from Stanford University

• Stanford Lecture - Don Knuth - Twintrees, Baxter Permutations, and Floorplans (2022) from Stanford University

• Stanford Seminar 2022 - Self Attention and Non-Parametric Transformers from Stanford University

• Stanford Seminar - Accelerating ML Recommendation with Over a Thousand RISC-V-Tensor Processors from Stanford University

• Stanford Seminar - Finding the Great Problems from Stanford University

• Deep Learning - Adversarial Attacks and GANs - Lecture 4 from Stanford University

• Information Theory of Deep Learning - Naftali Tishby from Stanford University

• Scoring News Articles to Fight Misinformation from Stanford University

• The Evolution of Public Key Cryptography from Stanford University

• Stanford Lecture - Don Knuth - "A Conjecture That Had To Be True" from Stanford University

• Stanford Seminar - Time Well Spent, Tristan Harris from Stanford University

• Stanford Seminar - Swiss Computer Systems from Stanford University

• Stanford Seminar - Challenges in Secure Messaging from Stanford University

• GPS for Humanity - Stanford Engineering Hero Lecture from Stanford University

• Algorithmic Governance: Auditing Search and Recommendation Algorithms for Problematic Content from Stanford University

• Beyond LLMs - Agents, Emergent Abilities, Intermediate-Guided Reasoning, and BabyLM - Stanford CS25 from Stanford University

• Stanford CS236: Deep Generative Models - Score Based Diffusion Models - Lecture 16 from Stanford University

• Deep Generative Models - Maximum Likelihood Learning - Lecture 4 from Stanford University

• Intuitions on Language Models and Shaping AI's Future - Stanford CS25 Lecture from Stanford University

• The Human Factors of Formal Methods - Stanford Seminar from Stanford University

• From Large Language Models to Large Multimodal Models - Stanford CS25 - Lecture 4 from Stanford University

• When Design Equals Planning - Computational Approaches to Robot Design from Stanford University

• Holistic OR Domain Modeling with Large Vision Language Models - MedAI #120 from Stanford University

• AI-Driven Advancements in Mammogram Analysis - MedAI #119 from Stanford University

• Role of Instruction-Tuning and Prompt Engineering in Clinical Domain - MedAI 125 from Stanford University

• Large Scale Multi-Microscope Datasets and Their Challenges in Medical AI from Stanford University

• Open-world Segmentation and Tracking in 3D from Stanford University

• Me-LLaMA - Medical Foundation Large Language Models for Comprehensive Text Analysis and Beyond from Stanford University

• Creating Fair, Useful, and Reliable AI in Healthcare from Stanford University

• AI and Access to Justice from Stanford University

• Large Language Models in 2025 - How Much Understanding and Intelligence? from Stanford University

• Using Far from Perfect ML to Help Patients - A Billion Medical Devices from Stanford University

• Public AI Assistant to Worldwide Knowledge - Performing Interactive Tasks Under Developer Control from Stanford University

• Information, Calcul, Communication: Introduction à la pensée informatique from École Polytechnique Fédérale de Lausanne

• Getting Robust - Securing Neural Networks Against Adversarial Attacks from University of Melbourne

• Convolutional Neural Networks from Alexander Amini

• Deep Learning New Frontiers from Alexander Amini

• Evidential Deep Learning and Uncertainty from Alexander Amini

• Deep CPCFG for Information Extraction from Alexander Amini

• Taming Dataset Bias via Domain Adaptation from Alexander Amini

• MIT 6.S191 - Recurrent Neural Networks from Alexander Amini

• Lessons From the Regulatory Process for Medical Software for Image Analysis and AI from Yale University

• Model-Based Deep Learning - Beyond Unrolling from Yale University

• 区块链和加密数字货币 from Tsinghua University

• 软件工程 from Tsinghua University

• Data Structures and Algorithm Design Part I from Tsinghua University

• AI and Ethical Governance from Tsinghua University

• A Reinforcement Learning Mechanism for Trading Wind Power Futures from New York University (NYU)

• The Evolution of Public Key Cryptography from New York University (NYU)

• The Era of Artificial Intelligence from New York University (NYU)

• Statistical Physics, Neural Networks, and Neuroscience: From Then to Now from New York University (NYU)

• Information Theory: Huffman and Arithmetic Codes - Lecture 7 from University of Oxford

• Actionable Machine Learning for Tackling Distribution Shift - Huaxiu Yao from Stanford University

• Efficiently Modeling Long Sequences with Structured State Spaces - Albert Gu from Stanford University

• Assignment Control Plots for Causal Inference Study Design - Rocky Aikens from Stanford University

• Mandoline - Model Evaluation under Distribution Shift from Stanford University

• Self-Supervision & Contrastive Frameworks - A Vision-Based Review from Stanford University

• Picking on the Same Person - Does Algorithmic Monoculture Homogenize Outcomes? from Stanford University

• HAI Weekly Seminar with Jeff Ding - The Rise and Fall of Great Technologies and Powers from Stanford University

• Towards Understanding and Building Embodied Intelligence from Stanford University

• Joint Learning Over Visual and Geometric Data from Stanford University

• Neural Networks in R and the MNIST Data - Lecture 10.R.1 from Stanford University

• Stanford Seminar - Computing with Physical Systems from Stanford University

• Stanford Seminar - Recent Progress in Verifying Neural Networks, Zico Kolter from Stanford University

• Stanford Seminar - Emerging Risks and Opportunities From Large Language Models from Stanford University

• Interactive Imitation Learning: Planning Alongside Humans from Stanford University

• Improving Natural Language Understanding Through Adversarial Testing from Stanford University

• Stanford Seminar - Computer-Designed Organisms - Josh Bongard from Stanford University

• Current Status of TinyML and the Enormous Opportunities Ahead - Panel Discussion from Stanford University

• Stanford Seminar - New Chip Technologies for AI and for Asia - The Edge is Where the Action Is from Stanford University

• Stanford Lecture - Don Knuth - "Dancing Links" 2018 from Stanford University

• Petascale Deep Learning on a Single Chip from Stanford University

• Multiscale Dataflow Computing - Competitive Advantage at the Exascale Frontier from Stanford University

• Unethical Algorithms of Massive Scale from Stanford University

• Stanford Seminar - Autonomous Driving, Are We There Yet? - Technology, Business, Legal Considerations from Stanford University

• Deep Learning in the Age of Zen, Vega, and Beyond from Stanford University

• Stanford Seminar - The Time-Less Datacenter from Stanford University

• Technology for Today's Problems - Addressing Global Challenges with Semiconductor Advancements from Stanford University

• Input with Deeply Custom Interfaces from Stanford University

• Democratizing Model Discovery with Neural Networks from Stanford University

• Retrieval Augmented Language Models - Stanford CS25 Lecture from Stanford University

• Towards Safe and Efficient Learning in the Physical World - Stanford Seminar from Stanford University

• Data Compression I - Lecture 4: Huffman Codes from Stanford University

• Stanford CS236: Deep Generative Models - Lecture 13 - Score Based Models from Stanford University

• Deep Generative Models - Lecture 2: Background from Stanford University

• Deep Generative Models - Energy Based Models - Lecture 12 from Stanford University

• Deep Generative Models - Normalizing Flows - Lecture 9 from Stanford University

• Deep Generative Models - Energy Based Models - Lecture 14 from Stanford University

• Deep Generative Models - Lecture 6: Variational Autoencoders from Stanford University

• Evaluation of Generative Models - Stanford CS236 Deep Generative Models Lecture 15 from Stanford University

• Stanford CS236: Deep Generative Models - Lecture 7 - Normalizing Flows from Stanford University

• Stanford CS236 - Deep Generative Models - Lecture 1: Introduction from Stanford University

• Aligning Open Language Models - Stanford CS25 Lecture from Stanford University

• HECTOR - Multimodal Deep Learning Model for Predicting Recurrence Risk in Endometrial Cancer from Stanford University

• Soma Design: Intertwining Aesthetics, Movement and Emotion in Design Work from Stanford University

• Using Pose and Action Estimation to Analyze Theater Performances from Stanford University

• Public AI Assistant to Worldwide Knowledge: 21st Century Knowledge Preservation and Access with AI from Stanford University

• Creating a Public AI Assistant to Worldwide Knowledge from Stanford University

• Exploring a Corpus - From Paper to Multilingual Chatbots from Stanford University

• Deploying AI in Organizations and Society from Stanford University

• Toward Relieving Clinician Burden by Automatically Generating Progress Notes from Stanford University

• Empire of AI - The Rise of OpenAI and the Future of Artificial Intelligence from Stanford University

• Shaping AI's Impact on Billions of Lives from Stanford University

• Accelerating the AI Revolution in Medicine from Stanford University

• Using Physics Informed Neural Networks to Build Digital Twins of Cardiac Hemodynamics from Stanford University

• AI in Healthcare Series - Empowering Patients from Stanford University

• Charting the Future - Open Innovation in an Era of Global AI Competition from Stanford University

• Collaboration Between Clinicians and Vision-Language Models in Radiology Report Generation from Stanford University

• Tractable Novelty Exploration Over Continuous and Discrete Sequential Decision Problems from University of Melbourne

• MIT: Neural Rendering from Alexander Amini

• Learning Steering for Parallel Autonomy from Alexander Amini

• MIT: Image Domain Transfer - NVIDIA Guest Lecture from Alexander Amini

• Convolutional Neural Networks from Alexander Amini

• Automating the Search for Artificial Life with Foundation Models from Massachusetts Institute of Technology

• GLOV: Guided Large Language Models as Implicit Optimizers for Vision Language Models from Massachusetts Institute of Technology

• Giving Sight to Speech Models from Massachusetts Institute of Technology

• Deep Subspace Learning for Dynamic MR Image Reconstruction from Yale University

• The Software Design Document - Requirements to Implementation - Medical Software Course 7.1 from Yale University

• The Ultimate Software Design Document Template Guide - Medical Software Course - 7.2 from Yale University

• Medical Software Life Cycles - Agile Development - 5.2 from Yale University

• Revolutionizing Patient Care - EHR and PACS - 3.4 from Yale University

• Introduction to Classical and Quantum Error Correction - Class 1 from Yale University

• Medium Earth Orbit and GPS - Rocket Science for Everyone - 2.2 from Yale University

• 人工智能原理 from Peking University

• 数据结构(上) from Tsinghua University

• 数据结构(下) from Tsinghua University

• 操作系统 from Tsinghua University

• 算法设计与分析 from Tsinghua University

• 区块链和加密数字货币 from Tsinghua University

• 大数据机器学习 from Tsinghua University

• 计算几何 from Tsinghua University

• 机器学习概论 from Tsinghua University

• Data Structures and Algorithm Design Part II from Tsinghua University

• 分布式数据系统应用实战-入门 from Tsinghua University

• Computational Geometry from Tsinghua University

• 信息素养——学术研究的必修课 from Tsinghua University

• 软件需求工程 from Tsinghua University

• 计算未来云讲坛（2020）——清华大学计算机系前沿系列讲座 from Tsinghua University

• AI and Sustainable Convergence from Tsinghua University

• Machine Learning for Personalized Healthcare - Opportunities, Challenges and Insights from New York University (NYU)

• Brooklyn Quant Experience: A Brief History of Quant Investing - From Traditional Equity Factors to Machine Learning from New York University (NYU)

• Machine Learning for Personalization from New York University (NYU)

• Curiosity Styles in the Natural and Artificial Wild from New York University (NYU)

• 软件设计模式 from University of Science and Technology of China

• Linux操作系统分析 from University of Science and Technology of China

• Information Theory: Defining Entropy and Information - Lecture 1 from University of Oxford

• Basic Properties of Information Theory - Lecture 2 from University of Oxford

• Introducing Codes in Information Theory - Lecture 3 from University of Oxford

• Information Theory: Typical Sequences and the Kraft-McMillan Inequality - Lecture 4 from University of Oxford

• Information Theory: Optimal Codes and Block Coding - Lecture 5 from University of Oxford

• Information Theory: Shannon's Code - Lecture 6 from University of Oxford

• Information Theory: Tunstall's Code - Lecture 8 from University of Oxford

• Kathleen Creel- Arbitrariness, Fairness, and Opportunity in Algorithmic Decision-Making Systems from Stanford University

• Highly Optimized Quantum Circuits Synthesized via Data-Flow Engines from Stanford University

• Stanford Seminar 2022 - Transformer Circuits, Induction Heads, In-Context Learning from Stanford University

• Stanford Seminar 2022 - DeepMind's Perceiver and Perceiver IO: New Data Family Architecture from Stanford University

• Stanford Seminar - Mixture of Experts Paradigm and the Switch Transformer from Stanford University

• Stanford Seminar 2022 - Transformers in Vision: Tackling Problems in Computer Vision from Stanford University

• Stanford Seminar - Dataflow for Convergence of AI and HPC - GroqChip from Stanford University

• Stanford Seminar - Universal Intelligent Systems by 2030 - Carl Hewitt and John Perry from Stanford University

• Stanford Seminar - Centaur Technology's Deep Learning Coprocessor from Stanford University

• Nanosecond-Level Clock Synchronization in a Data Center from Stanford University

• Extending the Theory of ML for Human-Centric Applications from Stanford University

• Autonomous Driving - AI's Biggest Endeavor, James Peng of Pony.ai from Stanford University

• The Case for Learned Index Structures from Stanford University

• Tiny Functions for Codecs, Compilation, and - Maybe - Soon Everything from Stanford University

• Stanford Seminar - Computing with High-Dimensional Vectors from Stanford University

• Generalized Reversible Computing and the Unconventional Computing Landscape from Stanford University

• Stanford Seminar - Beyond Floating Point - Next Generation Computer Arithmetic from Stanford University

• The Analysis of Algorithms - 2015 Recreation of 1969 Lecture from Stanford University

• Designing the iPhone's Magic Flute - Ge Wang from Stanford University

• Runway - A New Tool for Distributed Systems Design from Stanford University

• Stanford CS109 - Fairness in Probability for Computer Scientists - Lecture 26 from Stanford University

• How I Learned to Stop Worrying and Love the Transformer - Stanford CS25 Lecture from Stanford University

• Dancing Cells - Efficient Data Structures for Combinatorial Problem Solving from Stanford University

• Data Compression - Video Compression - Lecture 18 from Stanford University

• Data Compression I - Course Introduction and Lossless Compression Basics - Lecture 1 from Stanford University

• Data Compression I - Lecture 5: Asymptotic Equipartition Property from Stanford University

• Context-based Arithmetic Coding and LLM Compression - Stanford EE274 Lecture 9 from Stanford University

• Data Compression I - Lecture 3: Kraft Inequality, Entropy, and Introduction to SCL from Stanford University

• Stanford EE274: Data Compression - Beyond IID Distributions: Conditional Entropy - Lecture 8 from Stanford University

• LZ and Universal Compression - Lecture 10 from Stanford University

• Arithmetic Coding - Stanford EE274 Data Compression I Lecture 6 from Stanford University

• Learnt Image Compression - Lecture 16 from Stanford University

• Lossy Compression Basics and Quantization - Lecture 11 from Stanford University

• Asymmetric Numeral Systems (ANS) - Data Compression Lecture 7 from Stanford University

• Deep Generative Models - Autoregressive Models - Lecture 3 from Stanford University

• Deep Generative Models - Discrete Latent Variable Models - Lecture 17 from Stanford University

• Deep Generative Models - Lecture 5: Variational Autoencoders from Stanford University

• Deep Generative Models - Diffusion Models for Discrete Data - Lecture 18 from Stanford University

• Deep Generative Models - Lecture 10: GANs from Stanford University

• Deep Generative Models - Lecture 8: GANs from Stanford University

• Deep Generative Models - Energy Based Models - Lecture 11 from Stanford University

• Demystifying Mixtral of Experts - Stanford CS25 Lecture from Stanford University

• Transformers that Transform Well Enough to Support Near-Shallow Architectures - Stanford CS25 Lecture from Stanford University

• Shaping the Future of AI from the History of Transformer Architectures - Stanford CS25 from Stanford University

• Zero Knowledge Proofs for Verifiable Computation on Blockchain Systems - Panel Discussion from Stanford University

• Divide and Conquer - Concept-based Models for Efficient Transfer Learning from Stanford University

• Improving Large Language Models for Clinical Named Entity Recognition via Prompt Engineering from Stanford University

• Analyzing and Exposing Vulnerabilities in Language Models - Session 131 from Stanford University

• Public AI Assistant to Worldwide Knowledge: 21st Century Knowledge Preservation and Access with AI from Stanford University

• Public AI Assistant to Worldwide Knowledge: Answering Queries of Structured and Unstructured Data from Stanford University

• AI in Healthcare Series: From Decision Support to Drug Prescriptions from Stanford University

• AI Audits and Autonomy in Sociotechnical Systems from Stanford University

• Transformers in Diffusion Models for Image Generation and Beyond from Stanford University

• The Future of Personalized Healthcare Technology with AI from Stanford University

• The Limited Impact of Medical Adaptation of Large Language and Vision-Language Models from Stanford University

• Managed by AI - Artificial Pancreas and Contemporary Treatment of Diabetes from Stanford University

• LoRKD - Low-Rank Knowledge Decomposition for Medical Foundation Models from Stanford University

• Diffusion Models in Medical Imaging from Stanford University

• Adaptive Federated Knowledge Injection into Medical Foundation Models from Stanford University

• How Can We Diagnose and Treat Bias in LLMs for Clinical Decision-Making - MedAI #142 from Stanford University

• The Role of Business - Policy Implications of Industry Leadership in Artificial Intelligence from Stanford University

• AI in Healthcare Series - Leveraging GPT-5, Cosmos, and Predictive Models for Better Outcomes from Stanford University

• Opportunistic Screening for Pancreatic Cancer - Multimodal AI Fusion of CT Imaging and Radiology Reports from Stanford University

• Introduction to Deep Learning - Lecture 1 from Stanford University

• The New DBification of ML-AI from University of Melbourne

• Convolutions in Image Processing - MIT 18.S191 Fall 2020 - Week 1 from The Julia Programming Language

• Aligning Language Models with LESS Data and Simple Preference Optimization (SimPO) from Massachusetts Institute of Technology

• The Promises and Pitfalls of Open-source Agent Systems from Massachusetts Institute of Technology

• Probabilistic Methods in Combinatorics from Massachusetts Institute of Technology

• Redefining Context for Powerful Test-Time Adaptation Using Unlabeled Data from Massachusetts Institute of Technology

• Inference-Time Policy Customization Through Interactive Task Specification from Massachusetts Institute of Technology

• The Semantic Hub Hypothesis: Language Models Share Semantic Representations Across Languages and Modalities from Massachusetts Institute of Technology

• Can Diffusion Model Disentangle? A Theoretical Perspective from Massachusetts Institute of Technology

• Recursive Reasoning with LLMs and VLMs from Massachusetts Institute of Technology

• Reducing Hallucinations in LLMs via Decoding, Detection, and Citation from Massachusetts Institute of Technology

• Quantifying Generalization Complexity for Large Language Models from Massachusetts Institute of Technology

• The Structures of Power in Early Modern England - Politics, Religion, and Society under the Tudors from Yale University

• Fast Motion-Resolved 4D MRI Using Convolutional Networks Without Data Consistency from Yale University

• Theoretical Interpretation of the ACID for Stabilizing Deep Reconstruction Networks from Yale University

• Fast Uncertainty Estimation and Diffusion Models in PET from Yale University

• Mastering Your SRS Template for Medical Software Course from Yale University

• Navigating the Medical Software Life Cycle - A Complete Guide - 5.4 from Yale University

• Diving Into Medical Software - Your Course Introduction - 1.1 from Yale University

• Navigating AI/ML Challenges in Medical Software Development - 11.6 from Yale University

• Demystifying Deep Learning - Neural Networks and Medical AI Applications - 11.3 from Yale University

• Navigating AI/ML Regulations - Global Guidance for Medical Software Course - 11.4 from Yale University

• Demystifying AI and ML - A Core Introduction for Medical Software Course - 11.1 from Yale University

• Signal Detection and ROC Curves - Optimizing Medical Software Decisions - 9.5 from Yale University

• Measurement in Circuit Quantum Electrodynamics - Class 7 from Yale University

• Decoding Problem and Statistical-Mechanical Mapping - Class 6 from Yale University

• Erasure Errors and Rydberg Atoms - Class 5 from Yale University

• Quantum Codes, Stabilizers, and Computation - Class 2 from Yale University

• Hardware Efficient Encodings - Cat Qubits and Dual-Rail Qubits - Class 4 from Yale University

• Introduction to Bosonic Modes and Kraus Operators - Class 3 from Yale University

• 移动图形概论 from Peking University

• 推荐系统 from Peking University

• 低资源场景下的对话系统任务的模型定制 from Peking University

• 算法初步 from Peking University

• 护理信息学 from Peking University

• 大数据平台核心技术 from Tsinghua University

• 物联网概论 from Tsinghua University

• 高级大数据系统 from Tsinghua University

• 软件理论基础 from Tsinghua University

• 高级操作系统 from Tsinghua University

• 操作系统(RISC-V) from Tsinghua University

• 计算机是如何实现智能的 from Tsinghua University

• 学堂在线×快手《新知如师说》清华名师系列讲座 from Tsinghua University

• 闲话AI：自然语言理解难在哪儿？ from Tsinghua University

• 机器学习训练营 from Tsinghua University

• 深度学习训练营 from Tsinghua University

• 分布式数据系统应用实战-进阶 from Tsinghua University

• 计算机系统架构的新挑战 from Tsinghua University

• 邓公漫谈数据结构-「疾风计划」导师专属直播【限时开放】 from Tsinghua University

• 操作系统专题训练课 from Tsinghua University

• AI肖像画大师：生成对抗网络驱动的多风格艺术肖像画创作 from Tsinghua University

• 推荐系统中的用户理解：偏好、意图、行为与满意度 from Tsinghua University

• 人工智能基础核心技术之事件检测 from Tsinghua University

• 当微信邂逅NLP基础研究 from Tsinghua University

• “神威·太湖之光”超级计算机优化方法与应用简介 from Tsinghua University

• 基于图神经网络的事实验证 from Tsinghua University

• 为网络化系统设计智能可靠的优化算法 from Tsinghua University

• 算法支撑的赛博智能经济 from Tsinghua University

• 浅谈面试中的算法题 from Tsinghua University

• Engineering Responsible AI from Tsinghua University

• 非易失内存在分布式存储领域的应用 from Tsinghua University

• 融合知识的预训练语言模型 from Tsinghua University

• 复杂场景下的机器阅读理解 from Tsinghua University

• 任务导向对话的数据和平台建设 from Tsinghua University

• 区块链助力小微企业融资 from Tsinghua University

• 智慧医疗创新体验 from Tsinghua University

• 电子信息科学与技术导引(1) from Tsinghua University

• 应用信息论基础 from Tsinghua University

• 大数据与机器智能 from Tsinghua University

• 清华大学计算机科学与技术系六十周年系庆学术报告（一）理论 from Tsinghua University

• 清华大学计算机科学与技术系六十周年系庆学术报告（三）人工智能 from Tsinghua University

• 清华大学计算机科学与技术系六十周年系庆学术报告（二）系统 from Tsinghua University

• 城市人工智能理论与方法 from Tsinghua University

• AI Medical and Health Applications: Innovative Practices and Inclusive Design from Tsinghua University

• 清华大学祝武：AI+金融 from Tsinghua University

• 杨斌×里德·霍夫曼：驾驭AI浪潮重塑未来竞争力 from Tsinghua University

• Online Education Dialogue 2025 from Tsinghua University

• 自然语言处理 from Shanghai Jiao Tong University

• 深度强化学习导论 from Fudan University

• 人工智能导论 from Fudan University

• Generative Models for Image Synthesis from New York University (NYU)

• Learning Representations Using Causal Invariance from New York University (NYU)

• The Information Knot - Tying Sensing and Action; Emergence Theory of Representation Learning from New York University (NYU)

• Spectral Transformers for Long-Range Sequence Modeling and Prediction from New York University (NYU)

• Towards Robust and Reliable Autonomous Vehicles with Foundation Models from New York University (NYU)

• 互联网体系结构 from University of Science and Technology of China

• Andrew Wiles Talks to Hannah Fry from University of Oxford

• 信息与电子工程导论 from Zhejiang University

• 知识图谱导论 from Zhejiang University

Programming (151)

• Computing in Python I: Fundamentals and Procedural Programming from Georgia Institute of Technology ★★★★★(272)

• Programming Abstractions in C++ - Stanford University from Stanford University ★★★★★(199)

• Computing in Python IV: Objects & Algorithms from Georgia Institute of Technology ★★★★★(116)

• Computing in Python II: Control Structures from Georgia Institute of Technology ★★★★★(60)

• Computing in Python III: Data Structures from Georgia Institute of Technology ★★★★★(52)

• CS50's Web Programming with Python and JavaScript from Harvard University ★★★★★(42)

• Introduction to Programming for the Visual Arts with p5.js from University of California, Los Angeles ★★★★★(36)

• Database Systems - Cornell University Course (SQL, NoSQL, Large-Scale Data Analysis) from Cornell University ★★★★★(36)

• Programming for Everybody (Getting Started with Python) from University of Michigan ★★★★★(20)

• Python Data Structures from University of Michigan ★★★★★(15)

• Using Python for Research from Harvard University ★★★★☆(12)

• CS50's Introduction to Programming with Python from Harvard University ★★★★★(11)

• Introduction to Functional Programming from Delft University of Technology ★★★★☆(11)

• MATLAB and Octave for Beginners from École Polytechnique Fédérale de Lausanne ★★★★☆(8)

• Introduction To MATLAB Programming (Fall 2011) from Massachusetts Institute of Technology ★★★★★(8)

• CS50's Introduction to Programming with Scratch from Harvard University ★★★★☆(6)

• Creating Video Games from Massachusetts Institute of Technology ★★★★☆(6)

• Android App Development Winter 2019 from Stanford University ★★★★★(6)

• The Computing Technology Inside Your Smartphone from Cornell University ★★★★★(5)

• Web Coding Fundamentals: HTML, CSS and Javascript from National University of Singapore ★★★★★(5)

• Software Development Process from Georgia Institute of Technology ★★★★☆(5)

• CS50's Introduction to Databases with SQL from Harvard University ★★★★★(4)

• Databases: Relational Databases and SQL from Stanford University ★★★★☆(3)

• Cloud Computing - What’s on the Horizon with Dr. Timothy Chou from Stanford University ★★★★☆(3)

• CS50's Mobile App Development with React Native from Harvard University ★★★★★(2)

• Database Systems Concepts & Design from Georgia Institute of Technology ★★★★☆(1)

• Automated Software Testing: Model and State-based Testing from Delft University of Technology ★★★★★(1)

• Using JavaScript, JQuery, and JSON in Django from University of Michigan ★★★★★(1)

• Databases: Semistructured Data from Stanford University ★★★★★(1)

• Programación para todos (empezando con Python) from University of Michigan ★★★★☆(1)

• Seven Databases in Seven Weeks - Fall 2014 from Carnegie Mellon University ★★★★★(1)

• Advanced Database Systems - Spring 2019 from Carnegie Mellon University ★★★★★(1)

• Stanford Seminar - Optional Static Typing for Python from Stanford University ★★★★★(1)

• Advanced Database Systems - Spring 2017 from Carnegie Mellon University ★★★★☆(1)

• Rocket- Securing the Web at Compile-Time from Stanford University ★★★★★(1)

• Stanford Seminar - KUtrace from Stanford University ★★★★★(1)

• Stop User Errors - Mastering Usability Engineering in Medical Software Course from Yale University ★★★☆☆(1)

• Automated Software Testing: Unit Testing, Coverage Criteria and Design for Testability from Delft University of Technology

• Quantitative Methods for Biology from Harvard University

• CS 6340: Software Analysis & Testing from Georgia Institute of Technology

• Databases: Advanced Topics in SQL from Stanford University

• Database Design and Basic SQL in PostgreSQL from University of Michigan

• R Programming Fundamentals from Stanford University

• CS50's Introduction to Programming with R from Harvard University

• Creating Virtual Reality (VR) Apps from University of California, San Diego

• How Virtual Reality Works from University of California, San Diego

• Introduction to Object-Oriented Programming with Java III: Exceptions, Data Structures, Recursion, and GUIs from Georgia Institute of Technology

• Databases: Modeling and Theory from Stanford University

• Using JavaScript and JSON in Django from University of Michigan

• Mobile Application Experiences from Massachusetts Institute of Technology

• UML Class Diagrams for Software Engineering from KU Leuven University

• Worldbuilding for Video Games from The University of British Columbia

• Real-Time Audio Signal Processing in Faust from Stanford University

• JSON and Natural Language Processing in PostgreSQL from University of Michigan

• Global Software Development from Delft University of Technology

• Statistical Learning with Python from Stanford University

• Databases: OLAP and Recursion from Stanford University

• Introduction to Object-Oriented Programming with Java II: Object-Oriented Programming and Algorithms from Georgia Institute of Technology

• Introduction to Object-Oriented Programming with Java I: Foundations and Syntax Basics from Georgia Institute of Technology

• Intermediate PostgreSQL from University of Michigan

• Minecraft, Coding and Teaching from University of California, San Diego

• Programming Reactive Systems from École Polytechnique Fédérale de Lausanne

• Building Web Applications in Django from University of Michigan

• Database Architecture, Scale, and NoSQL with Elasticsearch from University of Michigan

• Web Application Technologies and Django from University of Michigan

• Introduction à la science des données sociales avec R from Université de Montréal

• Django Features and Libraries from University of Michigan

• MATLAB et Octave pour débutants from École Polytechnique Fédérale de Lausanne

• Estructuras de Datos con Python from University of Michigan

• C++ Programming | C++程序设计 from Peking University

• Java程序设计 | Java Programming from Peking University

• CS193p - Developing Apps for iOS from Stanford University

• Virtual Reality from University of Illinois at Urbana-Champaign

• How to Design Addictive Games from Stanford University

• iPhone Application Development Spring 2020 from Stanford University

• 程序设计基础 from Peking University

• Stanford Seminar - Programming Should Be More Than Coding from Stanford University

• Stanford Seminar - Stories from CoCoLab: Probabilistic Programs, Cognitive Modeling, & Smart Web Pages from Stanford University

• Ciencia de Datos: Fundamentos de R from Harvard University

• Extended Reality for Everybody - Michael Nebeling from Stanford University

• CS 241: System Programming from University of Illinois at Urbana-Champaign

• C++语言程序设计基础 from Tsinghua University

• Stanford Seminar - Accessible Virtual Reality for People with Limited Mobility from Stanford University

• Haskell: Lecture notes and assignments from University of Pennsylvania

• Learn Computer Science Online from University of Illinois at Urbana-Champaign

• Computer Language Engineering (SMA 5502) from Massachusetts Institute of Technology

• Advanced Database Systems - Spring 2016 from Carnegie Mellon University

• User Experience (UX) Design: Human Factors and Culture in Design from Tsinghua University

• Intro to Database Systems - Fall 2017 from Carnegie Mellon University

• Stanford Seminar - Mind Your State for Your State of Mind from Stanford University

• Making Teamwork an Objective Discipline - Sid Sijbrandij CEO & Chairman of GitLab from Stanford University

• Stanford Seminar - Concatenative Programming- From Ivory to Metal from Stanford University

• Programming Languages - The Fundamental Tools of the Computer Age from University of Melbourne

• Intro to Database Systems - Fall 2018 from Carnegie Mellon University

• Advanced Database Systems - Spring 2018 from Carnegie Mellon University

• Paul's Disciples - Pseudepigraphic Letters to Colossians and Ephesians from Yale University

• LaTeX course from University of Amsterdam

• Intro to Database Systems - Fall 2021 from Carnegie Mellon University

• Advanced Database Systems - Spring 2020 from Carnegie Mellon University

• Hardware Accelerated Database Lectures - Fall 2018 from Carnegie Mellon University

• 程序设计基础 from Tsinghua University

• 学做小程序——基础篇 from Tsinghua University

• 计算机程序设计基础 from Tsinghua University

• Stanford Seminar - The Future of Edge Computing from an International Perspective from Stanford University

• Missing Semester IAP 2020 from Massachusetts Institute of Technology

• Structure and Interpretation of Computer Programs from Massachusetts Institute of Technology

• Internet Technology in Local and Global Communities from Massachusetts Institute of Technology

• Intro to Database Systems - Fall 2019 from Carnegie Mellon University

• Time Series Database Lectures from Carnegie Mellon University

• The Databaseology Lectures - Fall 2015 from Carnegie Mellon University

• PACS & AI – From Integration to Cloud from Yale University

• Java程序设计 from Tsinghua University

• Designing the Interactive Paper from Stanford University

• Stanford Seminar - PyWren - Pushing Microservices to Teraflops from Stanford University

• Living in Information Everywhere from Stanford University

• Wearing a VR Headset While Driving to Improve Vehicle Safety from Stanford University

• Master Code Management - Essential Revision Control Systems for Medical Software Course from Yale University

• Software Testing Essentials - Finding Bugs and Ensuring Quality in Medical Software - 8.3 from Yale University

• C++语言程序设计进阶 from Tsinghua University

• 学做小程序——实战篇：树洞小程序 from Tsinghua University

• 学做小程序--云开发篇：近义词小程序 from Tsinghua University

• Jeremy Bailenson: Your Mind on the Metaverse from Stanford University

• Stanford Seminar - TechFail: From Intersectional Inaccessibility to Inclusive Design from Stanford University

• Understanding the Utility of Haptic Feedback in Telerobotic Devices from Stanford University

• Stanford Seminar - I Forgot, I Invented Hypertext - Ted Nelson from Stanford University

• Edge Computing and the Evolution of AR-VR - Panel Discussion from Stanford University

• Stanford Seminar - Virtual & Mixed Reality for Security of Critical City-Scale Cyber-Physical Systems from Stanford University

• Graph Analysis of Russian Twitter Trolls Using Neo4j from Stanford University

• An Alternative to the American Way of Innovation from Stanford University

• Integrating Interactive Devices with the User's Body from Stanford University

• Beyond Benchmarks – Building a Science of AI Measurement from Stanford University

• VR/AR in IR - Mixed Reality in Medicine from Yale University

• JAVA程序设计进阶 from Tsinghua University

• Web前端攻城狮 from Tsinghua University

• 基于R语言的社会统计分析 from Tsinghua University

• Making the Invisible Visible - Observing Complex Software Dynamics from Stanford University

• Stanford Seminar - Robosion: Software Platform for Lifelike Humanoids from Stanford University

• From Flat to Phantasmal: Enhancing User Experiences Through Spatial Computing Advancements from Stanford University

• Essential Medical Software Verification and Testing Strategies - 8.5 from Yale University

• VC++面向对象与可视化程序设计（上）：Windows编程基础 from Tsinghua University

• VC++面向对象与可视化程序设计（下）：MFC编程基础 from Tsinghua University

• 汇编语言程序设计 from Tsinghua University

• 基于Linux的C++ from Tsinghua University

• JAVA程序设计进阶 from Tsinghua University

• 面向对象程序设计（C++） from Tsinghua University

• 游戏程序设计 from Tsinghua University

• C++编程训练营 from Tsinghua University

• 低时延网络挑战赛：从5G和边缘计算到互联网 from Tsinghua University

• 界面设计导论 from Tsinghua University

• 高级数据库系统 from Tsinghua University

• 游戏分析与评测 from Tsinghua University