CSO Notes update

Author: localhost433

notes/courses/CSCI-UA-201/01-num-mem.md

@@ -1,6 +1,6 @@
 ---
 title: Number Systems & Memory Organization
-date: 
+date: 2025-09-02/09
 ---
 
 ## Number system fundamentals
@@ -83,15 +83,12 @@ An $n$-bit quantity can represent $2^n$ distinct values:
 - $1$ bit -> $2$ values.
 - $8$ bits ($1$ byte) -> $2^8 = 256$ values.
 
-### Text encoding
+### Where text and numeric formats live
 
-- **ASCII:** uses $1$ byte ($8$ bits) per character; can encode up to $256$ characters (e.g., `'A' = 65_{10}$).
-- **Unicode:** uses $16$ bits or more; supports many languages and symbols ($2^{16}$ or more code points).
+This note focuses on bases, units, and memory sizing. For how bits represent:
 
-### Numbers
-
-- **Integers:** stored as binary whole numbers (with specific schemes for signed vs unsigned).
-- **Floating-point:** used for real numbers; stored using standardized formats (e.g., IEEE-754) with finite precision, so not all real values can be represented exactly.
+- **Text (ASCII, Unicode, UTF-8)**, see **[02 - Data Representation](https://robinc.vercel.app/note.html?course=CSCI-UA-201&note=02-data-repr)**.
+- **Signed integers (two's complement)** and **floating point (IEEE 754)**, see **[02 - Data Representation](https://robinc.vercel.app/note.html?course=CSCI-UA-201&note=02-data-repr)**.
 
 ## Memory organization
 

notes/courses/CSCI-UA-201/02-data-repr.md

@@ -1,6 +1,6 @@
 ---
 title: Data Representation
-date:
+date: 2025-09-04
 ---
 
 ## Text and character encoding

notes/courses/CSCI-UA-201/03-c-fund.md

@@ -1,6 +1,6 @@
 ---
 title: C Programming Fundamentals
-date:
+date: 2025-09-11
 ---
 
 ## From source code to execution

notes/courses/CSCI-UA-201/04-arrays-ptr.md

@@ -1,6 +1,6 @@
 ---
 title: Arrays, Pointers, and Dynamic Memory
-date:
+date: 2025-09-16/18/23
 ---
 
 ## Stack vs heap memory

notes/courses/CSCI-UA-201/05-ll-bit.md

@@ -1,8 +1,82 @@
 ---
 title: Linked Lists and Bitwise Operators
-date:
+date: 2025-09-25/30
 ---
 
+## Bitwise operators in C
+
+Integer values are stored as bits. Bitwise operators operate on each bit position.
+
+Assume 8-bit examples for clarity.
+
+### AND `&`
+
+- Result bit is 1 only if both input bits are 1.
+
+Example:
+
+- $00000111_2 \quad \\& \quad 00000100_2 = 00000100_2$
+
+Truth table:
+
+- $0 \\& 0 = 0$
+- $0 \\& 1 = 0$
+- $1 \\& 0 = 0$
+- $1 \\& 1 = 1$
+
+Typical uses:
+
+- Masking to zero out some bits.
+- Testing whether specific bits are set.
+
+### OR `|`
+
+- Result bit is 1 if at least one input bit is 1.
+
+Example:
+
+- $00000111_2 \mid 00000100_2 = 00000111_2$
+
+### XOR `^`
+
+- Result bit is 1 if the input bits are different.
+
+Truth table:
+
+- $0 \oplus 0 = 0$
+- $0 \oplus 1 = 1$
+- $1 \oplus 0 = 1$
+- $1 \oplus 1 = 0$
+
+> Using $\oplus$ here means XOR.
+
+Typical uses:
+
+- Flipping bits under a mask.
+- Simple parity or checksum calculations.
+- Toy "encryption" where the same key applied twice recovers the original.
+
+### NOT `~`
+
+- Flips every bit (0 becomes 1 and 1 becomes 0).
+
+If we consider 8 bits, then
+
+- $\sim 00000101_2 = 11111010_2.$
+
+In two's complement, this is closely related to negation: $-x = \sim x + 1$.
+
+### Shift operators `<<` and `>>`
+
+- `x << k` shifts bits of `x` left by $k$ positions (fills with zeros on the right).
+- `x >> k` shifts bits right. For unsigned values this fills with zeros on the left; for signed values it may copy the sign bit.
+
+Shifting left by $k$ is equivalent to multiplying by $2^k$ when there is no overflow.
+
+Example:
+
+- $00000101_2 << 1 = 00001010_2$ which is $5$ shifted to $10$.
+
 ## Linked lists in C
 
 A linked list is a dynamic data structure built from nodes that point to one another.
@@ -98,77 +172,3 @@ void print_list(CELL *head) {
 - Overwriting `head` while traversing, then losing access to the list.
 - Forgetting to initialize `next` for new nodes.
 - Failing to `free` nodes eventually, causing memory leaks.
-
-## Bitwise operators in C
-
-Integer values are stored as bits. Bitwise operators operate on each bit position.
-
-Assume 8-bit examples for clarity.
-
-### AND `&`
-
-- Result bit is 1 only if both input bits are 1.
-
-Example:
-
-- $00000111_2 \quad \\& \quad 00000100_2 = 00000100_2$
-
-Truth table:
-
-- $0 \\& 0 = 0$
-- $0 \\& 1 = 0$
-- $1 \\& 0 = 0$
-- $1 \\& 1 = 1$
-
-Typical uses:
-
-- Masking to zero out some bits.
-- Testing whether specific bits are set.
-
-### OR `|`
-
-- Result bit is 1 if at least one input bit is 1.
-
-Example:
-
-- $00000111_2 \mid 00000100_2 = 00000111_2$
-
-### XOR `^`
-
-- Result bit is 1 if the input bits are different.
-
-Truth table:
-
-- $0 \oplus 0 = 0$
-- $0 \oplus 1 = 1$
-- $1 \oplus 0 = 1$
-- $1 \oplus 1 = 0$
-
-> Using $\oplus$ here means XOR.
-
-Typical uses:
-
-- Flipping bits under a mask.
-- Simple parity or checksum calculations.
-- Toy "encryption" where the same key applied twice recovers the original.
-
-### NOT `~`
-
-- Flips every bit (0 becomes 1 and 1 becomes 0).
-
-If we consider 8 bits, then
-
-- $\sim 00000101_2 = 11111010_2.$
-
-In two's complement, this is closely related to negation: $-x = \sim x + 1$.
-
-### Shift operators `<<` and `>>`
-
-- `x << k` shifts bits of `x` left by $k$ positions (fills with zeros on the right).
-- `x >> k` shifts bits right. For unsigned values this fills with zeros on the left; for signed values it may copy the sign bit.
-
-Shifting left by $k$ is equivalent to multiplying by $2^k$ when there is no overflow.
-
-Example:
-
-- $00000101_2 << 1 = 00001010_2$ which is $5$ shifted to $10$.

notes/courses/CSCI-UA-201/06-cli-io.md

@@ -1,6 +1,6 @@
 ---
 title: Command-Line Arguments and File I/O
-date:
+date: 2025-10-30/11-06
 ---
 
 ## Command-line arguments

notes/courses/CSCI-UA-201/07-asm-intro.md

@@ -1,6 +1,6 @@
 ---
 title: Introduction to Assembly Language
-date:
+date: 2025-10-23
 ---
 
 ## CPU registers
@@ -50,29 +50,24 @@ Read `mov S, D` as "move S into D".
 
 ## Core instructions
 
-### MOV (copy data)
+### MOV (copy data, brief)
 
 ```asm
 mov SOURCE, DEST
 ```
 
-- Copies data from `SOURCE` into `DEST`.
-- The source is not changed.
+- Copies data from `SOURCE` into `DEST` (the source is not changed).
+- Operand order is `source, destination` in AT&T syntax.
 
-Example:
-
-```asm
-mov $25, %rax
-mov %rax, %rbx
-```
-
-Common mistake: leaving out `$` for immediates:
+Common pitfall (immediate vs address):
 
 ```asm
 mov 25, %rax    # WRONG: uses address 25
 mov $25, %rax   # RIGHT: literal 25
 ```
 
+For the full set of `mov` forms (memory dereference, offsets, base/index/scale) and array/struct addressing, see **08**.
+
 ### ADD and SUB
 
 ```asm

notes/courses/CSCI-UA-201/08-mov-addr.md

@@ -1,6 +1,6 @@
 ---
-title: Move Instructions, Addressing, and Calling Conventions
-date:
+title: Move Instructions and Addressing Modes
+date: 2025-10-28/30
 ---
 
 ## Move instructions and data movement
@@ -95,103 +95,4 @@ Given a pointer to `struct student` in `%rsi` and index `i` in `%rcx`, `grades[i
 - plus `i * 4` (size of each `int`),
 
 which matches `mov 12(%rsi, %rcx, 4), %rax`.
-
-## Calling conventions
-
-### Caller-saved and callee-saved registers
-
-Registers are grouped according to who must preserve them across function calls.
-
-- Caller-saved registers (scratch):
-  - `RAX`, `RCX`, `RDX`, `RDI`, `RSI`, `R8`, `R9`, `R10`, `R11`.
-  - A callee is allowed to overwrite these.
-  - If the caller needs their values later, the caller must save and restore them.
-
-- Callee-saved registers (preserved):
-  - `RBX`, `RBP`, `R12`, `R13`, `R14`, `R15`.
-  - If a function uses any of these, it must save the old value (usually with `push`) and restore it before returning.
-
-### Function parameters and return values
-
-For integer and pointer parameters, the System V x86-64 convention passes the first six arguments in registers:
-
-1. `RDI`
-2. `RSI`
-3. `RDX`
-4. `RCX`
-5. `R8`
-6. `R9`
-
-Additional arguments are pushed on the stack by the caller from right to left.
-
-The return value is placed in `RAX`.
-
-Example call:
-
-```asm
-mov $10, %rdi   # arg1
-mov $20, %rsi   # arg2
-mov $30, %rdx   # arg3
-mov $40, %rcx   # arg4
-mov $50, %r8    # arg5
-mov $60, %r9    # arg6
-push $80        # arg8 (pushed first)
-push $70        # arg7 (pushed second)
-call g
-```
-
-Inside `g`, the parameters appear in the same registers and the extra ones are on the stack.
-
-### Function prologue and epilogue
-
-Standard function layout:
-
-```asm
-.globl f
-f:
-    # prologue
-    push %rbp
-    mov %rsp, %rbp
-
-    # optionally save callee-saved registers, for example:
-    # push %rbx
-
-    # body
-
-    # restore callee-saved registers if saved:
-    # pop %rbx
-
-    # epilogue
-    pop %rbp
-    ret
-```
-
-- The prologue creates a new stack frame with `RBP` as a stable base pointer.
-- The epilogue restores the old base pointer and returns to the caller.
-
-### Simple example
-
-C code:
-
-```c
-int add_5(int a) {
-    return a + 5;
-}
-```
-
-Assembly:
-
-```asm
-.globl add_5
-add_5:
-    push %rbp
-    mov %rsp, %rbp
-
-    mov $5, %rax      # RAX = 5
-    add %rdi, %rax    # RAX = a + 5 (a is in RDI)
-
-    pop %rbp
-    ret               # result is in RAX
-```
-
-This respects the register and calling conventions and computes the sum correctly.
+For calling conventions (arg registers, caller/callee-saved, stack frames, prologue/epilogue), see **[09 - Function Conventions and Cache Basics](https://robinc.vercel.app/note.html?course=CSCI-UA-201&note=09-func-cache)**.