Merge pull request #5 from TrudeEH/computer

New Note: Computer from Scratch

content/.obsidian/appearance.json

@@ -5,5 +5,6 @@
   "textFontFamily": "Adwaita Sans",
   "monospaceFontFamily": "Adwaita Mono",
   "nativeMenus": false,
-  "baseFontSize": 16
+  "baseFontSize": 16,
+  "theme": "obsidian"
 }

content/.obsidian/community-plugins.json

@@ -3,5 +3,6 @@
   "obsidian-linter",
   "table-editor-obsidian",
   "obsidian-languagetool-plugin",
-  "obsidian-link-converter"
+  "obsidian-link-converter",
+  "oz-clear-unused-images"
 ]

content/.obsidian/plugins/oz-clear-unused-images/manifest.json

@@ -0,0 +1,11 @@
+{
+    "id": "oz-clear-unused-images",
+    "name": "Clear Unused Images",
+    "version": "1.1.1",
+    "minAppVersion": "0.11.13",
+    "description": "Clear the images that you are not using anymore in your markdown notes to save space.",
+    "author": "Ozan",
+    "authorUrl": "https://www.ozan.pl",
+    "fundingUrl": "https://ko-fi.com/ozante",
+    "isDesktopOnly": false
+}

content/.obsidian/plugins/oz-clear-unused-images/styles.css

@@ -0,0 +1,10 @@
+.unused-images-logs {
+    margin-bottom: 13px;
+    margin-top: 5px;
+}
+
+.unused-images-center-wrapper {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}

content/.obsidian/workspace.json

@@ -13,12 +13,12 @@
             "state": {
               "type": "markdown",
               "state": {
-                "file": "notes/ready/pass.md",
+                "file": "notes/ready/how_to_computer/index.md",
                 "mode": "source",
                 "source": false
               },
               "icon": "lucide-file",
-              "title": "pass"
+              "title": "index"
             }
           }
         ]
@@ -78,7 +78,7 @@
       }
     ],
     "direction": "horizontal",
-    "width": 200
+    "width": 331.5
   },
   "right": {
     "id": "f049c1d8215eafd9",
@@ -141,13 +141,23 @@
             "state": {
               "type": "outline",
               "state": {
-                "file": "notes/ready/pass.md",
+                "file": "notes/ready/how_to_computer/index.md",
                 "followCursor": false,
                 "showSearch": false,
                 "searchQuery": ""
               },
               "icon": "lucide-list",
-              "title": "Outline of pass"
+              "title": "Outline of index"
+            }
+          },
+          {
+            "id": "7f8f8508a01e0795",
+            "type": "leaf",
+            "state": {
+              "type": "advanced-tables-toolbar",
+              "state": {},
+              "icon": "spreadsheet",
+              "title": "Advanced Tables"
             }
           }
         ],
@@ -171,6 +181,32 @@
   },
   "active": "ab03f7100c1ce0fb",
   "lastOpenFiles": [
+    "notes/ready/c-snippets.md",
+    "notes/ready/encryption.md",
+    "notes/ready/firewall.md",
+    "notes/ready/gdb.md",
+    "notes/ready/git.md",
+    "notes/ready/http.md",
+    "notes/ready/https-ssl-certs.md",
+    "notes/ready/irc.md",
+    "notes/ready/how_to_computer/d1.png",
+    "notes/ready/how_to_computer/index.md",
+    "notes/ready/how_to_computer/Pasted image 20250306105245.png",
+    "notes/ready/how_to_computer/Pasted image 20250311102143.png",
+    "Pasted image 20250311101850.png",
+    "Pasted image 20250311100411.png",
+    "notes/ready/how_to_computer/Pasted image 20250311091929.png",
+    "notes/ready/how_to_computer/Pasted image 20250311091659.png",
+    "notes/ready/how_to_computer/Pasted image 20250311091203.png",
+    "notes/ready/how_to_computer/Pasted image 20250311083348.png",
+    "notes/ready/how_to_computer/Pasted image 20250311083221.png",
+    "notes/ready/c-language.md",
+    "notes/ready/binary_operations/index.md",
+    "notes/ready/cpu_architecture/index.md",
+    "Clippings/Latches in Digital Logic - GeeksforGeeks.md",
+    "Clippings",
+    "notes/ready/how_to_computer",
+    "notes/ready/pass.md",
     "posts/notes-update.md",
     "_Templates/post.md",
     "_Templates/note.md",
@@ -182,27 +218,6 @@
     "notes/drafts/linux/index.md",
     "TODO.md",
     "notes/ready/flask.md",
-    "notes/ready/gdb.md",
-    "notes/ready/git.md",
-    "notes/ready/http.md",
-    "notes/ready/html.md",
-    "notes/ready/binary_operations/d1.png",
-    "notes/ready/binary_operations/index.md",
-    "notes/ready/binary_operations/d6.png",
-    "notes/ready/binary_operations/d5.png",
-    "notes/ready/binary_operations/d4.png",
-    "notes/ready/binary_operations/d3.png",
-    "notes/ready/binary_operations/d2.png",
-    "notes/ready/binary_operations/multiplication.png",
-    "notes/ready/firewall.md",
-    "drafts/nvim.md",
-    "drafts/rust.md",
-    "drafts/swift.md",
-    "drafts/TODO.md",
-    "drafts/Untitled.md",
-    "drafts/hardware-tools.md",
-    "drafts/macOS.md",
-    "ready/algorithms_and_data/index.md",
-    "ready/binary_operations/index.md"
+    "notes/ready/html.md"
   ]
 }

