1.2 Notational Systems & Character Representation

Notational Systems & Character Representation

Core Foundation: Microprocessors cannot directly comprehend English text, decimal fractions, or photographic images. Modern digital computers are built from billions of microscopic transistors that function as physical electrical switches. A switch is either conducting electricity (state 1 / High Voltage) or resisting electricity (state 0 / Low Voltage). Notational numbering systems and character encodings provide the mathematical framework that maps human concepts onto binary machine states.

---

Positional Numeral Systems in Computing

A positional numeral system expresses numbers using an ordered set of digits where the value of each digit depends on its position relative to the radix (base). The value of any digit is calculated as:

$\text{Value} = d \times b^p$

Where $d$ is the digit coefficient, $b$ is the base, and $p$ is the zero-indexed position exponent moving from right to left.

The Four Primary Bases in IT

1. Decimal (Base 10): The standard human counting system based on ten distinct digits (0, 1, 2, 3, 4, 5, 6, 7, 8, 9). Each position moving left represents an increasing power of ten ($10^0 = 1, 10^1 = 10, 10^2 = 100, 10^3 = 1000$).
2. Binary (Base 2): The native language of computing hardware, consisting of only two digits: 0 and 1. Each position represents an increasing power of two ($2^0 = 1, 2^1 = 2, 2^2 = 4, 2^3 = 8, 2^4 = 16, 2^5 = 32, 2^6 = 64, 2^7 = 128$).
3. Hexadecimal (Base 16 or "Hex"): Uses sixteen distinct symbols: numerals 0 through 9 followed by letters A through F (where A=10, B=11, C=12, D=13, E=14, F=15). Hexadecimal is used to express memory dump addresses, MAC addresses, IPv6 segments, and HTML/CSS color codes in human-readable shorthand.
4. Octal (Base 8): Uses eight digits (0, 1, 2, 3, 4, 5, 6, 7). Each octal digit corresponds exactly to a 3-bit binary group ($2^3 = 8$). While less common in modern hardware than hexadecimal, octal is frequently encountered in Unix and Linux file permission structures (e.g., chmod 755).

Comparative Value Matrix: 0 through 17

---

Step-by-Step Conversion Methodologies

Converting values between decimal, binary, and hexadecimal is an essential technical competency tested on the CompTIA Tech+ exam.

1. Binary to Decimal Conversion

To convert an 8-bit binary string (a Byte) to decimal, write out the binary digits beneath the standard powers-of-two positional weight chart, multiply each digit by its positional weight, and sum the active values:

Positional Weights:  128   64   32   16    8    4    2    1
Binary Digits:        1    0    1    1    0    1    0    1

• Calculation: $(1 \times 128) + (0 \times 64) + (1 \times 32) + (1 \times 16) + (0 \times 8) + (1 \times 4) + (0 \times 2) + (1 \times 1)$
• Sum: $128 + 32 + 16 + 4 + 1 = 181$
• Result: $10110101_2 = 181_{10}$

2. Decimal to Binary Conversion

Decimal values can be converted to binary through two proven methods:

Method A: Subtraction of Powers of Two

Take the target decimal number, find the largest power of two that fits inside it, subtract that power, place a 1 in that bit's column, and repeat with the remainder:

• Target: $157_{10}$
  • $157 \ge 128$ -> Place 1 in 128 column. Remainder: $157 - 128 = 29$
  • $29 < 64$ -> Place 0 in 64 column.
  • $29 < 32$ -> Place 0 in 32 column.
  • $29 \ge 16$ -> Place 1 in 16 column. Remainder: $29 - 16 = 13$
  • $13 \ge 8$ -> Place 1 in 8 column. Remainder: $13 - 8 = 5$
  • $5 \ge 4$ -> Place 1 in 4 column. Remainder: $5 - 4 = 1$
  • $1 < 2$ -> Place 0 in 2 column.
  • $1 \ge 1$ -> Place 1 in 1 column. Remainder: $1 - 1 = 0$
• Result: $157_{10} = 10011101_2$

Method B: Successive Division by 2 with Remainders

Divide the integer repeatedly by 2, recording each remainder (0 or 1), until the quotient reaches zero. Read remainders from bottom to top (Least Significant Bit to Most Significant Bit):

• $157 \div 2 = 78$ remainder 1 (Bit 0)
• $78 \div 2 = 39$ remainder 0 (Bit 1)
• $39 \div 2 = 19$ remainder 1 (Bit 2)
• $19 \div 2 = 9$ remainder 1 (Bit 3)
• $9 \div 2 = 4$ remainder 1 (Bit 4)
• $4 \div 2 = 2$ remainder 0 (Bit 5)
• $2 \div 2 = 1$ remainder 0 (Bit 6)
• $1 \div 2 = 0$ remainder 1 (Bit 7)
• Reading from bottom to top yields: 10011101.

3. Binary to Hexadecimal (The Nibble Method)

Because $2^4 = 16$, one hexadecimal digit represents exactly 4 binary bits (known as a nibble). Converting between binary and hex does not require intermediate decimal math:

1. Divide the binary string into 4-bit nibbles starting from the right. (Pad with leading zeros on the left if necessary).
2. Translate each 4-bit group into its single hex equivalent.

