inflearn logo

Learning Computer Architecture from Scratch - From Transistors to CPUs

Are you frustrated because you can follow along with the code but can't explain why it works? This course starts from a single transistor and connects logic gates, memory, ALU, and CPU right before your eyes, even without any prior knowledge of programming or hardware. Understand abstract theories as if you were assembling them through rich visual materials and three comprehensive projects. Complete your foundational development strength by learning to explain the entire process of how variables and functions become machine code and are executed.

15 learners are taking this course

Level Beginner

Course period Unlimited

Computer Architecture
Computer Architecture
Computer Architecture
Computer Architecture

What you will gain after the course

  • Beyond just memorizing grammar and copying code, you will be able to explain how the programs you write are actually executed in the CPU and memory.

  • Understand the principles of how variables, functions, conditionals, and loops connect to machine language and data flow, and build the foundational development strength to reason through unfamiliar code and errors with logic.

  • By connecting and understanding core terms such as memory, registers, and addresses, learning data structures and operating systems becomes much easier.

  • By understanding the principles of computer operation to identify why code execution time and memory usage vary, you will establish a standard for considering more efficient code.

  • By connecting everything from transistors to actual program execution into a single map, you won't get lost when studying subsequent CS subjects such as operating systems, networks, and compilers.


⭐️From Transistors to CPUs: Learning Computer Architecture from the Ground Up⭐️



From transistors
to assembling a CPU


If you continue coding while skipping computer architecture, you will eventually hit the same wall again.

In operating systems, memory and processes become vague; in data structures, time and space costs become unclear; and in debugging, the causes of errors become ambiguous once again. If you don't know what the CPU and memory are actually doing beneath the code, you'll end up relying on memorization instead of principles every time you learn a new concept.

This course fills that gap from the very bottom. Starting from a single transistor without any prior knowledge of programming or hardware, we will sequentially connect logic gates, memory, ALU, and CPU. Follow along with rich visual materials and three comprehensive design projects to understand the entire process of how variables and functions turn into machine code and are executed.

There is no coding practice. Instead, without any installation or preparation, you will visually follow complex circuits and data flows as we explain to the very end why the code operates the way it does.

By mastering these fundamentals now, you will be able to understand unfamiliar concepts much more easily and quickly when you later study operating systems, data structures, networks, and compilers.

What you can gain from this course

Assemble the computer architecture from the ground up.

Instead of memorizing abstract terms, you will visually connect the process of how transistors become a CPU through logic gates and arithmetic circuits. By following three comprehensive design projects, you will be able to explain the principles of how a computer calculates on your own.

You can connect scattered CS concepts such as bits, registers, memory, and instructions into a single map. You will be able to build a solid foundation that prevents you from being shaken by new terminology when learning operating systems, data structures, networks, and compilers.

Understand the principles of how variables, functions, and conditional statements translate into machine language and data flow. Move beyond simply memorizing and writing code to reasonably infer the causes of errors and performance differences, allowing you to contemplate better code.

Grow into a developer who understands the core principles of a computer as if assembling them.
I will be with you, cheering for your growth.

Understand computers from the bottom up, from transistors to the CPU.


You can follow along and write the code, but it is difficult to explain why the program operates that way. When you open a computer architecture book, the unfamiliar terms increase, but it is hard to see how the concepts connect to one each other.

How can we solve this sense of helplessness?

If you memorize bits, gates, memory, and instructions separately, you will quickly forget them and have to start studying from scratch every time you encounter a new CS subject.

That is why this course does not skip a single step. First, you will see it with your own eyes, and then you will build from transistors to the CPU by connecting the components you learned earlier to the next concept.

Upon completing the course, you will be able to explain the entire process—from variables and functions turning into machine code to being executed by the CPU—as a single, continuous flow.

For concepts that feel difficult, I will first show them visually and establish sufficient connections before explaining the terminology. With a flow that doesn't skip a single step from transistors to program execution, I will guide you so that you can explain the essence of code yourself.



Course Overview

Computer Architecture: From the Bottom Up

Section 1

Lecture Introduction and Learning Objectives

First, we take a bird's-eye view of the entire journey, from a single transistor to the execution of CPUs and programs. We will check the prerequisite knowledge and learning sequence, and set goals for what to complete in the three comprehensive design projects.

Section 2

Bits and Binary: The Language of Machines

Understand why all data and commands in a computer are represented as 0s and 1s. Learn how machines handle numbers and information by connecting binary, hexadecimal, encoding, and two's complement.

Section 3

Transistors and the First Logic Circuit

Visually confirm the principle of transistors controlling current with voltage. By following the process of how two transistors become a NOT gate, understand how a physical switch becomes the starting point of computation.

Section 4

Logic Gates: The Basic Language of Chips

From AND·OR·NOT to NAND·NOR·XOR, you will master the basic grammar of logic used by all chips. Through truth tables and gate delays, you will learn to read how circuits make decisions and perform calculations.

Section 5

Boolean Algebra: The Mathematics of Logic

Learn how to transform complex logic into simpler circuits using Boolean algebra and De Morgan's laws. By connecting truth tables and Karnaugh maps, you will establish criteria for designing faster and more efficient circuits with fewer gates.

Section 6

Combinational Circuits: Instantaneous Operations

