Mixins and CFML

Mike's Notes

Pipi needs multi-inheritance, so how?

Modelling nature and complex systems requires multiple inheritance, but CFML does not support it. Here are some initial notes on figuring out what to do. I discovered some possible solutions on Ben Nadel's blog.

Thank you, Ben Nadel.

Resources

References

  • Reference

Repository

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

Last Updated

15/10/2025

Mixins and CFML

By: Mike Peters
On a Sandy Beach: 15/10/2025

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

When building Pipi 4, 20 years ago, I once wrote to software architect  Sean Corfield asking how to implement multiple inheritance in CFML.

He replied, "Multiple inheritance is bad".

I'm using a database-driven workaround based on BORO at the moment, which works. The thing is, I need a better way to implement multiple inheritance in code.

This morning, for no real reason, I did a Google search for

"cfapplication multiple inheritance cfml"

And discovered what Ben Nadel came up with. He uses CFInclude to create a mixin.

From Wikipedia

"In object-oriented programming languages, a mixin (or mix-in) is a class that contains methods for use by other classes without having to be the parent class of those other classes. How those other classes gain access to the mixin's methods depends on the language. Mixins are sometimes described as being "included" rather than "inherited".

Mixins encourage code reuse and can be used to avoid the inheritance ambiguity that multiple inheritance can cause (the "diamond problem"), or to work around lack of support for multiple inheritance in a language. A mixin can also be viewed as an interface with implemented methods. This pattern is an example of enforcing the dependency inversion principle."

From Ben Nadel on 2013-06-07 

A couple of months ago, I read Practical Object-Oriented Design in Ruby: An Agile Primer, by Sandi Metz. I haven't reviewed the book yet, but I wanted to explore one of the concepts Metz talked about: Ruby Modules. From what I understood (and this may be somewhat off-base, I'm not a Ruby programmer), a module is a way to "inherit" behavior without using classical inheritance. Essentially, behavior is "included" into a class, rather than "inherited" into a class. In a language that only allows for single-class inheritance, a Module provides a mechanism for including behavior from several different sources. Furthermore, it allows the developer to borrow behaviors without worrying about the "is-a-type-of" inheritance relationship. It seems fairly interesting, so I wanted to see how this kind of behavior could be used in ColdFusion."

Code Sample

From https://www.bennadel.com/blog/1551-exploring-mixins-and-coldfusion-components.htm

<cfcomponent
output="false"
hint="I am a component whose methods are created via Mixin methodology.">

<!--- Include the mixin UDFs in the pseudo-constructor. --->
<cfinclude template="public_udf.cfm" />
<cfinclude template="private_udf.cfm" />


<cffunction
name="Init"
access="public"
returntype="any"
output="false"
hint="I return an initialized object.">

<!--- Return THIS reference. --->
<cfreturn THIS />
</cffunction>


<cffunction
name="GetVariables"
access="public"
returntype="any"
output="false"
hint="I return the private scope of this component.">

<cfreturn VARIABLES />
</cffunction>

</cfcomponent>

Ben's blog posts go into much more detail. I will need to experiment and test. Maybe a combination of the existing Boro datamodel and this code might work. It adds a lot of complexity and could be a maintenance nightmare, but with Pipi managing it, it should be OK. Pipi runs on complexity.

Summary

The CFinclude can go in the CFcomponent and/or the CFfunction.

Producing a Better Software Architecture with Residuality Theory

Mike's Notes

Very interesting. Read the references and watch the talk.

Resources

References

  • An Introduction to Residuality Theory: Software Design Heuristics for Complex Systems by Barry M. Barry O'Reilly. 2020.

Repository

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

Last Updated

14/10/2025

Producing a Better Software Architecture with Residuality Theory

By: Ben Linders
InfoQ: 07/10/2025

Ben Linders is an Independent Consultant in Agile, Lean, Quality and Continuous Improvement, based in The Netherlands. Author of Getting Value out of Agile Retrospectives, Waardevolle Agile Retrospectives, What Drives Quality, The Agile Self-assessment Game, Problem? What Problem?, and Continuous Improvement. Creator of many Agile Coaching Tools, for example, the Agile Self-assessment Game. As an adviser, coach and trainer he helps organizations by deploying effective software development and management practices. He focuses on continuous improvement, collaboration and communication, and professional development, to deliver business value to customers. Ben is an active member of networks on Agile, Lean and Quality, and a frequent speaker and writer. He shares his experience in a bilingual blog (Dutch and English) and as an editor for Agile at InfoQ. Follow him on twitter: @BenLinders.

