Bytes
Bytes are an ordered sequence of values, each conventionally eight bits, used to represent binary data.
Learn Rust in a Month of Lunches
A byte is a fixed-size unit of digital information consisting of eight bits in conventional modern systems.
- How it is used
- Uses bytes to relate integer type sizes and string lengths to the data they represent.
- How deep it goes
- Defines a byte as eight bits, works through binary values, and demonstrates byte counts without detailing encoding rules.
- Examples
- Compares `u8` with larger integers and counts the bytes and characters in `"Hello!"` and `"안녕!"`.
- What you can do after
- Evaluate/understand why an integer’s type determines its size and a string’s byte length can differ from its character count.
API Design Patterns
Byte data is binary content represented as a sequence of bytes.
- How it is used
- Uses bytes to reason about storage bounds and database representations for identifiers.
- How deep it goes
- Explains allocation units and storage alternatives, stopping short of detailed binary encoding algorithms.
- Examples
- Uses UTF-32 sizing, MySQL BINARY fields, and 32- or 64-bit integer representations as concrete examples.
- What you can do after
- Evaluate identifier storage formats and configure raw-byte fields with uniqueness constraints and indexes.
The Well-Grounded Rubyist, Fourth Edition
A byte is a unit of digital data consisting of eight bits and serving as a basic unit of file storage and input.
- How it is used
- Uses bytes to process strings, files, and IO streams at a level below character-oriented operations.
- How deep it goes
- Explains integer representation, encoding differences, stream operations, and a worked XOR transformation without covering binary storage internals.
- Examples
- Uses ASCII-valued characters, repeated-key XOR, each_byte, getbyte, getc, and IO#write examples.
- What you can do after
- Apply byte-wise enumeration, file reading, and reversible XOR transformations in Ruby.
Read how The Well-Grounded Rubyist, Fourth Edition explains bytes →
100 Go Mistakes and How to Avoid Them
A byte is Go's alias for the unsigned 8-bit integer type uint8 and commonly represents one raw byte of data.
- How it is used
- Uses bytes to explain string storage, indexing, iteration mistakes, and direct []byte processing.
- How deep it goes
- Explains byte storage and UTF-8 indexing through runnable output, then stops short of broader byte-level APIs.
- Examples
- Uses ĥ-free hês? No: uses "hêllo", byte indexes, corrupted à output, rune slices, and UTF-8 rune counting.
- What you can do after
- Diagnose string iteration bugs by distinguishing byte indexes, byte values, rune values, and rune counts.
Read how 100 Go Mistakes and How to Avoid Them explains bytes →
Classic Game Programming on the NES: Make your own retro video game
A byte is a unit of digital information consisting of eight bits and commonly used to represent a small integer or character.
- How it is used
- Represents game state, graphics, coordinates, and flags as addressable 8-bit memory values.
- How deep it goes
- Defines byte structure, bit numbering, numeric ranges, binary conversion, hexadecimal notation, and nibbles; defers combining bytes for larger numbers.
- Examples
- Uses %10101010 as decimal 170 and $AF as decimal 175, alongside sprite coordinates, tile pixels, and flags.
- What you can do after
- Apply it via 6502 assembler to express byte values in decimal, binary, or hexadecimal.
Read how Classic Game Programming on the NES: Make your own retro video game explains bytes →
Modern C, Third Edition
A byte is the C memory unit corresponding to the storage occupied by one char object and used as the basic unit of object representation.
- How it is used
- Explains how C accounts for, views, and inspects the storage representation of objects.
- How deep it goes
- Defines byte size and object representation, then works through union-based inspection and implementation-defined byte order.
- Examples
- Uses an unsigned value 0xAABBCCDD, an unsigned-char union member, and printed byte values to demonstrate representation order.
- What you can do after
- Evaluate object representations with sizeof and inspect individual bytes through an unsigned-char overlay.
Rust in Action: Systems programming concepts and techniques
A byte is a unit of digital information consisting of eight binary bits.
- How it is used
- Represents instruction components in an emulator and arbitrary raw values in a key-value store.
- How deep it goes
- Explains byte composition through nibbles and demonstrates masking, shifting, and [u8] storage without broader binary representation details.
- Examples
- Uses CHIP-8 opcode fields, u8 registers, country-capital records, and Rust byte literals.
- What you can do after
- Apply it via Rust to decode opcode fields and represent arbitrary-length stored data as byte sequences.
Read how Rust in Action: Systems programming concepts and techniques explains bytes →
Related concepts
- bithas part · A bit is a binary digit and unit of digital information that represents one of two distinguishable values, conventionally 0 or 1.
- serializationproduced by · Serialization is the encoding of structured data or in-memory values into a representation suitable for storage or transmission and later reconstruction.
- token idkind of · A token ID is a numeric identifier assigned to a token in a vocabulary so it can be represented and processed numerically.
- stringcontrasts with · A string is a programming-language value representing an ordered sequence of characters or character units as text.
- data formatused by · A data format is a defined representation, structure, and encoding scheme for storing, transmitting, exchanging, or interpreting data.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.