Zero one infinity rule

From Wikipedia, the free encyclopedia
  (Redirected from Zero One Infinity)
Jump to navigation Jump to search

The Zero one infinity (ZOI) rule is a rule of thumb in software design proposed by early computing pioneer Willem van der Poel.[1] It argues that arbitrary limits on the number of instances of a particular type of data or structure should not be allowed. Specifically, an entity should either be forbidden entirely, only one should be allowed, or any number of them should be allowed.[2] Although various factors outside that particular software could limit this number in practice, it should not be the software itself that puts a hard limit on the number of instances of the entity.

Allow none of foo, one of foo, or any number of foo.

The only reasonable numbers are zero, one and infinity.

— Bruce J. MacLennan

Examples of this rule may be found in the structure of many file systems' directories (also known as folders):

  • 0 – The topmost directory has zero parent directories; that is, there is no directory that contains the topmost directory.
  • 1 – Each subdirectory has exactly one parent directory (not including shortcuts to the directory's location; while such files may have similar icons to the icons of the destination directories, they are not directories at all).
  • ∞ (infinity) – Each directory, whether the topmost directory or any of its subdirectories, according to the file system's rules, may contain any number of files or subdirectories. Practical limits to this number are caused by other factors, such as space available on storage media and how well the computer's operating system is maintained.[citation needed]

In real-world software design, violations of this rule of thumb are common. For example, the FAT16 file system imposes a limit of 65,536 (i.e. 216) files to a directory.[3]


Van der Poel confirmed that he was the originator of the rule, but Bruce MacLennan has also claimed authorship:

Of course, the Zero-One-Infinity Principle was intended as a design principle for programming languages, and similar things, in order to keep them cognitively manageable. I formulated it in the early 70s, when I was working on programming language design and annoyed by all the arbitrary numbers that appeared in some of the languages of the day. I certainly have no argument against estimates, limits, or numbers in general! As you said, the problem is with arbitrary numbers. I don't think I used it in print before I wrote my 1983 PL book. Dick Hamming encouraged me to organize it around principles (a la Kernighan & Plauger and Strunk & White), and the Zero-One-Infinity Principle was one of the first. (FWIW, the name “Zero-One-Infinity Principle” was inspired by George Gamow’s book, “One, Two, Three… Infinity,” which I read in grade school.) [4]


  1. ^
  2. ^ "Zero-One-Infinity Rule". Jargon File.
  3. ^ "NTFS vs. FAT vs exFAT". Retrieved 2015-03-09.
  4. ^ "The Zero, One, Infinity Disease". Retrieved 2019-06-30.

See also[edit]