Showing posts with label pattern. Show all posts
Showing posts with label pattern. Show all posts

No posts for a wee while

Mike's Notes

I was on holiday for the last few weeks and am back now. There will be no blog posts, newsletters or meetings until Pipi Core is back up and running.

Update 27/05/2026

Lots of surprises. Making rapid progress. The peace and quiet are bliss.

Update 31/05/2026

The problem and solution are how things are named. Pipi auto-generates thousands of code names using multiple pattern languages, and all the naming conventions require many minor fixes for several unexpected reasons after migrating from a developer laptop to a production server environment. Everything else is absolutely fine.

Other naming problems are also being solved now, including:

  • The rapid development of Boxlang by Ortus has brought forward another challenge. Pipi 10 will be migrated to run on top of Boxlang in 2027 to support multiple languages, including C++, CFML, COBOL, Go, Java, JavaScript, PHP, Python, Rust, etc.
  • Future integration with cloud-based LLMs.
  • Future integrations with Office365, Google Workspace, Zoho, LibreOffice, etc.

The common solution is to create standardised naming systems that are simple, stable, robust, schema-based, versioned, self-documenting, and extensible to meet unanticipated future needs.

This is done by replacing code-based naming rules with database-driven ones that can be easily edited in the future via an admin UI.

90% of these names are internal, hidden in the closed core, and how they work and what they are will not be discussed here. The rest will be publicly and fully documented as part of the open-source workspaces for developers to work with.

Update 02/06/2026

I'm changing the disclosure boundary between the Pipi closed-core and open-source workspaces. Previously, "disclose everything unless there is a security reason not to". This is now changed to "disclose on the basis of need to know".

Closed-core accounts for 90% and open-source workspaces for 10% of lines of code, databases, etc.

This will reduce the documentation burden, given Pipi's vast scale. So, the open-source workspaces will be fully shared and documented on GitHub, etc, without restriction. This includes;

  • Standards schema
  • Ontologies
  • Parameters
  • Laws of physics
  • HTML + CSS
  • Algorithms
  • Module DDD models
  • Workflow diagrams
  • Documentation
  • API schema
  • UI code
  • etc

This also means some existing technical documentation about the closed-core will become hidden and only available internally.

Update 07/06/2026

Pipi Core is the IDE used to edit Pipi Core (AKA: which came first, the chicken or the egg?). Temporary UIs have been created and are being used across multiple engines to edit the names in use. This is much faster than directly editing data, which had to be done initially. The next step will be turning auto-generation back on. Once that's done, temporary UIs will be used to build permanent UIs. More automation will then be enabled via the UIs, and so on, as Pipi Core builds itself with a human in the loop.

Update 08/06/2026

The list of code cases available to use now for auto-generated naming, I/O translation, etc with examples, includes;

  • camelCase: userProfilePicture
  • kebab-case: user-profile-picture
  • PascalCase: UserProfilePicture
  • snake_case: user_profile_picture
  • SCREAMING_SNAKE_CASE: USER_PROFILE_PICTURE
  • Train-Case: User-Profile-Picture
  • flatcase: userprofilepicture
  • UPPER-CASE-KEBAB-CASE: USER-PROFILE-PICTURE
  • Sentence case: User profile picture
  • Title Case: User Profile Picture
  • middot·case: user·profile·picture
  • dot.case: user.profile.picture
  • UPPER CASE: USER PROFILE PICTURE
  • lowercase: user profile picture

Update 12/06/20026

Checking that these changes to variable names and internal messaging do not clash with the Gödel Machine.

Update 17/06/2026

The DevOps Engine (dvp) has unexpectedly proven to be critical to solving this puzzle. Mostly fixed last night. Watching the rather excellent live Google talk, Beyond the GPU: Maximising goodput with self-healing AI infrastructure, this morning has given me valuable insights into how to fix the remaining issues by reviewing Google HPC YAML files. 😎😎 Sometimes insights come from the strangest places.

Update 01/07/2026

The main work now is rapidly configuring Pipi for production and full autonomous automation. Using Google Search AI Mode (Gemini) and then Grammarly Pro makes the work easier and 100x faster.

  • I have decided to have Pipi re-render the many Ajabbi draft public websites with the new and missing developer information. (20K pages)
  • The website's .robot.txt file will then be unlocked to enable search engines.
  • The HTML will be updated to make it easier for AI to read.
  • This blog will be imported into Pipi, cleaned up, re-exported from Pipi, and published to Blogger via the API.
  • The new posts created in Pipi will return to A Sandy Beach to discuss something already built rather than being built.

Update 02/07/2026

The DevOps and IaC engines are getting rapid data model overhauls. The IaC engine is a great test for the variable names. I'm building a capability into Pipi to autonomously and automatically run OpenTofu and Ansible, initially targeting the Pipi Data Centre, then GCP and AWS for deployments. It's going very well and making rapid progress.

Update 05/07/2026

Pipi will initially run the open-source enterprise applications on Google Cloud Run and Google Cloud Storage (GCS). The code is complete and will be very low-cost to run, giving Ajabbi, a bootstrapping-purpose startup, a very long runway.

Update 18/07/2026

The job has now shifted to configuring, networking and deploying many physical servers. Installing software, including Pipi, labelling cables and rack gear, throwing out junk, tidying, etc., leaving nothing to chance. Shipping delays are holding up part deliveries.

Update 28/07/2026

Most of the equipment has arrived, and the small data centre setup is coming together. More deliveries later this week. It's already running a lot better and is much more productive.

Update 31/07/2026

Work on Pipi has reached a tipping point or system phase change as Pipi takes over tasks using autonomous automation. Pipi now has deadlines, not me. Soon it will set the deadlines. It's now a downhill run; daily posts from me resume tomorrow, and much more will come.

In hindsight. This whole project has been systematic trial and error, spending 10 years learning how to crack a hard problem.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

31/07/2026

No posts for a wee while

By: Mike Peters
On a Sandy Beach: 15/05/2026

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

I was on a no-coding holiday for the last few weeks to clear my mind, and it has been great. I am back on the job today.

Suspended

Until the closed-source Pipi Core is back up and running 100% on autopilot, 10x faster, the following are suspended.

  • New posts "On a Sandy Beach
  • All newsletters, including the weekly Friday Report and the monthly Ajabbi Research Newsletter.
  • The fortnightly online Open R&D meeting.

Rapid refocus

  • A new developer area with five coding screens, designed to be more productive for hypervisual learners.
  • A better library has been set up for my A4 drawings in ring binders, the many reference books I use, and more bookshelves are on the way.
  • The server rack has been moved to a better location.
  • The light levels have been adjusted.
  • A big office tidy is almost done. An office-work-only desk has yet to be set up with a cat bed included.
  • A separate area with no screens for the happy cat, coffee, music, reading and drawing.

Less is more

Minimise screen time to be more productive at work. The new setup is also much less tiring.

Get the job done

The good thing is that, with a holiday and lots of drawing, I now have mental clarity about what needs fixing and how to fix it. Mainly, quite delicate changes here and there, organised into a list of steps. Now, I need to concentrate on one thing only: go as fast as possible, without meetings, post-deadlines, phone calls, or other distractions.

How

1. Use an AI workforce

Be the architect, and AI fills in the dots to make it happen.

Use Google Search AI mode (Gemini) to generate 99% of the code in one-page chunks (including references) to copy and paste, then manually change the variable names and SQL. Careful, test everything, resulting in 100x faster progress. Know how everything works and rapidly raise personal skill level.

2. Then build a cathedral

Make a wooden scale model of a cathedral for the builders. Google Search AI mode (Gemini) makes each brick, and Pipi Core assembles the bricks into floors, arches, walls, and vaults...

Speed is king

With the 100x coding productivity gains from Google Search AI mode (Gemini), plus the 10x10x10x speedup of Pipi Core currently underway over the next few months, what previously took a year will be done in hours and better.

Phase transitions

Once these initial migration issues from laptop to server are resolved, further transitions can be anticipated as the number of engines rapidly increases beyond 20. Increasing the number of engines slowly changes the whole system's behaviour from deterministic to probabilistic and adaptive.

Here is a partial list of transitions expected as the number of engines increases from 0 to 200. The actual numbers are a bit of a guess.

  • 20 engines enable Pipi 9 Core in a simple, deterministic structure.
  • 40 engines enable a workspace with a UI for administering Pipi Core.
  • 60 engines enable self-generation of user documentation.
  • 80 engines enable REPL and IAC (infrastructure-as-code).
  • 100 engines enable Workspaces for different user accounts.
  • Different Pipi 9 editions are made with the same engines, which recombine differently in response to the external environment.
  • And so on until...
  • 200 engines self-organise into a multi-layered complex fluid structure with probabilistic behaviour and emergent properties, as engines also act as agents.
  • 200+ engines enable Pipi 10 to interact with externally cloud-hosted LLMs, combining the very different strengths of both.

How function diversity scales, from cells to companies

Mike's Notes

Fascinating work. Something to test Pipi against using long-cycle simulations.

Resources

References

  • Scaling laws for function diversity and specialization across socioeconomic and biological complex systems. Authors: Vicky Chuqiao Yang, James Holehouse, Hyejin Youn, José Ignacio Arroyo, Sidney Redner, Geoffrey B. West, and Christopher P. Kempes. PNAS (February 12, 2025). DOI: 10.1073/pnas.2509729123

Repository

  • Home > Ajabbi Research > Library > Subscriptions > Parallax
  • Home > Handbook > 

Last Updated

04/05/2026

How function diversity scales, from cells to companies

By: Santa Fe Institute
Parallax: 18/02/2026

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

A mystery novel, a history book, and a fantasy epic may have little in common in plot or style. But count the words inside them and a strange regularity appears: many new words show up early, then fewer and fewer as the author reuses what has already been introduced.

That pattern, known as Heaps’ law, turns out not to belong to books alone. A new study in PNAS finds that the same rule also describes the growth patterns in many complex systems, from living cells and corporations to universities and government agencies — and could even be used to predict how they will change in the future.

The study, led by scientists at the Santa Fe Institute and MIT, doesn’t just document this regularity; it introduces a mathematical model that quantifies how different systems diversify and specialize. It finds that, while systems vary in how much they invest in creating entirely new functions, once those functions exist, their subsequent growth follows a remarkably universal rich-get-richer process.

“What’s striking is that these systems weren’t designed to follow the same rules,” says SFI Program Postdoctoral Fellow James Holehouse, who co-led the study with Vicky Chuqiao Yang, a former SFI Omidyar Fellow now at MIT. “Yet when you look at how they grow, you see the same trade-off between adding something new and building on what already exists.”

“It is remarkable that cells, bureaucracies, and companies, despite obvious differences, all grow their function repertoire with a similar pattern.”

In the study, researchers focus on what they call “distinct functions” — the different kinds of work a system performs. In a cell, that might mean different proteins. In an organization, it could mean different kinds of jobs. As systems grow, they do add new kinds of work, but they do so more and more slowly over time.

Using their model, the team analyzed dozens of bacterial and microbial cells, more than a hundred U.S. federal agencies, thousands of companies and universities, and hundreds of metropolitan areas. Across most of these cases, the same pattern appeared: as systems got bigger, the pace at which they added new functions steadily slowed, growing sublinearly.

In practical terms, sublinear growth means that doubling the size of a system does not double the number of functions inside it. Instead, growth increasingly comes from expanding what already exists. A growing organization hires more people into established jobs before creating new titles. A cell produces more of the proteins it already uses instead of evolving entirely new ones.

“It is remarkable that cells, bureaucracies, and companies, despite obvious differences, all grow their function repertoire with a similar pattern,” says Yang, an assistant professor at MIT Sloan and the Institute for Data, Systems, and Society. “This suggests that the regularity discovered in Heaps’ law applies not only to what humans create, like books, but also to human organizations themselves.”

Cities, however, follow a different version of the same trend. They still add new kinds of jobs as they grow, but they do so much more slowly, following a logarithmic pattern rather than the power-law pattern seen in other systems. Even as populations soar, genuinely new job types become increasingly rare.

That difference reflects a deeper structural divide. Cells, firms, and agencies behave like organisms, with clear boundaries and unified goals. Cities, by contrast, resemble ecosystems shaped by the independent choices of individuals rather than centralized control.

Geoffrey West, a co-author and Santa Fe Institute Shannan Distinguished Professor, adds, “There are underlying regularities shaping how complexity builds, even in systems that look completely different on the surface.”

This material is based upon work supported by the U.S. National Science Foundation under Award No. 2526746

Tony Hoare introduced Communicating Sequential Processes (CSP)

Mike's Notes

Alex introduced me to Tony Hoare.

"As far as I remember, the main focus of messaging is on exchange protocols—a whole separate field of algorithmic analysis of interacting processes. Hoare wrote a treatise on this back in the last century, "Interacting Sequential Processes"—I think that's what it's called." - Alex Shkotin

Resources

References

  • Learning CSP, by Tony Hoare
  • Communicating Sequential Processes by Tony Hoare, ACM

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

31/01/2026

Tony Hoare introduced Communicating Sequential Processes (CSP)

By: 
Stanford: Copied 31/01/2026

Sir Charles Antony Richard Hoare (/hɔːr/ HOR; born 11 January 1934), also known as C. A. R. Hoare, is a British computer scientist who has made foundational contributions to programming languages, algorithms, operating systems, formal verification, and concurrent computing.[3] His work earned him the 1980 ACM Turing Award, usually regarded as the highest distinction in computer science.


 

Tony Hoare, winner of the Association for Computing Machinery's A.M. Turing Award, discusses the origin of his model of "Communicating Sequential Processes" and the central importance of keeping processes from directly accessing the state information of other processes. This clip taken from an interview conducted with Hoare by Cliff Jones for the ACM on November 24. 2015. Video of the full interview is available as part of Hoare’s ACM profile at https://amturing.acm.org/award_winners/hoare_4622167.cfm


