Executable Use Cases: Formalizing Context in Pervasive Healthcare

13507_Executable Use Cases Requirements for a Pervasive Health Care System.

Summary
Problem
Method
Results
Takeaways

This paper introduces Executable Use Cases (EUCs), a three-tiered requirement engineering framework designed for pervasive healthcare systems. By integrating prose descriptions, Coloured Petri Nets (CPN), and graphical animations, the method bridges the gap between informal user ideas and formal system implementation.

TL;DR

Pervasive computing requires systems to be "context-aware," yet traditional requirement engineering often ignores the environment. This paper presents Executable Use Cases (EUCs), a framework that uses Coloured Petri Nets (CPN) to model not just the software, but the physical workflows of a hospital. By providing an "Animation Tier," it allows nurses and doctors to validate complex formal logic through intuitive interaction.

The "Immobile" Digital Record

Traditional Electronic Patient Records (EPR) suffer from a paradox: while digital, they often anchor medical staff to stationary PCs. In the hectic environment of a Danish hospital, the authors observed two primary pain points:

  1. Immobility: Unlike paper records, digital systems couldn't be carried to the bedside easily.
  2. Interaction Overhead: High-security requirements led to nested menus and constant logins, which are incompatible with the frequent interruptions of clinical work.

The insight here is that the work process and the environment must be explicitly modeled. A prototype of a screen is not enough; you must prototype the nurse's movement through the ward.

Methodology: The Three-Tier EUC Framework

The core of the EUC approach is its ability to move from "informal prose" to "rigid logic" and back to "visual intuition."

1. The Prose Tier (Informal)

Stakeholders, including anthropologists and nurses, draft natural language descriptions of work. While accessible, these are often ambiguous and struggle to handle concurrency (e.g., what happens when two nurses use the same cabinet?).

2. The Formal Tier (Logical Core)

Here, the developers use Coloured Petri Nets (CPN). Unlike standard flowcharts, CPNs are mathematically rigorous and handle concurrency, resource sharing, and synchronization natively.

Model Architecture: CPN Formal Tier Figure 3: A CPN module modeling the "pouring and checking" of medicine. Notice how 'NURSE' and 'COMPUTER' are represented as distinct states within a single logical system.

3. The Animation Tier (Visual Validation)

To ensure nurses can critique the model without learning Petri Nets, the authors built a graphical layer. When the underlying CPN state changes (e.g., a "token" moves), a virtual nurse icon moves on a map.

Animation Tier Interface Figure 4: The Animation Tier allows users to interact with the formal model through a familiar departmental map and UI.

Impact: From Spec to Context-Awareness

By formalizing the environment, the team moved toward Propositional Design. The system doesn't wait for a user to search for a patient; it "guesses" based on context.

  • Context: Nurse Jane stands near the medicine cabinet with Patient Bob’s tray.
  • Action: The RFID tag triggers a "Medicine Plan: Bob" button on the taskbar automatically.

This reduces the "login and navigate" problem into a single, context-aware click.

Experimental Validation

Using EUCs, the authors discovered requirements that prose missed:

  • Multi-user Conflict: How to handle two nurses at one computer? (The CPN model forced a resolution: generate two sets of taskbar buttons).
  • Concurrency Control: Can one nurse pour while another gives medicine to the same patient? (The model revealed the need for fine-grained record locking).

System Interface Comparison Figure 2: The resulting pervasive interface, focusing on propositional buttons (e.g., "Medicine Plan: Tom Smith") derived from the environmental context.

Critical Analysis & Takeaways

The brilliance of this work lies in Explicit Environment Modeling. Most developers treat the world outside the screen as a "black box" of random inputs. By treating the environment as a set of formal states (via Petri Nets), the authors turned "pervasive" computing from a buzzword into a verifiable specification.

Limitations: The authors admit that Coloured Petri Nets require specialized expertise. While Tiers 1 and 3 are user-friendly, the "Formal Tier" remains a bottleneck for many development teams.

Conclusion: EUCs prove that for AI and IoT systems of the future, we cannot just prototype the "App." We must prototype the "App-in-the-World."

Find Similar Papers

Try Our Examples

  • Search for recent papers that extend Executable Use Cases (EUCs) or Coloured Petri Nets to modern Internet of Things (IoT) and Edge Computing environments.
  • Which research first established the link between Coloured Petri Nets and Requirements Engineering, and how does the three-tier model in this paper build upon that foundation?
  • Explore how the "propositional design principle" and context-aware triggers from this healthcare case study have been applied to autonomous systems or smart home technologies.
Contents
Executable Use Cases: Formalizing Context in Pervasive Healthcare
1. TL;DR
2. The "Immobile" Digital Record
3. Methodology: The Three-Tier EUC Framework
3.1. 1. The Prose Tier (Informal)
3.2. 2. The Formal Tier (Logical Core)
3.3. 3. The Animation Tier (Visual Validation)
4. Impact: From Spec to Context-Awareness
5. Experimental Validation
6. Critical Analysis & Takeaways