While the integration of large language models (LLMs) into software development holds immense promise, it simultaneously shines a spotlight on persistent, deeply embedded weaknesses within current coding practices. These include convoluted codebases, a high risk associated with making safe modifications, and a general lack of transparency regarding internal operations.
Addressing these critical challenges, researchers at MIT’s Computer Science and Artificial Intelligence Laboratory (CSAIL) are now advocating for a fundamentally more “modular” approach to software design.
A new methodology is reshaping how software systems are designed, breaking them down into two fundamental components: “concepts” and “synchronizations.” Concepts represent discrete, self-contained pieces of a system, each engineered to perform one specific function with high efficiency. Synchronizations, on the other hand, are explicit rules that precisely dictate how these individual concepts interoperate and fit together.
This architectural approach promises to yield software that is significantly more modular, transparent, and easier for developers to understand and maintain. A pivotal element enabling this design is a compact domain-specific language (DSL), crafted to express these synchronizations simply. Crucially, this DSL’s streamlined format also allows Large Language Models (LLMs) to reliably generate the required synchronization code.
In a practical demonstration, a real-world case study showcased the method’s effectiveness, successfully unifying features that would typically be dispersed across numerous independent services, thus proving its potential to streamline complex software architectures.
A research team, led by MIT’s Daniel Jackson, a professor of electrical engineering and computer science (EECS) and associate director at CSAIL, has introduced a novel approach to enhance software legibility. Joining him is Eagon Meng, an EECS PhD student and CSAIL affiliate, credited with designing the new synchronization Domain Specific Language (DSL) that underpins their work.
The team presented their findings in the paper, “What You See Is What It Does: A Structural Pattern for Legible Software,” at the Splash Conference in Singapore this October. Their research highlights a significant challenge in modern software development: the pervasive issue of features not being self-contained. As they explain, a single function—such as adding a “share” button to a platform like Instagram—does not reside within one isolated service. Instead, its operations are fragmented across various code modules responsible for tasks like posting content, managing notifications, and authenticating users. This dispersion necessitates meticulous alignment of all these components, as even minor alterations can inadvertently trigger widespread side effects across the entire system.
Software reliability is fundamentally undermined by a pervasive issue Jackson terms “feature fragmentation.” He asserts that modern software development inherently struggles because core functionalities are not localized; instead, they are scattered across the codebase. Jackson illustrates this challenge with the common “sharing” feature: understanding its full scope requires developers to hunt through three or four different locations, only to find its crucial connections deeply embedded and obscured within low-level code.
To address the complexities of modern software development and integration, an innovative system introduces two key components: “concepts” and “synchronizations.”
A “concept” serves as a fundamental, self-contained building block of functionality. Think of it as a modular unit encapsulating a distinct feature, such as user “sharing,” “liking,” or “following.” Each concept is comprehensive, bundling not only its specific behavior but also its internal state and the actions it can perform.
The seamless interaction between these individual concepts is orchestrated by “synchronizations.” Operating at a higher level of abstraction, synchronizations streamline development by eliminating the need for developers to craft intricate, low-level integration code. Instead, engineers leverage a concise, domain-specific language (DSL) to directly articulate how these connections should function.
Within this remarkably clear DSL, the rules are straightforward: an action initiated by one concept can readily trigger a response in another. This mechanism ensures that changes in one piece of the system’s state are automatically mirrored and kept consistent across all interconnected functionalities.
A new paradigm for software development proposes that “concepts” should function as entirely clean and independent modules, with “synchronizations” acting as explicit contracts dictating their interactions. This design, according to Jackson, offers a powerful dual benefit: it simplifies system comprehension for humans and enhances the accuracy of code generation by advanced tools like Large Language Models (LLMs).
Echoing this vision, Meng questions why code traditionally lacks the intuitive readability of a book. He asserts that software ought to be inherently legible, crafted to resonate with human understanding. The ultimate goal, Meng explains, is for “concepts” to directly map to familiar real-world phenomena, while “synchronizations” should instinctively reflect our intuition about how these components behave when brought together.
The advantages of explicit and declarative synchronizations extend far beyond mere clarity. Their very design enables deep analysis, stringent verification, and even automated generation by Large Language Models (LLMs). This pivotal capability promises a significant transformation in software development, paving the way for a future where automation is enhanced and safety is paramount. AI assistants will be empowered to propose novel features with confidence, effectively preventing the introduction of hidden side effects.
In a recent case study, researchers unveiled an innovative architecture designed to streamline complex application features. Their approach involved dedicating each core functionality, such as ‘liking,’ ‘commenting,’ and ‘sharing,’ to a single, distinct ‘concept’—envisioned as a highly modular evolution of microservices. This contrasts sharply with previous methods, where these features were often scattered across a multitude of services, significantly hindering their location and testing. By implementing their “concepts-and-synchronizations” methodology, the team achieved newfound centralization and legibility for each feature, while explicit ‘synchronizations’ precisely articulated how these individual concepts interacted.
The research also highlighted how synchronizations can effectively centralize and abstract away common operational complexities. These include critical functions such as error handling protocols, standardized response formatting, and persistent data storage. Rather than scattering these details across every individual service, synchronization allows for their management from a single point, thereby guaranteeing uniform application and consistency throughout the entire system.
Beyond its foundational applications, synchronization holds the potential for sophisticated advancements. Crucially, it could unify distributed systems, ensuring data replicas across disparate servers remain perfectly synchronized, or facilitate seamless interaction among shared databases. Furthermore, a strategic weakening of synchronization protocols could usher in the benefits of “eventual consistency,” all while steadfastly preserving the clarity and coherence of the underlying architectural design.
Jackson envisions a fundamental re-imagining of software development, foreseeing a significant cultural transformation within the industry. Central to this shift is his proposal for “concept catalogs” – communal, rigorously vetted libraries containing specialized, domain-specific functionalities.
Under this paradigm, crafting applications would evolve from the arduous task of building code components from scratch to a more strategic process of identifying and integrating the most suitable pre-defined concepts, then meticulously defining their interactions. As Jackson articulates, this effectively means that “Concepts could become a new kind of high-level programming language, with synchronizations as the programs written in that language.”
A new methodology championed by Jackson seeks to bring the intricate connections within software into plain view, a significant shift from the current practice of embedding them invisibly within code. Jackson argues that by explicitly visualizing these interdependencies, developers can elevate their reasoning and analysis of the software to a much higher level. While the inherent complexities stemming from feature interactions will inevitably persist, he emphasizes that this approach ensures they are “out in the open,” rather than scattered and obscured by hidden code.
Industry experts are commending new research by Meng and Jackson that proposes a revolutionary shift in software design, moving away from machine-centric abstractions towards human understanding.
University of Virginia Associate Professor Kevin Sullivan criticizes the conventional approach, stating that software built on “abstractions from underlying computing machines” has resulted in applications that are frequently “costly, frustrating, even dangerous” for human users. He points to “devastating” consequences in critical sectors like healthcare. However, Sullivan praises Meng and Jackson for “flipp[ing] the script,” advocating for interactive software constructed upon “abstractions from human understanding,” which they term ‘concepts.’ This innovative methodology merges “expressive mathematical logic and natural language” to precisely specify these purposeful abstractions, thereby creating a framework for verifying their meanings, composing them into complex systems, and ultimately refining them into user-friendly programs. Sullivan describes this as “a new and important direction in the theory and practice of software design that bears watching.”
Echoing this sentiment, Thomas Ball, an honorary professor at Lancaster University and affiliate faculty at the University of Washington, highlights a long-standing challenge: the continuous need for “better ways to describe and specify what we want software to do.” Ball notes that the rise of Large Language Models (LLMs) and their code-generating capabilities has only “added fuel to the specification fire.” He identifies Meng and Jackson’s “concept design” as particularly promising, offering a “modular manner” to articulate software requirements. Ball further suggests that their meticulously crafted concepts and specifications are “well-suited to be paired with LLMs to achieve the designer’s intent.”
The researchers anticipate their work will profoundly influence the discourse around software architecture in the era of artificial intelligence, impacting both industry practices and academic thought. Lead researcher Jackson emphasized that for software to achieve greater trustworthiness, its intentions must be transparently communicated, positioning “concepts and synchronizations” as a key step towards this goal.
This project received partial financial backing from the Machine Learning Applications (MLA) Initiative, an arm of CSAIL Alliances. At the time of funding, the initiative’s board notably included British Telecom, Cisco, and Ernst and Young.