Software architecture is tough because it blends coding, math, and business systems. Due to surprises, architectures tend to become irrelevant over time, Barry O’Reilly said at Goto Copenhagen. He presented residuality theory, where he suggested stressing naive architectures to reveal hidden "attractors" in complex business systems. This allows designs to better survive change and uncertainty.

Software architecture is difficult because it requires a broad skillset, O’Reilly said. We have to master the world of code, math, and logic, and the world of human and business systems, and understand how these two relate to and affect each other.

At university, they only teach us the tech. When we start to design systems, we realise that the complexity of the business environment constantly surprises us, rendering our architectures irrelevant, O’Reilly said. Making something as static and rigid as a software architecture survive in a fluid world that is always changing is not an easy task, he added.

Residuality assumes that a random simulation of stress on a naive architecture will produce a better architecture than the traditional methods around requirements engineering, risk management, or reacting to change as it happens, O’Reilly explained:

This started out as a curious observation, and for the last 10 years, I have had to build theoretical explanations and experiments to show that this actually is the case. Armed with this knowledge, we can think differently about software architecture and build new tools.

As students of Western science, our first recourse is to reduce any complex system to its component parts and study those parts in detail. This is the default for software engineers, O’Reilly said. In complex systems, the number of elements and potential interactions and states makes this kind of detail-oriented analysis impossible. Previous generations of architects have tried to reduce the complexity of the business environment to logic, or to structures, or to the development process.

One of the key aspects of complex systems is that they never visit all the possible states that the combination of their elements allows. Instead, the interactions of the elements constrain the system to a very small number of potential states, which we call "attractors", O’Reilly said. A complex business system is therefore not modelled as a number of interaction elements and their relationships, but instead as a number of attractors, he explained:

When we build an architecture, it is these attractors that the architecture must survive in. Attractors therefore provide a much simpler and easier and more pragmatic way of interfacing with the complexity of the environment.

The problem is that we don’t know what the attractors are, but by randomly simulating stress, we can discover many of them, O’Reilly said. If you think back to the major architectural failures you’ve seen, you will see that they mostly fail because they missed attractors, he mentioned.

Residuality theory is a very simple process. Sometimes, people are put off because the theoretical work necessary to prove that residuality works is very heavy, but applying it is easy, O’Reilly explained:

We start out with a suggestion, a naive architecture that solves the functional problem. From there we stress the architecture with potential changes in the environment. These stressors allow us to uncover the attractors, often through conversations with domain experts. For each attractor, we identify the residue, what’s left of our architecture in this attractor, and then we change the naive architecture to make it survive better.

We do this many times and, at the end, integrate all of these augmented residues into a coherent architecture. We can then test this to show that it survives unknown forms of stress better than our naive architecture.

In complex business environments with uncertainty, residuality makes it possible to create architectures quickly instead of chasing down stakeholders demanding specific requirements or answers to questions that are unknown by the business itself, O’Reilly said. It pulls technical architects out of details and teaches them to productively engage with a business environment without the lines and boxes of traditional enterprise architecture, he concluded.

InfoQ interviewed Barry O’Reilly about residuality.

InfoQ: How can we prove that the residual architecture that we created is an improvement over the naive architecture?

Barry O’Reilly: A simple test is to use a second set of stressors to check that our residual architecture survives more unknown events than our naive architecture. You can easily see the similarities between this and the training/testing sets of ML. Residuality theory ultimately states that architectures should be trained, not designed.

InfoQ: What benefits have you seen from residual analysis?

O’Reilly: Senior architects report that it gives a theoretical justification for practices that many had already figured out and a shared vocabulary for teams to talk about architecture. Ultimately, it makes architecture more explicit, better defined, and easier to teach. The result is architectures we can believe in and decision-making that is traceable.

It has its challenges as well. A small number of developers find the jump from the linear, logical, mathematical world we are trained for to the lateral, imaginative techniques very difficult. Residuality is a subject as big as OOP and requires the same amount of effort to learn.

Industry workspace

Mike's Notes

Working notes, subject to change, on building the first workspaces.

This is a proof-of-concept thought experiment with the platform that enables the creation of any future workspace configuration.

This needs to work for users and learning, developers and technical documentation, and be consistent with any schema.

There is a my-workspace for each individual, and the rest are shared-workspaces for groups.

These configurations are now being imported into Pipi 9, replacing the settings first created in Pipi 6.

Resources

References

  • Reference

Repository

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

Last Updated

13/10/2025

Industry workspace

By: Mike Peters
On a Sandy Beach: 13/10/2025

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

SaaS applications for industries must be both useful and easy to use for people.

Issues

  • Use nouns.
  • Singular, not plural.
  • Use standard English industry terms and then translate (i18n).
  • Separate the industry from the template.

Industry

This is a very rough draft outline of the industry applications. The objects can be recombined, shared and deeply nested. Many were built some years ago.

  • Agriculture
    • Equipment
    • Farm
  • Aviation
    • Aircraft
    • Airport
    • Airspace
    • Cargo
    • Flight
    • Passenger
  • Conservation
    • Climate
    • Ecosystem
    • Pesticide
    • Soil
    • Spatial
    • Taxonomy
  • Construction
    • Construction Site
    • Materials
  • Devops
    • Code
    • Documentation
  • Drainage
    • Network
    • Storage
    • Treatment
    • Education

      • Electricity Supply
        • Generator
        • Network
        • Faith
          • Event
        • Forestry
          • Harvesting
          • Planting
          • Silverculture
          • GLAM
            • Collection
            • Event
            • Loan
            • Health
              • Booking
              • Health Record
              • Health Worker
              • Imaging
              • Medication
              • Patient
              • Procedure
              • Transport
              • Horticulture
                • Crop
                • Fertiliser
                • Harvest
                • Learning
                  • Docs
                  • How-to-guide
                  • Reference
                  • Tutorial
                • My
                  • Profile
                  • Tasks/Calendar
                • Performing Art
                  • Dance
                  • Drama
                  • Magic
                  • Music
                  • Puppetry
                  • Port
                    • Port
                    • Ship
                    • TEU
                    • Rail
                      • Booking
                      • Freight
                      • Track
                      • Passenger
                      • Rolling Stock
                      • Track
                      • Research
                        • Experiment
                        • Library
                        • Publish
                          • Presentation
                          • Website
                            • Blog
                            • Wiki
                      • Road
                        • Network
                        • Sewer
                          • Network
                          • Sewerage Farm
                          • Screen
                            • Art Department
                              • Makeup & Hair
                              • Minatures
                              • Props
                              • Set
                              • Wardrobe
                            • Budget
                            • Recording
                              • Audio
                              • Camera
                              • Lighting
                            • Location
                            • Script
                            • Transport
                              • Roading
                              • Shipment
                              • Truck
                            • Visual Art
                              • Painting
                              • Photography
                              • Sculpture
                              • Water Supply
                                • Network
                                • Storage
                                • Treatment
                                • Website

                                  • Zoo
                                    • Animal Health
                                    • Visitors

                                  Domain Model Templates

                                  Industry customised for use.

                                  • Agriculture
                                  • Aviation
                                    • Airport
                                    • Passenger
                                  • Conservation
                                    • Park
                                  • Construction
                                    • Civil
                                    • Housing
                                  • DevOps
                                  • Drainage
                                  • Education
                                  • Electricity Supply
                                    • City
                                    • Home
                                    • Hydroelectric
                                    • Nuclear Power Station
                                    • Wind Turbine
                                  • Faith
                                    • Church
                                    • Mosque
                                    • Synagogue
                                    • Temple
                                  • Forestry
                                    • Plantation
                                    • Farm Forestry
                                  • GLAM
                                    • Gallery
                                    • Library
                                    • Archive
                                    • Museum
                                  • Learning
                                  • Health
                                    • Allied
                                    • Animal Vet
                                    • Emergency
                                    • Family Doctor Clinic
                                    • Hospital
                                    • Public Health System
                                    • Patient
                                  • Horticulture
                                    • Crop Farm
                                    • Plant Nursery
                                    • Viticulture
                                  • Performing Art
                                    • Concert Hall
                                    • Theatre
                                  • Port
                                  • Rail
                                    • Urban
                                  • Research
                                    • Institute
                                    • Lab
                                    • Student
                                  • Road
                                    • City
                                    • Home
                                  • Sewer
                                    • City
                                    • Home
                                  • Screen
                                    • Crew
                                    • Studio
                                      • Preproduction
                                      • Production
                                      • Post Production
                                      • Distribution
                                    • Web Cast
                                  • Transport
                                    • Depot
                                  • Visual Art
                                    • Art Studio
                                    • FX Studio
                                  • Water Supply
                                    • City
                                    • Home
                                  • Website
                                  • Zoo

                                  Your Users Aren’t Lazy—They’re Managing Change Overload

                                  Mike's Notes

                                  More thoughtful words of wisdom from IT Revolution.

                                  Resources

                                  References

                                  • Progressive Delivery: Build The Right Thing For The Right People At The Right Time by James Governor, Kim Harrison, Heidi Waterhouse, and Adam Zimman (IT Revolution Press, November 2025).

                                  Repository

                                  • Home > Ajabbi Research > Library > Subscriptions > IT Revolution
                                  • Home > Handbook > 

                                  Last Updated

                                  12/10/2025

                                  Your Users Aren’t Lazy—They’re Managing Change Overload

                                  By: Leah Brown
                                  IT Revolution: 02/10/2025

                                  Managing Editor at IT Revolution working on publishing books and guidance papers for the modern business leader. I also oversee the production of the IT Revolution blog, combining the best of responsible, human-centered content with the assistance of AI tools.

                                  Picture this: A seasoned medical coder sits down at her workstation every morning and flies through insurance claims at lightning speed. Her fingers dance across function keys and the ten-key pad without her eyes ever leaving the screen. She processes more claims in an hour than most people could handle in a day.

                                  Then your team delivers a “user-friendly” modernization of her software. Suddenly, she needs a mouse. The keyboard shortcuts she’s memorized over decades no longer work. Tasks that took seconds now require multiple clicks through dropdown menus. Her productivity plummets.

                                  Is she being resistant to change? Lazy? Unwilling to learn?

                                  None of the above. She’s managing change overload in the only way that makes sense: by protecting the workflows that keep her livelihood intact.

                                  This scenario, shared by coauthor Heidi Waterhouse in the upcoming book Progressive Delivery, illustrates a fundamental misunderstanding that’s costing organizations millions in failed software rollouts, user frustration, and abandoned features.

                                  The Change Paradox

                                  Here’s what seems contradictory but is actually perfectly logical: the same person who eagerly upgrades their iPhone every year might resist a minor update to their work software. The same developer who constantly experiments with new programming languages might refuse to adopt your team’s new deployment tool.

                                  This isn’t hypocrisy—it’s smart change management.

                                  People have a finite capacity for absorbing change. We instinctively protect our most critical workflows while remaining open to improvement in areas where failure isn’t catastrophic. Your iPhone upgrade can be undone or worked around. Your work software, which determines whether you can pay your mortgage, demands much more careful consideration.

                                  Beyond Stakeholders: Understanding Your Full Constituency

                                  Most organizations think about their users as “stakeholders”—people who have a financial or organizational interest in the product’s success. But Progressive Delivery requires thinking about “constituents”—everyone who is actually affected by your software, whether they appear on your org chart or not.

                                  Consider medical records software. The obvious stakeholders are:

                                  • Doctors who input patient data.
                                  • Hospital administrators who purchase the software.
                                  • IT teams who maintain the systems.
                                  • Your development team who builds features.

                                  But the full constituency includes:

                                  • Nurses who need to access information during emergencies.
                                  • Patients who use portals to view their own data.
                                  • Family members helping elderly relatives navigate health information.
                                  • Regulatory bodies ensuring privacy compliance.
                                  • Insurance companies processing claims.
                                  • Medical billers like our friend above.

                                  Each constituent has different change tolerance levels, different technical sophistication, and different stakes in maintaining stability versus embracing innovation.

                                  The Three Types of Change Capacity

                                  Not all users approach change the same way. Understanding these differences is crucial for delivering software that actually gets adopted:

                                  • The Builder Mindset Some users see software as LEGO blocks—they want to understand how things work and customize their experience. These are your early adopters who read release notes, experiment with beta features, and provide detailed feedback. They have high change tolerance because they enjoy the process of discovery and optimization. They’re willing to invest time learning new workflows because they see it as creative problem-solving.
                                  • The Tool Mindset Most users see software as a hammer—they want it to reliably perform specific tasks without requiring constant attention. They’ve developed efficient workflows around current functionality and view changes through the lens of “will this help me get my job done better?” They have moderate change tolerance when improvements clearly align with their goals, but they resist changes that disrupt established patterns without obvious benefit.
                                  • The Survival Mindset Some users interact with software in high-stakes environments where mistakes have serious consequences. Medical professionals, financial traders, air traffic controllers—these users have optimized their workflows for safety and reliability above all else. They have very low change tolerance because their primary concern isn’t efficiency improvement—it’s avoiding catastrophic failure.

                                  The Cost of Misreading Your Constituency

                                  When you misunderstand your users’ change capacity, you create what Progressive Delivery calls “technological jerk“—the jarring experience of change happening too fast for people to absorb.

                                  Slack’s 2019 redesign perfectly illustrates this mismatch. Slack’s design team saw an opportunity to create a more modern, streamlined interface. They were thinking like builders—excited about cleaner visual hierarchy and improved information architecture. But most Slack users weren’t builders—they were people managing dozens of conversations across multiple workspaces while trying to get their actual jobs done. The redesign disrupted muscle memory, changed keyboard shortcuts, and reorganized familiar layouts. What felt like an improvement to the design team felt like chaos to users trying to maintain productivity.

                                  Sonos’s 2024 app disaster represents an even more dramatic failure. The company released an app update that broke core functionality like sleep timers and queue management. Users weren’t just annoyed—they were unable to perform basic tasks with expensive hardware they’d already purchased. CEO Patrick Spence was forced to resign in January 2025.

                                  In both cases, the companies built better software from a technical perspective but failed to consider how changes would land with people who depended on existing workflows.

                                  The Adobe Alternative: Progressive Control

                                  Adobe provides a masterclass in respecting user change capacity while still driving innovation. When they integrated AI into their Creative Cloud suite, they could have simply pushed the latest models to everyone simultaneously. Instead, they implemented what Progressive Delivery calls “radical delegation.”

                                  Users can choose which AI model version to use for different projects. Someone working on a long-term brand campaign can maintain consistency with Firefly v1, while someone experimenting with new creative techniques can opt into Firefly v3. The same user might make different choices for different contexts.

                                  This isn’t just about offering a “classic mode” checkbox. Adobe created granular controls that let users manage their own change absorption rate based on their specific needs and risk tolerance.

                                  Three Strategies for Respecting Change Capacity

                                  1. Delegate Control to the Point of Impact: Instead of deciding when users should adopt new features, give them the tools to make that decision themselves. Microsoft’s “Try the new Outlook” toggle lets users test the redesigned experience and revert if needed. Google Workspace offers separate release tracks for organizations with different change tolerance levels. The key is making this choice meaningful—not just a temporary beta flag that eventually disappears, but ongoing control over their experience.
                                  2. Design for Multiple Speeds Simultaneously: Your power users and cautious users don’t need to move at the same pace. GitHub ships hundreds of small changes that are mostly invisible to casual users but provide meaningful improvements for developers who spend all day in the platform. Meanwhile, major feature releases are carefully communicated and gradually rolled out. This allows your constituency to self-select into the change pace that matches their capacity and context.
                                  3. Build Reversible Experiences: Make it safe to experiment by making it easy to step back. This isn’t just about technical rollback capabilities—it’s about user confidence. When people trust they can explore new functionality without getting trapped in unfamiliar territory, they’re more willing to try changes. Netflix’s interface experiments are a good example. They test thousands of variations, but users never feel stuck with a version they dislike because the changes are either subtle or easily reversible.

                                  The Empathy Advantage

                                  Organizations that successfully implement Progressive Delivery share a crucial insight: user “resistance” is usually valuable information about change capacity, not character flaws to overcome.

                                  When users complain about the pace of updates, they’re telling you about their bandwidth for absorption. When they create workarounds to avoid new features, they’re showing you that your timing doesn’t match their readiness. When they stick with “legacy” workflows, they’re protecting something valuable that you might not understand.

                                  Instead of viewing this feedback as obstacles to overcome, Progressive Delivery treats it as essential input for delivering software that actually creates value.

                                  The Path to Sustainable Innovation

                                  Here’s the paradox: When you respect users’ change capacity, you can actually innovate faster. Users who trust that you won’t disrupt their critical workflows are more willing to experiment with new capabilities. Users who feel heard and respected become advocates rather than resistors.

                                  Progressive Delivery isn’t about slowing down innovation—it’s about ensuring innovation actually reaches the people who need it, when they’re ready to receive it.

                                  Your users aren’t lazy. They’re not change-averse. They’re not technologically backward.

                                  They’re intelligent people managing complex workflows in environments where stability matters. They’re making rational decisions about where to invest their limited change capacity. They’re protecting their ability to be productive while remaining open to genuine improvements.

                                  The question isn’t how to overcome user resistance. The question is how to build delivery systems that work with human change capacity rather than against it.

                                  When you get that right, everyone wins: users get software that actually makes their lives better, and you get the sustainable adoption that drives real business value.

                                  This post explores concepts from the upcoming book Progressive Delivery: Build The Right Thing For The Right People At The Right Time by James Governor, Kim Harrison, Heidi Waterhouse, and Adam Zimman (IT Revolution Press, November 2025).


                                  The most powerful medicine we have

                                  Mike's Notes

                                  Doing the rounds at the moment.

                                  Resources

                                  References

                                  • Reference

                                  Repository

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

                                  Last Updated

                                  11/10/2025

                                  The most powerful medicine we have

                                  By: A US Physician
                                  UAMS Patient Experiences group: 01/10/2025

                                  Note by Kristen Koll

                                  From a US physician [And in response to those who have asked: I am still trying to confirm authorship, but the post appears to originate from UAMS Patient Experiences group (facebook page) and I’ve messaged them to see if the author can be named. Also, they confirmed in response to another query that the names are pseudonyms, so HIPAA privacy was not violated]


                                  I know the exact pressure it takes to crack a rib during CPR. But last Tuesday, I learned a patient’s silence can break a doctor’s soul.

                                  His name was David Chen, but on my screen, he was "Male, 82, Congestive Heart Failure, Room 402." I spent seven minutes with him that morning. Seven minutes to check his vitals, listen to the fluid in his lungs, adjust his diuretics, and type 24 required data points into his Electronic Health Record. He tried to tell me something, gesturing toward a faded photo on his nightstand. I nodded, said "we'll talk later," and moved on. There was no billing code for "talk later."

                                  Mr. Chen died that afternoon. As a nurse quietly cleared his belongings, she handed me the photo. It was him as a young man, beaming, his arm around a woman, standing before a small grocery store with "CHEN'S MARKET" painted on the window.

                                  The realization hit me like a physical blow. I knew his ejection fraction and his creatinine levels. I knew his insurance provider and his allergy to penicillin. But I didn't know his wife's name or that he had built a life from nothing with his own two hands. I hadn’t treated David Chen. I had managed the decline of a failing organ system. And in the sterile efficiency of it all, I had lost a piece of myself.

                                  The next day, I bought a small, black Moleskine notebook. It felt like an act of rebellion.

                                  My first patient was Eleanor Gable, a frail woman lost in a sea of white bedsheets, diagnosed with pneumonia. I did my exam, updated her chart, and just as I was about to leave, I paused. I turned back from the door.

                                  "Mrs. Gable," I said, my voice feeling strange. "Tell me one thing about yourself that’s not in this file."

                                  Her tired eyes widened in surprise. A faint smile touched her lips. "I was a second-grade teacher," she whispered. "The best sound in the world... is the silence that comes just after a child finally reads a sentence on their own."

                                  I wrote it down in my notebook. Eleanor Gable: Taught children how to read.

                                  I kept doing it. My little black book began to fill with ghosts of lives lived.

                                  Frank Miller: Drove a yellow cab in New York for 40 years.

                                  Maria Flores: Her mole recipe won the state fair in Texas, three years running.

                                  Sam Jones: Proposed to his wife on the Kiss Cam at a Dodgers game.

                                  Something began to change. The burnout, that heavy, gray cloak I’d been wearing for years, started to feel a little lighter. Before entering a room, I’d glance at my notebook. I wasn’t walking in to see the "acute pancreatitis in 207." I was walking in to see Frank, who probably had a million stories about the city. My patients felt it too. They'd sit up a little straighter. A light would flicker back in their eyes. They felt seen.

                                  The real test came with Leo. He was 22, angry, and refusing dialysis for a condition he’d brought on himself. He was a "difficult patient," a label that in hospital-speak means "we've given up." The team was frustrated.

                                  I walked into his room and sat down, leaving my tablet outside. We sat in silence for a full minute. I didn't look at his monitors. I looked at the intricate drawings covering his arms.

                                  "Who's your artist?" I asked.

                                  He scoffed. "Did 'em myself."

                                  "They're good," I said. "This one... it looks like a blueprint."

                                  For the first time, his gaze lost its hard edge. "Wanted to be an architect," he muttered, "before... all this."

                                  We talked for twenty minutes about buildings, about lines, about creating something permanent. We didn't mention his kidneys once. When I stood up to leave, he said, so quietly I almost missed it, "Okay. We can try the dialysis tomorrow."

                                  Later that night, I opened my Moleskine. I wrote: Leo Vance: Designs cities on paper.

                                  The system I work in is designed to document disease with thousands of data points. It logs every cough, every pill, every lab value. It tells the story of how a body breaks down.

                                  My little black book tells a different story. It tells the story of why a life mattered.

                                  We are taught to practice medicine with data, but we heal with humanity. And in a world drowning in information, a single sentence that says, "I see you," isn't just a kind gesture.

                                  It’s the most powerful medicine we have.

                                  Pipi release cadence

                                  Mike's Notes

                                  The current work on building SaaS workspaces has raised the question of the Pipi release cadence. Documentation also has to be versioned. Then there is the monthly research newsletter. Here is a plan to use Fridays to create a rhythm of deadlines.

                                  I was deeply influenced by writings from Shopify and Refactoring.

                                  Resources

                                  References

                                  • Reference

                                  Repository

                                  • Home > Ajabbi Research > Library > Subscriptions > Refactoring
                                  • Home > Handbook > Teams > Cadence

                                  Last Updated

                                  12/10/2025

                                  Pipi release cadence

                                  By: Mike Peters
                                  On a Sandy Beach: 10/10/2025

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

                                  There have been thousands of changes to Pipi since version 9, but the official Pipi version is frozen till full automated self-management kicks in 2026. This is a description of what will happen then.

                                  Pipi Versioning

                                  Pipi uses Semantic Versioning <major>.<minor>.<patch>.<build>

                                  Example

                                  • 9.04.23.1453455072

                                  Build

                                  • Every change to a namespaced object increments the Build Number by 1
                                  • It is the internal system change ID
                                  • Daily Builds could vary from 0 to 1,000s
                                  • Never resets.

                                  Patch

                                  • Release daily if there have been Build Number increases
                                  • Numbered 0-999
                                  • Resets when a Minor Release occurs
                                  • Minor documentation edits

                                  Minor Release

                                  • Release 4x per year, 3 months apart on the 2nd Friday.
                                  • Numbered 0-99
                                  • Resets when a Major Release occurs
                                  • Documentation officially updated

                                  Major Release

                                  • Release when a Minor Release backwards-incompatible change occurs, on the 2nd Friday of January, April, July or October.
                                  • Usually every 2-3 years
                                  • Numbered 1-99
                                  • New documentation released
                                  • Account migration required

                                  On a Sandy Beach

                                  • Published daily
                                  • My notes on building Pipi, a self-organising platform to support critical infrastructure

                                  Friday Report

                                  • Published every Friday 
                                  • A summary of the week's work is sent to other researchers.

                                  Research Newsletter

                                  • Published 12x per year on the 1st Friday.
                                  • Numbered 1-99999
                                  • Dated by month and year, eg "January 2026"
                                  • Named by theme, eg " Design Systems Issue"

                                  Cadence

                                  Type What Date
                                  Newsletter Design System 1st Friday, January
                                  Release 9.1.0 2nd Friday, January
                                  Newsletter i18n 1st Friday, February
                                  Newsletter Open Handbook 1st Friday, March
                                  Newsletter Complex Adaptive Systems 1st Friday, April
                                  Release 9.2.0 2nd Friday, April
                                  Newsletter Origins of Pipi 1st Friday, May
                                  Newsletter   1st Friday, June
                                  Newsletter   1st Friday, July
                                  Release 9.3.0 2nd Friday, July
                                  Newsletter   1st Friday, August
                                  Newsletter   1st Friday, September
                                  Newsletter   1st Friday, October
                                  Release 9.4.0 2nd Friday, October
                                  Newsletter   1st Friday, November
                                  Newsletter   1st Friday, December

                                  Agentic Design Patterns

                                  Mike's Notes

                                  This book looks interesting.

                                  Resources

                                  References

                                  • Reference

                                  Repository

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

                                  Last Updated

                                  09/10/2025

                                  Agentic Design Patterns

                                  By: Antonio Gulli
                                  On a Sandy Beach: 01/10/2025

                                  Note by Pawel Huryn
                                  The Product Compass

                                  A senior AI engineer at Google just dropped a 400-page book for review: Agentic Design Patterns.

                                  It’s got everything about AI agents + code:

                                  • Prompting
                                  • MCP
                                  • Tools
                                  • RAG
                                  • Memory
                                  • Humans in the loop
                                  • Multi-agent
                                  • Guardrails
                                  • You name it

                                  You can read it here (Google Drive + links to chapters): docs.google.com/documen…

                                  Remember to pre-order (published by Springer): a.co/d/b5SxY8t (all royalties go to Save the Children).


                                  Agentic Design Patterns

                                  A Hands-On Guide to Building Intelligent Systems Antonio Gulli

                                  Table of Contents - total 424 pages   = 1+2+1+1+4+9+103+61+34+114+74+5+4 11

                                  Dedication, 1 page 

                                  Acknowledgment, 2 pages  [final, last read done]

                                  Foreword, 1 page   [final, last read done]

                                  A Thought Leader's Perspective: Power and Responsibility   [final, last read done]

                                  Introduction, 4 pages [final, last read done]

                                  What makes an AI system an "agent"?, 9 pages [final, last read done]

                                  Part One, (Total: 103 pages)

                                  1. Chapter 1: Prompt Chaining (code), 12 pages [final, last read done, code ok]

                                  2. Chapter 2: Routing (code), 13 pages [fina, last read done, code ok]

                                  3. Chapter 3: Parallelization (code), 15 pages [final, last read done, code okl]

                                  4. Chapter 4: Reflection (code), 13 pages [final, last read done, code okl]

                                  5. Chapter 5: Tool Use (code), 20 pages [final, last read done, code ok]

                                  6. Chapter 6: Planning (code), 13 pages [final, last read done, code ok]

                                  7. Chapter 7: Multi-Agent (code), 17 pages [final,  last read done, code ok], 121

                                  Part Two (Total: 61 pages)

                                  1. Chapter 8: Memory Management (code), 21 pages [final, last read done, code ok]

                                  2. Chapter 9: Learning and Adaptation (code), 12 pages [final, last read done, code ok]

                                  3. Chapter 10: Model Context Protocol (MCP) (code), 16 pages  [final, last read done, code ok]

                                  4. Chapter 11: Goal Setting and Monitoring (code), 12 pages [final, last read don, code oe], 182

                                  Part Three (Total: 34 pages)

                                  1. Chapter 12: Exception Handling and Recovery (code), 8 pages [final,  last read done, code ok]  

                                  2. Chapter 13: Human-in-the-Loop (code), 9 pages [final, last read done, code ok]

                                  3. Chapter 14: Knowledge Retrieval (RAG) (code), 17 pages [final, last read done, code ok], 216

                                  Part Four (Total: 114 pages)

                                  1. Chapter 15: Inter-Agent Communication (A2A) (code), 15 pages [final, last read done, code ok]

                                  2. Chapter 16: Resource-Aware Optimization (code), 15 pages  [final,  last read done, code ok]

                                  3. Chapter 17: Reasoning Techniques (code), 24 pages [final,  last read done, code ok]

                                  4. Chapter 18: Guardrails/Safety Patterns (code), 19 pages [final, last read done, code ok]

                                  5. Chapter 19: Evaluation and Monitoring (code), 18 pages [final, last read done, code ok]

                                  6. Chapter 20: Prioritization (code), 10 pages [final, last read done, code ok ]

                                  7. Chapter 21: Exploration and Discovery (code), 13 pages [final, last read done, code ok],330

                                  Appendix (Total: 74 pages)

                                  1. Appendix A: Advanced Prompting Techniques, 28 pages [final, last read done, code ok]

                                  2. Appendix B - AI Agentic ….: From GUI to Real world environment, 6 pages [final, last read done, code ok]

                                  3. Appendix C - Quick overview of Agentic Frameworks, 8 pages [final, last read done, code ok] ,

                                  4. Appendix D - Building an Agent with AgentSpace (on-line only), 6 pages [final, last read done, code ok]

                                  5. Appendix E - AI Agents on the CLI (online) , 5 pages [final, last read done, code ok]

                                  6. Appendix F - Under the Hood: An Inside Look at the Agents’ Reasoning Engines, 14 pages [final, lrd, code ok],

                                  7. Appendix G -  Coding agents, 7 pages  406

                                  Conclusion, 5 pages [final, last read done] 

                                  Glossary, 4 pages  [final, last read done]

                                  Index of Terms, 11 pages  (Generated by Gemini. Reasoning step included as an agentic example) [final, lrd]

                                  Online Contribution - Frequently Asked Questions: Agentic Design Patterns

                                  Pre Print:>https://www.amazon.com/Agentic-Design-Patterns-Hands-Intelligent/dp/3032014018/ 

                                   [1] All my royalties will be donated to Save the Children