Conceptual Questions
Process vs Thread Differences
Read aloud is unavailable in this browser.
The Most Fundamental OS Question
If you had to identify the single most frequently asked operating system interview question, "What is the difference between a process and a thread?" would be a strong contender. This seemingly simple question reveals deep understanding—or catastrophic gaps—in a candidate's grasp of operating system fundamentals.
Yet despite its ubiquity, most answers remain superficial: "Threads share memory, processes don't." While technically true, this response barely scratches the surface. It fails to explain why this matters, how operating systems implement this distinction, and what consequences emerge for application design, performance, and correctness.
This page provides the comprehensive, conceptually rigorous answer that distinguishes an engineer with genuine understanding from one reciting memorized fragments.
By the end of this page, you will understand: (1) the precise definitions of processes and threads from the kernel's perspective, (2) how they differ in resource ownership, scheduling, memory, and lifecycle, (3) the implementation details across major operating systems, (4) performance and design implications, and (5) how to structure a world-class interview answer that demonstrates genuine mastery.
Foundational Definitions: Getting the Basics Right
Before comparing processes and threads, we must establish precise definitions. Imprecise terminology leads to confused thinking.
What Is a Process?
A process is an instance of a program in execution. It represents the fundamental unit of resource ownership and protection in an operating system. When you launch an application—whether a web browser, database server, or command-line utility—the operating system creates a process to manage its execution.
Critically, a process is not just running code. A process encompasses:
- Address space: A dedicated region of virtual memory containing the program's code (text segment), global/static data, heap (dynamically allocated memory), and stack(s)
- Execution state: The current state of the CPU registers, program counter, and stack pointer
- Resource handles: Open files, network sockets, mutexes, semaphores, shared memory segments, and other kernel-managed resources
- Security context: User ID, group ID, capabilities, SELinux context, and other credentials that govern what the process can access
- Accounting information: CPU time consumed, memory usage, I/O statistics, and other metrics
- Kernel data structures: The process control block (PCB) or task structure that the kernel uses to track and manage the process
Think of a process as a container that holds everything needed for an independent program execution: its own memory space, its own file descriptors, its own credentials. This isolation is not incidental—it's a fundamental design choice that enables protection, security, and stability in multitasking operating systems.
What Is a Thread?
A thread is the fundamental unit of CPU scheduling and execution. It represents a single sequential flow of control within a process. While processes own resources, threads use those resources to actually execute instructions.
A thread consists of:
- Program counter: The address of the next instruction to execute
- Stack: A private region of memory for local variables, function parameters, and return addresses
- Register set: The current values of CPU registers (general-purpose, floating-point, vector, etc.)
- Thread-local storage (TLS): Per-thread data that appears global within the thread but is actually private
- Scheduling state: Priority, scheduling class, CPU affinity, and other scheduler-relevant metadata
Critically, threads within the same process share:
- The process's address space (code, global data, heap)
- Open file descriptors and network sockets
- Signal handlers and signal disposition
- Process ID, parent process ID, and group IDs
- Resource limits and accounting
- Security credentials and capabilities
If a process is a container (an apartment), threads are the workers (residents) inside it. Each worker has their own desk and personal workspace (stack and registers), but they share the kitchen, living room, and utilities (address space and resources). They can communicate trivially by speaking across the room (shared memory), but they must also coordinate to avoid conflicts (synchronization).
The Historical Evolution
The process/thread distinction wasn't always so clear. Early operating systems (1960s-1970s) had only processes—each process had exactly one thread of execution. The concept of multiple threads within a process emerged gradually:
1. Early Multitasking (1960s)
- Processes as independent programs with isolated memory
- Context switching between processes was the only form of concurrency
- Heavyweight: each process had complete, independent resource allocation
2. Lightweight Processes (1980s)
- Recognition that intra-process concurrency had value
- User-level threading libraries (e.g., pthreads precursors)
- Kernel still saw only processes; threads were invisible to the OS
3. Kernel-Supported Threads (1990s-present)
- POSIX threads (pthreads) standardization
- Kernels redesigned to schedule threads, not just processes
- Linux's 1:1 threading model, Windows NT's thread architecture, Solaris's M:N model
This evolution reveals a key insight: processes and threads solve different problems. Processes provide isolation and protection; threads provide concurrency and parallelism within a shared context.
The Kernel's Perspective: How Operating Systems See It
Understanding the process/thread distinction requires examining how operating system kernels actually implement these abstractions. Different kernels take different approaches, and these implementation choices have real consequences.
Linux: Tasks and Thread Groups
Linux doesn't fundamentally distinguish between processes and threads at the kernel level. Instead, Linux has a single abstraction: the task (represented by struct task_struct). What we call "processes" and "threads" are both tasks—they differ in how much they share.
When you call fork() to create a new process:
- A new task is created with its own memory mapping (new page tables)
- File descriptors are duplicated (though they reference shared file descriptions)
- A new process ID is assigned
- The new task has its own thread group ID (TGID) equal to its PID
When you call pthread_create() (which uses clone() internally) to create a new thread:
- A new task is created sharing the parent's memory mapping
- File descriptors are shared directly (same file descriptor table)
- A new thread ID (TID) is assigned, but the TGID remains the parent's
- The new task shares almost everything with its creator
1234567891011121314151617181920212223242526
// Creating a new PROCESS (fork-like behavior):// Very few sharing flags - almost complete isolationclone_flags = SIGCHLD; // Creates new: mm_struct, files_struct, fs_struct, signal handlers // Creating a new THREAD (pthread_create-like behavior):// Many sharing flags - extensive resource sharingclone_flags = CLONE_VM | // Share address space (virtual memory) CLONE_FS | // Share filesystem info (cwd, root) CLONE_FILES | // Share file descriptor table CLONE_SIGHAND | // Share signal handlers CLONE_THREAD | // Same thread group (same TGID) CLONE_SYSVSEM | // Share System V semaphores CLONE_SETTLS | // Set thread-local storage CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID; // The kernel's task_struct includes:struct task_struct { pid_t pid; // Unique task ID pid_t tgid; // Thread group ID (process ID in userspace) struct mm_struct *mm; // Memory descriptor (shared for threads) struct files_struct *files; // Open file table (shared for threads) struct fs_struct *fs; // Filesystem context (shared for threads) // ... hundreds of other fields};In Linux, getpid() returns the thread group ID (TGID), not the actual task ID. This means all threads in a process see the same "process ID," preserving POSIX semantics. The actual unique task ID is accessible via gettid(). This design elegantly provides both process-level and thread-level identity.
Windows: Processes and Threads as Distinct Objects
Windows takes a different architectural approach. Processes and threads are genuinely distinct kernel objects:
Processes (EPROCESS structure):
- Contain the virtual address space descriptor (VAD tree)
- Own the handle table (references to kernel objects)
- Hold security tokens and credentials
- Store process-wide statistics and accounting
- Are containers—they don't execute code themselves
Threads (ETHREAD structure):
- Are the units of execution within processes
- Have their own kernel-mode and user-mode stacks
- Contain scheduling information (priority, quantum, processor affinity)
- Hold thread-local storage pointers
- Reference their owning process
This architectural distinction means Windows never confuses processes and threads. A process cannot execute code—only its threads can. Every process has at least one thread (the initial thread), and when the last thread terminates, the process exits.
Comparison of Implementation Approaches
Neither approach is inherently superior; they represent different design philosophies:
| Aspect | Linux (Unified Tasks) | Windows (Distinct Objects) |
|---|---|---|
| Core abstraction | Task (struct task_struct) | Process (EPROCESS) + Thread (ETHREAD) |
| Creating threads | clone() with sharing flags | CreateThread() or related APIs |
| Scheduling unit | Task | Thread |
| Process identity | Thread group ID (TGID) | Process ID (from process object) |
| Flexibility | Can create hybrids (partial sharing) | Clean separation, less flexibility |
| Kernel complexity | Simpler core (fewer object types) | More object types, but clearer semantics |
| Signal delivery | Complex (task vs thread group) | Simpler (APCs to threads) |
Memory and Address Space: The Critical Distinction
Memory isolation is the defining difference between processes and threads. Understanding exactly what is shared and what is private is essential for writing correct concurrent programs.
Process Memory Isolation
Each process has its own virtual address space. This means:
-
Independent page tables: Each process has its own mapping from virtual addresses to physical addresses. Address 0x7fff0000 in Process A maps to a completely different physical location than 0x7fff0000 in Process B.
-
Protection by default: A process cannot accidentally (or maliciously) access another process's memory. The MMU hardware enforces this protection—attempts to access invalid addresses trigger page faults.
-
Explicit sharing required: Processes that need to share memory must establish shared memory regions explicitly via:
mmap()with MAP_SHARED and file descriptors- POSIX shared memory (
shm_open(),mmap()) - System V shared memory (
shmget(),shmat()) - Memory-mapped files
-
Copy-on-write for fork(): When
fork()creates a child process, the address space is initially shared but marked copy-on-write. Writes trigger page faults that create private copies.
1234567891011121314151617181920212223242526
#include <stdio.h>#include <unistd.h>#include <sys/wait.h> int global_counter = 0; // Global variable int main() { global_counter = 100; pid_t pid = fork(); if (pid == 0) { // Child process: has COPY of parent's memory global_counter += 50; // Modifies child's copy only printf("Child: global_counter = %d", global_counter); // Output: Child: global_counter = 150 } else { wait(NULL); // Wait for child printf("Parent: global_counter = %d", global_counter); // Output: Parent: global_counter = 100 // Parent's value unchanged - processes have separate memory! } return 0;}Thread Memory Sharing
Threads within a process share the entire address space. This has profound implications:
-
Same page tables: All threads see identical virtual-to-physical mappings. Address 0x7fff0000 refers to the same physical memory for every thread in the process.
-
Instant visibility: When Thread A writes to a memory location, Thread B sees that write immediately (subject to memory ordering constraints).
-
No isolation by default: Any thread can read/write any memory in the process. There are no hardware-enforced boundaries between threads.
-
What threads share:
- Code (text) segment
- Global and static variables
- Heap (dynamically allocated memory)
- Open file descriptors
- Signal handlers
- Current working directory
- User and group IDs
-
What threads own privately:
- Stack (each thread has its own)
- Register contents (saved/restored on context switch)
- Thread-local storage (TLS)
- Signal mask (can vary per thread)
- errno (actually TLS in modern systems)
- Thread ID
123456789101112131415161718192021222324252627282930313233
#include <stdio.h>#include <pthread.h>#include <unistd.h> int global_counter = 0; // Shared between all threads void* thread_function(void* arg) { // This thread shares global_counter with main thread for (int i = 0; i < 100000; i++) { global_counter++; // Race condition! Not atomic. } return NULL;} int main() { pthread_t thread; pthread_create(&thread, NULL, thread_function, NULL); // Main thread also modifies shared counter for (int i = 0; i < 100000; i++) { global_counter++; // Race condition! } pthread_join(thread, NULL); // Expected: 200000, Actual: unpredictable (race condition) printf("global_counter = %d", global_counter); // Could print anything from ~100000 to ~200000! return 0;}Thread memory sharing is both the greatest advantage and the greatest danger of multithreading. It enables efficient communication without kernel intervention, but it also enables race conditions, data corruption, and some of the most difficult bugs in software engineering. Every shared mutable state requires synchronization—without exception.
Memory Layout Visualization
Understanding the memory layout helps clarify what's shared and what's private:
| Memory Region | Process Ownership | Thread Behavior |
|---|---|---|
| Text (code) | Private to process | Shared among all threads (read-only) |
| Data (global/static) | Private to process | Shared among all threads (read-write) |
| BSS (uninitialized) | Private to process | Shared among all threads (read-write) |
| Heap | Private to process | Shared among all threads (read-write) |
| Stack | Private to process | Private to each thread |
| Thread-Local Storage | Private to process | Private to each thread |
| Memory-mapped files | Depends on mapping flags | Shared based on process mapping |
| Kernel structures | N/A (kernel space) | Some per-thread, some per-process |
Scheduling and Context Switching
Understanding how the scheduler treats processes and threads reveals critical performance implications.
The Scheduler's View
Modern operating system schedulers are thread-aware. The scheduler doesn't schedule processes directly; it schedules threads (or tasks in Linux terminology). This has important implications:
-
Threads are the scheduling entities: When the scheduler decides what to run next, it chooses among runnable threads, not processes.
-
Threads from different processes compete equally: A thread in Process A and a thread in Process B compete for CPU time based on their individual priorities, not based on which process they belong to.
-
Multi-threaded processes get more CPU time by default: If Process A has 4 threads and Process B has 1 thread, and all have equal priority, Process A will get approximately 4× the CPU time. (Some schedulers have group scheduling to address this.)
Context Switch Costs
The cost of switching between execution contexts varies dramatically between processes and threads:
- •Save CPU registers: General-purpose, floating-point, vector registers (~50-100 values)
- •Switch page tables: Update CR3 register (x86) or TTBR (ARM) to point to new address space
- •Flush TLB: Invalidate translation lookaside buffer entries (or use ASID/PCID to avoid)
- •Flush CPU caches (indirect): New address space likely has different working set, causing cache misses
- •Reload processor state: Segment registers, control registers, debug registers
- •Update kernel data structures: Current process pointer, scheduling statistics
- •Typical cost: 1,000 - 10,000+ CPU cycles (microseconds)
- •Save CPU registers: Same as process switch
- •NO page table switch: Same address space, CR3/TTBR unchanged
- •NO TLB flush: TLB entries remain valid
- •Minimal cache disruption: Threads share data, so cache contents likely still useful
- •Switch stack pointer: Point to new thread's stack
- •Update kernel data structures: Current thread pointer, scheduling statistics
- •Typical cost: 100 - 1,000 CPU cycles (sub-microsecond to microseconds)
TLB (Translation Lookaside Buffer) flushes are often the most expensive part of process context switches. Modern CPUs use ASIDs (Address Space Identifiers) or PCIDs (Process-Context Identifiers) to tag TLB entries, allowing multiple address spaces to coexist in the TLB and avoiding expensive flushes. Check if your system uses this optimization with 'cat /proc/cpuinfo | grep pcid' on Linux.
Quantifying the Difference
Actual context switch costs vary by hardware, OS version, and workload, but rough magnitudes are instructive:
| Metric | Thread Switch | Process Switch | Ratio |
|---|---|---|---|
| Registers saved/restored | ~50-100 | ~50-100 + control regs | ~1.2x |
| TLB flush cost | None (same ASID) | Full flush or ASID update | N/A vs ~1000 cycles |
| Page table switch | None | MMU register update | 0 vs ~10-50 cycles |
| Cache warming | Minimal (shared data) | Significant (different working set) | Variable |
| Total time (typical) | 0.5 - 2 μs | 2 - 20 μs | 4x - 10x faster |
| Throughput impact (high-frequency switching) | Minor | Significant | Thread wins |
Practical Implications for System Design
These cost differences drive architectural decisions:
Use threads when:
- Tasks need to communicate frequently (shared memory is cheap)
- Context switches are frequent (server handling many requests)
- Tasks share significant common data (code, read-only resources)
- Startup/teardown latency matters (thread creation is faster)
Use processes when:
- Fault isolation is critical (one crash shouldn't kill all work)
- Security isolation is required (different privilege levels)
- Tasks are long-running with infrequent communication
- Memory consumption must be controlled per-unit (OOM killer granularity)
- Third-party code might be unstable or malicious
Creation, Lifecycle, and Termination
The lifecycle of processes and threads differs in important ways, affecting application architecture and resource management.
Process Creation
Process creation is a heavyweight operation involving substantial kernel work:
On Unix/Linux (fork + exec pattern):
123456789101112131415161718192021222324
// fork() creates a child processpid_t pid = fork(); if (pid == 0) { // Child process // Has copy-on-write copy of parent's address space // Has duplicated file descriptors // Has separate PID // Usually followed by exec() to load new program execve("/usr/bin/program", argv, envp); // execve replaces entire address space // Only kernel structures retained} // What fork() does internally:// 1. Allocate new task_struct// 2. Copy (COW) page tables and mm_struct// 3. Duplicate file descriptor table// 4. Copy signal handlers// 5. Initialize scheduling state// 6. Add to process list and scheduler// Cost: tens to hundreds of microsecondsOn Windows (CreateProcess):
Windows uses a different model—new processes are created with CreateProcess, which combines process creation and program loading in one call:
123456789101112131415161718192021222324
STARTUPINFO si = { sizeof(si) };PROCESS_INFORMATION pi; BOOL success = CreateProcessW( L"C:\\Program.exe", // Application path NULL, // Command line NULL, // Process security attributes NULL, // Thread security attributes FALSE, // Inherit handles 0, // Creation flags NULL, // Environment NULL, // Current directory &si, // Startup info &pi // Process information (output)); // CreateProcess internally:// 1. Create EPROCESS structure// 2. Create initial ETHREAD for primary thread// 3. Create address space (VAD tree)// 4. Map executable and required DLLs// 5. Initialize handle table// 6. Set up security token// Cost: milliseconds (heavier than fork)Thread Creation
Thread creation is significantly lighter. The key work is allocating a stack and creating scheduler state:
12345678910111213141516171819202122232425262728293031
// POSIX thread creationpthread_t thread;pthread_attr_t attr; pthread_attr_init(&attr);pthread_attr_setstacksize(&attr, 1024 * 1024); // 1 MB stack int result = pthread_create( &thread, // Thread ID output &attr, // Attributes (stack size, detached state, etc.) thread_function, // Entry point arg // Argument); // What pthread_create does internally:// 1. Allocate stack (mmap a few MB)// 2. Set up TLS area// 3. Clone with CLONE_THREAD | CLONE_VM | CLONE_FILES | ...// 4. Initialize thread-local errno// 5. Call entry function// Cost: microseconds (10-100x faster than process creation) // Windows thread creationHANDLE hThread = CreateThread( NULL, // Security attributes 0, // Default stack size ThreadFunction, // Entry point lpParam, // Argument 0, // Creation flags &dwThreadId // Thread ID output);Because thread creation has non-trivial cost (especially stack allocation), high-performance systems use thread pools. Threads are created once at startup and reused for many tasks, amortizing creation cost across thousands of operations.
Termination Behavior
How processes and threads terminate differs significantly:
Process termination:
- All threads in the process are terminated (no choice)
- All file descriptors are closed
- All memory mappings are released
- Parent process receives SIGCHLD (Unix) or can wait on handle (Windows)
- Resources are reclaimed by the kernel
- Child processes may be orphaned (re-parented to init/systemd)
Thread termination:
- Only the specific thread terminates
- Process resources (files, memory) remain open
- Other threads continue executing
- Pthread: pthread_join() retrieves exit status
- Resources consumed by thread (stack, TLS) are freed
- Main thread termination: process may or may not terminate (depends on implementation)
Critical difference: Killing a process kills ALL its threads atomically. Killing a thread leaves the process and sibling threads intact. This is why process isolation is valuable for fault tolerance—a bug that crashes one thread won't necessarily crash others in a different process.
Communication Mechanisms
The communication patterns between processes and threads differ fundamentally, with significant implications for performance and complexity.
Inter-Thread Communication (ITC)
Threads communicate through shared memory—the same address space provides immediate, zero-copy access to shared data:
Mechanisms:
- Global variables and shared data structures
- Thread-safe queues and buffers
- Condition variables for signaling
- Read-write locks for concurrent access patterns
- Atomic operations for lock-free algorithms
Advantages:
- Zero copy: Data is accessed in place, not copied
- Negligible latency: No kernel involvement for data access
- Simple programming model (at first glance): Just access the variable
Challenges:
- Race conditions: Concurrent access requires synchronization
- Deadlocks: Improper lock ordering causes hangs
- Memory visibility: CPU caches and compiler optimizations require memory barriers
- Priority inversion: Lock contention can invert scheduling priorities
- Debugging difficulty: Non-deterministic behavior is hard to reproduce
12345678910111213141516171819202122232425262728293031323334353637383940414243
#include <pthread.h>#include <stdbool.h> // Shared state between producer and consumer threadstypedef struct { int buffer[100]; int count; int in, out; pthread_mutex_t mutex; pthread_cond_t not_empty; pthread_cond_t not_full;} SharedQueue; void produce(SharedQueue* q, int item) { pthread_mutex_lock(&q->mutex); while (q->count == 100) { // Buffer full pthread_cond_wait(&q->not_full, &q->mutex); } q->buffer[q->in] = item; // Direct memory access! q->in = (q->in + 1) % 100; q->count++; pthread_cond_signal(&q->not_empty); pthread_mutex_unlock(&q->mutex); // No copy, no kernel call for the data transfer itself} void consume(SharedQueue* q, int* item) { pthread_mutex_lock(&q->mutex); while (q->count == 0) { // Buffer empty pthread_cond_wait(&q->not_empty, &q->mutex); } *item = q->buffer[q->out]; // Direct memory access! q->out = (q->out + 1) % 100; q->count--; pthread_cond_signal(&q->not_full); pthread_mutex_unlock(&q->mutex);}Inter-Process Communication (IPC)
Processes must use explicit kernel-mediated mechanisms to communicate:
Mechanisms:
- Pipes and named pipes (FIFOs)
- Message queues (POSIX and System V)
- Shared memory (explicitly mapped)
- Sockets (Unix domain for local, TCP/UDP for network)
- Signals (limited data, mostly for events)
- Memory-mapped files
Characteristics by mechanism:
| Mechanism | Data Copy | Kernel Involvement | Max Data Size | Use Case |
|---|---|---|---|---|
| Pipe | Yes (2 copies: write→kernel→read) | Every transfer | Limited by buffer | Parent-child streaming |
| Message Queue | Yes (copy to/from kernel) | Every send/receive | Configurable | Decoupled producers/consumers |
| Shared Memory | No (mapped to both address spaces) | Setup only | Limited by RAM | High-bandwidth data sharing |
| Unix Socket | Yes (copy through socket buffer) | Every transfer | Unlimited streaming | Client-server, fd passing |
| Signal | Minimal (just signal number) | Yes | ~1 integer | Notifications, not data |
1234567891011121314151617181920212223242526
#include <sys/mman.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h> // Process A: Create shared memoryint fd = shm_open("/my_shared_mem", O_CREAT | O_RDWR, 0666);ftruncate(fd, 4096); // Set sizevoid* ptr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); // Now ptr points to memory shared with other processes// that open the same shared memory object // Process B: Attach to existing shared memoryint fd = shm_open("/my_shared_mem", O_RDWR, 0666);void* ptr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); // ptr in Process B points to the SAME physical memory// Changes by A are visible to B and vice versa // CRITICAL: Still need synchronization!// Shared memory between processes has the same// race condition risks as shared memory between threads.// Use POSIX semaphores: sem_open(), sem_wait(), sem_post()A common misconception is that shared memory between processes is simpler than thread communication. In fact, it has all the same synchronization challenges as threads—race conditions, visibility issues, and ordering concerns—plus the additional complexity of cross-process synchronization primitives.
Resource Ownership: The Complete Picture
Let's consolidate everything into a comprehensive ownership comparison. This table represents the definitive reference for what belongs to processes versus threads:
| Resource | Process-Private | Thread-Private | Notes |
|---|---|---|---|
| Virtual address space | ✓ | ✗ | All threads share the process's address space |
| Page tables | ✓ | ✗ | MMU configuration is per-process |
| Program counter | ✗ | ✓ | Each thread at different instruction |
| Stack (+ stack pointer) | ✗ | ✓ | Each thread needs its own call stack |
| CPU registers | ✗ | ✓ | Saved/restored on context switch |
| Thread-local storage | ✗ | ✓ | __thread in C, ThreadLocal in Java |
| Global variables | ✓ | Shared | Visible to all threads in process |
| Heap memory | ✓ | Shared | All threads can allocate/free |
| File descriptors | ✓ | Shared | Opening file in one thread visible to all |
| Current working directory | ✓ | Shared | chdir() affects all threads |
| User/Group IDs | ✓ | Shared | Security context is process-wide |
| Signal handlers | ✓ | Shared | Handler functions are process-wide |
| Signal mask | ✗ | ✓ | Can be set per-thread |
| Priority/nice value | Varies | ✓ | Can be per-thread in some systems |
| CPU affinity | ✗ | ✓ (usually) | Often settable per-thread |
| Process ID (PID) | ✓ | Shared | All threads report same PID |
| Thread ID (TID) | ✗ | ✓ | Unique within the system |
Think of it this way: Processes own resources. Threads borrow them. A process is the container that holds files, memory, and credentials. Threads are the workers that use those resources to execute code. Each worker has their own task (program counter), tools at their desk (registers), and scratch paper (stack), but they share everything else in the container.
KEEP LEARNING
Keep learning for free.
Read the complete lesson, save your notes and pick up where you left off with a free account. No card needed.