On Design

"There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies." - Tony Hoare

Introduction

Tony Hoare introduced Communicating Sequential Processes (CSP) in 1978 as a language to describe interactions between concurrent processes. Historically, software advancement has mainly relied upon improvements in hardware that create enable faster CPUs and larger memory. Hoare recognized that a machine with hardware that is 10 times as fast running a code that consumes 10 times more resources is not an improvement.

While concurrency has many advantages over traditional sequential programming, it has failed to gain a popular audience because of its erroneous nature. With CSP, Hoare introduced a precise theory that can mathematically guarantee programs to be free of the common problems of concurrency. In his book, Learning CSP (the third most quoted book in Computer Science), Hoare uses calculus to show that it is possible to work with deadlocks and nondeterminism as if they were terminal events in ordinary processes. By reducing the errors of CSP, Hoare has enabled computer scientists to fully exploit the capacity of CPUs.

What is concurrency?

The ordinary task of doing your laundry illustrates the basics of concurrency. There are two ways to finish two loads of laundry:

  1. Put 1st load in washing machine → put 1st load in dryer → fold 1st load → put the 2nd load into the washing machine → repeat process.
  2. Put 1st load in washing machine → put 1st load in dryer → put 2nd load in washing machine → etc…

Clearly, the second method is quicker and better utilizes resources. If the first load is in the dryer, the washing machine isn’t being used and should be used by the second load. This is the basics of concurrency.

Historical Information

The earliest ideas for concurrent processing arose naturally in the 1960’s because of scarce resources. At that time, processing power was expensive, and it was wasteful for a processor to have to wait while it communicated with slow peripheral equipment or human (Hoare, Learning CSP).

Ex: The task of performing a simple addition problem shows how concurrency can greatly improve computational efficiency. Adding numbers requires three parts:

  1. Ask user for input numbers
  2. Performing calculation
  3. Printing the answer

Problems of concurrency and Hoare’s solution

While concurrency offers great potential for faster computation, it is not without fault. Unlike parallelism, where n tasks run on n processors, in concurrency, n tasks run on 1 processor. Because the amount of resources doesn’t increase, programs that need to use the same resource must wait.

  1. The amount of time user waits increases linearly
  2. The amount of storage space needed increases with number of jobs
  3. Difficulty verifying program correctness

The difficulty of verifying program correctness has been the primary hindrance in the field. Programmers have shied away from parallel programming because errors that arise in this method of programming are notoriously difficult to track down. Programs are often prone to errors that not obvious and surface under arbitrary and unrepeatable situations. The complex nature of concurrency leaves the programmer in doubt. Programmers often resort to exhaustive search tactics to find errors:

Testing the code rigorously to sort out obvious concurrency issues and hoping that all problems have been resolved

Completely follow design patterns and guidelines for concurrent programming. This method is limited in its applicability.

OR...

Hoare’s approach CSP uses mathematical deductions to prove that a program is error free. Through the application of CSP, programmers no longer search for bugs in written programs, but rather can write programs that are logically guaranteed to be correct.

General terms in CSP

Alphabet- set of events which are considered relevant for a particular object. The alphabet of a process is enclosed within curly brackets. a. ex: vending machine- alphabet {coin, chocolate} b. not valid: {coin, car} Trace: sequence of symbols recording the events in which the process has engaged in within a given time. The trace is enclosed within angle brackets. c. Vending machine:

Nondeterminism

In a concurrent program, two or more processes compete for the same resource. The resolution of this dilemma is not always deterministic. The unpredictable arrival order of messages creates a nondeterministic state (2).

Ex: A change machine can give change for a dollar in many different ways: four quarters, ten dimes, 100 pennies. The type of change given is not dependent on the type of change machine, but rather by some arbitrary or nondeterministic fashion.

Ex2: A passenger waiting for the bus to take him to London. The A, B, D, and F lines all go to London. The passenger can take any f these lines. Which line he gets on is only dependent upon which bus arrives first.

Why nondeterminism? Programmers use nondeterminism to exclude the events that don’t effect the outcome as a technique to simplify the problem. In the case of the change machine, only the sum, not the combination of coins matters. By reducing the number of variables, nondeterminism helps maintain a high level of abstraction when describing complicated systems.

Problems with nondeterminism Although nondeterminism can greatly reduce the complexity of problems, they also introduce their other issues. In a deterministic program, the answer will always be the same given the same inputs. In a nondeterministic program, the same inputs can yield different answers on different cycles or machines. This characteristic makes it difficult to check whether the program works.

CSP and nondeterminism

CSP introduces the notation Π to signify a process which “behaves either like P or like Q, where the selection between them is arbitrarily, without the knowledge of the external environment (1).”

Ex: During lunch, you can choose between an apple or an orange. The choice can be mathematically expressed as: orange Π apple, where the choice between the two is based on a unaccounted external factor.

Algebraic laws governing nondeterministic choices are simple.

  • Idempotenence: A choice between P and P is empty P Π Q = P
  • Symmetry: P Π Q= Q Π P The order does not influence the choice
  • Associative: P Π (Q Π R) = (P Π Q) Π R The choice between three options can be divided into two successive single choices.
  • Distributive: x → (P Π Q) = (x → P) Π (x → Q) Going from a defined path x to a choice between path P and Q, is the same as choosing between the options of going from path x to P or from path x to Q.

Fairness

In some theories, nondeterminism is obliged to be fair, in the sense that an event that infinitely often may happen eventually must happen (though there is no limit to how long it may be delayed). In Hoare’s theory, the concept of fairness doesn’t exist:

“Because we observe only finite traces of the behaviour of a process, if an event can be postponed indefinitely, we can never tell whether it is going to happen or not. If we want to insist that the event shall happen eventually, we must state that there is a number n such that every trace longer than n contains that event. Then the process must be designed explicitly to satisfy this constraint. For example, in the process P0 defined below, then event a must always occur within n steps of its previous occurrence.”

-Learning CSP

If fairness is required for the program, it must be considered and accounted for separately.

Shared Resources

Laws for reasoning about sequential processes derives from the fact that each variable is updated by one process (learning CSP). If storage is shared, only one process can change the variable. The potential for data corruption makes common variables and communication amongst processes difficult to implement.

Deadlock

Deadlock is the permanent blocking of a set of processes. It is a common problem in concurrency and arises from the conflicting needs of processes for similar resources or when communicating with each other.

Example of deadlock: Intersection of cars(3). The shared resources can be thought of as the lanes. Each car shares the four lanes. The process is the car. Deadlock occurs when each process holds one resource and requests the other. While one car can decide to switch lanes, no car can agree on the proper action to take. As in traffic, deadlock in computer science slows or completely halts a program.

Classical illustration of deadlock

