CAUCE - Model-driven development of ubiquitous computing environments
-
Upload
ricardo-tesoriero -
Category
Technology
-
view
132 -
download
3
description
Transcript of CAUCE - Model-driven development of ubiquitous computing environments
PhD. Dissertation
Candidate: Ricardo Tesoriero
Supervisors: PhD. José Antonio Gallud Lázaro PhD. María Dolores Lozano Pérez
Introduction
CAUCE Model-driven Development
CAUCE CASE tool
Conclusions and Future Work
InspirationMajor trends in computingCalm TechnologyContext awarenessRelated Work
Introduction CAUCE MDD CAUCE CASE Conclusions
“The world is not a desktop”
“A good tool is an invisible tool. By invisible, we mean that the tool does not intrude on your consciousness; you focus on the task, not the tool.”
Eyeglasses are a good tool
Mark Weiser, November 7th, 1993
The major trends in computing Mainframe computing (N users 1 computer)
Personal computing (1 user 1 computer) ▪ Internet – widespread distributed computing
(transition)
Ubiquitous computing (N users - N computers)
Mark Weiser and John S. Brown (1997)
“Calm technology engages both the center and the periphery of our attention, and in fact moves back and forth between the two”
Mark Weiser and John S. Brown
By placing things in the periphery we are able to attune many more things than we could if everything had to be at the center
By re-centering something formerly in the periphery we take control of it.
Context Awareness
The Context is any information that can be used to characterize the situation of an entity. An entity is a person, place, or object that is considered relevant to the interaction between a user and an application, including users and applications themselves.
A system is context-aware if it uses the context to provide relevant information and/or services to the user, where relevancy depends on the user's task
Understanding and using context , A. Dey, 2001
There is more context than location, Albrecht Schmidt et al., 1999
Human Factors
Physical Environment
User Information
Social Environment
User Task
Physical conditions
Infrastructure
Location
LightPressure
AccelerationAudio
Temperature
LevelFlikering
Wave-Lenght
Context awareness feature space
Development of a set of applications in a distributed environment
Do not have a fixed architecture Deployed in heterogeneous platforms Connectivity affects how the information is
transported Multiple devices should exchange information
to carry out system tasks Society of entities (collaboration) Location of the entity Knowledge about which task is being performed
by entities to assist them
The capability to define metamodels to match specific characteristics of the system, no matter the level of abstraction it addresses.
Tools for merging and transforming models to reuse information from one layer of abstraction to the next.
Tools to turn these models into source code for different platforms
A Meta Object Facility (MOF) Metamodel for the Development of Context-Aware Mobile Applications Provides contextual model independent of the application domain Manages low level concepts only (event and service) does not support task or role concepts. Does not take into account deployment issues, it is based on SOA
Model-driven Composition of Context-aware Web Services Using ContextUML and Aspects Handles business logic and context-dependent service behavior as two separate concerns Focused in Web applications only (SOA) and services
Towards Context Independence in Distributed Context-aware Applications by the Model-driven Approach Entity vision vs. service vision Low semantic meaning (services)
Context-aware model-driven development by parameterized transformation Different layers of PIMs by parameterized transformations (includes additional information) Context is not characterized, very high level of abstraction that does not provide enough information
about context Towards a Model-Driven Approach for Ontology-Based CAA Development: A Case
Study Step based development Embraces concepts such as Device, Event, Communication, Channel and Activity Does not take into account Roles , Location, etc. Steps are not part of a development process
Model-Driven Development of Context-Aware Services Development process (preparation and service creation phases) Modelling process (PI Service design, PS service design) Low level concepts (events, queries and actions) Lack of task, space, location and role concepts
Managing an Integrated Ubicomp Environment Using Ontologies and Reasoning Good description of the systems Enterprise applications only (client-server) Lack of insulation between context and domain logic, social environment, etc.
An Ontology for Context-Aware Pervasive Computing Environments Space composition Location modelling is not technology independent Notion of agent (entity) No role based functionality Task is taken into account No history is supported at any level
Aspect-Oriented Model-Driven Development for Mobile Context-Aware Computing Combination of AOP and MDD Attached to AspectJ Low level concepts, instead of tasks, roles, spaces, entities and so on
Main goalProposalThe analysis layerThe information layerAnalysis to information layer M2M transformationMapping modelInformation to source code M2T transformation
Introduction CAUCE MDD CAUCE CASE Conclusions
The main goal of this work is:
“The definition of a semi-formal methodology to tackle the development of Context-aware Applications for Ubiquitous Computing Environments”.
1. Perform a review of the main characteristics of CAAs for UCEs.
2. Perform a review of the most relevant design processes to develop CAAs for UCEs.
3. Define a methodology together with modeling languages to specify the design of CAAs for UCEs based on the characteristics presented in 1.
4. Implement a CASE tool to support the defined methodology allowing the developer to create and edit models conforming metamodels as defined in 3.
5. Define and implement a set of transformations to generate the basic structure of the system source code.
6. Apply the process to a set of scenarios that embraces most CAS features for UCEs to prove the validity of the proposal.
PSM
Platform -Characteristics
PIM
Analysis LayerCAS - Characteristics
Information LayerSoftware - Characteristics
Task modelTask Metamodel
Social modelSocial Metamodel
Space modelSpace Metamodel
M2M
Tra
nsfo
rma
tion
Entity Context modelEC Metamodel
Information Flow model IF Metamodel
Referential Space modelRS Metamodel
M2T
Tra
nsfo
rma
tion
So
urc
e C
od
e
Mapping model
MappingMetamodel
Task model
Space model
Social Model
Introduction CAUCE MDD CAUCE CASE Conclusions
Analysis layer TransformationInformation layer
Context-aware application feature model
Physical EnvironmentEntity Factors
The goal of this layer is the provision of modeling tools to represent the high-level features of CAAs for UCEs defined in (Schmidt, 1999)
Task modelTask Metamodel
Social modelSocial Metamodel
Space modelSpace Metamodel
Tim
eSocial
EnvironmentLocationInfrastructure
Physical Conditions
Entity Information
Entity Task
The TaMM provides a modeling tool to represent the relationship between tasks and entities that are immersed into CAS for UCEs.
Based on:Petri Nets (Workflows) – To relate tasks and entities
Regular Expressions – To express conditions that relate the TaMM models to SoMM and SpMM models
Analysis layer TransformationInformation layer
Introduction CAUCE MDD CAUCE CASE Conclusions
Workflow Concept * TaMM Concept
Task Task
Condition Condition
Sequential Routing Task dependency
Selective Routing Task dependency
Iteration Routing Task dependency
Parallel Routing Task synchronization/Communication
Process Work session
Token Entity session
* According to the Workflow Management Coalition.
-id : int
-name : string
ContextAwareSystem
-id : int
Task
-id : int
-socialExpression : SocialExpression
-spaceExpression : SpaceExpression
-taskExpression : TaskExpression
-logicExpression : LogicExpression
-dataExpression : DataExpression
Condition
SystemTask
-system_1 1
-systemTasks_1
*
RouteTask
-condition
1
-routeTask1
-system
1
-routeTasks *
TaskOutputCondition
TaskInputCondition
InitialCondition
-system 1
-initialConditions 1..*
FinalCondition
-system
1
-finalConditions 1..*
PreCondition
-system
1
-preConditions *-precondition1
-systemTask 1
PostCondition
-postCondition_1
1
-systemTask_1
1
-system 1
-postConditions *
Join
-outputCondition
1
-routeTask
1
-inputConditions 1..*
-routeTask
1
Split
-outputConditions*
-inputCondition
1
-routeTask1
-inputCondition
1
-routeTask1
System Tasks
Route Tasks
Prefix ConditionAttribute
Metaclass RegularExpression
Template
[So:] socialExpression SocialInstanceSocialSynchronizationSocialAlternative
WordConcatenationUnion
socialInstancesocialExpr , socialExprsocialExpr + socialExpr
[Ta:] taskExpression TaskPerformanceTaskDependenceTaskAlternativeTaskRepetitionTaskAtLeastOnce
WordConcatenationUnionKleene ClausureKleeneClausure +
socialInstance(task)taskExpr , taskExprtaskExpr + taskExprtaskExpr*taskExpr!
[Sp:] spaceExpression SpaceEventSpacePathSpaceAlternativeSpaceRepetitionSpaceAtLeastOnce
WordConcatenationUnionKleene ClausureKleeneClausure +
socialInstance(event,space)spaceExpr , spaceExprspaceExpr + spaceExprspaceExpr*spaceExpr!
[Lo:] logicExpression LogicExpression - (string)
[Da:] dataExpression DataExpression - socialInst(data),...
The SoMM provides the specification of the relationships among individuals and group of individuals that are part of a CAS.
Based on Subset of Penichet’s Organization Structure Diagram (OSD)
Analysis layer TransformationInformation layer
Introduction CAUCE MDD CAUCE CASE Conclusions
Elements
▪ Individual: represents particular entity instances (a token in the workflow during a work session)
▪ Role: represents the characteristics of a group of entities
Relationships
▪ Initialization: represents the “plays” relationship
▪ Specialization: represents inheritance
-id : int
-name : string
Role
Realization
Specialization-target
1
-parent
0..*
-source1
-children
0..*
-realizes
1
-source
1
-isRealizedByIndividual0..*
-target
1 -name : string
Society
-society 1-individuals 0..*
-society
1
-governedBy
0..*
-society1
-generalizations
0..*
-society
1
-realizations
0..* -id : int
-name : string
SocialInstanceInstance
XSocial model
Task model
Social model
Task model
Expresses task alternatives according to entity roles
X
Social model
Task model
Expresses tasks performed by actors belonging to different roles
Social model
Task model
any timeany time
Expresses task concurrency or parallelism between two or more entities
Social model
Task model
same time
same time
Expresses a synchronization points among entities
Social model
Task model
same time same time
The main goal of SpMM is the expression of location aware characteristics of CAS for UCEs
Basic concepts:Positioning reference (space)
Space granularity (composition / grouping)
Space characteristics (generalization)
Time (regular expressions)
Analysis layer TransformationInformation layer
Introduction CAUCE MDD CAUCE CASE Conclusions
PhysicalSpace
Contention
-parent
1
-innerSpaces
0..*
-child1
-container
0..1
Grouping
-id : int
-name : string
Space
VirtualSpace
-groupedBy 0..*
-child
1
-parent
1-contains
0..*
LocartionUnit
-locationUnit 1
Generalization -generalizedBy
0..*
-generalizes
1
-generalizes
0..*
-parent 1
-id : int
-name : string
Universe
-universe
1
-physicalSpaces0..*
-universe1
-virtualSpaces0..*
-universe
1
-groupRelationships
0..*
-universe
1
-generalizations
0..*
-universe1
-inclusions
0..*
Expresses task execution restrictions according to entity location
XSpace model
Task model
Expresses task execution restrictions according entity location history
Space model
Task model
X
Syntax sugar (abbreviations)
How to represent concepts Initialization Pre-conditions Post-conditions Roles vs. Instances Expression calculus Empty expression interpretations
Extensions (to represent CTT constructors)
Comparison to related work Based on Schmidt characteristics we expose the advantages of
this approach compared to related work
Information Flow model
Referential Space model
Entity Context model
Analysis layer TransformationInformation layer
Introduction CAUCE MDD CAUCE CASE Conclusions
The goal of this layer is the provision of modeling tools for designers to represent the context of an entity from the software perspective.
Two views of the system
Inte
r-en
tity
vie
wIn
tra-entity vie
wessential features
contextualfeatures
communicationfeatures
referentialfeatures
Space ReferenceMetamodel
Information Flow Metamodel
Entity CoreMetamodel
Entity Context Metamodel
Software perspective of a CAS
The goal of the IFMM is the description of the information flows among entities of a CASs for UCEs
Basic conceptsEntities involved in the system
The Information flow data exchange through information flows among entities
The Information flow data definition
How Information is delivered
Analysis layer TransformationInformation layer(Inter-entity view)
Introduction CAUCE MDD CAUCE CASE Conclusions
+incomingFlow(entrada flow : InformationFlow)
-id : int
-name : string
ContextAwareEntity
+flow()
-name : string
-id : int
InformationFlow
Data
InputData
OutputData
BroadcastInformationFlowPointToPointInformationFlow
-data
*
-data 1
-target
1
-incomingInformationFlows
*-source
1
-ongoingInformationFlows
*
-id : int
-name : string
SystemInformationFlow
-system1
-broadcastInformaitonFlows*
-system
1
-pointToPointInformationFlows*
-system
1
-entities*
-flow1
DataDefinition
-definition
1
BinaryOperationDataDefinition
-param1 1
-param2
*
UnaryOperationDataDefinition
-param1
CollectionDataDefinition
-name : string
VaraibleDataDefinition
NotEmptyCollectionDataDefinition
SequenceDataDefinition
AlternativeDataDefinition
TypeDataDefinition ConstantDataDefinition
-name : string
TerminalDataDefinition
Entity
Broadcast information flow
Point to Point information flow
Input data
Output data
Entity
Entity
Entity
Output data
Eve
nt-
dri
ven
Inf.
Exc
han
ge
Po
olin
g
Act
uat
or
The goal of the RSMM is the definition of the runtime environment of the entity contexts in CASs for UCEs
Basic conceptsContext –aware entity (Context-aware entity reference)
Runtime Environment (Referential Space)
Bounding Relationship (Dependence relationship)
Cardinality
Analysis layer TransformationInformation layer(Inter-entity view)
Introduction CAUCE MDD CAUCE CASE Conclusions
An entity reference can be defined by the Send button
A referential space can be defined by the Login interface
Dependency relationships
Cardinality (a Shopping cart is associated to a single user interface)
Cardinality (the Virtual shopping is composed by many user interfaces)
Session modeling
Information Exchange
Information flow model
Referential space model
The goal of the ECMM is the description of the context that an entity is able to perceive from the environment
Basic concepts:Entity context
Context situation
Context Condition
Data Definition
Analysis layer TransformationInformation layer(Intra-entity view)
Introduction CAUCE MDD CAUCE CASE Conclusions
Referential space model
Information flowmodel
-context
1
-entity
1
+matches(entrada flow : InformationFlow)
-name : string
ContextSituation
+satisfies(entrada flow : InformationFlow) : bool
ContextCondition
-situation
1
-conditions*
SensingContextCondition
-expression
ContextMemoryCondition
+flow()
-name : string
-id : int
InformationFlow
+incomingFlow(entrada flow : InformationFlow)
+ongoingFlow(entrada flow : InformationFlow)
-id : int
-name : string
ContextAwareEntity
-source
1
-ongoingInformationFlows
*
-target
1
-incomingInformationFlows
*
+incoming(entrada flow : InformationFlow)
+ongoing(entrada flow : InformationFlow)
EntityContext
-context
1
-situations*
EntityCore
-entity 1-core
1
BroadcastInformationFlow
PointToPointInformationFlow Data
-data
*
-flow1
DataDefinition-definition
1
OutputData
-data
1
-name : string
VaraibleDataDefinition
-variables
*
UnaryOperationDataDefinition -parent
1
-param1-informationFlow 1
+match(entrada expression : string) : bool
+update(entrada expression : string)
-name : string
ContextMemory
DictionaryMemory
-memory
1HolderMemory
-context1
-state*
StackMemory
+execute()
-expression
ContextAction
-situation1
-actions
*
-memory1
-action
1
LogicMemory
TimeMemory
Context-aware sensing Pooling
Explicit Initialization
Implicit Initialization
The underlying infrastructure Detailed description of semantics
Services provided to support these models (such as, time service)
Communication infrastructure
How changes are propagated and assimilated by contexts
Memory behavior description
Memory synchronization
How situations are executed
More patterns
Comparison to related work
The analysis to information layer transformation
The information layer to source code transformation + The mapping model
Analysis layer TransformationInformation layer
Introduction CAUCE MDD CAUCE CASE Conclusions
Main goal:
Social model(SoMM)
Space model(SpMM)
Task model(TaMM)
Information Flow model(IFMM)
Referential Space model(RSMM)
Entity Context model(ECMM)
Multi-model Transformation (ATL)
The transformation is composed by:
5 modules to process:▪ regular expressions
▪ the Social model
▪ the Task model
▪ the Space model
▪ a common interface to access these modules
Containing rules and helper functions
Information Flow model(IFMM)
Referential Space model(RSMM)
Entity Context model(ECMM)
Model to Text Transformation (MOFScript) Mapping model(Mapping MM)
Source Code
Main goal:
The goal of this model is the specification of the mapping between information layer models and the source code to be generated
Basic concepts:•Mapping elements
•Devices•Connections
•Definition elements•Protocols•Mediums•Operating systems•Programming languages
Analysis layer TransformationInformation layer
Introduction CAUCE MDD CAUCE CASE Conclusions
-name : string
-version : string
Medium
-name : string
DevelopmentEnvironment
-type : string
-technology : string
-version : string
Protocol
-name : string
-version : string
-revision : string
-profile : string
ProgrammingLanguage
-name : string
-version : string
-revision : string
OperatingSystem
DevicePlatform
-name : string
Platform
ConnectionPlatform
-name : string
Connection
-name : string
Device
-name : string
Entity
-id : int
Edge
ConnectionToDeviceEdge
DeviceToConnectionEdge
-name : string
Information-environment 1
-mediums *
-environment 1
-protocols *
-environment1
-os
*
-environment1
-programmingLanguages
*
-environment
1
-connections *
-environment
1
-devices*
-environment
1
-edges
*
-device
1-platforms
*
-connection
1
-platforms
*
-informations*
-entities *
-source
1
-ongoing
0..*
-ongoing
*
-source
1
-incoming*
-target1
-target1
-incoming*
-language
1
-os
1
-protocol
1
-medium
1
The same PIM can be defined for several PSMs
Underlying infrastructure(Model semantics)
Conceptual Architecture(Class level)
Abstract Framework(Source code)
GeneratedSource
code
Modelled by
Implemented by
Compiles to
CAUCE CASE ToolStudy cases
Introduction CAUCE MDD CAUCE CASE Conclusions
The CAUCE CASE tool supports the CAUCE model-driven development
Developed using the Eclipse platform (EMF, GMF, etc) Editors: The Social model editor The Space model editor The Task model editor The Information Flow model editor The Entity Context model editor The Referential Space model editor The Mapping model editor
Transformations ATL Model to Model transformation MOFScript Model to Text transformation
Abstract Framework structure
For validation purposes we have defined three scenarios that cover Schmidt CAS characteristics
FeatureScenarios
Light Controller
Healthy Screen
Shared Blackboard
Entity Factors
Information on Entities X
Social environment X
Tasks X
Physical Environment
Physical conditions X
Infrastructure X
Location X
RevisionProposalImplementationContributionsPublicationsFuture Work
Introduction CAUCE MDD CAUCE CASE Conclusions
The context awareness concept
The ubiquitous computing concepts
UML, MDA, EMOF, OCL, ATL, MOFScript
Formal Methods: Petri Nets Workflows Regular Expressions
Related work on Model-driven development of CAS using MOF Model-driven development of CAS using UML profiles Ontology driven development of CAS
Implementation Eclipse platform (EMF, GMF, etc.) Java Technology
The analysis layer to define the characteristics of CAS to be developed, composed by The Task metamodel The Social metamodel The Space metamodel
The information layer to define the software characteristics of the CAS to be developed, composed by: The Information Flow metamodel The Referential Space metamodel The Entity Context metamodel
An analysis to information layer M2M transformation to turn CAS characteristics into software artefacts
An information layer to source code M2T transformation to turn CAS software characteristics into source code The Mapping metamodel to specify the PSM of the system
The underlying infrastructure to describe model behaviour
A conceptual architecture to support the proposed models
An abstract framework to decouple generated code from implementation
To develop CAS for UCE we have implemented the CAUCE CASE Tool: The Space model editor The Task model editor The Social model editor The Information Flow model editor The Entity Context editor The Referential Space editor ATL M2M transformation between analysis and information layer models MOFScript M2M transformation from information layer models to source
code Abstract Conceptual Framework
We have also generated the source code structure for three study cases covering all CAS for UCE characteristics exposed by Schmidt. The light controller The healthy screen The shared blackboard
MDA Implementation of the CAUCE CASE tool
Ubiquitous Computing 3 metamodels and DSLs to describe CAS for UCE characteristics. 3 metamodels and DSLs to describe software characteristics of CAS for UCE
Verification and formal methods The use of semi-formal methods to model high level characteristics (Petri Nets, Workflows
and Regular Expressions)
HCI Description of interaction elements in terms of regular expressions providing a precise syntax
to describe events
Groupware Some of the methods used to describe CAS for UCE may be used to describe Groupware
systems
AI and Agents The ECMM provides designers to model entity contexts in terms of Horn clauses.
About 20 publications
More than 25% of them were published in journals that belong to Q1 and Q2 (JCR 2008).
More that 50 % of them where published in International congresses
A patent “Interaction device to explore geo-referenced documents” (Spain)
Intra-layer inter-model consistency verification
Adaptation to commercial APIs and programming interfaces
Automatic generation of code for system testing
Verification of Petri Nets properties liveness, bounderness, etc (export to Petri Nets files)
Simulators for the task and flow models.
Metamodel extension to provide the proposed operators in the analysis layer
Implementation of the proposed syntax sugar in the analysis layer
PhD. Dissertation
Candidate: Ricardo Tesoriero
Supervisors: PhD. José Antonio Gallud Lázaro PhD. María Dolores Lozano Pérez