Number Systems in Computing: Binary, Decimal, and Hexadecimal

Every time you save a file, send a message, or run an app, your computer is quietly working in a language made entirely of numbers – but not the numbers you learned in school. Underneath every program and piece of data is a system of number representations that computers rely on to function. Understanding these number systems is foundational to understanding how computing actually works, and it is far more accessible than it might first appear.

The need for number systems in computing 🔗

Humans count in base 10 – the decimal system – because we have ten fingers. Computers, however, are built from transistors, and a transistor has just two physical states: on or off. As Intel’s digital education resources explain, computers transform all information into a simple code using 0 and 1 to represent those off and on states. A circuit that only needs to distinguish between two voltage levels – high or low – is far simpler, more reliable, and less prone to errors than one that must juggle ten distinct levels. That is the core reason binary became the language of machines.

TechTarget describes binary as the foundation of modern computing: inside the CPU and RAM, digital signals are either on (1) or off (0), and without those signals, the processor simply cannot work. Everything a computer does – arithmetic, logic, storing text, rendering images – ultimately reduces to sequences of 1s and 0s processed at extraordinary speed.

But binary alone creates a practical problem for humans. The decimal number 65, for example, becomes 1000001 in binary. Larger numbers become even longer strings that are difficult to read, write, and check for errors. This is where additional number systems – octal and hexadecimal – step in as efficient shorthand.

The binary and octal number systems 🔗

Electronics Tutorials notes that binary is a base-2 numbering system where each digit (called a bit) represents a power of 2. Reading from right to left, the positions carry values of 1, 2, 4, 8, 16, 32, and so on. To convert a binary number to decimal, you multiply each bit by its positional power of 2 and add the results together.

For example, the binary number 1011 converts to decimal as follows:

• 1 × 2³ = 8
• 0 × 2² = 0
• 1 × 2¹ = 2
• 1 × 2⁰ = 1

Total: 8 + 0 + 2 + 1 = 11 in decimal.

To go the other direction – converting a decimal number to binary – you repeatedly divide by 2 and record the remainders. The binary result is then read from the last remainder back to the first. Educative.io describes this repeated-division method as a reliable shortcut for any decimal-to-binary conversion.

The octal system 🔗

GeeksforGeeks explains that the octal system is base 8, using digits 0 through 7, where each digit’s place value is a power of 8. Its key advantage is compactness: three binary digits (bits) map directly to one octal digit. So binary 111 = 7 in octal, and binary 101 110 = 56 in octal. This grouping of bits into triplets makes octal a convenient shorthand when working with binary data in digital circuit design and older computing environments.

To convert binary to octal, start from the rightmost bit, group the digits in sets of three (adding leading zeros to the leftmost group if needed), and replace each triplet with its octal equivalent. To convert decimal to octal, divide repeatedly by 8 and read the remainders from bottom to top – the same logic as decimal-to-binary, only with a different base.

Decimal and hexadecimal systems 🔗

The decimal system – base 10, digits 0 through 9 – is the number system humans use naturally every day. Each digit’s position represents a power of 10. In computing, decimal is the system users interact with on screen, but Digital Skills notes that internally, computers use binary rather than decimal because it maps directly onto electronic circuit states. Decimal values entered by a user are converted to binary for processing, then converted back to decimal for display.

Hexadecimal: the programmer’s shorthand 🔗

Hexadecimal (hex) is a base-16 system that uses the digits 0-9 and the letters A-F, where A = 10, B = 11, C = 12, D = 13, E = 14, and F = 15. Electronics Tutorials explains that each hexadecimal digit corresponds to exactly four binary bits – a grouping called a nibble. This means an 8-bit byte can always be expressed as just two hex digits, making long binary strings dramatically shorter and more readable.