There is a group of five philosophers who do nothing but eat and think all day. The philosophers sit around a round table with a bowl of noodles in the middle. As philosophers get paid less than computer scientists, they can afford only five single chopsticks, which are placed on each side of the philosopher. To eat the noodle, the philosopher needs both chopsticks. The philosopher first picks up the chopstick from his left, and then his right if it is not being used.

Deadlock arrives when all philosophers want to eat at exactly the same time. All philosophers pick up the chopstick to their left. However, none of the philosophers can eat because another philosopher is currently using the other chopstick.

Events that lead to Deadlock

There are several combinations of events can cause deadlock

  1. Mutual exclusion: Only one process can use a resource at a time
  2. Hold- and- wait: A process holds onto its resource until the next resource its needs becomes available
  3. No preemption: No process can be forced to give up its resources
  4. Circular wait: closed chain of processes where each process holds the resource the next process needs to function.

While these situations can lead to deadlock, there are precautions programmers can take to prevent their occurrence.

  1. Mutual exclusion: Restrict the way in which resources can be requested.
  2. Hold- and- wait: Require all processes to provide information about the resources they will need in advance. Use algorithms to insure that all resources are available to the process before it attempts to acquire them.
  3. Circular wait: Establish a priority system that requires processes to request resources and process them in that order, such that a higher priority process will always have access to the resource first. This solution can lead to starvation.

Eliminating the possibility of a deadlock is better than dealing the deadlock during execution. However there will may arise arrive unique combination of situations that lead to deadlock. There are methods of resolving a deadlock when it’s detected, but these solutions are not efficient and resolve in lost data (4).

  1. Preempt the resource from a process. The preempt process can be resumed at a later time.
  2. Return to a point where the process did not need the acquired resource causing the deadlock.
  3. Systematic killing of jobs until deadlock is resolved.

CSP and deadlock solution

In order to prevent data corruption, Hoare purposed the concept of a critical area. Processes cross the critical area to gain access to the shared data. Before entry to the critical area, all other processes must verify and update the value of the shared variable. Upon exit, the processes must again verify that all processes have the same value.

Another technique to maintain data integrity is through the use of mutual exclusion semaphore or a mutex. A mutex is a specific subclass of a semaphore that only allows one process to access the variable at once. A semaphore is a restricted access variable that serves as the classic solution to preventing race hazards in concurrency. Other processes attempting to access the mutex are blocked and must wait until the current process releases the mutex. When the mutex is released, only one of the waiting processes will gain access to the variable, and all others continue to wait.

In the early 1970s, Hoare developed a concept known as a monitor based on the concept of the mutex. According to a tutorial on CSP in the Java programming language written by IBM:

“A monitor is a body of code whose access is guarded by a mutex. Any process wishing to execute this code must acquire the associated mutex at the top of the code block and release it at the bottom. Because only one thread can own a mutex at a given time, this effectively ensures that only the owing thread can execute a monitor block of code.”

Monitors can help prevent data corruption and deadlocks (5)

Possible Solutions to Philosopher Problem

A physical representation of the solution to the deadlock problem can be visualized as the footman. The behavior of the footman allows him to sit only four philosophers at the table simultaneously.

The metaphor of the dining philosophers was thought by the well known computer scientist, Edsger Dijkstra. Carel S. Scholten discovered the footman solution.

Infinite Overtaking

This problem arises when priority is assigned to programs. Some program always takes precedence at the expense of other programs that are delayed forever.

Ex: You are waiting to be seated at a restaurant. You are next in line, and just about to be shown your table when a famous actor walks in. The restaurant, mindful of good publicity, seats the famous actor first. When the next table becomes available, the waiter turns to you, but then sees a famous singer walk in. Again, the waiter seats the singer before you. The weighting of resources leaves you at a disadvantage. If this cycle continues, you could be delayed forever, or at least for an unacceptable period of time.

Overtaking Solution

The task of deciding how to allocate resources to waiting processes is called scheduling. Scheduling is split into two events, which Hoare terms the please and the thankyou:

  1. Please- processes requesting the resource
  2. Thankyou- the allocation of the resource to processes.

The time between the request and granting of the resource is the waiting period. In CSP, there are several techniques that prevent infinite waiting times.

  1. Limiting resource use and increasing availability of resource.
  2. First in first out (FIFO)- allocate resource to the process that has waited the longest.
  3. Bakery algorithm (A more technical explanation of the scheduling algorithm can be found in the reference (6))

Limitations of CSP

In determininistic programs, the result will be the same if the environment is constant. Because concurrency is based on non-determinisim, the environment does not affect the program. Given the paths chosen, the program can run several times and receive different result. To insure the accuracy of concurrent programs, programmers must be able to consider the execution of their program on a holistic level.

However, despite the formal methods that Hoare introduced, there still lacks any proof method to verify correct programs. CSP can only catch problems it knows exists, not unknown problems. While commercial applications based on CSP, such as ConAn, can detect the presence of errors, it can’t detect their absence. While CSP gives you the tools to write a program that can avoid the common concurrency errors, the proof of a correct program remains an unresolved area in CSP.

Future of CSP

CSP has great potential in biology and chemistry to model complex systems in nature. It has not been widely used in industry because of the many existing logical problems facing the industry. At the conference for the 25th anniversary for the development of CSP, Hoare noted that despite the many research projects funded by Microsoft, Bill Gates ignores the issue of when Microsoft will be able to commercialize the work on CSP (7).

Hoare reminds his audience that the area of dynamic procedures still requires much more research. Currently, the computer science community is stuck in the paradigm of sequential thought. With the foundation in formal methods of concurrency established by Hoare, the scientific community is primed to being the next revolution in parallel programming.

References

  1. Hoare, C.A.R. Learning CSP. June 21, 2004.
  2. Haghighi, Hassan and Mirian-Hosseinabadi, Seyyed H. Nondeterminism in Formal Development of Concurrent Programs: A Constructive Approach
  3. Concurrency: Deadlock and Starvation. Presentation Obtained from engr.smu.edu/~kocan/7343/fall05/slides/Chapter06.ppt
  4. Rinard, Martin C. Operating Systems Lecture Notes
  5. Abhijit Belapurkar. CSP for Java Programmers, Part 1
  6. Carnegie Melon. Bakery Algorithm
  7. Numerico, Teresa an Bowen, Jonathon. 25 Years of CSP

Sharable Content Object Reference Model (SCORM®)

Mike's Notes

This has been used in the Learning Object Engine (lob).

The original article has many links to resource material.

Resources

References

  • Reference

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

08/12/2025

Sharable Content Object Reference Model (SCORM®)

By: Mike Peters
On a Sandy Beach: 01/12/2025

Overview

The Sharable Content Object Reference Model (SCORM®) was created in 2000 by ADL to address e-learning interoperability, reusability, and durability challenges. This research was driven by the challenge that enterprise organizations faced when upgrading systems or changing vendors, which often required them to abandon expensive content and start from scratch. Conversely, large content vendors often specified their own delivery environment, requiring organizations to implement different delivery modules for each content vendor. To provide organizations with the capability to reuse instructional components in multiple applications and environments regardless of the tools used to create them, ADL led and conducted the research required to ensure that content could be separated from context specific run-time constraints and proprietary systems so that it could be incorporated into different applications.

