# process-book: a Japanese Unix process handbook that runs its labs in Docker > Shinpeim/process-book is a Japanese language book on Unix processes and signals, written for readers who want to understand processes properly, with every example expected to be run inside a container so the behaviour can be observed rather than memorised. **Shinpeim/process-book** — Unix系システムのプロセスについて日本語で解説しています - Repository: https://github.com/Shinpeim/process-book - Stars: 659 · Forks: 36 - Language: Ruby - License: not declared - Published: 2026-10-21 · Updated: 2026-10-21 · Language: en - Canonical page: https://hysenlabs.com/projects/shinpeim-process-book ## A book about processes, aimed at people who half know them The repository description says it explains processes on Unix-like systems in Japanese, and the README states the audience plainly: the intended reader is someone who thinks they do not really understand processes and wants to know properly. That framing is unusual for a technical repository, because what is being published is a book rather than a tool. The top level entries confirm it, with eight numbered Markdown chapters from 001.md to 008.md, images, an examples directory, a script directory, a Rakefile, a Gemfile and a .ruby-version file. The chapter titles form a coherent arc: an introduction, the creation of processes, processes and file input and output, file descriptors, building a prefork server, zombie and orphan processes, signals and kill, and process groups and foreground processes. The licence is Creative Commons Attribution Share Alike 3.0 Unported, and the last push to the repository was on 2026-10-08. ## Docker is the lab, not an optional extra The README makes a strong argument for the container approach: it says that in this document it is important to actually run commands and confirm how processes behave, and it recommends using a Docker container so that learning proceeds in a unified environment. The prerequisites are Docker Desktop or Docker installed, and docker-compose available. The setup is three commands. First build the image, then start the container and open a shell inside it, and finally tear it down when you are done. ```bash docker-compose build ``` ```bash docker-compose up -d ``` ```bash docker-compose exec process-book bash ``` The compose file makes the isolation concrete. The service mounts the host's examples directory into /app/examples, so the sample code you write lives on your machine and survives the container, and it enables stdin_open, tty and init, with a comment noting that the init process is used the same way as in a normal Linux environment. That last detail is deliberate: the book covers process groups, foreground processes and signal handling, and a container without an init process behaves differently from a normal Linux system in exactly the areas the book is teaching. ## Two terminals, because the examples are networked The README warns that some examples in the text involve communication between a server and a client, which means more than one terminal, and gives the pattern for it. You open a second shell into the same container rather than a second container, so the two processes can see each other. ```bash docker-compose exec process-book bash ``` The teardown command is the mirror image of the setup. ```bash docker-compose down ``` The README also clarifies a notational point that would otherwise confuse readers: everywhere the text says to open a terminal and log in to the container, it means running the docker-compose exec process-book bash command above. That kind of explicit convention is a small signal about the book's style. It is written for someone following along, so the instructions are written to be followed exactly, and the container exists so that the reader can see the same behaviour every time rather than inheriting whatever process supervision their own machine happens to have. ## The image is a deliberately small toolset The Dockerfile shows the environment in full, and it is short. The base is ruby:3.4-slim, and the apt install list names procps, psmisc, strace, vim and telnet. The choice of tools maps directly onto the chapters. procps gives you the process listing and inspection tools, psmisc gives you the process tree and signal utilities, strace is there to show what a process is doing at the syscall level, vim is the editor for the sample code, and telnet is the client used in the server and client examples. The work directory is /app, an examples directory is created for the sample code, and the default command is a bash shell. The Ruby base is not incidental: the README's update history for 2025 states that the sample code was unified in Ruby, and there is a .ruby-version file at the repository root to pin the interpreter, with a Gemfile and a Rakefile for the build. ## Reading it as a PDF, or reading the source There are two ways to consume the book. The README says that cloning the repository lets you try things out easily in a Docker environment, and separately that the Releases page publishes prebuilt PDF files for readers who just want to read it. The release history supports that: the tagged releases are dated builds such as 2025-06-24-20-51-02, so the PDF is produced from the Markdown sources by a scripted pipeline rather than being a separate publication. The update history for 2025 explains what changed in that year, and it is a list that reads like a maintenance log: automatic publishing through GitHub Pages, improved HTML generation, an optimised build process, sample code unified in Ruby, content rewritten to be easier to follow, and the removal of other technical debt. The project is also built on GitHub Pages, which is why the individual chapters are linked as 001.md through 008.md from the README. ## Where process-book is the wrong tool The limitation is not a missing feature, it is the language. The entire text is written in Japanese, so for a reader who does not read Japanese the repository is a set of untranslated chapters with a working lab around them, and the English and Chinese versions of the same concepts exist elsewhere in far more depth. The second limitation is the emphasis. This is a book about process mechanics on Unix-like systems, and the chapters reflect that focus: process creation, file descriptors, prefork servers, zombie and orphan processes, signals, and process groups. It says nothing about Windows process models, about container orchestration, or about the runtime behaviour of managed languages, so it will not answer questions about how a Go runtime or a JVM handles signals and threads. The third is the dependency on Docker for the exercises, which for some readers is a heavier requirement than the subject matter deserves. The alternative worth naming is any of the classic systems texts, which cover the same ground in English and go further, and the honest comparison is that this book's advantage is its labs and its Japanese prose, not its coverage. ## Conclusion Adopt process-book if you read Japanese and want a hands-on explanation of processes, signals and file descriptors that expects you to run every command, and if you are comfortable with Docker as the lab environment. Do not adopt it if you need the text in English, since the book is written entirely in Japanese, and treat the generated PDF releases as the convenient reading option rather than the source of truth. Verify first that your Docker and docker-compose setup is working before starting, since the whole book depends on a working container. ## FAQ ### How do I run the process-book examples? Clone the repository, then use docker-compose build to build the image, docker-compose up -d to start the container, and docker-compose exec process-book bash to open a shell inside it. The README recommends running every command in the container so behaviour is consistent. ### What chapters does process-book cover? Eight chapters: an introduction, creation of processes, processes and file input and output, file descriptors, building a prefork server, zombie and orphan processes, signals and kill, and process groups and foreground processes. Each is a separate Markdown file from 001.md to 008.md. ### Can I read process-book without using Docker? You can read the text, and prebuilt PDF files are published on the Releases page for readers who only want to read it. The Docker environment is for running the examples rather than reading them. ### What licence is process-book released under? Creative Commons Attribution Share Alike 3.0 Unported, as stated in the README's licence section. A derivative must be shared under the same licence. ## Sources - [Issues](https://github.com/Shinpeim/process-book/issues) - [README](https://github.com/Shinpeim/process-book/blob/master/README.md) - [Releases](https://github.com/Shinpeim/process-book/releases) - [Shinpeim/process-book on GitHub](https://github.com/Shinpeim/process-book) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/shinpeim-process-book