Your First Computer - Revision history

Lawrziepan: Added a paragraph in the example program section describing the assembly notation used in the example

2025-10-18T09:05:57Z

Added a paragraph in the example program section describing the assembly notation used in the example

← Older revision		Revision as of 09:05, 18 October 2025
Line 185:		Line 185:
	Move 6, 0 ; 10 000 110		Move 6, 0 ; 10 000 110
	Jump ; 11 101 ___		Jump ; 11 101 ___
	</syntaxhighlight>Visualizing the process, we can imagine the first instruction being copied into the instruction register, the instruction pointer being incremented, then the value being copied from the instruction register to register 0.		</syntaxhighlight>Note that in this notation, the instruction name comes first, and subsequent numbers are the operands of the instruction. Instructions such as the ''Move'' instruction have two operands; The first is the destination register, which describes the register to save data to, the other is the source register, which describes the register to load data from. For example, the Move instruction moves the data from the source register, and '''copies''' it to the destination register directly.

			Visualizing the process, we can imagine the first instruction being copied into the instruction register, the instruction pointer being incremented, then the value being copied from the instruction register to register 0.

	Then the step counter resets, and we begin again, fetching the instruction, incrementing the instruction counter, and moving the content of register 0 to register 2. Reset the step counter and on and on it goes.		Then the step counter resets, and we begin again, fetching the instruction, incrementing the instruction counter, and moving the content of register 0 to register 2. Reset the step counter and on and on it goes.

N00basaurus: Expanded the Building a Computer portion of the guide.

2025-10-18T00:27:37Z

Expanded the Building a Computer portion of the guide.

@@ Line 194: / Line 194: @@
 ==Building the Computer==
-This will make rearranging things easier.
+=== Mental Preparations ===
-Use sockets to create interfaces. This will make changing and swapping out a component easier.
+If you want to know what it takes to carry out a big project, the book "How Big Things Get Done" by Bent Flyvbjerg and Dan Gardner is an invaluable resource. If you read it, you might get the impression that the "correct" way to handle a project like this is to plan every little detail on paper ''before'' you start building.
-It helps to build everything except the control unit first, then to build the control unit interface so you know what inputs and outputs your control unit needs to have.
+'''Do not do this!'''
-Test as you go, and be prepared to do some troubleshooting. Nothing ever works perfectly the first time.
+The key idea you should take away from this book is there are some things you just don't think about until you start putting shovels in the ground. Rather than waiting until this moment, instead try putting a spoon in a sandbox first. Do it for real, but on a smaller and cheaper scale.

N00basaurus: Minor update to phrasing and formatting

2025-10-17T21:36:51Z

Minor update to phrasing and formatting

← Older revision		Revision as of 21:36, 17 October 2025
Line 27:		Line 27:
	Coordinating these instruction fetches, data moves, and ALU operations is the control unit. It's job is to decode the instruction fetched from program memory and decide what control signals to send out and when.		Coordinating these instruction fetches, data moves, and ALU operations is the control unit. It's job is to decode the instruction fetched from program memory and decide what control signals to send out and when.

	While this module can get very complicated, the simplest control unit consists of a [[Lookup Table\|lookup table]] that takes the current instruction and the value of a [[counter]] as a combined input, and produces all the read, write, and function signals the computer needs as an output. A clock is used to increment the counter, and ~~produce~~ a [[Edge Detection\|~~rising~~ edge]] ~~for the write signals~~, ~~and~~ the table is configured to read from program memory and write to an instruction register when the counter is 0, then increment an instruction pointer register when the counter is 1. From there, the table can be configured to do different things depending on the value of the instruction register. The counter register is reset when the instruction is complete, and the fetch-decode-execute cycle repeats.		While this module can get very complicated, the simplest control unit consists of a [[Lookup Table\|lookup table]] that takes the current instruction and the value of a [[counter]] as a combined input, and produces all the read, write, and function signals the computer needs as an output. A clock is used to increment the counter, and to a pulse for the write signals through the use of a [[Edge Detection\|falling edge detector]], while the table is configured to read from program memory and write to an instruction register when the counter is 0, then increment an instruction pointer register when the counter is 1. From there, the table can be configured to do different things depending on the value of the instruction register. The counter register is reset when the instruction is complete, and the fetch-decode-execute cycle repeats.

	On top of being able to move data around and perform operations, there is a third common type of action a computer can perform called a control flow instruction. These consist of instructions like jumping, conditional branching, calling and returning, and software interrupts. Though we'll only be focusing on jumping and conditional branching here. These all have one thing in common, and that is to break the linear sequence of the program.		On top of being able to move data around and perform operations, there is a third common type of action a computer can perform called a control flow instruction. These consist of instructions like jumping, conditional branching, calling and returning, and software interrupts. Though we'll only be focusing on jumping and conditional branching here. These all have one thing in common, and that is to break the linear sequence of the program.
