the-craft-of-selfteaching is forty-odd notebooks and a NoDerivatives licence

The entire method is eight lines of pseudo-Python

The project file opens with the argument in code, labelled as pseudo-code of self-teaching in Python:

# pseudo-code of selfteaching in Python

def teach_yourself(anything):
    while not create():
        learn()
        practice()
    return teach_yourself(another)

teach_yourself(coding)

Read it carefully, because the forty-odd notebooks are an expansion of it. The loop is learn then practice, repeated while you have not yet created anything, which is the operational definition of the craft the book is about. Then the function returns a call to itself with a different subject, and the last line seeds the whole thing with coding. Two things are undefined on purpose. There is no create(), because creating something is the condition the loop is waiting on rather than a step it performs, and there is no anything, because the function is a shape rather than a procedure for one field. The footnote at the bottom of the file, which links an Oxford Dictionary usage note on themselves versus themself, is the same instinct applied to a pronoun.

Sixteen chapters of argument come before the first line of code

The table of contents is an argument before it is a syllabus. After the preface and the proof-of-work chapter come five chapters with no programming in them: why you must master self-teaching, why programming is the entry point to it, the claim that a new skill can be acquired by reading alone, preparation for reading, and an entrance chapter. Only then does the language start, with values and their operators, control flow, functions, strings, containers and files, followed by a chapter on coping with knowledge that contains too many forward references and a local copy of the official Python tutorial. Classes do not appear until part three, and test-driven development is part two, section D.7. A reader who opens the repository looking for object-oriented programming has to get through twenty-eight chapters first, and that ordering is the book's argument rather than an accident of writing.

Reading is the method, and forward references are the named enemy

One chapter claims a new skill can be acquired by reading alone, and another is devoted to the problem that makes reading hard: knowledge full of forward references, where a sentence uses a term the reader has not met yet. Managing that is treated as a skill of its own rather than a defect of the documentation, and the chapter that follows it is a local copy of the official Python tutorial, linked as part one, chapter G. Having the reference inside the same notebook set means a reader who is sent backwards by an unfamiliar term has somewhere to go without leaving the sequence. The later chapters extend the same method past the fundamentals: deliberate practice, why to start writing functions, then arguments in two parts, lambda under the heading of aliases and anonymity, recursion, docstrings, modules as functions saved to files, test-driven development, and executable Python files.

NoDerivatives is the clause that decides what you may do with it

The copyright statement at the bottom of the file names a CC-BY-NC-ND licence, Creative Commons Attribution, NonCommercial, NoDerivatives, version 3.0, in its Chinese deed. The three conditions together are restrictive in a way that matters more than the attribution part. You may read it, share it and host it, crediting the author. You may not use it commercially, and you may not produce a derivative work, which in practice rules out adapting the chapters into a paid course, translating and then revising them, or folding the prose into your own material with edits. The repository's licence metadata is not set, so a tool that checks licences from metadata sees nothing at all and the statement in the file is the one that binds. One more detail for anyone hunting for the wrong repository: the Markdown version of the book was added on 2019-03-23 under a different organisation path, the selfteaching one, not under the account that hosts the notebooks.

The contribution model is proofreading, and the file tells you to read chapter 2 first

The way to help is stated in one line, and it is not code. Anyone interested in helping is asked to read 02.proof-of-work.ipynb first, the notebook titled how to prove you really read this book, before contributing. That notebook is the second chapter of the book itself, so the request to proofread begins with the chapter about establishing that you read the thing. It is an unusual arrangement and it is a coherent one: the primary language recorded for this repository is Jupyter Notebook, which means the chapters are prose with runnable cells, so the error a contributor is most likely to find is a sentence that is wrong, an example that no longer behaves, or a claim that has drifted. The project also asks readers to install Jupyterlab locally, with an appendix covering the installation and setup, because the notebooks are meant to be run rather than only read.

The data files at the root are the exercises, not sample clutter

Look at what sits beside the notebooks. There are two plain text data files, hdi-china-1870-2015.txt and life-expectancy-china-1960-2016.txt, and a results.txt that looks like the output of processing them. There is a mycode.py, a regex-target-text-sample.txt for the regular expression chapter, a symbols.numbers file, and an images directory. That is a working set, not a packaged release, and it tells you the chapters do real work on files rather than describing work. The same is true of the directories: from-readers/ and my-notes/ hold contributions and the author's own notes, and a .vs/ directory is committed at the top level, which is what happens when someone keeps a Visual Studio workspace next to a book they are writing. A Markdown directory sits alongside for readers who do not want notebooks at all.

No releases, so a chapter name is the only handle you have

The maintenance picture is thin and worth stating plainly. The repository publishes no GitHub releases, the default branch is master, there is no homepage recorded, and the last push recorded for the repository is 2026-05-20. The book's own status is announced in the file rather than in release notes, and the closest thing to a distribution event is the March 2019 addition of the Markdown version. If you are writing a syllabus, a blog post or a citation that points at a specific chapter, the file name is the only stable thing you can hold, since a correction lands directly on master with no version boundary behind it. The final chapters point the same way: one on communication, one called the self-teacher's destination, and one asking what to do next, which is a book telling you the reading does not stop at the last page rather than a project telling you to upgrade something.

Editorial conclusion

The book fits a reader who has decided to learn programming alone and wants a curriculum that argues for the method before teaching the language. It does not fit a commercial course author, because CC-BY-NC-ND permits reading and sharing with attribution and forbids commercial use and derivative works, and the repository's licence metadata is not set at all. Before you build on it, read the proof-of-work notebook, which is the second chapter and the file the project asks would-be proofreaders to open before sending a pull request. Then decide your reading surface: the chapters are notebooks with an appendix for installing Jupyterlab, while a Markdown version was added in March 2019 under a different organisation path. And note there are no releases, so a chapter's file name is the only stable reference, and the last push recorded for the repository is 2026-05-20.

Frequently asked questions

Official sources

1. Issues
2. README
3. xiaolai/the-craft-of-selfteaching on GitHub