Notes on Bits, Booleans, Gates, and Memory (Video Notes)

Homework/game structure described: eight basic levels, six procedure levels, and six loop questions. It’s not a requirement to complete the game; the idea is to have fun and think about the concept.
The worksheet should be used in conjunction with the book (read about algorithms and abstraction, as discussed in session 04).
Must have a Canvas profile picture to avoid missing points.
If you’re interested in an alternate option, you can mention it after class and the instructor will set something up.
The session content ties into broader course topics such as algorithms, abstraction, and data representation.

A bit is a short form for binary digit, which is either 0 or 1; that is the fundamental language a computer understands.
From zeros and ones, computers build more complex representations via a sequence of operations and circuits.
A bit is often thought of as a pulse on a wire in hardware.

Boolean values: True and False (often represented as 1 and 0 in hardware).
Core Boolean operations to study: AND, OR, XOR (exclusive or), and NOT.
NOT is a unary operation (inverts a single input).
AND: output is true only if both inputs are true.
OR: output is true if at least one input is true.
XOR: output is true if exactly one of the inputs is true (true when inputs differ).
Example intuition:
- If today is Monday (true) and tomorrow is Sunday (false), then:
- True AND False -> False.
- True OR False -> True.
These operations are implemented in hardware as gates, which are the building blocks of more complex circuits.

Gates implement Boolean operations; they are the basic building blocks of digital circuits.
Gates can be combined to construct flip-flops.
Flip-flops are a fundamental unit of computer memory; they store a single bit of information.
From flip-flops, memory can be built, creating a larger memory system.

Memory in a computer is divided into cells; each cell stores data.
A common unit is a byte, which is 8 bits:
- $1\ \text{byte} = 8\ \text{bits}$
Each memory cell has a unique address (like a house address); this allows direct access to any cell without sequentially scanning from the beginning (random access).
Memory is faster than hard drives because of random access capabilities.
Memory is measured in bytes, with prefixes such as kilobytes, megabytes, and gigabytes:
- $2^{10} = 1024\ \text{bytes}$ (1\ K}\B)
- $2^{20} = 1{,}048{,}576\ \text{bytes}$ (1\ MB)
- $2^{30} = 1{,}073{,}741{,}824\ \text{bytes}$ (1\ GB)
It’s common (and advantageous) for memory sizes to be powers of two because of the binary nature of storage.
The memory hierarchy and data manipulation considerations often influence hardware design and software performance.

Everything in digital storage is fundamentally based on binary (base-2) with zeros and ones.
Data sizes are typically described in powers of two, not powers of ten:
- 1 KB = $2^{10}$ bytes = 1024 bytes
- 1 MB = $2^{20}$ bytes = 1,048,576 bytes
- 1 GB = $2^{30}$ bytes = 1,073,741,824 bytes
The emphasis on powers of two arises because addressing and memory organization align with binary addressing.

Humans typically use decimal representation; computers use binary.
Conversion example 1:
- $1001010<em>2 = 74</em>{10}$
The transcript also discusses an example where a decimal number is represented in binary; another common conversion example from the lecture is:
- $1011<em>2 = 11</em>{10}$
When given a binary sequence, the decimal equivalent can be read by summing powers of two corresponding to the positions of 1s.
Clarification from the lecture: the specific decimal value 74 is just a decimal number, and its binary representation is 1001010; it’s not the number of bits in memory.

The lecture included a discussion about the ethico-practical implications of data representation choices.
Example discussed: two-digit year representation (Y2K issue) where storing years as two digits (e.g., 99, 00) could cause ambiguity when the century changes, leading to potential software issues.
This serves as a concrete example of how representation choices (binary, decimal, or two-digit years) have real-world consequences for reliability and correctness.

The content ties back to algorithms and abstraction discussed in session 04, emphasizing:
- How low-level representations (bits, booleans) underpin higher-level data manipulation
- The importance of abstraction layers in computer science
The material also foreshadows practical considerations when selecting hardware (CPU, memory) and understanding performance implications.

Understanding bits, booleans, and gates helps explain how computers perform logic and make decisions.
Direct memory access (via addresses) enables fast data retrieval, which is essential for system performance.
Memory sizes growing in powers of two facilitate predictable addressing and efficiency in hardware design.
Awareness of data representation choices is important for software reliability and historical lessons (e.g., Y2K).