Line 38:		Line 38:

	== Planning A Computer ==		== Planning A Computer ==
	While you might be inclined to jump head-first into building, computers are complicated things, as the previous section shows. A little bit of forethought is required before you start building in order to help guide your building decisions. Otherwise you will end up with a computer that's too messy to modify, and if it ends up malfunctioning, it'll be too messy to troubleshoot as well. '''Documentation''' ~~is key~~.		While you might be inclined to jump head-first into building, computers are complicated things, as the previous section shows. A little bit of forethought is required before you start building in order to help guide your building decisions. Otherwise you will end up with a computer that's too messy to modify, and if it ends up malfunctioning, it'll be too messy to troubleshoot as well. '''Documentation is key'''.

	Before you begin, think about what you want this computer to do. What ALU functions do you want it to have? What special instructions or special hardware? You'll also want to consider key details such as the width of your ALU, the width of your working memory and program memory, as well as the size of these memory modules, as this will determine the width of your address bus and indexing registers.		Before you begin, think about what you want this computer to do. What ALU functions do you want it to have? What special instructions or special hardware? You'll also want to consider key details such as the width of your ALU, the width of your working memory and program memory, as well as the size of these memory modules, as this will determine the width of your address bus and indexing registers.

N00basaurus: /* Instruction Set */ spelling

2025-10-12T15:13:56Z

Instruction Set: spelling

← Older revision		Revision as of 15:13, 12 October 2025
Line 62:		Line 62:
	!Name		!Name
	!Opcode (8 bits)		!Opcode (8 bits)
	!~~Opperands~~		!Operands
	!Description		!Description
	\|-		\|-

N00basaurus: /* Hardware Theory */ Added a schematic diagram for a very basic control unit

2025-10-12T15:03:31Z

Hardware Theory: Added a schematic diagram for a very basic control unit

← Older revision		Revision as of 15:03, 12 October 2025
Line 24:		Line 24:

	While it might be hard to wrap your head around this at first, everything that computers do can mostly be reduced to these two operations: moving data around, and operating on data. How these two operations can be structured to do things like browse the internet or play games requires a study of software, and is thus outside the scope of this article. But under the hood, millions of these operations are happening at a rate of billions a second, and it's this size and speed that allows computers to perform much more complicated tasks.		While it might be hard to wrap your head around this at first, everything that computers do can mostly be reduced to these two operations: moving data around, and operating on data. How these two operations can be structured to do things like browse the internet or play games requires a study of software, and is thus outside the scope of this article. But under the hood, millions of these operations are happening at a rate of billions a second, and it's this size and speed that allows computers to perform much more complicated tasks.
			[[File:A schematic view of a very basic control unit.png\|thumb\|A lookup table takes in as its inputs the content of a step counter and an instruction register, and produces as its outputs various read, write, and function signals. On the clocks rising edge, the step counter is incremented. The lookup table immediately updates its outputs, reading from various components and sending function signals. The write signals do not get sent out though until the falling edge of the clock. As this diagram suggests, the lookup table is in control of its own instruction register, and has the ability to reset the step counter. The instruction register is updated at the beginning of every instruction sequence, and the step counter is reset at the end of every instruction sequence.]]
	Coordinating these instruction fetches, data moves, and ALU operations is the control unit. It's job is to decode the instruction fetched from program memory and decide what control signals to send out and when.		Coordinating these instruction fetches, data moves, and ALU operations is the control unit. It's job is to decode the instruction fetched from program memory and decide what control signals to send out and when.

