split, one piece per page
Twenty-eight lessons on what split is: the split utility and why long files break into pieces; the default 1000-line pieces and the plain run that writes xaa, xab and xac; the suffix alphabet with -d digits and -a length, naming pieces with your own prefix; sizing with -l lines, -b bytes and -C whole lines, and the day the suffixes run out; rejoining with cat, the cmp proof, glob order and the stale piece trap; csplit by content, splitting stdin, the quiet pipeline half and large files with -n; when not to split, the keeper command, the naming ritual, and teaching a friend one honest hour.
One file, one cut, one honest hour. That's the rhythm.
split, one piece per page
Twenty-eight lessons on what split is: the split utility and why long files break into pieces; the default 1000-line pieces and the plain run that writes xaa, xab and xac; the suffix alphabet with -d digits and -a length, naming pieces with your own prefix; sizing with -l lines, -b bytes and -C whole lines, and the day the suffixes run out; rejoining with cat, the cmp proof, glob order and the stale piece trap; csplit by content, splitting stdin, the quiet pipeline half and large files with -n; when not to split, the keeper command, the naming ritual, and teaching a friend one honest hour.
Set in Space Grotesk, Inter and JetBrains Mono (SIL Open Font License).
Every fact in this book is as the official source states it, fetched and read during this build: the local manual pages split(1), csplit(1) and cat(1) (GNU coreutils 9.4), the definition of truth for this book, and the Wikipedia articles Split (Unix), Csplit, Cat (Unix), Standard streams, GNU Core Utilities, Seq (Unix), Dd (Unix), Cut (Unix) and Nl (Unix). No facts are sourced from Reddit, Stack Overflow, vendor blogs or commercial sites. Every command and output pair was run on this machine with temporary files under the build scratch directory only, each capture cached verbatim so the pair is reproducible. The piece-name room counts 26, 676 and 17576 are derived from the base-26 suffix alphabet, computed during this build and labeled as derived. Honest note: the requested Coreutils title redirected and was read at GNU Core Utilities. SAFETY LAW: no file outside the book directory's scratch area was written by any demonstration; every run was read-only toward the rest of the machine, and sudo was never invoked. An independent guide, not affiliated with or endorsed by the Free Software Foundation, the IEEE, or the Wikimedia Foundation.
Your purchase is for personal use only. You do not have redistribution rights: please do not share, resell, or republish this book or its pages.
© 2026 Steve Hodgkiss. All rights reserved. Personal use only; no redistribution rights.
Edition 1.0 · stevehodgkiss.net
Contents
Per the Wikipedia Split (Unix) article, the default behavior of split is to generate output files of a fixed size, default 1000 lines. Per the split(1) manual page, output pieces of FILE go to PREFIXaa, PREFIXab and so on, with default size 1000 lines and default PREFIX 'x'. This machine's capture: wc --lines on the pieces answered 1000, 1000 and 600.
The thousand lines
The number built into the tool. The article: output files of a fixed size, default 1000 lines; the manual page agrees: default size is 1000 lines, default PREFIX 'x'.
Our capture: split big.txt with no flags, then wc --lines xa* answered 1000 xaa, 1000 xab, 600 xac, 2600 total.
A thousand lines a piece: the rhythm every flag later in this book exists to change.
Run one flagless split on a file over 2000 lines, then count every piece and find the thousand.
Per the Wikipedia Split (Unix) article, its example runs wc --lines xa* after splitting myfile.txt and prints 1000 xaa, 1000 xab, 1000 xac and 3000 total. This machine's capture: wc --lines xaa xab xac big.txt answered 1000, 1000, 600 and 2600.
Count the pieces
The article's own audit: after splitting, it runs wc --lines xa* and reads 1000 xaa, 1000 xab, 1000 xac, 3000 total.
Our capture on the 2600-line file: wc --lines xaa xab xac big.txt answered 1000, 1000, 600, 2600. The pieces sum to the whole.
Count after every split: the day the total disagrees with the original is the day something else wrote to the directory.
Split any file, then let wc --lines star-expand the pieces and check the total against the original.
Per the split(1) manual page, output pieces of FILE go to PREFIXaa and so on, the synopsis takes FILE [PREFIX], and --additional-suffix=SUFFIX appends an additional SUFFIX to file names. This machine's captures: split -l 4 twelve.txt part_ wrote part_aa to part_ac, and with --additional-suffix=.txt, part_aa.txt to part_ac.txt.
Your own prefix
x is only the default. The manual page sends pieces to PREFIXaa, PREFIXab, and the synopsis takes FILE [PREFIX]: name them yourself.
Our captures: split -l 4 twelve.txt part_ wrote part_aa, part_ab, part_ac; adding --additional-suffix=.txt wrote part_aa.txt, pieces that look like documents, still counted underneath.
A prefix states where a piece belongs: part_, batch_, week10_. Name pieces so a stranger could guess the rejoin order.
Split one file with a prefix that names the job, then prove a stranger could guess the rejoin order.
Per the split(1) manual page, -a generates suffixes of length N, default 2, and -d uses numeric suffixes starting at 0. This machine's capture: seq 1 28 | split -l 1 -a 1 - printed split: output file suffixes exhausted and exited with status 1 after writing 26 pieces.
Suffixes run out
Names are a finite shelf. Our capture hit the wall: seq 1 28 | split -l 1 -a 1 - wrote xaa through xaz, then stopped with output file suffixes exhausted, exit status 1.
Twenty-six pieces were already on disk when it stopped: a late, quiet failure. The fix is room: -a 3, or -d for digits.
When a split fails late, count the pieces. Twenty-six means the name shelf gave out, not the disk.
Build the wall yourself with -a 1 on 28 lines, count the pieces left behind, then rerun with -a 2.
Per this book's plan, the danger of re-splitting into a used prefix: split writes only as many pieces as the new input needs, and older pieces keep their old bytes. This machine's capture: after split -l 4 twelve.txt made 4, 4, 4, a second split -l 4 small.txt left xaa at 2 lines while xab and xac kept 4 each, cat x* answered 10 lines, and cmp failed.
The stale piece
The red page. Our capture: split -l 4 twelve.txt wrote 4, 4, 4. Then split -l 4 small.txt wrote a 2-line xaa and stopped: xab and xac still held the old 4 lines each.
The rejoin told the truth: cat x* answered 10 lines for a 2-line file, and cmp failed with EOF after byte 8.
split never cleans up after itself. Clear the old pieces before re-splitting into the same prefix; the rejoin cannot tell new bytes from stale ones.
Reproduce the trap: split, re-split smaller, cat the star, and find the stale lines with wc.
Per the split(1) manual page, with no FILE, or when FILE is -, split reads standard input. Per the Wikipedia Split (Unix) article, when a hyphen is used instead of the input filename, data is derived from standard input. This machine's capture: seq 1 12 | split -l 4 - pipe_ wrote pipe_aa to pipe_ac, and pipe_ab held 5 through 8.
stdin or a name
The input is optional. The manual page: with no FILE, or when FILE is -, read standard input; the article agrees, a hyphen means data is derived from standard input.
Our capture: seq 1 12 | split -l 4 - pipe_, and the pipe wrote pipe_aa, pipe_ab, pipe_ac; cat pipe_ab answered 5 6 7 8.
No temp file, no second step: the producer streams, split chunks. That is split as a pipeline citizen, not just a file tool.
Feed split from a pipe with the hyphen and a prefix, then cat the middle piece.
Per this book's plan, the last lesson hands split to a friend in one honest hour: five captured lines from this book, typed by the learner, read aloud by the teacher. The captures behind the five lines: the plain split, the wc audit, the -d run, the exhausted suffixes, and the silent cmp.
Teaching split
The last piece is passing the tool on: one friend, one honest hour, per this book's plan.
They type; you read aloud. The five lines are this book's captures: split big.txt, the wc that reads 1000, 1000, 600, split -d -l 4 twelve.txt, the wall that answers output file suffixes exhausted, and the cmp that says nothing.
When they can say why the stale rejoin held ten lines, the hour is done and the knife is theirs.
Sit with one friend and teach split in one sitting; they type the five lines, you read each answer aloud.