content/TODO.md

@@ -19,5 +19,6 @@ In draft folder? (checkbox)
 - [x] Neovim, vim bindings, text editor
 - [x] Hardware Debug/Repair Tools (maybe integrate JCionx page?)
 - [ ] Android and custom ROMs
+- [ ] netcat
 
 ### Enhancements

content/notes/drafts/nvim.md

@@ -1,14 +1,18 @@
 ---
-title: "nvim"
+title: nvim
 description: 
 draft: true
-tags: 
+tags:
+  - tools
+  - nvim
+  - vim
 author: TrudeEH
 showToc: true
 ---
 
 ## VIM Bindings
 
+
 ## Using Neovim
 
 ## Configuring Neovim

content/notes/ready/binary_operations/index.md

@@ -1,345 +0,0 @@
----
-title: Binary Operations
-description: 
-draft: false
-tags:
-  - computer-science
-author: TrudeEH
-showToc: true
----
-
-## Binary
-
-Binary is a base-2 numeral system: A simple way to represent numbers using only two states.
-
-|Binary|Decimal|Hexadecimal|
-|---|---|---|
-|0000|00|00|
-|0001|01|01|
-|0010|02|02|
-|0011|03|03|
-|0100|04|04|
-|0101|05|05|
-|0110|06|06|
-|0111|07|07|
-|1000|08|08|
-|1001|09|09|
-|1010|10|0A|
-|1011|11|0B|
-|1100|12|0C|
-|1101|13|0D|
-|1110|14|0E|
-|1111|15|0F|
-
-![Binary Calculations](binarycalc.png)
-
-### Speaking Binary
-
-> The information in this section is non-standard, and mostly a curiosity.
-
-You may struggle to pronounce large binary numbers, as saying a long list of 0s and 1s is very inefficient. Instead, we can do something like this:
-
-![speaking binary](sb1.png)
-
-To be able to say any binary number, list the number, starting by the last digit:
-
-![speaking binary](sb2.png)
-
-And pronounce the ones that correspond to a `1` bit.
-
-![speaking binary](sb3.png)
-
-#### Pronounce a Binary Number at a Glance
-
-1. Break the number at its largest pair of bits.
-    
-    ![speaking binary](sb4.png)
-    
-2. Represent the left and right sides.
-    
-    ![speaking binary](sb5.png)
-    
-    In this example, there is a `two` in the order of magnitude `hex`.
-    
-3. Continue to represent the left and right sides recursively.
-    
-    ![speaking binary](sb6.png)
-    
-    The last number is `four`.
-
-#### Decode a Spoken Binary Number
-
-Starting with `two hex four`:
-
-1. Find the largest power of two.
-    
-    ![speaking binary](sb7.png)
-    
-2. The number is equal to the left side, times the order of magnitude, plus the right side.
-    
-    ![speaking binary](sb8.png)
-
-#### Avoiding Repetition
-
-Repetition can be avoided by combining some very common, small numbers:
-
-![speaking binary](sb9.png)
-
-![speaking binary](sb10.png)
-
-These shortcuts essentially create a quaternary system to pronounce binary, but in this case, the result improves spoken efficiency by a lot.
-
-## Arithmetic Operations
-
-### Addition
-
-Adding two numbers can be done using a simple, manual algorithm: By adding the last bit of both numbers first, carry if necessary, then move on to the next number, and so on.
-
-| **+** | 0 | 1  |
-| ------- | --- | ---- |
-| 0     | 0 | 1  |
-| 1     | 1 | 10 |
-
-![addition](addition.png)
-
-> To add numbers more efficiently by hand, you can group bits together and memorize the patters, effectively doubling your speed.
-> 
-> ![hand addition](hand_addition1.png)
-> 
-> To improve calculation speed even further, you can group more bits, and learn those patterns as well.
-> 
-> ![hand addition](hand_addition2.png)
-
-#### Half Adder
-
-Add 2, single-digit binary numbers.
-
-| **A** | **B** | **Carry** | **Sum** |
-| ----- | ----- | --------- | ------- |
-| 0     | 0     | 0         | 0       |
-| 0     | 1     | 0         | 1       |
-| 1     | 0     | 0         | 1       |
-| 1     | 1     | 1         | 0       |
-
-![image68](image68.png)
-
-#### Full Adder
-
-When adding 2 binary numbers, one operation might return a carry value, which the `half adder` can't accept, as it only has 2 inputs.
-
-![image69](image69.png)
-
-To solve this issue, a `full adder` accepts 3 inputs.
-
-![image70](image70.png)
-
-#### 8-Bit Adder
-
-![image71](image71.png)
-
-### Subtraction
-
-Subtraction can result in negative numbers. Like how additions need a carry, subtraction needs a borrow.
-
-#### Half Subtractor
-
-Subtract 2, single-digit binary numbers.
-
-| **A** | **B** | Diff | **Borrow** |
-| ----- | ----- | ---- | ---------- |
-| 0     | 0     | 0    | 0          |
-| 0     | 1     | 1    | 1          |
-| 1     | 0     | 1    | 0          |
-| 1     | 1     | 0    | 0          |
-
-![image72](image72.png)
-
-#### Full Subtractor
-
-A `full subtractor` accepts the borrow value, allowing us to chain results.
-
-| **A** | **B** | **B**in | **Diff** | **B**out |
-| ----- | ----- | ------- | -------- | -------- |
-| 0     | 0     | 0       | 0        | 0        |
-| 0     | 0     | 1       | 1        | 1        |
-| 0     | 1     | 0       | 1        | 1        |
-| 0     | 1     | 1       | 0        | 1        |
-| 1     | 0     | 0       | 1        | 0        |
-| 1     | 0     | 1       | 0        | 0        |
-| 1     | 1     | 0       | 0        | 0        |
-| 1     | 1     | 1       | 1        | 1        |
-
-![image73](image73.png)
-
-#### 8-Bit Subtractor
-
-![image74](image74.png)
-
-### Multiplication
-
-Multiplication is also similar to its decimal counterpart, but because binary is so small compared to decimal, the steps are also much simpler.
-
-First, multiply the top number to every digit of the bottom one, and then add the results together.
-
-| X   | 0   | 1   |
-| --- | --- | --- |
-| 0   | 0   | 0   |
-| 1   | 0   | 1   |
-
-![multiplication](multiplication.png)
-
-#### 2-Bit By 2-Bit Multiplier
-
-![image75](image75.png)
-
-### Division
-
-1. Find the smallest part of the dividend greater than or equal to the **divisor**.![d1](d1.png)
-
-  
-2. Write the first digit of **the answer**, and **copy the original divisor down**.![d2](d2.png)
-
-  
-3. Subtract the **aligned dividend digits** by **the digits under the dividend**.![d3](d3.png)
-
-4. Lower **the next dividend digit**.![d4](d4.png)
-
-5. Is **the total** greater or equal to the **divisor**? If so, add a `1` to the answer. If not, **add a `0` to the answer and return to step 4**.![d5](d5.png)
-
-
-6. Return to step 2, until you reach the end of the number. If you reached the end, you found **the answer**.![d6](d6.png)
-
-### ASCII
-
-Binary can also be used to represent characters.
-
-| Dec | Hex | Binary   | HTML     | Char        | Description               |
-| --- | --- | -------- | -------- | ----------- | ------------------------- |
-| 0   | 00  | 00000000 | `�`   | NUL         | Null                      |
-| 1   | 01  | 00000001 | ``   | SOH         | Start of Heading          |
-| 2   | 02  | 00000010 | ``   | STX         | Start of Text             |
-| 3   | 03  | 00000011 | ``   | ETX         | End of Text               |
-| 4   | 04  | 00000100 | ``   | EOT         | End of Transmission       |
-| 5   | 05  | 00000101 | ``   | ENQ         | Enquiry                   |
-| 6   | 06  | 00000110 | ``   | ACK         | Acknowledge               |
-| 7   | 07  | 00000111 | ``   | BEL         | Bell                      |
-| 8   | 08  | 00001000 | ``   | BS          | Backspace                 |
-| 9   | 09  | 00001001 | `	`   | HT          | Horizontal Tab            |
-| 10  | 0A  | 00001010 | `
`  | LF          | Line Feed                 |
-| 11  | 0B  | 00001011 | ``  | VT          | Vertical Tab              |
-| 12  | 0C  | 00001100 | ``  | FF          | Form Feed                 |
-| 13  | 0D  | 00001101 | `
`  | CR          | Carriage Return           |
-| 14  | 0E  | 00001110 | ``  | SO          | Shift Out                 |
-| 15  | 0F  | 00001111 | ``  | SI          | Shift In                  |
-| 16  | 10  | 00010000 | ``  | DLE         | Data Link Escape          |
-| 17  | 11  | 00010001 | ``  | DC1         | Device Control 1          |
-| 18  | 12  | 00010010 | ``  | DC2         | Device Control 2          |
-| 19  | 13  | 00010011 | ``  | DC3         | Device Control 3          |
-| 20  | 14  | 00010100 | ``  | DC4         | Device Control 4          |
-| 21  | 15  | 00010101 | ``  | NAK         | Negative Acknowledge      |
-| 22  | 16  | 00010110 | ``  | SYN         | Synchronize               |
-| 23  | 17  | 00010111 | ``  | ETB         | End of Transmission Block |
-| 24  | 18  | 00011000 | ``  | CAN         | Cancel                    |
-| 25  | 19  | 00011001 | ``  | EM          | End of Medium             |
-| 26  | 1A  | 00011010 | ``  | SUB         | Substitute                |
-| 27  | 1B  | 00011011 | ``  | ESC         | Escape                    |
-| 28  | 1C  | 00011100 | ``  | FS          | File Separator            |
-| 29  | 1D  | 00011101 | ``  | GS          | Group Separator           |
-| 30  | 1E  | 00011110 | ``  | RS          | Record Separator          |
-| 31  | 1F  | 00011111 | ``  | US          | Unit Separator            |
-| 32  | 20  | 00100000 | ` `  | space       | Space                     |
-| 33  | 21  | 00100001 | `!`  | !           | exclamation mark          |
-| 34  | 22  | 00100010 | `"`  | "           | double quote              |
-| 35  | 23  | 00100011 | `#`  | #           | number                    |
-| 36  | 24  | 00100100 | `$`  | $           | dollar                    |
-| 37  | 25  | 00100101 | `%`  | %           | percent                   |
-| 38  | 26  | 00100110 | `&`  | &           | ampersand                 |
-| 39  | 27  | 00100111 | `'`  | '           | single quote              |
-| 40  | 28  | 00101000 | `(`  | (           | left parenthesis          |
-| 41  | 29  | 00101001 | `)`  | )           | right parenthesis         |
-| 42  | 2A  | 00101010 | `*`  | *           | asterisk                  |
-| 43  | 2B  | 00101011 | `+`  | +           | plus                      |
-| 44  | 2C  | 00101100 | `,`  | ,           | comma                     |
-| 45  | 2D  | 00101101 | `-`  | -           | minus                     |
-| 46  | 2E  | 00101110 | `.`  | .           | period                    |
-| 47  | 2F  | 00101111 | `/`  | /           | slash                     |
-| 48  | 30  | 00110000 | `0`  | 0           | zero                      |
-| 49  | 31  | 00110001 | `1`  | 1           | one                       |
-| 50  | 32  | 00110010 | `2`  | 2           | two                       |
-| 51  | 33  | 00110011 | `3`  | 3           | three                     |
-| 52  | 34  | 00110100 | `4`  | 4           | four                      |
-| 53  | 35  | 00110101 | `5`  | 5           | five                      |
-| 54  | 36  | 00110110 | `6`  | 6           | six                       |
-| 55  | 37  | 00110111 | `7`  | 7           | seven                     |
-| 56  | 38  | 00111000 | `8`  | 8           | eight                     |
-| 57  | 39  | 00111001 | `9`  | 9           | nine                      |
-| 58  | 3A  | 00111010 | `:`  | :           | colon                     |
-| 59  | 3B  | 00111011 | `&#59;`  | ;           | semicolon                 |
-| 60  | 3C  | 00111100 | `&#60;`  | <           | less than                 |
-| 61  | 3D  | 00111101 | `&#61;`  | =           | equality sign             |
-| 62  | 3E  | 00111110 | `&#62;`  | >           | greater than              |
-| 63  | 3F  | 00111111 | `&#63;`  | ?           | question mark             |
-| 64  | 40  | 01000000 | `&#64;`  | @           | at sign                   |
-| 65  | 41  | 01000001 | `&#65;`  | A           |                           |
-| 66  | 42  | 01000010 | `&#66;`  | B           |                           |
-| 67  | 43  | 01000011 | `&#67;`  | C           |                           |
-| 68  | 44  | 01000100 | `&#68;`  | D           |                           |
-| 69  | 45  | 01000101 | `&#69;`  | E           |                           |
-| 70  | 46  | 01000110 | `&#70;`  | F           |                           |
-| 71  | 47  | 01000111 | `&#71;`  | G           |                           |
-| 72  | 48  | 01001000 | `&#72;`  | H           |                           |
-| 73  | 49  | 01001001 | `&#73;`  | I           |                           |
-| 74  | 4A  | 01001010 | `&#74;`  | J           |                           |
-| 75  | 4B  | 01001011 | `&#75;`  | K           |                           |
-| 76  | 4C  | 01001100 | `&#76;`  | L           |                           |
-| 77  | 4D  | 01001101 | `&#77;`  | M           |                           |
-| 78  | 4E  | 01001110 | `&#78;`  | N           |                           |
-| 79  | 4F  | 01001111 | `&#79;`  | O           |                           |
-| 80  | 50  | 01010000 | `&#80;`  | P           |                           |
-| 81  | 51  | 01010001 | `&#81;`  | Q           |                           |
-| 82  | 52  | 01010010 | `&#82;`  | R           |                           |
-| 83  | 53  | 01010011 | `&#83;`  | S           |                           |
-| 84  | 54  | 01010100 | `&#84;`  | T           |                           |
-| 85  | 55  | 01010101 | `&#85;`  | U           |                           |
-| 86  | 56  | 01010110 | `&#86;`  | V           |                           |
-| 87  | 57  | 01010111 | `&#87;`  | W           |                           |
-| 88  | 58  | 01011000 | `&#88;`  | X           |                           |
-| 89  | 59  | 01011001 | `&#89;`  | Y           |                           |
-| 90  | 5A  | 01011010 | `&#90;`  | Z           |                           |
-| 91  | 5B  | 01011011 | `&#91;`  | [           | left square bracket       |
-| 92  | 5C  | 01011100 | `&#92;`  | \|backslash |                           |
-| 93  | 5D  | 01011101 | `&#93;`  | ]           | right square bracket      |
-| 94  | 5E  | 01011110 | `&#94;`  | ^           | caret / circumflex        |
-| 95  | 5F  | 01011111 | `&#95;`  | _           | underscore                |
-| 96  | 60  | 01100000 | `&#96;`  | `           | grave / accent            |
-| 97  | 61  | 01100001 | `&#97;`  | a           |                           |
-| 98  | 62  | 01100010 | `&#98;`  | b           |                           |
-| 99  | 63  | 01100011 | `&#99;`  | c           |                           |
-| 100 | 64  | 01100100 | `&#100;` | d           |                           |
-| 101 | 65  | 01100101 | `&#101;` | e           |                           |
-| 102 | 66  | 01100110 | `&#102;` | f           |                           |
-| 103 | 67  | 01100111 | `&#103;` | g           |                           |
-| 104 | 68  | 01101000 | `&#104;` | h           |                           |
-| 105 | 69  | 01101001 | `&#105;` | i           |                           |
-| 106 | 6A  | 01101010 | `&#106;` | j           |                           |
-| 107 | 6B  | 01101011 | `&#107;` | k           |                           |
-| 108 | 6C  | 01101100 | `&#108;` | l           |                           |
-| 109 | 6D  | 01101101 | `&#109;` | m           |                           |
-| 110 | 6E  | 01101110 | `&#110;` | n           |                           |
-| 111 | 6F  | 01101111 | `&#111;` | o           |                           |
-| 112 | 70  | 01110000 | `&#112`  | p           |                           |
-| 113 | 71  | 01110001 | `&#113;` | q           |                           |
-| 114 | 72  | 01110010 | `&#114;` | r           |                           |
-| 115 | 73  | 01110011 | `&#115;` | s           |                           |
-| 116 | 74  | 01110100 | `&#116;` | t           |                           |
-| 117 | 75  | 01110101 | `&#117;` | u           |                           |
-| 118 | 76  | 01110110 | `&#118;` | v           |                           |
-| 119 | 77  | 01110111 | `&#119;` | w           |                           |
-| 120 | 78  | 01111000 | `&#120;` | x           |                           |
-| 121 | 79  | 01111001 | `&#121;` | y           |                           |
-| 122 | 7A  | 01111010 | `&#122;` | z           |                           |
-| 123 | 7B  | 01111011 | `&#123;` | {           | left curly bracket        |
-| 124 | 7C  | 01111100 | `&#124;` | \|          | vertical bar              |
-| 125 | 7D  | 01111101 | `&#125;` | }           | right curly bracket       |
-| 126 | 7E  | 01111110 | `&#126;` | ~           | tilde                     |
-| 127 | 7F  | 01111111 | `&#127;` | DEL         | delete                    |

