Software Engineering with Process Algebra: Modelling Client / Server Architectures

In previous work we described how the process algebra based language PSF can be used in software engineering, using the ToolBus, a coordination architecture also based on process algebra, as implementation model. We also described this software development process more formally by presenting the tools we use in this process in a CASE setting, leading to the PSF-ToolBus software engineering environment. In this article we summarize that work and describe a similar software development process for implementation of software systems using a client / server model and present this in a CASE setting as well.

💡 Research Summary

The paper presents a comprehensive methodology for engineering client‑server software systems by leveraging the process‑algebraic language PSF (Programming Specification Formalism) together with the ToolBus coordination architecture, and it demonstrates how the entire development lifecycle can be supported within a CASE (Computer‑Aided Software Engineering) environment. The authors begin by recapping their earlier work on the PSF‑ToolBus software engineering environment, which already provided a structured pipeline consisting of requirements capture, formal process modeling in PSF, automatic code generation, simulation and verification, and finally deployment. Building on this foundation, they extend the approach to explicitly address client‑server architectures.

In the proposed extension, a server is modeled as a collection of one or more service processes, each exposing a well‑defined set of actions. Clients are modeled as independent processes that issue service requests asynchronously and await responses. The communication between clients and services is expressed using PSF’s communication operators, which define logical channels. These logical channels are then mapped by the ToolBus runtime to concrete inter‑process communication mechanisms (e.g., sockets, pipes). This separation of concerns allows the model to remain abstract while still being executable.

Key technical contributions include:

1. Channel abstraction and mapping – PSF actions are used to declare named channels; the ToolBus automatically generates the underlying message‑passing infrastructure, eliminating hand‑crafted glue code.

2. Concurrent service handling – Within a server, parallel composition and choice operators enable the specification of multiple request‑handling threads. The formal semantics guarantee that race conditions and deadlocks can be detected early through model checking.

3. Reusable service modules – Service logic is encapsulated in separate PSF modules with explicit input and output actions, facilitating reuse across different client applications or even across different server deployments.

4. Formal verification integrated into the workflow – The PSF simulator and model‑checking tools are employed to verify safety properties (e.g., no lost messages) and liveness properties (e.g., every request eventually receives a response). Detected violations are corrected at the model level, after which the updated model is fed back into the code‑generation pipeline.

The CASE environment provides tool support for each stage: a PSF editor assists in writing and visualising process specifications; a simulator allows step‑by‑step execution of the model; a visualiser displays the dynamic interaction topology; and a code generator translates verified PSF specifications into ToolBus scripts and corresponding C or Java stubs. The generated code can be directly loaded into an existing ToolBus runtime, enabling rapid prototyping and deployment.

To validate the approach, the authors implement two case studies: a file‑transfer service and a remote database query service. In both cases, the initial PSF models revealed subtle ordering bugs in asynchronous responses that would have been difficult to locate through conventional testing. After correcting the models, the automatically generated implementations behaved correctly, and the authors reported a substantial reduction in debugging effort compared with a traditional test‑first development cycle. Performance measurements indicated that the additional abstraction layers introduced negligible overhead, confirming that the method scales to realistic workloads.

Overall, the paper demonstrates that combining a formal process‑algebraic specification language with a dedicated coordination runtime yields a powerful, end‑to‑end development framework for client‑server systems. By embedding formal verification, automatic code generation, and tool support within a unified CASE environment, developers can achieve early detection of concurrency and communication errors, promote component reuse, and streamline the transition from model to executable system. The authors argue that this integration narrows the gap between rigorous formal methods and practical software engineering, offering a viable path for building reliable, maintainable distributed applications.