With this, ADL designed SCORM to leverage standard web technologies as well as emerging learning technology specifications. SCORM allowed browser-based e-learning with plug-and-play portability, reusability, and instructional sequencing of self-paced content.

Under a series of DoD Instructions – most recently DoDI 1322.26 – SCORM has been officially specified as one of the allowed metadata tracking options for DoD e-learning content.

To extend these concepts to track performance data on emerging learning capabilities (e.g., mobile learning), DoDI 1322.26 has been updated to allow a more capable standard called the Experience API, or xAPI. Unlike SCORM, xAPI can be used to track and share data from mobile learning, simulations, virtual worlds, serious games, real-world activities, wearable devices, experiential learning, social learning, offline learning, and more.

SCORM History

A 1999 executive order signed by President Bill Clinton established a task force charged with developing new standards and specifications for e-learning across the Federal Government and the private sector. Version 1.0 of SCORM was released in 2000, followed by SCORM 1.2 in 2001. The most recent release (2009) is SCORM 2004 4th Edition.

ADL maintains documentation for SCORM 1.2, SCORM 2004 3rd Edition, and SCORM 2004 4th Edition (see Versions & Resources section below). In 2008, the Learning-Education-Training Systems Interoperability (LETSI) Federation was formed to investigate the next generation of SCORM requirements. LETSI produced over 100 white papers that would later become essential artifacts and sources of requirements for the newer xAPI specification for e-learning.

While ADL (and DoDI 1322.26) now recommends xAPI and cmi5 solutions for new e-learning acquisitions and implementations, it is understood that SCORM solutions are still in wide use to enable interoperability (course re-use) across compliant systems. Developers who are implementing other versions of SCORM are encouraged to modify their work to comply with one of the existing specified versions. DoDI 1322.26 contains the current guidance for SCORM conformance in DoD.

SCORM Acquisition Guidance

DoD and other Federal Government organizations are encouraged to use the following statement in their acquisition documents (e.g., statements of work, performance work statements, or other applicable program requirements documentation):

The contractor shall ensure distributed learning content is conformant to SCORM [insert preferred edition].

The following documents will be cited in the solicitation document (keyed to the appropriate section) for distributed learning (DL): ADL SCORM [insert preferred edition] conformance testing requirements.

Acceptance shall be based on the following:

    • Conformance: An error-free repeatable test log output saved as a .zip file for each Content Package (CP), providing evidence that the CP SCORM [insert preferred edition]. Conformant conformance label has been achieved, shall verify SCORM-conformance.
    • Target DL System Verification: A report from the target DL system or operator of the target DL system certifying that the content ran properly.

SCORM Technical Details

The latest SCORM specification consists of three different technical “books” (available in the Versions and Resources section below) that collectively address challenges associated with interoperability, portability, reusability, and the instructional sequencing of self-paced e-learning content.

Interoperability

The SCORM Run-time Environment (RTE) book defines a common data model and application program interface (API) for e-learning content. This combination of data model and API allow for standardized communications between client-side content and a system component (called “the run-time environment”), which is commonly provided by a Learning Management System (LMS).

Portability

The SCORM Content Aggregation Model (CAM) book defines how to package content for exchange from system to system, in a transferable ZIP file called the Package Interchange Format (PIF). Packaging enables a standardized portability mechanism between various learning environment applications.

Reusability

The SCORM Content Aggregation Model (CAM) book describes the components used in a learning experience and how to describe those components to enable search and discovery. Therefore, the CAM book promotes reusability of learning content across LMSs and repositories. The CAM book describes responsibilities and requirements for building content and content organizations (e.g., course, lessons, modules, etc.). It contains instructions for applying metadata to the all the content organization components in the content package. On the server side, the CAM details the format an LMS must be able to “import” for the purpose of providing content to users.

Sequencing

The SCORM Sequencing and Navigation (SN) book, in combination with the CAM book, describe how SCORM-conformant content is delivered to learners through a set of learner or system-initiated navigation events. The branching and flow of that content may be described by a predefined set of activities. SCORM 2004’s sequencing rules allow instructional designers and content developers to specify the order in which sharable content objects (SCOs), the smallest piece of content that tracks progress, are delivered to learners and what navigation controls are present in a SCORM 2004-conformant LMS.

SCORM Conformance, Certification, and Adoption Support

Although SCORM is being overtaken by newer, more capable e-learning specifications, ADL continues to support SCORM adoption, including with help-desk verification of conformance through validation of test suite logs for vendors and content developers. The US Army has also developed a SCORM 2004 (3rd Edition) Test Suite, last updated in 2018. Conformance Test Suite software and documentation are provided for each version in the SCORM Versions and Resources section below.

Many products claim to be SCORM certified, SCORM conformant, or offered by a SCORM Adopter. ADL has specific terms and criteria regarding each of these levels of conformance:

SCORM Conformance – The only criteria for claiming SCORM conformance (to a specific version of SCORM, i.e., SCORM version 1.2) is to pass the corresponding test within the ADL Conformance Test Suite, or the Army-developed conformance test for SCORM 2004 (3rd Edition). These tests are done on an honor system and require no ADL involvement. Test logs should be submitted to ADL to confirm an organization’s SCORM adoption.

SCORM Adopter – A product must be SCORM conformant before it can be considered a SCORM Adopter. The logs that result from a passing test in the ADL Conformance Test Suite are submitted to ADL and if found to be correct, the product is labeled as a SCORM Adopter.

SCORM Certification – Certified products are those that have been tested through ADL Certification Testing Centers. Certification is no longer offered through independent centers or ADL.

NOTE: As an alternative to previous SCORM Certified Products and SCORM Adopter forms and searchable databases, ADL has posted locked spreadsheets of the data until the forms and process are updated. Click the links below to access these static resources.

  • SCORM Certified Products
  • SCORM Adopters List

Known Issues

Members of the SCORM user/developer community have identified some JavaScript vulnerability and cross-domain API issues. ADL has assessed these issues and published the following papers to provide solutions and workarounds.

  • Securing Your Assessments
  • SCORM Content Vulnerability Workarounds
  • Cross-Domain Scripting Issue

SCORM Versions and Resources

Multiple versions of SCORM remain in use worldwide, with SCORM 2004 (4th Edition) being the most recent. ADL encourages content developers and those who produce distributed learning products and must use SCORM (as opposed to xAPI or cmi5) to conform with this version. Support resources for the three prominent versions are provided below, including zip file downloads.

SCORM 2004 (4th Edition)

  • Technical Specification (4th Ed.) (zip file)
  • Testing Requirements

Compatibility Testing Resources

  • 2004 4th Edition Conformance Requirements Version 1.1
  • Conformance Test Suite 1.1.1 (zip file)
  • LMS Test Packages (4th Ed.) (zip file)
  • Sample Run-time Environment 1.1.1 (zip file)