content/notes/ready/cpu_architecture/index.md

@@ -1,161 +0,0 @@
----
-title: CPU Architecture
-description: 
-draft: false
-tags:
-  - computer-science
-author: TrudeEH
-showToc: true
----
-
-## Components
-
-### Registers
-
-We can combine registers to reduce the amount of wires needed.  
-![image8](image8.png)  
-Using a data bus (wiring at the top) and a binary decoder, we can select which register to read/write to.
-
-### Memory
-
-![image9](image9.png)
-
-## Assembly
-
-Assembly is a human-friendly representation of code: binary values that a computer can understand.  
-![image10](image10.png)  
-An assembler converts ASM instructions into machine code, which is given to the CPU as input.
-
-### Arithmetic Operations
-
-For example, a simple computer architecture could use `00` to represent arithmetic operations.  
-![image11](image11.png)  
-To decide which type of operation to execute (subtraction, multiplication, addition, etc), the 3rd and 4th bits could be used.  
-![image12](image12.png)  
-Using a [index](ready/binary_operations/index.md), we can build an inefficient, but simple circuit to do this.  
-![image13](image13.png)  
-This type of circuit is an Arithmetic Logic Unit (ALU).
-
-### Memory Operations
-
-Of course, assembly can also provide instructions to store or load values.  
-![image14](image14.png)
-
-#### Load
-
-```Assembly
-LOAD R2 1000 ;Load into register 2 the value in the memory address 1000
-```
-
-![image15](image15.png)
-
-#### Store
-
-```Assembly
-STORE R1 0110 ;Store the value in register 1 into the 0110 memory address
-```
-
-![image16](image16.png)
-
-#### Select Which Instruction to Execute (first 2 bits)
-
-To decide which operation to execute, a binary decoder can be used.  
-![image17](image17.png)  
-For memory operations, the 3rd and 4th bits are used to select which register to use.  
-![image18](image18.png)  
-The last 4 bits represent the memory address to read/write to.  
-![image19](image19.png)
-
-### Instruction Register
-
-For the instruction to be given, it is stored in a special register: An Instruction Register.  
-![image20](image20.png)
-
-### Optimization
-
-We can use a single Binary Decoder instead of two, to achieve the same result. (Optimization on the right pane)  
-![image21](image21.png)  
-Different architectures can have the exact same functionality, while being implemented differently, or even having different instructions. This is why code that is compiled for Intel x64 is not compatible with ARM or RISC-V.
-
-## Control Unit
-
-We can finally add the ALU (Arithmetic Logic Unit) we built before into the new circuit, like so:  
-![image22](image22.png)  
-The gray trapezoids are multiplexers:  
-![image23](image23.png)  
-The output value is then stored in a temporary register, before replacing the first operand register's value.  
-The component we just built to control the `ALU` is part of a `Control Unit`. The full `control unit` is very complex, as it needs to handle every possible instruction. (So far, we have seen how to implement the `ALU` and `RAM`.)  
-![image24](image24.png)  
-Each register in the `CU` has a specific purpose, unlike `RAM`, which can be used to store any values.  
-![image25](image25.png)  
-To read the first instruction, the `CU` will **fetch** data from the first address in memory.  
-![image26](image26.png)  
-After **fetching**, the `CU` will **decode** the instruction: interpret the bit sequence in the `instruction register`, to send the necessary signals to the components that will **execute** the instruction. We can finally load instructions into the instruction register.  
-![image27](image27.png)  
-Then, the `CU` increments 1 byte, to point the `address register` to the next instruction. (Modern architectures increment different values, as the instruction set is more complex)  
-If the instruction is an arithmetic operation, the steps are similar. The ALU stores the output in a temporary register, which overwrites the register 0 with the result. The result can then be stored in `RAM`.  
-![image28](image28.png)
-
-## Load a Program Into Memory
-
-So far, we can store instructions in memory, but it is also necessary to store values, besides from the instructions themselves.  
-For example:  
-![image29](image29.png)  
-This program uses 2 numeric values. The first 2 instructions load these values into the registers, and then, these values are added together and stored in another memory address. The final instruction, `HALT`, marks the end of the program, to make sure the `CU` does not attempt to read the number 20 as an instruction.  
-If the program is extended, all memory addresses must be altered. To fix this issue, we can instead store values at the end of the memory stack.  
-![image30](image30.png)
-
-## Conditions and Loops
-
-To create a loop, we can simply jump to a smaller address in memory.  
-![image31](image31.png)  
-Internally, the `JMP` command overwrites the Address Register, making it so that the next CPU **cycle** *fetches* the chosen memory address, instead of the next one.  
-![image32](image32.png)
-
-### Flags
-
-Sometimes, we might want to loop only if a certain condition is met.  
-For context, imagine subtracting a number from itself. In this case, the ALU will provide some extra information, using 1 bit registers called `flags`.  
-![image33](image33.png)  
-
-| N   | Flag         | Description                                               |
-| --- | ------------ | --------------------------------------------------------- |
-| 0   | **O**verflow | When a number is too large to fit in the output register. |
-| 1   | **Z**ero     | When the result is zero.                                  |
-| 0   | **N**egative | When a number is negative.                                |
-
-This additional information can be used to make decisions, and make **conditional jumps** possible.  
-
-| ASM            | Command       | Description                                                                                                                                                                               |
-| -------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `JMP_OFW XXXX` | Jump Overflow | Overwrites the `Address Register` with the value `XXXX` if the `O_FLAG` is **ON**. If the flag is **OFF**, the `Address Register`'s value is incremented by **1**.                        |
-| `JMP_ZRO XXXX` | Jump Zero     | Overwrites the `Address Register` with the value `XXXX` if the `Z_FLAG` is **ON**. If the flag is **OFF**, the `Address Register`'s value is incremented by **1**.                        |
-| `JMP_NEG XXXX` | Jump Negative | Overwrites the `Address Register` with the value `XXXX` if the `N_FLAG` is **ON**. If the flag is **OFF**, the `Address Register`'s value is incremented by **1**.                        |
-| `JMP_ABV XXXX` | Jump Above    | Overwrites the `Address Register` with the value `XXXX` if **neither** the `Z_FLAG` nor `N_FLAG` are **ON**. If either is **ON,** the `Address Register`'s value is incremented by **1**. |
-
-Comparing two numbers is the same as subtracting them.  
-
-$$a - 5 = b$$
-
-| **b** is negative | **b** is zero | **b** is positive |
-| ----------------- | ------------- | ----------------- |
-| then              | then          | then              |
-| a < 5             | a == 5        | a > 5             |
-
-For example:  
-![image34](image34.png)  
-An `IF` statement works in the exact same way, but without the need to loop:  
-![image35](image35.png)  
-Note: These instructions are not from any real architecture. These are examples for this simple, custom architecture.
-
-## Clock
-
-The final piece of the puzzle is the clock. A clock can give us time before a circuit loops.  
-![image36](image36.png)  
-This is necessary, because energy travels extremely quickly, and so, all memory would be reset before we could even use the stored values. Each clock tick corresponds to an action the `CU` performs (fetch, decode and execute).  
-A `Data FLIP-FLOP`, for example, uses the clock to store data, acting as the manual `RESET` input.  
-![image37](image37.png)  
-This circuit can be used to build a single bit register.  
-![image38](image38.png)  
-To generate a clock pulse, we can use a circuit similar to this one:  
-![image39](image39.png)

