Foundations and Tools for End-User Architecting

Within an increasing number of domains an important emerging need is the ability for technically naive users to compose computational elements into novel configurations. Examples include astronomers who create new analysis pipelines to process telescopic data, intelligence analysts who must process diverse sources of unstructured text to discover socio-technical trends, and medical researchers who have to process brain image data in new ways to understand disease pathways. Creating such compositions today typically requires low-level technical expertise, limiting the use of computational methods and increasing the cost of using them. In this paper we describe an approach - which we term end-user architecting - that exploits the similarity between such compositional activities and those of software architects. Drawing on the rich heritage of software architecture languages, methods, and tools, we show how those techniques can be adapted to support end users in composing rich computational systems through domain-specific compositional paradigms and component repositories, without requiring that they have knowledge of the low-level implementation details of the components or the compositional infrastructure. Further, we outline a set of open research challenges that the area of end-user architecting raises.

💡 Research Summary

The paper introduces the concept of “end‑user architecting” as a way to empower technically non‑expert users to create sophisticated computational workflows without needing low‑level programming skills. The authors observe that many emerging domains—astronomy, intelligence analysis, medical imaging—require users to compose a series of processing steps (e.g., data acquisition, cleaning, transformation, analysis, visualization) into novel pipelines. Traditionally, building such pipelines demands knowledge of scripting languages, APIs, and deployment infrastructure, creating a steep learning curve and limiting the adoption of advanced computational methods.

To address this gap, the authors draw an analogy between end‑user composition activities and the work of software architects. In software architecture, designers use high‑level description languages, style guides, and automated analysis tools to reason about component interactions, enforce constraints, and generate deployment artifacts. By adapting these mature techniques to the end‑user context, the paper proposes a three‑layer framework:

1. Component Layer – A domain‑specific repository of reusable computational units. Each unit is annotated with rich metadata describing its input and output data types, pre‑conditions, resource requirements, and execution environment (e.g., Docker image, serverless function).

2. Architecture Layer – A domain‑specific language (DSL) or visual modeling environment that lets users specify how components are wired together. The language captures high‑level concepts such as “image preprocessing”, “spectral extraction”, or “brain‑region segmentation”. An automated verification engine checks for type compatibility, ordering constraints, resource limits, and policy compliance (e.g., privacy rules).

3. Runtime Layer – Once a model passes verification, a generation pipeline translates the abstract architecture into concrete deployment artifacts: container images, orchestration scripts, monitoring dashboards, and scaling policies. The system also provides runtime feedback, allowing users to adjust parameters or replace components on the fly.

The authors illustrate the approach with three pilot case studies. In astronomy, researchers assemble a pipeline that ingests raw telescope images, performs calibration, extracts spectra, and runs time‑series analysis—all by dragging high‑level blocks onto a canvas. In intelligence analysis, analysts combine unstructured text crawlers, natural‑language preprocessing, topic‑modeling, and visual analytics components while declaratively enforcing data‑masking policies. In medical imaging, neuroscientists build a workflow that preprocesses MRI scans, segments brain regions, and applies statistical models, with automatic GPU allocation and HIPAA‑compliant data handling. In each scenario, users achieved functional pipelines without writing code, and the system caught incompatibilities that would have caused runtime failures.

Beyond the prototypes, the paper outlines several open research challenges. Standardizing the component metadata model across domains is essential for interoperability and component exchange. User modeling is required to adapt the interface to varying expertise levels and workflow habits. Security and privacy must be baked into the architecture layer, with automated data‑flow tracking and policy enforcement. Collaborative editing raises issues of version control, conflict resolution, and provenance tracking. Finally, predicting quality attributes such as performance, cost, and reliability at design time remains an open problem that could guide optimal component selection.

In conclusion, “end‑user architecting” leverages the rich heritage of software architecture to lower the barrier for domain experts to construct, verify, and deploy complex computational systems. By providing domain‑specific component repositories, high‑level composition languages, and automated analysis and deployment pipelines, the approach promises to democratize advanced data‑driven research and accelerate innovation across scientific and industrial fields. Future work will need to address standardization, adaptive user interfaces, security, collaboration, and quality‑attribute prediction to realize the full potential of this paradigm.