Coding with large language models (LLMs) is promising, however it also exposes some long-standing flaws in software: code that’s messy, difficult to alter safely, and sometimes not transparent about what's really happening under the hood. Researchers at MIT's Computer Science and Artificial Intelligence Laboratory (CSAIL) are planning a more “modular” path.
Their recent approach divides systems into “concepts,” separate parts of a system, each designed to perform a task well, and “synchronizations,” explicit rules that describe exactly how those parts fit together. The result’s software that’s more modular, transparent and comprehensible. A small domain-specific language (DSL) allows synchronizations to be expressed easily and in a form that LLMs can reliably generate. In a real-world case study, the team showed how this method can bring together functionality that will otherwise be spread across multiple services.
The team, consisting of Daniel Jackson, an MIT professor of electrical engineering and computer science (EECS) and CSAIL associate director, and Eagon Meng, an EECS graduate student, CSAIL partner and designer of the brand new synchronization DSL, explores this approach of their paper “What you see is what it does: A structural pattern for readable software“, which they presented on the Splash conference in Singapore in October. The challenge, they explain, is that in most recent systems, a single function isn’t completely self-contained. Adding a share button to a social platform like Instagram, for instance, just isn’t anchored in only one service. Its functionality is split between code that handles posting, notification, authenticating users, and more. All of those parts, although scattered throughout the code, have to be fastidiously tuned together, and every change carries the danger of unintended unwanted effects elsewhere.
Jackson calls this “functional fragmentation” a key obstacle to software reliability. “The way we construct software today, functionality isn't localized. You want to know how sharing works, but you’ve got to search for it in three or 4 different places, and if you find it, the connections are buried in low-level code,” says Jackson.
Concepts and synchronizations are intended to handle this problem. An idea bundles a single, coherent functionality equivalent to sharing, liking or following, in addition to its status and the actions it might perform. Synchronizations, then again, describe at a better level how these concepts interact. Instead of writing messy low-level integration code, developers can use a small, domain-specific language to directly formulate these connections. In this DSL, the foundations are easy and clear: the motion of 1 concept can trigger one other, so a change in a single state could be kept in sync with one other.
“Think of concepts as modules which are completely clean and independent. Synchronizations then act like contracts – they are saying exactly how concepts should interact. This is powerful since it makes the system each easier for people to know and easier for tools like LLMs to generate accurately,” says Jackson. “Why can't we read code like a book? We consider that software ought to be readable and written by way of our understanding: our hope is that concepts map to known phenomena and synchronizations reflect our intuition about what happens after they come together,” says Meng.
The advantages transcend clarity. Because synchronizations are explicit and declarative, they could be analyzed, verified, and naturally generated by an LLM. This opens the door to safer, more automated software development where AI assistants can suggest recent features with none hidden unwanted effects.
In their case study, the researchers assigned functions equivalent to liking, commenting and sharing to a single concept – much like a microservices architecture, but more modular. Without this pattern, these features were spread across many services, making them difficult to search out and test. Using the concept and synchronization approach, each feature was centralized and readable, while the synchronizations detailed how the concepts interacted.
The study also showed how synchronizations can eliminate common issues equivalent to error handling, response formatting, or persistent storage. Instead of embedding these details into each service, synchronization allows them to be processed just once, ensuring consistency across the system.
More advanced directions are also possible. Synchronizations could coordinate distributed systems, keep replicas on different servers in lockstep, or allow shared databases to interact cleanly. Weakening synchronization semantics could enable eventual consistency while preserving clarity on the architectural level.
Jackson sees potential for broader cultural change in software development. One idea is to create “concept catalogs,” shared libraries of proven, domain-specific concepts. Application development could then be less about putting code together from scratch and more about selecting the correct concepts and writing the synchronizations between them. “Concepts could turn into a brand new kind of high-level programming language, with synchronizations since the programs are written on this language.”
“It’s a strategy to make the connections within the software visible,” says Jackson. “Today we hide these relationships within the code. But when you’ll be able to see them explicitly, you’ll be able to think concerning the software at a much higher level. You still should take care of the inherent complexity of the interacting functions. But now it's open, not scattered and hidden.”
“Creating software for human use based on abstractions of underlying computing machines has burdened the world with software that is simply too often costly, frustrating and even dangerous to know and use,” says Kevin Sullivan, an associate professor on the University of Virginia who was not involved within the research. “The impact (e.g. in healthcare) has been devastating. Meng and Jackson are flipping the script and insisting on constructing interactive software based on abstractions of human understanding that they call “concepts.” They mix expressive mathematical logic and natural language to specify such goal-directed abstractions and supply a basis for verifying their meanings, composing them into systems, and refining them into programs suitable for human use. It is a brand new and essential direction in software design theory and practice that’s price watching.”
“It has been clear for a few years that we’d like higher ways to explain and specify what software should do,” adds Thomas Ball, an honorary professor at Lancaster University and affiliate faculty on the University of Washington, who also was not involved within the research. “The ability of LLMs to generate code has only fueled the specification fire. Meng and Jackson's work on conceptual design offers a promising strategy to describe in a modular way what we expect from software. Their concepts and specifications lend themselves well to combining with LLMs to realize the designer's intent.”
Looking forward, the researchers hope their work can influence how industry and academia take into consideration software architecture within the age of AI. “If software is to turn into more trustworthy, we’d like notations that make their intentions transparent,” says Jackson. “Concepts and synchronizations are a step towards this goal.”
This work was funded partly by the Machine Learning Applications (MLA) Initiative of the CSAIL Alliances. At the time of funding, the initiative's board consisted of British Telecom, Cisco and Ernst and Young.