content/notes/ready/diodes.md

@@ -1,109 +0,0 @@
----
-title: Diodes
-description: 
-draft: false
-tags:
-  - electronics
-author: TrudeEH
-showToc: true
----
-
-
-
-A diode allows current to only flow in one direction in a circuit.
-
-## Schematic
-
-```Plain
-Anode (+) --|>|-- Cathode (-)
-```
-
-## Examples
-
-```Plain
-[Conventional Current (+) -> (-)]
-(+)------|>|------(-)   Current can flow - The diode is now a conductor.
-(+)------|<|------(-)   Current can't flow - The diode is now an insulator.
-```
-
-## Use Cases
-
-- Protect a circuit (if a battery is connected incorrectly, for example)
-- Convert AC to DC current  
-Fun fact: An LED, for example, is a Light-Emitting Diode.
-
-## How a Diode Works
-
-### Conductors and Insulators
-
-An atom contains the following elements:
-- Nucleus (Protons - Neutrons)
-- Orbital Shells (Holds the electrons, which orbit around the nucleus)
-- Conduction band  
-The electrons closest to the nucleus hold the most energy.  
-The outermost shell is the valence shell. A conductor has 1-3 electrons in the valence shell.  
-If an electron reaches the conduction band, it can break free and move to another atom.  
-An insulator, however, has a conduction band that is far from the valence shell, making it difficult for an electron to escape.  
-For example, for copper (a great conductor), the valence shell and conduction band overlap, so it's very easy for an electron to jump between atoms.  
-Semiconductors have a conduction band close to the valence shell, but have one extra electron in it, making it an insulator. However, given some external energy, some electrons will gain enough energy to reach the conduction band and become free.
-
-### P-Type and N-Type Doping
-
-Silicon is a good semiconductor, having 4 electrons in its valence shell. When close to other `Si` atoms, they share 4 electrons with their neighbors, thus, having 8, each, and becoming stable.
-
-```Plain
-Silicon:
-Si Si Si Si Si Si Si Si Si Si Si
-Si Si Si Si Si Si Si Si Si Si Si
-Si Si Si Si Si Si Si Si Si Si Si
-Si Si Si Si Si Si Si Si Si Si Si
-Si Si Si Si Si Si Si Si Si Si Si
-Si Si Si Si Si Si Si Si Si Si Si
-```
-
-#### N-Type
-
-Some Phosphorus is added to the Silicon. ==`p`== has one extra electron in its valence shell.  
-These electrons are not needed, and so, they flow freely from atom to atom.  
-
-```Plain
-Si Si p Si Si Si Si Si Si Si p
-p Si Si Si Si p Si Si Si Si Si
-Si Si Si p Si Si Si Si p Si Si
-Si p Si Si p Si Si Si Si Si Si
-Si Si Si Si Si Si p Si Si p Si
-Si p Si Si Si Si Si Si p Si Si
-```
-
-#### P-Type
-
-Some Aluminum is added to the Silicon. `Al` is missing one electron, so it can't provide its 4 neighbors with an electron to share.
-
-```Plain
-Si Si Al Si Si Si Si Si Si Si Al
-Al Si Si Si Si Al Si Si Si Si Si
-Si Si Si Al Si Si Si Si Al Si Si
-Si Al Si Si Al Si Si Si Si Si Si
-Si Si Si Si Si Si Al Si Si Al Si
-Si Al Si Si Si Si Si Si Al Si Si
-```
-
-### Combining both Types
-
-When an N-Type is combined with a P-Type, some electrons from the N-Type side will move over to the P-Type side and occupy the missing electrons there. This creates a barrier between both types, creating an electric field that prevents more electrons from switching sides.
-
-#### Forward Bias
-
-If energy is provided to the Cathode, the electrons flow, as the voltage is superior to the barrier's.
-
-```Plain
-(-)-----[P|N]-----(+)
-```
-
-#### Reverse Bias
-
-If energy is provided to the Anode, the electrons can't flow, as the barrier expands.
-
-```Plain
-(-)--[P]      [N]--(+)
-```