
Abstract
In this paper we examine the current state of affairs in Computer-Aided Software Engineering (CASE) tools specifically aimed at software design. We look at individual tools as well as entire categories of tools with respect to applicability and effectiveness, and we find them all wanting.
This post is support material for Towards Authoritative Software Design.
(Useful pre-reading: About these papers)
The list
Through the decades, many tools and methodologies have been developed to aid software architecture and design. A common pattern in them is that they try to make some aspect of development more visual rather than textual. Here is a long, but non-exhaustive list:
Implementation tools
These express implementations rather than designs.
- Integrated development environments (IDEs) - They are limited to fancy source code editors, form builders, visualization tools, and, in some cases, architecture conformance tools, all of which are discussed below. As such, they are implementation tools, not design tools.1
- Fancy source code editors - No matter how fancy, they express implementations, not designs.
- Form builders (a.k.a. graphical user interface (GUI) editors) - They only help define those small parts of a system that are visible by the user, and they can only specify their looks, not their functionality.
- Visual component composition tools (e.g. the JavaBeans BeanBox, the Visual Composition Editor of IBM VisualAge for Java) - They allow components to be placed on a canvas and wired together visually. However, the wires represent events, (e.g. "when this button is clicked, copy the text of this field into that field,") so they express program logic rather than the structure of a system. Furthermore, they are mostly geared towards user interfaces, and they have long been discontinued.2
- Visual programming languages (e.g. Snap!, Scratch, EduBlocks, Blockly, LabVIEW, etc.) - They are indeed visual, and they do in fact produce runnable software, but they are structurally equivalent to code, so they express implementations rather than designs. (See On Visual Programming Languages.)
- Microsoft "Visual" programming languages (e.g. Microsoft Visual C++) - The only visual thing about them is a form builder (see above); the languages themselves are as textual as any other, so the name is mostly marketing. (See On Microsoft 'Visual' products.)
- Rapid application development (RAD) tools (e.g. Delphi, Visual Basic, PowerBuilder) - Their visual part is limited to form builders and graphical designers for database queries and reports. They require the use of a particular programming language and a vendor-specific platform; they do not scale; they are aimed at easy creation of user-interface-centric applications rather than software design.3
- No-code development platforms (NCDPs) and low-code development platforms (LCDPs) - They require a massive vendor-specific platform; they impose limitations on what can be done; they do not scale; they are aimed at non-programmers, allowing easy creation of simple, small-scale, user-interface-centric applications to quickly meet specific narrow business needs without having to write code.
Reverse-engineering tools
These extract information from existing systems, rather than help design new ones.
- Visualization tools (e.g. class diagrams, dependency diagrams, call trees, control flow graphs, etc.) - These are restricted to the visualization of various aspects of existing systems, rather than the design of new systems, or the modification of existing systems. As such, they are reverse-engineering tools rather than design tools. Furthermore, since these tools have no knowledge of the intended structure of the system, (which components are entry points, which are adapters, which implement cross-cutting concerns, which are worth showing at all,) the diagrams they produce are almost always a mess, even when the code base is not.4
- Cloud infrastructure visualization tools (e.g. Lucidscale, Cloudviz, Hyperglance, etc.) - They suffer from the same drawbacks as visualization tools, and they are also limited to specific realms, i.e. the cloud environments of particular vendors.5
- Architecture conformance tools (e.g. Structure101, Lattix, ArchUnit, etc.) - They go a step beyond visualization tools by allowing rules to be defined about which parts of the code base may depend on which, and by checking the code against these rules. However, they are still reverse-engineering tools: they extract the structure from the code, so they can only detect deviations after they have been written, and they can never materialize a system from its design.6
- Encore - Services, APIs, databases and queues are declared in application code. Encore derives a model of the system from the code, provisions the infrastructure, and generates architecture diagrams, which it then keeps in sync as the code changes. However, the diagrams are extracted from the code, so they describe the system rather than prescribe it. It also supports only Go and TypeScript backends.
Modelling tools
These produce models, which describe systems but cannot prescribe them: there are no technical means of materializing a system from its model, nor of guaranteeing that the system matches the model.
- Whiteboards, pen and paper, and general-purpose drawing tools (e.g. the drawing features of Microsoft Word or PowerPoint) - These are the most common means of software design in practice. They impose no notation and have no notion of what the shapes stand for, so whatever is drawn with them is merely suggestive: a work of art rather than an engineering document, bearing no necessary relationship to reality. (See The perils of whiteboards.)7
- Diagramming software (e.g. Microsoft Visio) - They are good for making fancy diagrams, and they keep the arrows connected to the boxes as we drag the boxes around the canvas; however, they have no understanding of the actual meaning of those boxes and arrows, so for design purposes, they offer no more than a whiteboard does.
- Modelling languages and tools (e.g. Unified Modeling Language (UML), SysML, the C4 model, ArchiMate, IBM Rational Rose, IBM Rational Software Architect Designer, etc.) - Since the model has to be maintained separately from the code, it amounts to double book-keeping, so developers tend to neglect it, and over time it drifts further and further away from reality.8
- Diagrams as code (e.g. PlantUML, Mermaid, Structurizr) - The diagrams are written as text and kept under version control together with the source code, which is a step in the right direction. However, the text merely describes boxes and arrows; nothing connects it to the actual components of the system. Some tools (e.g. Structurizr) can extract components from code, but the extraction runs only from the code to the diagram, which makes it reverse engineering rather than design.9
- Model-driven engineering (MDE) (e.g. Model Driven Architecture (MDA), Executable UML) - It promises to generate software from models, which would in theory make the models prescriptive rather than descriptive. In practice, the generated code is usually partial and must be completed by hand, at which point the model and the code start drifting apart. Where code generation is complete, (as in Executable UML,) the model must contain the entire behavior of the system, expressed in an action language, so it is an implementation in graphical form rather than a design. Furthermore, existing approaches require scarce specialist skills, such as UML, metamodelling, and model transformation languages.10
- Architecture description languages (ADLs) (e.g. AADL, Darwin, Koala, Acme, Wright, etc.) - Most of them describe architectures for the purpose of analysis, (completeness, consistency, performance, etc.,) which makes them modelling languages by another name. A few go further and generate systems from their descriptions, but these are either confined to niche domains, (e.g. AADL to avionics and space systems, Koala to Philips television sets,) or never left academia (e.g. Darwin). Overall, ADLs are rarely integrated into the software life cycle, and are seldom supported by mature tools.11
Domain-specific tools
These are confined to narrow domains.
- Specification languages (e.g. Z, VDM, TLA+, Alloy, B-Method, SDL, etc.) - They specify the behavior of a system and the properties it must satisfy, usually in mathematical notation, so that the specification can be verified. They do not describe the structure of a system as components wired together, and the few that lead to code (e.g. the B-Method) do so by requiring the specification to be refined down to the level of algorithms, which is implementation rather than design. Furthermore, they require expertise in formal methods, so they are mostly confined to niche uses such as safety-critical systems and the core algorithms of distributed systems. SDL in particular describes behavior as state machines, and is used mainly in telecommunications.12
- Web Services Description Language (WSDL) - It exclusively focuses on the narrow domain of web services, and therefore cannot be used for software design at large.
- Business process modelling (BPM) tools (e.g. Business Process Model and Notation (BPMN), Business Process Execution Language (BPEL)) - They do see some use in describing business processes within software systems, but not the software systems themselves. BPEL is even executable, but only as an orchestration of calls between web services.13
- Infrastructure as code (IaC) tools (e.g. Terraform, Kubernetes manifests, Docker Compose, AWS CloudFormation, etc.) - These are genuinely prescriptive: the infrastructure is materialized from the document, so it matches the document. However, they are only applicable to the narrow domain of computing infrastructure (hosts, OS-level containers, networks, storage); they do not describe the software components running on that infrastructure, nor the interfaces through which those components communicate. A connection between two services amounts to a host name and a port number; nothing verifies that what one service sends over that connection is what the other service expects. Furthermore, each tool is tied to particular vendors or platforms.14
- Microsoft Aspire - An "app model", written in C# or TypeScript, declares the services, containers and cloud resources that make up a system, and how they connect. The system is then launched locally or deployed straight from that model, so it is genuinely prescriptive. However, its building blocks are processes, containers and infrastructure resources, not software components interacting via typed interfaces. Also, the model is code, so there is no visual design.
- Real-Time Object-Oriented Modeling (ROOM) (e.g. ObjecTime Developer, UML-RT / Rational Rose RealTime, Eclipse eTrice) - Systems are composed of nested components with ports typed by protocols, and the entire system is generated from the model. However, components may only communicate via asynchronous messages, the behavior of each component must be expressed in the model as a state machine, so the model is largely an implementation rather than a design, and components must be written against a specific runtime library. Furthermore, it is aimed at the niche domain of event-driven real-time embedded systems.15
- Simulink - It is visual, its connections are typed, its diagrams are hierarchical, and it can generate production code from them. However, a diagram describes a single computation as a flow of signals between blocks, not a system of software components interacting via interfaces. Furthermore, it is confined to niche domains, (control systems, signal processing,) and tied to a proprietary vendor platform.16
- Flow-based programming (FBP) (e.g. Node-RED, Apache NiFi, NoFlo, JavaFBP, etc.) - Systems are expressed as networks of black-box components exchanging data packets over connections that are defined outside the components. This comes close to design, but in practice these networks are used to express processing logic, so they describe implementations rather than designs. Furthermore, components can only communicate by asynchronously passing data packets, and most implementations are aimed at niche domains such as wiring together IoT devices (Node-RED) and data ingestion pipelines (NiFi). Worst of all, connections are generally untyped, so nothing can verify that what one component sends is what the other component expects; therefore, such networks cannot guarantee that the system they describe can actually work.17
Component technologies
These provide means of composing systems out of components, but no means of designing them.
Component-based software engineering (CBSE) technologies (e.g. Microsoft OLE / COM, CORBA, Enterprise JavaBeans, OSGi, etc.) - Existing implementations suffer from critical limitations such as:
- Assuming the exclusive use of a particular operating system or operating environment.
- Assuming the exclusive use of a particular programming language.
- Requiring components to include debilitating amounts of bureaucracy.
- Forcing components to be heavyweight, sometimes as heavyweight as a process.
- Requiring components to communicate exclusively via a specific mechanism, such as asynchronous message passing, data streams, etc.
- Complete absence of visual design tools, even though such tools could, in principle, be developed.
The shortcomings of these technologies are reflected in the limited extent of their adoption. Whatever meager adoption Microsoft OLE in particular enjoys can be attributed to coercion rather than merit: it is the only way to accomplish certain things under Microsoft Windows, so people use it because they have to, not because they want to.18
Google Service Weaver - Systems are written as what Google calls a "modular monolith" of components, then deployed as distributed services with a single command. However, the components and their wiring exist only in code, so there is no design to look at. It supports only Go, and adopting it meant rewriting existing applications, so it saw little use; Google discontinued it at the end of 2024.
Dependency injection (DI) frameworks (e.g. Spring, Guice, Microsoft.Extensions.DependencyInjection, etc.) - They automate the wiring of components, which is a necessary ingredient of materializing a system from its design; however, components are declared as offering and consuming interfaces, and the framework matches them by type, so the wiring is implicit, and there is no single place where the structure of the system can be seen graphically. Furthermore, they operate at the level of individual classes, which is much too fine-grained for design, and they resolve dependencies by magic at runtime, so errors surface late. Finally, the field is fragmented: each framework is tied to a single programming language, so a system spanning several languages cannot be wired by any one of them.19
Conclusion
Some of the technologies listed above are prescriptive, but each of them is either confined to a narrow domain, or operates at the level of implementation rather than design. The rest are applicable to software design at large, but they are descriptive rather than prescriptive, so in practice, software design remains a whiteboard exercise.
For what is wrong with whiteboards, see The perils of whiteboards.
For what we should be doing instead, see Towards Authoritative Software Design.
For architecture conformance in an IDE, see Microsoft: Live dependency validation in Visual Studio 2017. ↩︎
See MC Press: VAJ: Writing Java Programs Without Writing Code, and the description of the Visual Composition Editor in NetBeans bug 14023. ↩︎
See Wikipedia: Rapid application development, and the PowerBuilder documentation on painters. ↩︎
See Simon Brown & Stefan Tilkov, GOTO 2021, part 2, at 15:29. ↩︎
See Techzine: Lucid launches Lucidscale for visualization of cloud environments (AWS, Azure, and Google Cloud only). ↩︎
See Structure101: headless check-spec (on breaking the build upon new violations), ArchUnit, and Sangal et al.: Using Dependency Models to Manage Complex Software Architecture (on Lattix). ↩︎
See Cherubini, Venolia, DeLine, Ko: Let's go to the whiteboard: how and why software developers use drawings, CHI 2007. ↩︎
See Marian Petre: UML in Practice, ICSE 2013, and a review of it with the breakdown of its findings (Never Work in Theory): of 50 professional software engineers interviewed, 35 used no UML at all, and none used it wholeheartedly. ↩︎
See Wikipedia: Model-driven architecture, section MDA concerns, Linköping University: ARECOMP (on generated code having to be extended manually), and Evidences of the mismatch between industry and academy on modelling language quality evaluation (arXiv) (on hand-edited code being erased upon regeneration). ↩︎
See Wikipedia: Architecture description language; for Darwin and Koala, Jeff Kramer, BCS presentation, 2006; for code generation from AADL, Validate, simulate, and implement ARINC653 systems using the AADL, SIGAda 2009. ↩︎
See Wikipedia: Specification language, Wikipedia: B-Method (on refinement down to an implementation, and its use for the automatic Paris Métro lines 14 and 1), Newcombe et al.: How Amazon Web Services Uses Formal Methods, CACM 2015, and the SDL-88 tutorial of the SDL Forum Society. ↩︎
For how services find each other in Docker Compose, see Docker: Networking in Compose. ↩︎
See Wikipedia: Real-Time Object-Oriented Modeling, Wikipedia: ObjecTime Developer, and IBM: UML-RT overview. ↩︎
See MathWorks: Embedded systems (on production code generation for automotive and aerospace standards). ↩︎
See Wikipedia: Flow-based programming, the Apache NiFi user guide, and a UCSB lecture on Node-RED (on the difficulty of managing large flows). ↩︎
See Wikipedia: Component Object Model (on DirectX, the Windows shell, and the Windows Runtime being built on COM). ↩︎
See Martin Fowler: Inversion of Control Containers and the Dependency Injection pattern. ↩︎
Comments are disabled until you accept functional cookies.