Extensions

  • Content Packaging Extensions Version 2.0 (zip file)
  • Navigation Extensions Version 1.0 (zip file)

Content Examples

  • Bookmarking (zip file)
  • Data Model (zip file)
  • Manifest Basics (zip file)
  • Sequencing Essentials (zip file)

SCORM 2004 (3rd Edition)

  • Technical Specification (3rd Ed.) (zip file)
  • Impact Summary

Compatibility Testing Resources

  • Conformance Test Suite 1.1.2 (zip file) (recommended)
  • Conformance Test Suite 1.0.2 (zip file)
  • LMS Test Packages (3rd Ed.) (zip file)

Content Examples

SCORM 1.2

(See the official SCORM 1.2 specification below for a complete list of changes and improvements from 1.0 to 1.1 and the 1.2 version.)

  • Technical Specification (Version 1.2) (zip file)
  • Conformance Test Suite 1.2.7 (zip file)

SCORM 1.0

  • Institute for Defense Analyses Report, July 2000

Additional SCORM Resources

  • The Next Generation of SCORM: Innovation for the Global Force
  • Users Guide for Instructional Designers
  • Users Guide for Programmers
  • SCORM Starter Template (zip file)
  • Official ADL SCORM API Wrappers (zip file)
  • RELOAD Content Editor (zip file)
  • Guidelines for Creating Reusable Content w/SCORM 2004
  • Utility and Applicability of SCORM Within Navy Higher Education
  • Choosing a Learning Management System (LMS)
  • Choosing a Learning Record Store (LRS)
  • Choosing Authoring Tools
  • SCORM and Experience API Roadmap
  • SCORM + xAPI Roadmap Release and Resources
  • cmi5 and the xAPI SCORM Profile
  • SCORM to xAPI Wrapper (GitHub page)
  • XAPI SCORM Profile (GitHub page)
  • Interactive PowerPoint and Printer-friendly PDF – (2011)

Videos

  • Training and Learning Architecture- Webinar - Meeting the Needs of the Next Generation of SCORM 51:16 – (2013)
  • Creating Reusable Content in SCORM 2004 – Part 1 6:00 – (2011)

Publications

  • DAU xAPI Content Module Analysis Chadwick, R.; Creighton, T.; Haag, J.; Potrack, J. 2019
  • Choosing a Learning Management System (LMS) Berking, P.; Gallagher, S. 2016
  • Choosing Authoring Tools Berking, P. 2016
  • Choosing a Learning Record Store (LRS) Berking, P. 2016 
  • The Next Generation of SCORM: Innovation for the Global Force Poltrack, J.; Haag J.; Johsnon, A.; Hruska, N. 2012, IITSEC
  • Sharable Courseware Object Reference Model (SCORM), Version 1.0 Ball, R; Burke, R; Fletcher, D; Hoberney, A; Jesukiewicz, P 2000

What is Diátaxis and should you be using it with your documentation?

Mike's Notes

I rediscovered this article by Technical Writer Tom Johnson while figuring out how to get the Pipi 9 CMS Engine (cms) to successfully integrate support material and learning documentation into the workspaces.

The actual Pipi 9 code base has no comments. Pipi writes the code and adds a metadata stamp, so why would it need comments? All documentation sits in parallel structures. This closes some doors and opens others.

Pipi 9 uses a structured combination of;

  • Read the Docs
  • Learning Objects
  • Diátaxis
  • The Good Docs Project

Information Pattern

Inspired by Read the Docs.

The whole is composed of Learning Objects in composable hierarchical structures. Each Learning Object

  • Is of one Diátaxis type
  • Uses one Good Docs Template

Learning material is presented in this default order because apparently it works for most people.

Tutorials > How-to guides > Technical reference > Explanation

Users can, however, explore learning material in any way that works for them and set it as a learning preference.

Show, not tell 

In my case, I like to see a diagram, then watch a talk with slides because I'm curious, then read the reference so that I can reverse-engineer to build a working model in my head, then a demo for the ahaha moment to confirm the model. Then an explanation to fill in the gaps, then a how-to guide and finally a tutorial to find the start button.😊 Worked examples are essential, because it gives me a pattern to start with and then change.

We all learn differently.

Ajabbi will need an excellent Technical Writer to improve what I have written, providing top-notch documentation and reducing complexity for readers.

Resources

References

  • Documenting APIs: A guide for technical writers and engineers. By Tom Johnson.

Repository

  • Home > Ajabbi Research > Library > Subscriptions > I'd rather be writing
  • Home > Ajabbi Research > Library > Learning > Learn API Docs
  • Home > Handbook > 

Last Updated

08/12/2025

What is Diátaxis and should you be using it with your documentation?

By: Tom Johnson
I'd rather be writing: 18/10/2023

I'm an API technical writer based in the Seattle area. On this blog, I write about topics related to technical writing and communication — such as software documentation, API documentation, AI, information architecture, content strategy, writing processes, plain language, tech comm careers, and more. Check out my API documentation course if you're looking for more info about documenting APIs. Or see my posts on AI and AI course section for more on the latest in AI and tech comm.

Summary

The Diátaxis approach to documentation organizes technical documentation into four types — tutorials, how-tos, reference, and explanation. In this post, I compare Diátaxis to DITA, Information Mapping, and the Good Docs Project, explaining similarities and differences. I also point out why identifying information patterns can be so worthwhile as a technical writer, and how identifying these patterns not only grounds our practice in the larger practice of rhetoric but also gives us useful patterns to use with AI tools.

Introduction

One topic I keep seeing surface in various places online is Diátaxis. Here are a few places I’ve seen it surface:

  • Upcoming webinars — see Introducing the Diátaxis Approach to Technical Documentation on the Content Wrangler’s BrightTALK
  • PyCon talks — see What nobody tells you about documentation
  • Reddit threads — see Diátaxis, a pragmatic system for technical documentation writing
  • Tutorials that mention it — see API tutorials beyond OpenAPI
  • Discussions among Python doc groups — see Adopting the Diátaxis framework for Python documentation, and more.
  • You can read more about it here: Diátaxis. It seems Diátaxis is gaining some traction in the technical writing community.

I knew Diátaxis involves organizing docs into four specific content types: explanation, reference, tutorials, and tasks. But I was fuzzy on most other specifics. The constant references to Diátaxis made me wonder, what am I missing? Is there something new here? Is this how I should be approaching the structure of my own documentation? And why is Diátaxis growing in popularity? What’s unique about the approach, and how does it differ from DITA?

Diataxis diagram

What is Diátaxis?

The Diátaxis approach divides documentation into four distinct content types:

  • Tutorials - Lessons that provide a learning experience, taking users step-by-step through hands-on exercises to build skills and familiarity.
  • How-To Guides - Practical guides focused on providing the steps to solve real-world problems.
  • Reference - Technical descriptions and factual information about the system, APIs, parameters, etc.
  • Explanation - Background information and conceptual discussions that provide context and illuminate topics more broadly.

The key premise of Diátaxis is that each content type serves a different user need and has a distinct purpose. Keeping them separated allows the content to be tailored and structured appropriately for that specific goal.

What does “Diátaxis” mean?

The name Diátaxis derives from Ancient Greek roots meaning “arrangement” or “layout.” It combines the Greek prefix dia, meaning “across”, with taxis, meaning “arrangement.”

This linguistic root relates to the organizational nature of the Diátaxis documentation approach. At its core, Diátaxis provides guidance for thoughtfully structuring documentation content into different categories based on user needs. The Diátaxis approach takes a jumble of disparate content and systematically arranges it into a meaningful, structured information architecture optimized around user goals.

Why follow the Diátaxis approach?

Here are some key benefits and promises of the Diátaxis approach:

  • Helps users find what they need more easily since content is organized by their goals.
  • Allows writers to focus on the type of content instead of wrestling with how to fit it into a less structured documentation system.
  • Serves both beginners and experts more effectively by separating learning content from reference.
  • Prevents muddling of content types, such as conceptual explanations in a how-to guide or instructions within a reference doc.
  • Provides a consistent, structured model for organizing documentation across products.
  • Promotes better quality content overall by keeping each type focused on its primary user need.

Who is Daniele Procida?

Daniele Procida developed the Diátaxis approach to documentation. Although he has a background in philosophy, Procida has been in the tech industry for a decade now, and has been involved in open-source software for even longer. He is currently an Engineering Director at Canonical.

Comparing Diátaxis with other approaches

As an approach for documentation, Diátaxis shares some similarities with other models.

How does Diátaxis compare with DITA?

DITA users will see quick comparisons with task, concept, and reference, but beyond these overlaps, DITA and Diátaxis actually have a lot of differences:

  • DITA is a formal XML-based standard maintained by the OASIS standards organization. It consists of XML schemas that content must validate against. Diátaxis isn’t an XML schema and doesn’t require validation.
  • DITA has a strong ecosystem of CMS tools and publishing systems built around its XML architecture. Diátaxis is not tied to specific tooling.
  • DITA defines a few more core topic types than Diátaxis, including troubleshooting, glossary, and generic topics. Diátaxis focuses on just four main types: tutorial, how-to, reference, and explanation.
  • DITA allows creating custom topic types through a specialization mechanism. Diátaxis doesn’t have extensibility for new types, as it’s not an XML schema.

Diátaxis has a more prescriptive recommended information architecture based on inherent user needs. DITA is more agnostic about optimal structures. For example, you can assemble the tasks, concepts, and reference types into whatever arrangements you want.

DITA emphasizes content reusability through topic-based authoring. The core idea is that componetizing information into these building blocks allows for efficient reuse across different deliverables (PDF, web, and more). Diátaxis isn’t concerned about content reusability and re-use across multiple outputs.

How does Diátaxis compare with Information Mapping?

DITA also shares some origins with Information Mapping, a technique developed by Robert Horn in the late 1960s. Although many details about Information Mapping are restricted by a paywall, here’s a brief comparison of Diátaxis and information mapping based on the information from Iva Cheung’s Introduction to Information Mapping post.

Cheung says Information Mapping identifies the following information types:

  • procedure—e.g., instructions on how to do something
  • process—e.g., description of how something works
  • principle—e.g., description of a standard or a convention
  • concept—e.g., description of a new idea or object
  • structure—e.g., description of an object’s components
  • fact—e.g., empirical information

You can see similarities here with other approaches. Diátaxis’ explanation is similar to principles and concepts. Reference might related to structure. How-to guides might relate to procedures and processes. I’m not sure what “fact” is, but perhaps it shares intent with tutorials.

Cheung says information management uses these three principles:

  • Chunking: group information into small, manageable chunks.
  • Relevance: limit each group or “unit of information” to a single topic, purpose, or idea.
  • Labelling: give each unit of information a meaningful name.

Here Information Mapping seems more similar to DITA than Diátaxis, in that information is broken down into small chunks with single ideas. The labels, however, seem unique to Information Mapping and interestingly seem to share commonality with embedding techniques used when preparing information for LLMs.

How does Diátaxis compare to The Good Docs project?

Both the Diátaxis approach and The Good Docs Project are focused on identifying best practice patterns and templates for technical documentation, but they approach it differently.

Diátaxis defines 4 core content types — tutorial, how-to, reference, and explanation. In contrast, The Good Docs Project has developed a set of templates mapped to various technical doc types and needs, including:

  • API quickstart
  • API reference
  • Code of conduct
  • Explanation
  • How-to
  • Installation guide
  • Logging
  • Our Team template
  • Overview
  • Quickstart
  • Style guide
  • Release notes
  • Troubleshooting
  • Tutorial

While Diátaxis focuses on the high-level IA, Good Docs provides more tactical templates and writing guides tailored to each type.

Good Docs templates help authors avoid “blank page anxiety” and provide examples with embedded best practices. In contrast, Diátaxis provides more general principles to help guide what should go in each content type.

Why is Diátaxis so popular?

I believe Diataxis is gaining popularity in part because it reveals discernible information patterns within documentation. The approach defines distinct information types, which helps writers recognize structures for organizing content tailored to specific user goals. By defining various information patterns, the Diátaxis helps writers shape and organize content.

The concept of information patterns extends far beyond documentation. For example:

  • Blog posts often follow story patterns.
  • Academic papers have a standard IMRaD pattern (intro, methods, results, discussion).
  • White papers use problem-solution patterns.
  • Knowledge base articles need clear question-focused patterns.
  • Speeches rely on patterns like the three-part list.
  • Legal documents leverage definitions, clauses, sections.
  • Marketing emails use subject lines, preview text, calls-to-action.

Seeing these patterns is like glimpsing the matrix behind communication. Understanding and applying patterns is at the core of rhetoric and document design.

The ability to identify and leverage information patterns in communication is central to the study of rhetoric. Rhetoric is often misunderstood as meaning language intended to manipulate or persuade. But its original definition is using language and information structuring techniques to fit a particular purpose, audience, or situation.

This is why so many technical communication academic programs are housed in rhetoric departments. The rhetorical tradition is fundamentally concerned with patterns of communication — how to shape content to achieve goals like persuading, informing, or motivating an audience.

Technical communicators are modern practitioners of rhetoric. Our job is fitting content to the expected discourse for optimal communication, comprehension, and usability.

Breaking down the Diátaxis information patterns

Let’s briefly look at the information patterns that Procida makes explicit. We’ll look at each information type and describe the salient characteristics.

Diátaxis information patterns

Information patterns in tutorials

In the Diátaxis approach to documentation, a tutorial is “a lesson, safely in the hands of an instructor” that provides a guided, hands-on learning experience.

Whereas DITA focuses on tasks/procedures, tutorials have a different rhetorical shape tailored for education rather than solving problems. Some key elements of a tutorial pattern are as follows:

  • Introduction/Learning goals - States what the user will accomplish in the tutorial.
  • Prerequisites - Lists required knowledge/tools.
  • Step-by-step instructions - Provides hands-on exercises and activities.
  • Recap - Summarizes key lessons and takeaways.
  • Assessment - Questions or exercises to check understanding.
  • Next steps - Points to additional resources for more learning.

