Executable Use Cases: Formalizing Context in Pervasive Healthcare
13507_Executable Use Cases Requirements for a Pervasive Health Care System.
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:
- Immobility: Unlike paper records, digital systems couldn't be carried to the bedside easily.
- 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.
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.
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).
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."
