The Usability Cost of Modular Software Architectures

28 concepts23 papers1 proposal

When designing software frameworks, engineers naturally strive for modularity, genericity, and extensibility. By decoupling data structures from execution logic, breaking monolithic systems into reusable components, and exposing granular configuration options, creators aim to build future-proof tools.

However, across diverse domains—ranging from machine learning and scientific computing to low-code development platforms—this architectural sophistication introduces a recurring friction known as the modularity-usability paradox. As a framework becomes more decoupled and generic, its cognitive load and initial learning curve spike. Users seeking to implement straightforward tasks are frequently forced to navigate a maze of abstract interfaces, verbose configurations, and unfamiliar paradigms, often driving them back to simpler, monolithic scripts.

Why Modularity Increases Cognitive Load

To understand why modularity breeds complexity, consider how a developer reasons about code. In a traditional monolithic or procedural script, execution flow is explicit and local: data flows sequentially from line to line.

When a framework modularizes this process, it replaces local control flow with abstract interfaces and distributed responsibilities. To perform a basic operation, a user can no longer simply call a function; they must instantiate data carriers, configure samplers, register hooks, or manage deep inheritance hierarchies.

Monolithic Script (Local & Sequential)
[ Data Input ] ---> [ Processing Logic ] ---> [ Output ]

Modular Framework (Distributed & Abstract)
[ Data Carrier ] ---> [ Abstract Interface ] <---> [ Configuration File / XML ]
                             |
                    [ Custom Subclass ] <---> [ Low-Level Sampler ]

This shift drastically increases implementation verbosity. For example, in reinforcement learning, Albert Bou et al. observe in TorchRL: A data-driven decision-making library for PyTorch that designing for high modularity and granular control inherently increases the verbosity of standard implementation tasks. While this flexibility enables complex custom pipelines, it makes basic training loops significantly harder to write and maintain compared to opinionated, high-level alternatives.

A similar pattern emerges in configuration-driven architectures. Instead of writing imperative code, users must master a specialized configuration schema that maps onto internal classes. As Albert Zeyer et al. note in RETURNN as a Generic Flexible Neural Toolkit with Application to Translation and Speech Recognition, while configuration-driven designs provide immense architectural flexibility, they create a high barrier to entry by requiring users to possess a deep understanding of internal layer classes and logic just to define standard models.

This trade-off between flexibility and accessibility is documented across multiple specialized domains:

The Friction in Scientific Prototyping

In fast-paced research environments, rapid prototyping is often prioritized over long-term software engineering principles. When a framework requires extensive upfront planning and architectural overhead, it directly clashes with the experimental workflows of researchers who are more comfortable with linear scripting.

In quantum computing control systems, Leon Riesebos et al. point out in Modular Software for Real-Time Quantum Control Systems that designing modular and portable software architectures involves a higher initial complexity than developing monolithic, experiment-specific scripts. This overhead can actively discourage the adoption of structured frameworks in environments where speed-to-experiment is paramount.

This friction is exacerbated when frameworks adopt advanced programming paradigms or high-level object-oriented design patterns. As Christian Gagné et al. argue in Genericity in Evolutionary Computation Software Tools: Principles and Case-study, the pursuit of high architectural genericity increases internal complexity, creating a steep barrier to entry for new users and highlighting the difficulty of balancing deep customization for experts with an intuitive interface for novices.

Even when generic architectures successfully preserve execution efficiency—such as the image processing library developed by Roland Levillain et al. in Practical Genericity: Writing Image Processing Algorithms Both Reusable and Efficient—the sophisticated library architecture required to implement high-performance generic programming often results in a steep learning curve that hinders adoption in standard workflows.

This pattern repeats across other scientific domains:

  • Materials Science: The shift toward highly modular, object-oriented architectures provides greater extensibility but results in a steeper learning curve for researchers accustomed to traditional, linear scripting approaches, as observed by Alex M. Ganose et al. in Atomate2: modular workflows for materials science.
  • Neural Architecture Search: Formal domain-specific languages designed to decouple search spaces from search algorithms introduce a steeper learning curve compared to standard imperative scripting, as shown by Renato Negrinho et al. in Towards modular and programmable architecture search.
  • Program Transformation: Frameworks utilizing advanced functional programming paradigms for multi-language code refactoring impose a steep learning curve, requiring significant time for developers to achieve proficiency, as noted by James Koppel et al. in Incremental Parametric Syntax for Multi-Language Transformation.

The Low-Code and End-User Illusion

The modularity-usability paradox is not confined to expert-level programming frameworks; it also subverts platforms explicitly designed for simplicity and non-programmers. Low-code development (LCD) and end-user development (EUD) platforms frequently market themselves as inherently easy to use by hiding architectural complexity behind graphical interfaces and pre-built templates.

However, this simplicity lasts only as long as the user stays within the boundaries of basic templates. The moment a user attempts to implement complex business logic or custom workflows, they hit a wall of proprietary platform logic.

In an empirical study of low-code development, Peng Liang 0001 et al. demonstrate in Characteristics and Challenges of Low-Code Development: The Practitioners' Perspective that practitioners frequently encounter a steep learning curve when moving beyond basic applications. This challenge is exacerbated when the platform's graphical interface fails to support a specific requirement, forcing users to master proprietary logic or integrate traditional programming languages to extend functionality.

This points to a fundamental conflict between functional scope and ease of use. As Gaurav Bhatia et al. argue in FORWARD: Design Specification Techniques for Do-It-Yourself Application Platforms, general-purpose programming languages offer unlimited flexibility but require specialized expertise, whereas simple template-based tools are accessible but lack customization. Attempting to bridge this gap by increasing a platform's functional generality typically introduces technical complexity that exceeds the capabilities of non-programmers.

The authors of Awareness and Control for Inter-Widget Communication: Challenges and Solutions, Olexiy Chudnovskyy et al., echo this finding, stating that a fundamental trade-off exists between the functional generality of a platform and its usability for non-technical users, where increasing developer flexibility directly decreases end-user accessibility.

This tension is also highly visible in project management and visualization tools:

Mitigating the Paradox: The Minimalist Strategy

To combat the usability cost of modularity, some framework designers have turned to an intentional counter-strategy: radical minimalism. Instead of building massive, all-encompassing toolkits with deep inheritance hierarchies, these frameworks deliberately limit their feature sets to preserve clarity and maintain a direct mapping between theory and implementation.

This approach is exemplified by Julia Kreutzer et al. in Joey NMT: A Minimalist NMT Toolkit for Novices. While industrial-strength toolkits prioritize performance and scalability—resulting in complex abstractions that make it difficult to trace execution flow—Joey NMT follows an "80/20 rule." By implementing only the most essential 20% of features to achieve 80% of the results, the authors created a codebase that remains easy to learn, modify, and trace, demonstrating that usability can be recovered by intentionally constraining architectural scope.

Key Foundational Work

Open BEAGLE: A New C++ Evolutionary Computation Framework (2002) — contributed 1 concept elements to this direction.
LORD: LISP-Oriented Resolver And Data Base (1975) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_low_code_learning_curve_paradox_f8a645d6,
  title = {low-code learning curve paradox},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/low-code-learning-curve-paradox/rdr_f8a645d68791441db51f370fe52d4372},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_low_code_learning_curve_paradox_f8a645d6_v1,
  title = {low-code learning curve paradox},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/low-code-learning-curve-paradox/rdr_f8a645d68791441db51f370fe52d4372/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake