Computer Science Fundamentals
From electron switches & boolean logic to operating systems and algorithmic thinking.
A structured, beginner-to-mastery track designed to explain how computers truly work under the hood. Master hardware foundations, logic gates, machine architectures, and software engineering principles.
Course Overview
Welcome to Computer Science Fundamentals on codeworking.org. This track is designed for anyone who wants to move beyond memorizing high-level programming syntax to deeply understand how computers truly work under the hood.
What You Will Master
- Historical Foundations: Why modern software is built on the ideas of Ada Lovelace, Alan Turing, Dennis Ritchie, and Linus Torvalds.
- Physical Hardware: How electrical voltage and silicon transistors create bits, bytes, numbers, text, images, and audio.
- Digital Logic: How Boolean algebra (AND, OR, NOT, XOR) combines into arithmetic circuits inside the CPU.
- Machine Architecture: How registers, RAM, cache, and operating systems execute software instructions.
- Networking & Security: How packets traverse the global internet and how cryptography secures communications.
Prerequisites
- Zero prerequisites required. This course begins at the physical hardware level and builds upward step by step.
Structured Learning Roadmap
Hardware Foundations, Electricity & Digital Representation
Historical pioneers, electron circuits, transistors, Boolean algebra, binary arithmetic, and IEEE-754 floating point.
The Dawn of Computing & The Visionaries
Meet the pioneering minds who transformed mathematics and mechanical engineering into modern computing: Ada Lovelace, Alan Turing, Dennis Ritchie, and Linus Torvalds.
How a Computer Works: Electricity, Circuits & Bits
Demystify how physical electricity turns into digital intelligence. Explore the lightbulb switch analogy, the transistor electron valve, and binary representation.
Floating-Point Arithmetic, Fractional Precision & IEEE-754 Standard
PlannedWhy 0.1 + 0.2 != 0.3 in binary, sign-exponent-mantissa representation, subnormals, and precision bugs.
Computer Architecture, Memory & Machine Execution
Von Neumann architecture, CPU fetch-decode-execute cycle, registers, cache hierarchy, and assembly language.
Boolean Logic & Logic Gates
Discover how electronic switches combine to form logic gates: AND, OR, NOT, XOR. Learn truth tables and see how gates perform physical binary arithmetic.
Von Neumann Architecture & The CPU Core Execution Engine
PlannedRegisters (RIP, RSP, RAX), the Program Counter, and the instruction execution pipeline.
The Memory Hierarchy: Registers, Caches & The Memory Wall
PlannedL1/L2/L3 cache latency scaling, cache lines, spatial locality, and RAM bus contention.
Machine Code, Instruction Sets & Assembly Language
Plannedx86-64 vs ARM64 instruction sets, opcodes, register conventions, and disassembled machine code.
Memory Organization: Stack, Heap & Virtual Address Space
PlannedStack frame push/pop, heap dynamic allocation, memory fragmentation, and segmentation faults.
Low-Level Programming & The System Stack
Compiler pipelines, C memory management, pointers, and systems programming paradigms.
The Compiler Pipeline: Preprocessor, Lexer, Parser, Optimizer & Linker
PlannedSource code translation, AST parsing, symbol resolution, and static vs dynamic linking.
Pointers, Manual Memory Management & Pointers Arithmetic in C
PlannedDirect memory addresses, pointer dereferencing, void pointers, malloc/free, and memory leaks.
System Calls, POSIX Standard & The OS Kernel Boundary
PlannedUser space (Ring 3) vs Kernel space (Ring 0), software interrupts, and syscall dispatching.
Modern Systems Programming: Rust, Memory Safety & The Borrow Checker
PlannedCompile-time ownership, lifetimes, zero-cost abstractions, and memory safety without GC.
Operating Systems, Kernels & Concurrency
Process management, virtual memory, paging, threads, race conditions, and synchronization primitives.
Processes, Threads & The CPU Scheduler
PlannedProcess control blocks (PCB), thread execution, context switching overhead, and CFS scheduling.
Virtual Memory, Page Tables & The MMU
PlannedHardware memory management units (MMU), multi-level page tables, TLBs, and Page Faults.
Concurrency, Race Conditions, Mutexes & Deadlocks
PlannedShared state hazards, atomic CPU instructions (CAS), mutexes, semaphores, and Coffman deadlock conditions.
File Systems, Inodes & Storage Subsystems
PlannedDisk block addressing, file descriptors, superblock, journaling, ext4, and NVMe architecture.
Computer Networking, Protocols & The Internet
OSI model, TCP/IP, packet encapsulation, DNS, routing, HTTP/HTTPS, and network security.
The OSI 7-Layer Model & The TCP/IP Internet Suite
PlannedLayer abstraction, packet encapsulation, header stacking, and physical frame transmission.
IP Addressing, Subnetting & The Global DNS Hierarchy
PlannedIPv4 vs IPv6 addressing, CIDR subnet masks, ARP resolution, and root DNS resolution trees.
Transport Protocols: TCP Reliability vs UDP Performance
PlannedTCP 3-way handshake, sequence numbers, sliding window flow control, and UDP real-time streaming.
The Application Layer: HTTP/1.1, HTTP/2, HTTP/3 (QUIC) & WebSockets
PlannedRequest/response cycles, head-of-line blocking, multiplexing, binary framing, and QUIC over UDP.
Theoretical Computer Science, Cryptography & Systems Design
Turing machines, P vs NP, public-key cryptography, TLS 1.3, and distributed systems.
Cryptography Foundations: Symmetric Ciphers & Public-Key (RSA/ECC)
PlannedOne-way trapdoor functions, modular arithmetic, AES encryption, Diffie-Hellman key exchange, and ECC.
Digital Signatures, PKI, Certificate Authorities & TLS 1.3
PlannedCryptographic hash functions (SHA-256), X.509 certificate chains, and TLS 1.3 zero-RTT handshakes.
Automata Theory, Turing Machines & Computability
PlannedDeterministic Finite Automata (DFA), context-free grammars, universal Turing machines, and the Halting Problem.
Complexity Classes: P, NP, NP-Complete & The Millennium Problem
PlannedPolynomial verification, polynomial reduction, Cook-Levin theorem, SAT, and P vs NP implications.
Distributed Systems Foundations: CAP Theorem & Consensus Algorithms
PlannedNetwork partitions, CAP tradeoff, Byzantine fault tolerance, Paxos, and Raft leader election.