Language Abstractions and Techniques for Developing Collective Adaptive Systems Using Context-oriented Programming

Nicolás Cardozo - Ivana Dusparic
@ncardoz - @ivanadusparic
n.cardozo@uniandes.edu.co - ivana.dusparic@scss.tcd.ie
Language abstractions and Techniques for
Developing Collective Adaptive Systems
Using Context-oriented Programming
2020
August 21
st
, 2020 (online)

Collective adaptive systems
2
Adaptive
Interactive
Autonomous adaptation to changes in the
surrounding execution environment to satisfy
performance and quality attributes of the system
Manage interaction between system entities to
ensure the emergence of desired behavior

… How do you engineer such systems?
1. How to introduce behavior adaptations?
2. How to make adaptive behavior modular?
3. How to plug adaptations whenever they are required?
4. How to execute adaptations appropriately to the environment?
5. How to manage interaction between adaptations?

4
Building a CAS
City transport systems characterize by the interaction
between its different individual systems (bus routes)
consisting of:
• Buses
• Stations
• Traveling passengers
• Traffic conditions
Roads Stations Buses

5
Building a CAS
We want to build a transport management system that adapts to
the situations that arise from the system execution
Alerts raised upon identified problems in the system functioning
RoadBlocked FullStation FullBus

5
Building a CAS
We want to build a transport management system that adapts to
the situations that arise from the system execution
Alerts raised upon identified problems in the system functioning
Dynamically change
the system behavior
for a more
appropriate one
foo() { … }
bar() { … }
Context-oriented programming
RoadBlocked FullStation FullBus

6
TranCity
Stations Buses
Enable passengers to enter
to wait for a bus in their
desired route.
Move between stations in a
specified route. At stations
passengers get off, letting new
passengers on the bus
Station = Trait({
id: id,
name: name,
open: true,
capacity: 120,
load: 0.0,
passengers: []
addPassenger: function(p) {
this.passengers.push(p);
this.setLoad();
},
})
Bus = Trait({
id: id,
route: “R4”,
capacity: 56,
load: 0,
currentNode: “S1”,
passengers: []
moveBus: function() {
//add and remove passengers
//move to the next station
},
})
Regular JS
objects

6
TranCity
Stations Buses
execution
loop
Enable passengers to enter
to wait for a bus in their
desired route.
Move between stations in a
specified route. At stations
passengers get off, letting new
passengers on the bus
Station = Trait({
id: id,
name: name,
open: true,
capacity: 120,
load: 0.0,
passengers: []
addPassenger: function(p) {
this.passengers.push(p);
this.setLoad();
},
})
Bus = Trait({
id: id,
route: “R4”,
capacity: 56,
load: 0,
currentNode: “S1”,
passengers: []
//add and remove passengers
//move to the next station
},
})
Regular JS
objects

7
Alerts and expected behavior
Full Station
Full Bus
Close the station
Divert passengers to near stations in
their route
Don’t allow passengers on the bus
Send additional bus to route of the full
bus
!
Road blocked
Split the route at the blockage point,
serve each road segment independently
(as a new route). Divert passengers
across the blocked point
!
!

1. Introduce adaptive behavior?
2. Make adaptive behavior modular?

9
Object to adapt
Full Station
Full Bus
!
Road blocked!
!
[Gonzalez et al. Context-traits MODULARITY’13]

9
Object to adapt
FullBus = cop.Context({
name = “Full bus”
})Full Station
Full Bus
!
Road blocked!
!

9
Object to adapt
})Full Station
Full Bus
!
Road blocked!
!
FullBusBehavior = Trait({
nextBusStation: function() {
filter(passengers, p =>
p.destination() != this.currentNode);
this.route.depot.sendBus(
this.currentNode);
}
})

9
Object to adapt
})Full Station
Full Bus
!
Road blocked!
!
this.currentNode);
}
})
FullBus.adapt(bus, FullBusBehavior)

9
Object to adapt
})Full Station
Full Bus
!
Road blocked!
!
this.currentNode);
}
})
Regular JS
objects

10
Object to adapt
})
filter(this.passengers, p =>
this.currentNode);
}
})
Independent objects
introduced “on-the-fly”
Minimum connection between
application and adaptation

3. Plug adaptations whenever
they are required?

12
Realization concerns
FullBus.adapt( * , FullBusBehavior );
bus
<<object instance>>
Adaptations applicable
to a single object
Bus
<<class>>
to all objects specified
by a given class
check()
<<function>>
to a given function
Fine grained adaptation enable global or localized modification of entities’
behavior

13
FullBus.adapt(Bus, FullBusBehavior)
RoadBlocked.adapt(Bus, BrokenBusBehavior)
BrokenBusBehavior = Trait({
callTowCar();
proceed();
}
})
Adaptations
are
composable by
definition