This clear rhetorical pattern serves the unique goal of building skills interactively. The lesson shape provides scaffolding and direction ideal for beginners.

(By the way, I’m not sure why “tutorials” isn’t an information type in DITA. The tutorial fills an important niche for learning content in technical communication. Maybe the DITA specification group felt that tasks include tutorials.)

Information patterns in explanation content

In Diátaxis, explanation content provides background and context to illuminate a concept. The goal is deeper understanding rather than problem solving. The following are some common elements of the explanation pattern:

  • Introduction - States the purpose and previews the discussion.
  • Definition - Formal definition of the concept.
  • Background - Provides history and context.
  • Details - Elaborates on various aspects of the concept.
  • Visuals - Diagrams, illustrations, examples that clarify.
  • Relationships - Connects concepts to other ideas and approaches.
  • Implications - Explores effects, outcomes, and significance.
  • Summary - Recaps the key points about the concept.
  • Further Reading - Additional resources to learn more.

This rhetorical structure moves from overview to specifics in order to paint a rich picture of a topic. The goal is synthesizing disparate details into a cohesive narrative about the concept.

Information patterns in reference

In the Diátaxis approach, reference content follows its own distinct pattern serving a dedicated purpose. Procida states, “Reference guides are technical descriptions of the machinery and how to operate it.”

Whereas tutorials focus on learning, reference focuses on factual details about a product or system. Some hallmarks of the reference pattern are:

  • Overviews - High-level summaries of a component’s purpose and capabilities.
  • Specifications - Precise technical details of inputs, outputs, configurations, etc.
  • Options - Charts comparing different options or versions.
  • Parameters - Lists defining all available parameters and their usage.
  • Code samples - Snippets demonstrating implementation and usage.
  • Visuals - Diagrams illustrating technical concepts and relationships.

The reference pattern emphasizes comprehensive, accurate information presentation. The goal is precise and authoritative descriptions users can consult to understand the machinery while working with it.

Information patterns in how-to guides

In Diataxis, how-to guides follow a recipe-like shape focused on solving real-world problems. How-to guides help readers work their way through a problem-field.

Whereas reference provides technical details, how-to guides show practical application. For example, see this topic from the Django documentation: How to configure and use logging.

Some common elements of the how-to pattern include:

  • Prerequisites - Required knowledge or conditions to solve the problem.
  • Intro - If needed, a more detailed description of what the guide will cover.
  • Ordered steps - Sequential instructions to solve the problem, to the extent that’s possible.
  • Visuals - Diagrams and illustrations supporting the steps.
  • Examples - Specific use cases demonstrating the problem and solution.
  • Variations - How the steps may differ under certain conditions.
  • Recap - Summary of what was accomplished.
  • Related links - Pointers to other related procedures.

This structured pattern provides problem-solving assistance distinct from conceptual information. The goal is unambiguous guidance users can follow to solve a particular problem.

Objections about separating content by type

In learning about Diátaxis, I was concerned about the separation of content into distinct groups. Siloing documentation into tutorials, how-tos, reference, and explanation seemed overly opinionated and arbitrary as an information model. What research was this information model based on?

I reached out to Daniele on the #diataxis WTD Slack channel, and he clarified that Diátaxis isn’t meant to impose four rigid buckets that content must squeeze into. Rather, it’s an analytical approach that emerges from identifying four core user needs. In other words, when you identify the user’s information needs, these four fundamental types of documentation arise from those needs: tutorials, explanation, references, and how-to guides.

He acknowledges the critique that people don’t strictly separate these modes, but says that documentation itself should still be clear about its purpose and stabilize around meeting specific user needs.

So the core argument is:

  • Users have different needs from docs.
  • These needs can be mapped to 4 categories.
  • If you write according to those needs, patterns will start to emerge, and …

Thus, 4 types of documentation naturally form to serve those needs.

This model may oversimplify things, but the 4 Diataxis types are still useful as an abstract approach for thinking about docs, even if divisions aren’t absolute in practice.

Experiments at work

In my documentation at work, I recently separated out some concepts by type. For example, when working on reference materials for map data concepts, I initially had conceptual explanations scattered throughout the docs. This made it hard for users to find the conceptual information they needed.

So I decided to group all the conceptual topics into a central “Map Data Concepts” section — like a Wikipedia for map terms and concepts. This created a reliable one-stop shop for reference on key concepts. I now have a space to continue adding more concepts, and I don’t have to worry about reusing similar concepts in different API overviews.

Although I was initially reluctant to separate out concepts from the API overviews, this turned out to be a good move. Both conceptual definitions and overviews probably fit under “Explanation,” but even more granular separation of content by different explanation types seemed helpful.


All-in-one platform to create, share, and manage your documentation

Clear technical documentation, complex translation, and content operations

Will information organization still be necessary when users interface with docs through AI tools?

At this point, note that I’m steering away from explanations of Diátaxis and introducing my own ideas.

With the rise of AI, I think the information architecture of help content may become less critical in the future. Most users will likely interface with documentation primarily through chatbots and other AI tools rather than navigating a complex help system. I wrote about this in AI chat interfaces could become the primary user interface to read documentation

In a way, this reduces the need to obsess over the perfect organizational schema. ChatGPT, Claude, and other AI agents can deliver hyper-personalized help on demand, without requiring the user to know where some piece of information lives in the docs. The AI interface essentially abstracts away the information architecture or pattern and just surfaces the most relevant content dynamically. This makes the documentation’s organization less important from a user perspective.

That said, the actual documentation source still needs to be well-structured for the AI to “learn” from it effectively. But the end user probably won’t care as much, if the AI delivers the right information to them directly.

How can information patterns be used with AI prompting techniques?

In the context of AI, there’s another major benefit to the Diátaxis information model. You can more easily create structured prompts that ask an AI to sort and arrange unstructured information into specific information patterns. I wrote about this in Use cases for AI: Arrange content into information type patterns.

Let’s say that you gather a large body of content about the Widget API from internal documents, code, threads, and more. You can then supply this corpus of unstructured content to an AI and ask it to arrange the relevant information into an information template like this:

{Intro}

{Prerequisites}

{Problem to solve}

{Ordered steps}

{Substeps}

{Examples}

{Expected outcome}

{Related links}

You could even include descriptions of each template section. The AI tool will then pick out the relevant information from the large body of material and arrange it into the pattern you defined. This can significantly speed time to a first draft.

Conclusion

In conclusion, should you be using Diátaxis? Even if you don’t separate content by type, defining and shaping content into these four content types might help improve your documentation. It’s an easy-to-understand approach to documentation that draws power and appeal from this simplicity. You can learn more at https://diataxis.fr.

Related resources

See this BrightTALK video Introducing the Diátaxis Approach to Technical Documentation.

I wrote this post with some AI assistance.