N00basaurus: Updated the terminology used when talking about instructions. Referring to them as instructions or opcodes rather than just binary integers.

2025-10-12T14:27:41Z

Updated the terminology used when talking about instructions. Referring to them as instructions or opcodes rather than just binary integers.

← Older revision		Revision as of 14:27, 12 October 2025
Line 15:		Line 15:
	All computers, regardless of complexity, need at least these 4 components. Program memory typically made using [[ROM\|read-only memory]], an [[Arithmetic logic unit\|ALU]], working memory typically made using individual [[Register\|registers]] and [[random-access memory]], and a [[Control Unit\|control unit]].		All computers, regardless of complexity, need at least these 4 components. Program memory typically made using [[ROM\|read-only memory]], an [[Arithmetic logic unit\|ALU]], working memory typically made using individual [[Register\|registers]] and [[random-access memory]], and a [[Control Unit\|control unit]].
	[[File:Computer_Structure_diagram.png\|right\|thumb\|300x300px\|The structure of the computer in this article]]		[[File:Computer_Structure_diagram.png\|right\|thumb\|300x300px\|The structure of the computer in this article]]
	Program memory is where the program to be executed is stored. It takes the form of a list of binary numbers called machine code. The computer will step through this list one ~~number~~ at a time, grabbing each ~~number~~, interpreting it, and performing an action corresponding to that ~~number~~. This process is referred to as the fetch-decode-execute cycle.		Program memory is where the program to be executed is stored. It takes the form of a list of binary numbers called machine code, and each number is called an instruction or opcode. The computer will step through this list one instruction at a time, grabbing each instruction, interpreting it, and performing an action corresponding to that instruction. This process is referred to as the fetch-decode-execute cycle.

	Actions that a computer can perform can vary greatly, but two of the most common actions are moving data around, and performing operations using data.		Actions that a computer can perform can vary greatly, but two of the most common actions are moving data around, and performing operations using data.
Line 25:		Line 25:
	While it might be hard to wrap your head around this at first, everything that computers do can mostly be reduced to these two operations: moving data around, and operating on data. How these two operations can be structured to do things like browse the internet or play games requires a study of software, and is thus outside the scope of this article. But under the hood, millions of these operations are happening at a rate of billions a second, and it's this size and speed that allows computers to perform much more complicated tasks.		While it might be hard to wrap your head around this at first, everything that computers do can mostly be reduced to these two operations: moving data around, and operating on data. How these two operations can be structured to do things like browse the internet or play games requires a study of software, and is thus outside the scope of this article. But under the hood, millions of these operations are happening at a rate of billions a second, and it's this size and speed that allows computers to perform much more complicated tasks.

	Coordinating these instruction fetches, data moves, and ALU operations is the control unit. It's job is to decode the ~~binary integer~~ fetched from program memory and decide what control signals to send out and when.		Coordinating these instruction fetches, data moves, and ALU operations is the control unit. It's job is to decode the instruction fetched from program memory and decide what control signals to send out and when.

	While this module can get very complicated, the simplest control unit consists of a [[Lookup Table\|lookup table]] that takes the current instruction ~~integer~~ and the value of a [[counter]] as a combined input, and produces all the read, write, and function signals the computer needs as an output. A clock is used to increment the counter, and produce a [[Edge Detection\|rising edge]] for the write signals, and the table is configured to read from program memory and write to an instruction register when the counter is 0, then increment an instruction pointer register when the counter is 1. From there, the table can be configured to do different things depending on the value of the instruction register. The counter register is reset when the instruction is complete, and the fetch-decode-execute cycle repeats.		While this module can get very complicated, the simplest control unit consists of a [[Lookup Table\|lookup table]] that takes the current instruction and the value of a [[counter]] as a combined input, and produces all the read, write, and function signals the computer needs as an output. A clock is used to increment the counter, and produce a [[Edge Detection\|rising edge]] for the write signals, and the table is configured to read from program memory and write to an instruction register when the counter is 0, then increment an instruction pointer register when the counter is 1. From there, the table can be configured to do different things depending on the value of the instruction register. The counter register is reset when the instruction is complete, and the fetch-decode-execute cycle repeats.

	On top of being able to move data around and perform operations, there is a third common type of action a computer can perform called a control flow instruction. These consist of instructions like jumping, conditional branching, calling and returning, and software interrupts. Though we'll only be focusing on jumping and conditional branching here. These all have one thing in common, and that is to break the linear sequence of the program.		On top of being able to move data around and perform operations, there is a third common type of action a computer can perform called a control flow instruction. These consist of instructions like jumping, conditional branching, calling and returning, and software interrupts. Though we'll only be focusing on jumping and conditional branching here. These all have one thing in common, and that is to break the linear sequence of the program.

	Normally, as part of the fetch-decode-execute cycle, the instruction pointer used to index the program memory is incremented after each instruction fetch. Setting up the next instruction in the list to be executed when the current instruction is complete. By writing a new value to the instruction pointer, we queue up a different section of the program memory to be executed next.		Normally, as part of the fetch-decode-execute cycle, the instruction pointer used to index the program memory is incremented after each instruction fetch. Setting up the next instruction in the list to be executed when the current instruction is complete. By writing a new value to the instruction pointer, we queue up a different section of the program memory, and the first instruction in that section is primed to be executed next.

	This is often used to create infinite loops in your program, or finite loops if you use a conditional branch that resumes a normal execution sequence if a ~~number comparison comes up not~~ equal.		This is often used to create infinite loops in your program, or finite loops if you use a conditional branch that resumes a normal execution sequence if a condition is met, like two numbers being equal or one being greater than the other.

	These three action types are the minimum required to create a [[wikipedia:Turing completeness\|turing complete]] computer - a computer that can calculate anything.		These three action types are the minimum required to create a [[wikipedia:Turing completeness\|turing complete]] computer - a computer that can calculate anything.

N00basaurus: /* Instruction Set */ clearing up an ambiguous "it"

2025-10-12T06:25:55Z

Instruction Set: clearing up an ambiguous "it"

← Older revision		Revision as of 06:25, 12 October 2025
Line 51:		Line 51:

	==== Instruction Set ====		==== Instruction Set ====
	This is the most influential part of planning. This will not only dictate what your computer does, but also how it will be stored in program memory.		This is the most influential part of planning. This will not only dictate what your computer does, but also how programs will be stored in program memory.

	You can design your own instruction set from scratch if you want something more complex. But for our instruction set, we will be adding 4 types of instructions: load immediate, operate, move, and jumping/branching. These will be organized with the prefixes <code>00</code> <code>01</code> <code>10</code> and <code>11</code> respectively.		You can design your own instruction set from scratch if you want something more complex. But for our instruction set, we will be adding 4 types of instructions: load immediate, operate, move, and jumping/branching. These will be organized with the prefixes <code>00</code> <code>01</code> <code>10</code> and <code>11</code> respectively.

N00basaurus: Major rewrite to focus more on teaching the reader what it takes to design and build your own computer, as well as teaching the reader a little more theory. With the build guide serving more as an example than instructions to follow.

2025-10-12T06:20:58Z

Major rewrite to focus more on teaching the reader what it takes to design and build your own computer, as well as teaching the reader a little more theory. With the build guide serving more as an example than instructions to follow.

Show changes

Lawrziepan at 13:14, 20 September 2025

2025-09-20T13:14:20Z

← Older revision		Revision as of 13:14, 20 September 2025
Line 132:		Line 132:
	Jump ; 11 101 ___		Jump ; 11 101 ___
	</syntaxhighlight>		</syntaxhighlight>
	==Building the Computer		==Building the Computer==

Lawrziepan at 13:13, 20 September 2025

2025-09-20T13:13:49Z

← Older revision		Revision as of 13:13, 20 September 2025
Line 132:		Line 132:
	Jump ; 11 101 ___		Jump ; 11 101 ___
	</syntaxhighlight>		</syntaxhighlight>
	~~{{Todo\|I will expand this article later}}~~		==Building the Computer