Consider binary 11111111: in hexadecimal, this is simply FF. In decimal it is 255. Programmers routinely work with hex when inspecting memory addresses, defining color values in web design (e.g., #FF5733), or debugging low-level code. As TheServerSide notes, engineers working with serialization formats at the byte level use hexadecimal numbers constantly because expressing byte values as one or two hex digits is far more practical than reading eight binary digits.

To convert decimal to hexadecimal, divide the decimal number repeatedly by 16, recording remainders at each step (replacing values 10-15 with A-F), and read upward from the last remainder. To convert binary to hex, group bits into sets of four from the right and replace each group with its corresponding hex digit.

Here is a quick reference for the relationship between the four systems:

Arithmetic operations in different number systems 🔗

Once you understand how numbers are represented, the next step is understanding how computers perform arithmetic – and how that arithmetic is physically implemented in hardware.

Binary addition and subtraction 🔗

Binary addition follows simple rules: 0 + 0 = 0, 0 + 1 = 1, 1 + 0 = 1, and 1 + 1 = 10 (which means 0 with a carry of 1 to the next position). Consider adding 1011 + 1101:

• Rightmost column: 1 + 1 = 0, carry 1
• Next: 1 + 0 + 1 (carry) = 0, carry 1
• Next: 0 + 1 + 1 (carry) = 0, carry 1
• Next: 1 + 1 + 1 (carry) = 1, carry 1
• Result: 11000

Binary subtraction uses borrowing, just like decimal. When subtracting a larger bit from a smaller one (0 − 1), you borrow from the next higher position, treating the current position as 10 in binary (which equals 2 in decimal), giving 10 − 1 = 1.

Hexadecimal arithmetic 🔗

Hex addition follows the same carry logic but in base 16. Adding 2B + 19 in hex: B (11) + 9 = 20 in decimal, which is 14 in hex (write 4, carry 1), then 2 + 1 + 1 (carry) = 4. Result: 44 in hex. Hex arithmetic is widely used by programmers to track memory allocation and manipulate byte-level data efficiently.

Logic gates: the hardware behind binary arithmetic 🔗

Binary arithmetic is not just an abstract math exercise – it is physically built into computer hardware through logic gates. Wikipedia defines a logic gate as a device that performs a Boolean function, taking one or more binary inputs and producing a single binary output. The seven basic gates are NOT, AND, OR, NAND, NOR, XOR, and XNOR, and they are constructed from transistors inside every processor.

GeeksforGeeks describes the three foundational gates as follows:

• AND gate: outputs 1 only when both inputs are 1; otherwise outputs 0.
• OR gate: outputs 1 when at least one input is 1; outputs 0 only when both inputs are 0.
• NOT gate: inverts its single input – a 1 becomes 0, and a 0 becomes 1.

Binary addition is physically implemented using combinations of these gates. Electronics Tutorials explains that a basic binary adder – called a half adder – is built by combining an XOR gate (which produces the sum bit) with an AND gate (which produces the carry bit). Two half adders and an OR gate form a full adder, which also accounts for a carry-in from a previous addition. Chain multiple full adders together and you have the core arithmetic circuit inside every CPU’s Arithmetic Logic Unit (ALU).

Adafruit’s digital circuits guide puts it well: these basic AND, OR, and NOT operations can be combined in any number of ways to build, literally, everything else in a computer. From simple addition to complex data processing, every operation a processor performs traces back to these fundamental gate combinations working on binary signals.

Why all four systems matter for teachers and students 🔗

For anyone teaching or studying computing, number systems are not an optional theoretical topic – they are the conceptual foundation on which everything else is built. Understanding binary explains why memory is measured in powers of 2 (8 bits = 1 byte, 1024 bytes = 1 kilobyte). Understanding hexadecimal explains why memory addresses and color codes look the way they do. Understanding octal gives insight into file permissions in Unix-based systems, where three bits represent read, write, and execute states for each permission group. And understanding how logic gates translate binary arithmetic into physical circuits closes the loop between mathematics and the machine.

As Jaro Education notes, grasping each of these number systems enables efficient programming, computation, and system design – skills that are central to computer science education at every level.

What do you think? Now that you understand why computers use binary and how hexadecimal simplifies it for programmers, do you see number systems differently? If logic gates physically build binary arithmetic into hardware, how does that change how you think about what a computer actually “does” when it performs even the simplest calculation?

References

1. https://www.intel.com/content/www/us/en/education/k12/the-journey-inside/explore-the-curriculum/digital-information.html
2. https://www.techtarget.com/whatis/definition/binary
3. https://www.electronics-tutorials.ws/binary/bin_1.html
4. https://www.educative.io/blog/computer-number-systems-binary-hexadecimal-conversions
5. https://www.geeksforgeeks.org/digital-logic/number-system-and-base-conversions/
6. https://digitalskills.org/ViewLesson/number-systems-decimal-binary–hex-9710/3182
7. https://www.electronics-tutorials.ws/binary/bin_3.html
8. https://www.theserverside.com/tip/Binary-and-hexadecimal-numbers-explained-for-developers
9. https://en.wikipedia.org/wiki/Logic_gate
10. https://www.geeksforgeeks.org/digital-logic/logic-gates/
11. https://www.electronics-tutorials.ws/combination/comb_7.html
12. https://learn.adafruit.com/binary-boolean-and-logic?view=all
13. https://www.jaroeducation.com/blog/concepts-of-binary-octal-and-hexadecimal-number-systems-in-digital-logic