Gall’s Law refers to an observation made by pediatrician, Dr. John Gall which states “A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.”
Functional complex systems arise from functional simple systems.
In simpler terms…if you start with a complex design, you will fail. If you start with a simple design and build on it, you will succeed.
Failing to heed this advice can and will lead to disaster. The 2013 rollout of healthcare.gov — the health insurance exchange website linked to the Affordable Care Act — was widely regarded as disastrous. Success could have been based on the fundamental observation that working complex systems arise from working simple systems. Most government tech projects likely could cost 10% of what they actually do, yet still provide 85% of the functionality.
This is a great read, written by Jennifer Pahlka.
https://bigthink.com/smart-skills/complex-project-galls-law/
Gall was a pediatrician, not a computer scientist, but his insights into system design have found relevance and applicability in the field of software engineering and other complex domains.
The essence of Gall’s Law lies in a quite literal evolutionary approach to system design. Instead of attempting to build a complex system from the ground up, it suggests that it’s often more effective to start with a simple system and then gradually evolve and improve it based on real-world feedback and needs.
Gall’s Law aligns well with the principles of iterative development and incremental improvement. By building upon existing functional systems, developers can better understand real-world usage, gather user feedback, and make informed decisions about further enhancements. Agile product owners, are you listening?
The idea of starting with a simple system doesn’t mean sacrificing functionality but rather focusing on essential features and functionalities. Simplicity can reduce the chances of unintended complexities and help identify the core requirements.
Next steps
Building on this, I plan to further explore the practical implications and applications of Gall’s Law in various fields, but especially in the context of software engineering. I plan to explore real-world examples where adherence to Gall’s Law has led to successful outcomes. Additionally, I plan to highlight how this principle encourages adaptability and resilience in the face of changing requirements and unforeseen challenges.
The inspiration for this series of articles comes from a long time frustration I have working for a services organization delivering vertical solutions upon our horizontal content management platform (I guess platforms now). We recreate the wheel…a lot…often…way too often. But why?
I think the biggest problem that we have as a services team, is that our consultants are brilliant but they aren’t coders. Our consultants want to build. They want to meet with customers. They want to train users, but most of all, they just want to build.
Coders are different.
People that come up through the ranks of coders, learn habits and disciplines that yield a lot of re-use in our field. See the myriad of Stack Overflow memes about stealing code from one another. Reuse is a thing. Microservices are a thing. And at some point I will prove to my compadres that Micro-Solutions are the next big thing, but that is the subject of another thread.
The point is, building on previous knowledge, experience, and code is a way to take some smaller components, to implement a large complex system that retains performance with scale, without compromising the user experience.
I think exploring Gall’s Law, is a great way to explore this complex, implementation conumdrum.
prompting up and back with ChatGPT 3.5
The following areas of focus are some prompts that I am working on with ChatGPT 3.5. I prompt with what I am looking for and then try to work up and back until there is something that inspires me to start writing. ChatGPT is a fantastic Rubber Duck.
Evolutionary Design in Software Engineering: Applying Gall’s Law
While Dr. John Gall’s observations originated outside the realm of computer science, the resonance of Gall’s Law in the field of software engineering is unmistakable. The journey from simple to complex, as advocated by Gall’s Law, aligns seamlessly with the principles of evolutionary design.
Realizing the Power of Iteration
In the world of software development, attempting to create an intricate system from scratch often results in numerous pitfalls. These can include architectural missteps, oversights in user experience, and a lack of adaptability to evolving user needs, not to mention the hurdles to scalability that will be inherent in the “final” implementation. Gall’s Law advocates for an iterative approach—start with a simple, functional system, and incrementally build upon it. This iterative process allows developers to learn from real-world usage, iterate based on user feedback, and make informed decisions about the system’s evolution.
Success Stories in Software Evolution
Several success stories in the software industry exemplify the effectiveness of Gall’s Law. One notable example is the evolution of the Linux operating system. Linus Torvalds initially created a simple kernel, and over time, it has evolved into a robust, complex system through the collaborative efforts of a global community. The evolutionary process allowed Linux to adapt to diverse hardware architectures and user requirements while maintaining stability and functionality.
Adaptability in the Face of Change
Gall’s Law also underscores the importance of adaptability in system design. In an ever-changing technological landscape, rigid and over-engineered systems can become obsolete quickly. A simple, adaptable system, on the other hand, is more likely to weather the storms of change and emerge stronger through continuous refinement.
Beyond Software: Gall’s Law in Practice
Beyond software engineering, Gall’s Law finds relevance in various domains. From product design to organizational processes, the principle of starting simple and evolving proves universally applicable. Companies that embrace iterative development and incremental improvement often find themselves better equipped to navigate the complexities of their respective industries.
Sources
- https://en.wikipedia.org/wiki/John_Gall_(author)
- https://bigthink.com/smart-skills/complex-project-galls-law/
- https://www.techmagic.co/blog/galls-law/
The content within this article is authored by a human. I have drawn upon multiple information sources and various tools. ChatGPT has served as a helpful tool during moments of writer’s block, functioning as a virtual rubber duck for prompts and for assistance in different aspects of the writing process. It’s important to note that no content generated by ChatGPT was directly incorporated into this article without thorough human intervention, review, and editing. (See Prompt)