13
FullBus.adapt(Bus, FullBusBehavior)
RoadBlocked.adapt(Bus, BrokenBusBehavior)
callTowCar();
proceed();
}
})
Reuse behavior
of other
available
adaptation
Adaptations
are
composable by
definition

14
callTowCar();
proceed();
}
})
this.currentNode);
}
})

14
callTowCar();
proceed();
}
})
this.currentNode);
}
})
FullBus.activate(); RoadBlocked.activate()
behave like FullBus, then like
RoadBlocked

14
callTowCar();
proceed();
}
})
this.currentNode);
}
})
RoadBlocked.activate(); FullBus.activate()
RoadBlocked
behave like RoadBlocked,
then like FullBus

14
callTowCar();
proceed();
}
})
this.currentNode);
}
})
cop.manager.addObjectPolicy(Bus, [BrokenBusBehavior, FullBusBehavior])
RoadBlocked.activate(); FullBus.activate()
RoadBlocked
behave like RoadBlocked,
then like FullBus
always use
BrokenBusBehavior
before
FullBusBehavior

4. Appropriateness of adaptations?

16
Temporal concerns
function checkCapacity(bus) {
if(bus.load >= 0.7)
FullBus.activate();
else
FullBus.deactivate();
}
Context
discovery
world
sensors/monitors
enacting
adaptations
execution
loop
Bus = Trait({
nextBusStation();
},
nextBusStation() { … }
})

16
Temporal concerns
function checkCapacity(bus) {
if(bus.load >= 0.7)
FullBus.activate();
else
FullBus.deactivate();
}
Context
discovery
world
sensors/monitors
enacting
adaptations
execution
loop
Bus = Trait({
nextBusStation();
},
nextBusStation() { … }
})
…
}
})

5. Managing interaction between
adaptations?

18
Interaction concerns
EDPr(ED)
Pr(¬ED)
req(ED) act(ED)
deac(ED)
req(¬ED)
FBPr(FB) Pr(¬FB)
req(FB)
act(FB)
deac(FB)
req(¬FB)
[Fandiño de la Hoz et al. Distributed Context Petri Nets. COP’19]
FullBus
Empty Depot
Node 2
Node 1
Context dependency relations define interaction between (unknown)
adaptations across nodes

18
EDPr(ED)
Pr(¬ED)
req(ED) act(ED)
deac(ED)
req(¬ED)
FBPr(FB) Pr(¬FB)
req(FB)
act(FB)
deac(FB)
req(¬FB)
[Fandiño de la Hoz et al. Distributed Context Petri Nets. COP’19]
FullBus
Empty Depot
Node 2
Node 1
Context dependency relations define interaction between (unknown)
adaptations across nodes
context dependency relations
encoded as Petri net
interaction

19
[Cardozo and Dusparic. Learning Run-time Composition of Interacting Adaptations. SEAMS’20]
FullStationBehavior = Trait({
closeStation: function() {
sendBus();
}
})
sendBus();
}
})
DepotEmptyBehavior = Trait({
recallBus: function() {
…
}
})
Based on interaction, learn when adaptations should be composed or
execute individually to best suit the requirements from the environment
? ?
?
Learn
relationships
using RL

20
[Cardozo and Dusparic. Learning Run-time Composition of Interacting Adaptations. SEAMS’20]
FullStationBehavior = Trait({
closeStation: function() {
sendBus();
}
})
sendBus();
}
})
DepotEmptyBehavior = Trait({
recallBus: function() {
…
}
})
Based on interaction, learn when adaptations should be composed or
execute individually to best suit the requirements from the environment
compatible compose conflicting individually
conflicting individually

21
Conclusion
Context-oriented programming (COP) is effective in
realizing Collective Adaptive Systems (CAS)

21
Conclusion
‣ COP posits ﬁrst-class modular entities to represent contexts and behavioral
adaptations

21
Conclusion
adaptations
‣ Adaptations are introduced dynamically through software composition

21
Conclusion
adaptations
‣ Adaptations take place reactively and promptly to changes in the environment

21
Conclusion
adaptations
‣ Adaptations take place reactively and promptly to changes in the environment
‣ Adaptations are managed through deﬁned dependency relations realized
dynamically, or learned from interactions

Nicolás Cardozo - Ivana Dusparic
@ncardoz - @ivanadusparic
n.cardozo@uniandes.edu.co - ivana.dusparic@scss.tcd.ie
Thanks for watching!
Language abstractions and Techniques for
Developing Collective Adaptive Systems Using
Context-oriented Programming
2020
August 21
st
, 2020 (online)

Language Abstractions and Techniques for Developing Collective Adaptive Systems Using Context-oriented Programming

More Related Content

More from Universidad de los Andes (18)

Recently uploaded (20)

Language Abstractions and Techniques for Developing Collective Adaptive Systems Using Context-oriented Programming