2.1 ASCII, EBCDIC and Unicode 

In this section, you learned that digital systems represent characters (letters, digits, punctuation marks, and control symbols) using standardized numeric codes. You explored ASCII, an early 7‑bit encoding that supports 128 characters and remains widely used in modern systems because of its simplicity and legacy compatibility. You also encountered EBCDIC, IBM’s 8‑bit character encoding used primarily on mainframe systems, which is incompatible with ASCII and organizes characters differently. Finally, you examined Unicode, a universal character encoding framework that supports over 150,000 characters across languages, symbol sets, and emojis. Unicode can be encoded in multiple formats, most notably UTF‑8, UTF‑16, and UTF‑32, which balance storage efficiency with global language support. By learning how ASCII, EBCDIC, and Unicode encode characters into binary, you developed foundational skills for interpreting text data, diagnosing encoding errors, and ensuring correct text handling across platforms and applications.

2.2 Non-negative and Negative Integers, and Arithmetic Operations on Integers

In this section, you examined how digital systems represent whole numbers using binary. You began with unsigned integers, which store only non‑negative values and have ranges determined entirely by the number of bits. You then explored three major encoding schemes for representing signed integers: sign‑magnitude, one’s complement, and two’s complement. Sign‑magnitude directly encodes the sign in the most significant bit but suffers from a “+0/–0” ambiguity. One’s complement also produces two versions of zero and requires an “end‑around carry” during addition. The most important of the three, two’s complement, resolves these issues by inverting the bits of a positive number and adding 1 to create its negative representation. Two’s complement supports a single zero, simplifies arithmetic, and is used in virtually all modern processors. You also practiced performing binary addition and subtraction using the two’s complement rules, an essential skill for understanding low‑level computation, debugging numeric errors, and analyzing how computers store and manipulate integer data.

2.3 Real Numbers and Floating-Point Representation of Real Numbers

In this section, you learned how computers represent real numbers, including rational and irrational values, using floating‑point formats. Building on earlier ideas, you saw that real numbers cannot always be stored exactly, so digital systems use the IEEE 754 standard, which separates each value into a sign bit, an exponent, and a mantissa. You studied both single‑precision (32‑bit) and double‑precision (64‑bit) formats. You learned how normalization allows floating‑point values to represent a wide range of magnitudes, from extremely small decimals to extremely large scientific quantities. You also practiced converting decimal numbers to IEEE 754 binary form, reinforcing how exponent biasing, leading‑1 normalization, and mantissa truncation interact to produce approximations. Understanding floating‑point representation is crucial for scientific computing, engineering simulations, and financial calculations, where rounding, precision limits, and representable ranges directly affect correctness and program behaviour.

2.4 Data Underflow, Overflow, and Interpreting Memory Content

In this final section, you investigated system-level issues that arise when numeric values exceed their representable range. Overflow occurs when a value is too large to be represented, causing binary results to wrap around or become invalid. In contrast, underflow occurs when floating-point values are too small to store, often producing zero unless denormalized (subnormal) numbers are used. You also learned how the same sequence of bits can be interpreted in different ways depending on the data type: whether as a signed or unsigned integer, a floatingpoint value, or a sequence of characters. The chapter also introduced endianness, explaining how byte order affects multi-byte values in memory and how mismatches between systems can lead to corrupted or misinterpreted data. By understanding overflow, underflow, denormalized values, and data reinterpretation, you developed critical skills for debugging low-level behaviour, analyzing memory layouts, and ensuring reliable software across heterogeneous computing environments.