We will examine the process of how multiplexers, decoders, comparators, and shifters select, interpret, and move data. You will understand the basic building blocks of data processing that determine 'which value to send where' within the CPU.

Section 7

Binary Arithmetic: Implementing Addition with Circuits

Starting from half adders and full adders, we complete the addition and subtraction of multiple bits. By comparing the delays caused by carry propagation and the methods to reduce them, we understand why calculation speeds vary depending on the circuit structure.

Section 8

Project: 4-bit ALU Design

Complete the design process of a 4-bit ALU by connecting the logic gates, adders, shifters, and multiplexers learned previously. Visually confirm the moment each component is integrated into the CPU's arithmetic unit.

Section 9

Sequential Logic and Clocks: Circuits that Remember

You will learn that a circuit can remember the past by feeding back a portion of its output. By connecting latches, flip-flops, and clocks, you will understand the principle of how states are stored and changed at specific timings.

Section 10

Registers and Memory: Storing Bits

Expand multiple circuits that remember a single bit into registers and memory. By following the process of selecting storage locations via addresses and reading/writing data, you will understand where variable values are actually stored.

Section 11

Bus: Communication Between Components

Learn how various components of the CPU share data without infinitely increasing the number of wires. Understand the internal data flow of a computer by observing how address, data, and control signals travel through the bus.

Section 12

Finite State Machines: Planned Actions

You will learn about Finite State Machines (FSM), which determine the next action based on the current state and input. Through the process of translating state diagrams and state tables into circuits, you will master the method of designing complex behaviors using small sets of rules.

Section 13

Project: Traffic Light Controller Design

Apply the state, transition, and output rules of an FSM to a real-world traffic light control problem. Follow the entire process of organizing requirements into a state diagram and designing the necessary circuits to see how sequential logic is utilized in practice.

Section 14

Von Neumann Architecture: Stored-Program

Understand the Von Neumann architecture, which stores instructions and data in the same memory. We will examine the core idea of how programs change a computer's operation without altering hardware wiring, along with its limitations.

Section 15

Instructions and Machine Code: The Language of the CPU

Read the Instruction Set Architecture (ISA) understood by the CPU and the bit configuration of machine language. Understand the process by which programs written by humans are transformed into a sequence of instructions for the CPU to execute by connecting operations, data movement, and branch instructions.

Section 16

Datapath: Connecting CPU Operations

Connect the program counter, registers, ALU, and memory into a single datapath. Visually track where the value starts and which components it passes through when a single instruction is executed.

Section 17

Control: CPU Instruction Interpretation

You will learn the principles of interpreting instruction bits and sending control signals to each component of the datapath. By completing the fetch-decode-execute cycle, you will understand how the CPU independently determines its next action.

Section 18

Final Project: Executing a Program on the CPU

Integrate the previously created ALU, memory, datapath, and control unit into a single CPU. Complete the overall structure by tracing the process of fetching, decoding, and executing each instruction of a simple machine language program until the end.

Section 19

Conclusion: Computer Architecture Map and Next Steps

Reconnect the flow from transistors to program execution into a single map. Check how the concepts you've learned connect to operating systems, data structures, networks, and compilers, and establish your next learning direction.




Target Audience for the Course

Recommended for these people

Programming beginners who can follow grammar and example codes but find it difficult to explain why the code they wrote actually works.

Non-majors and aspiring developers who want to build a solid CS foundation before learning data structures, operating systems, and networks.




Notes before taking the course


Hands-on Environment

  • There is no coding practice. No separate program installation or practice equipment is required.

  • You can learn using only videos and visual materials in your preferred environment, such as a PC, tablet, or mobile device.


Prerequisite Knowledge and Notices

  • It is okay even if you have no programming experience.

  • It is good if you are curious about the principles of how code works.

  • All you need is basic arithmetic and a curiosity about 0 and 1.


Learning Materials

  • For each class, class notes are provided as PDF documents.

Recommended for
these people

Who is this course right for?

  • A beginner who has started programming but feels frustrated because they are stuck on memorizing syntax and don't understand why the code actually works.

  • Aspiring developers who want to build an unwavering foundation in computer science before properly learning operating systems, data structures, and performance optimization.

  • A beginner developer who can follow along and write code but feels lost when debugging because they cannot guess the cause of errors.

  • Learners who want to establish a common foundation for how computers store data and process instructions before learning data structures, operating systems, and networks.

  • A job seeker who started studying development as a non-major and feels that CS terms are like disconnected fragments rather than being linked together.

Need to know before starting?

  • No prior knowledge is required other than basic arithmetic operations.

  • No programming experience is required.

Hello
This is codingmax

Career Verified

623

Learners

49

Reviews

18

Answers

4.9

Rating

4

Courses

Hello. I am CodingMax, the operator of the Enjoyable Coding Experience on YouTube - CodingMax channel.
I enjoy learning and sharing new knowledge as I go through life. 😊

 

📺 https://www.youtube.com/@coding-max
📘https://www.codingmax.net

 

I will always come back with informative and substantial content!

More

Curriculum

All

103 lectures ∙ (11hr 37min)

Course Materials:

Lecture resources
Published: 
Last updated: 

Reviews

Not enough reviews.
Please write a valuable review that helps everyone!

codingmax's other courses

Check out other courses by the instructor!

Similar courses

Explore other courses in the same field!

Limited time deal

$49,500.00

50%

$77.00