• Example: Convert $11011010_2$ to Hexadecimal.

  • Left Nibble: $1101_2 = 8 + 4 + 1 = 13 \rightarrow \mathbf{D}$
  • Right Nibble: $1010_2 = 8 + 2 = 10 \rightarrow \mathbf{A}$
  • Combined Result: 0xDA (or $DA_{16}$)

• Reverse Example: Convert Hexadecimal 0x3F to Binary.

  • Hex digit 3: $0011_2$
  • Hex digit F ($15_{10}$): $1111_2$
  • Combined 8-bit Byte: 00111111 ($63_{10}$)

4. Decimal to Hexadecimal Conversion

To convert larger decimal numbers to hexadecimal, use successive division by 16:

• Convert $254_{10}$ to Hex:
  • $254 \div 16 = 15$ with a remainder of $14$.
  • The quotient $15$ corresponds to hex digit F.
  • The remainder $14$ corresponds to hex digit E.
  • Result: 0xFE.

---

Digital Character Encoding Standards

A character encoding is a defined mapping table that assigns numeric binary values (code points) to human characters, punctuation symbols, and system control signals.

ASCII (American Standard Code for Information Interchange)

Formulated in 1963 by the American National Standards Institute (ANSI), Standard ASCII is a 7-bit encoding standard capable of representing $2^7 = 128$ distinct characters (code points 0 through 127 / hex 0x00 through 0x7F).

• Control Characters (0–31 and 127): Non-printing signals used for device communication, including 0x00 (NULL), 0x09 (Horizontal Tab), 0x0A (Line Feed / Newline), 0x0D (Carriage Return), and 0x1B (Escape).
• Printable Characters (32–126): Includes standard numerals 0–9, uppercase English alphabet A–Z, lowercase English alphabet a–z, and standard punctuation symbols.

Key Benchmark ASCII Code Points (Memorize for Exam):
* Space (' ')   = Decimal 32  (Hex 0x20, Binary 0010 0000)
* Zero ('0')    = Decimal 48  (Hex 0x30, Binary 0011 0000)
* Uppercase 'A' = Decimal 65  (Hex 0x41, Binary 0100 0001)
* Lowercase 'a' = Decimal 97  (Hex 0x61, Binary 0110 0001)

Exam Trap: Notice the mathematical relationship between uppercase and lowercase ASCII letters: Lowercase 'a' (97) is exactly 32 greater than uppercase 'A' (65). In binary, this corresponds to setting bit 5 (weight 32) from 0 to 1! Thus, changing 01000001 ('A') to 01100001 ('a') toggles letter case.

Extended ASCII

As computing globalized, 7 bits proved insufficient. Extended ASCII expanded character representation to an entire 8-bit byte ($2^8 = 256$ code points).

• Code points 0–127 remained identical to Standard ASCII.
• Code points 128–255 introduced accented characters (e.g., é, ñ, ü), currency symbols (e.g., £, ¥), and box-drawing graphical characters.
• The Limitation: Different regions and operating systems created conflicting "Code Pages" (such as IBM Code Page 437 and Windows-1252). A file written on one system displayed unreadable corrupted symbols—known as mojibake—when opened on another.

Unicode: The Universal Global Standard

To resolve code page fragmentation, the Unicode Consortium created Unicode. Unicode decouples character identity from storage format, assigning a unique code point written as U+XXXX to every character in human history.

• Architecture: Unicode supports up to 1,114,112 code points, divided across 17 "Planes" of 65,536 characters each.
• Plane 0 (Basic Multilingual Plane - BMP): Covers virtually all modern languages (Latin, Greek, Cyrillic, Hebrew, Arabic, Devanagari, Han ideographs for Chinese, Japanese, and Korean).
• Supplementary Planes (Planes 1–16): Accommodate historical scripts (Egyptian hieroglyphs), specialized musical and mathematical notations, and modern graphical emojis (e.g., 🚀 U+1F680).

Unicode Encoding Implementations: UTF-8 vs. UTF-16

UTF-8 Multi-Byte Structure:
1-Byte Character (ASCII):     0xxxxxxx
2-Byte Character (Latin/Greek): 110xxxxx 10xxxxxx
3-Byte Character (Asian/CJK):   1110xxxx 10xxxxxx 10xxxxxx
4-Byte Character (Emojis):      11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

---

Practical Diagnostic Scenarios & Exam Pitfalls

• Trap 1: Confusing Numeric Value with Character Code. On an exam, candidates are often asked what binary value represents the character '5'. The numeric integer 5 is represented in binary as 00000101. However, the ASCII character '5' has a decimal code point of 53, which is stored in memory as 00110101!
• Trap 2: Hexadecimal Letter Offsets. Remember that in hexadecimal, letter A represents decimal 10, not 11. The sequence is: A=10, B=11, C=12, D=13, E=14, F=15.
• Trap 3: Assuming UTF-8 Is Always 8 Bits. The "8" in UTF-8 signifies that the minimum character unit is 8 bits (one byte). However, UTF-8 dynamically expands up to four bytes (32 bits) to represent complex international scripts and modern emojis.