1. Ambient-Oriented Dataflow Programming for
Mobile RFID-Enabled Applications
Andoni Lombide Carreton
Promotor: Prof. Dr. Wolfgang De Meuter
Copromotor: Prof. Dr. Theo D’Hondt Vrije Universiteit Brussel
Brussels, Belgium
Private PhD Defense, October 11th 2011, Brussels 1

2. Roadmap
Part I: Mobile RFID-Enabled Applications
Part II: Ambient-Oriented Programming for Mobile RFID-
Enabled Applications
Part III: Node-Centric Ambient-Oriented Dataflow
Programming
Part IV: Network-Centric Ambient-Oriented Dataflow
Programming
Part V: Conclusion
2

3. Part I: Mobile RFID-Enabled Applications
3

4. RFID Technology
0 cm ~ 10 m
0 Kb ~ 32 Kb
0.02$ ~ 0.50$
4

5. Mobile RFID-Enabled Applications
5

6. 6

7. 6

8. 6

9. 7

10. 7

11. 7

12. 7

13. Event-based Decoupling and Inversion of Control
(register-connection-callback
(lambda (tagged-object)
(register-reply-callback
(lambda (reply)
...))
(register-disconnection-callback
(lambda (tagged-object)
...))
...))
8

14. Event-based Decoupling and Inversion of Control
(register-connection-callback
(lambda (tagged-object)
(register-disconnection-callback
(lambda (tagged-object)
...))
(register-reply-callback
(lambda (reply)
...))
...))
8

15. Event-based Decoupling and Inversion of Control
Shared state
?
(register-reply-callback
(lambda (reply)
(set! Shared state ...) ...))
(register-connection-callback
(lambda (tagged-object)
(set! Shared state ...) ...))
(register-disconnection-callback
(lambda (tagged-object)
(set! Shared state ...) ...))
9

16. Event-based Decoupling and Inversion of Control
Shared state
?
(register-reply-callback
(lambda (reply)
(set! Shared state ...) ...))
(register-connection-callback
(lambda (tagged-object)
(set! Shared state ...) ...))
(register-disconnection-callback
(lambda (tagged-object)
(set! Shared state ...) ...))
9

17. Event-based Decoupling and Inversion of Control
Shared state
?
(register-reply-callback
(lambda (reply)
(set! Shared state ...) ...))
(register-connection-callback
(lambda (tagged-object)
(set! Shared state ...) ...))
(register-disconnection-callback
(lambda (tagged-object)
(set! Shared state ...) ...))
9

18. Event-based Decoupling and Inversion of Control
Shared state
? in space
Decoupling
(register-reply-callback
Decoupling in time
(lambda (reply)
(set! Shared state
Decoupling in arity ...) ...))
(register-connection-callback
Rich representation of events
(lambda (tagged-object)
(set! Shared state ...) ...))
No inversion of control
(register-disconnection-callback
(lambda (tagged-object)
Global(set! Shared state ...) ...))
control flow management
9

19. RFID-tagged Things as Objects
book.addReview(“Good book”);
println(book.getReviews());
10

20. RFID-tagged Things as Objects
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
10

21. RFID-tagged Things as Objects
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
10

22. RFID-tagged Things as Objects
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
10

23. RFID-tagged Things as Objects
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
10

24. RFID-tagged Things as Objects
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
10

25. RFID-tagged Things as Objects
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
10

26. Survey of Related Work
Publish/subscribe
systems
Reactive programming
Explicit dataflow
programming
Node-centric sensor-
network programming
Network-centric sensor-
network programming 11

27. Survey of Related Work
Publish/subscribe
systems
Publish/subscribe
Reactive programming +
dataflow programming
Explicit dataflow =
ambient-oriented dataflow
programming
Node-centric sensor-
network programming
Network-centric sensor-
network programming 11

28. Part II: Ambient-Oriented Programming for Mobile
RFID-Enabled Applications
12

29. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

30. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

31. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

32. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

33. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

34. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

35. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

36. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

37. RFID in AmbientTalk
RFID event loop
Hardware Abstraction Layer
13

38. Things: Proxies for Tags
deftype Book;
def aBook := thing: {
def isbn := 123;
def title := “My book”;
def reviews := Vector.new();
RFID event loop
def setTitle(newTitle)@Mutator {
title := newTitle;
};
Hardware Abstraction Layer
def addReview(review)@Mutator {
reviews.add(review);
};
} taggedAs: Book;
14

39. Things: Proxies for Tags
deftype Book;
def aBook := thing: {
def isbn := 123;
def title := “My book”;
def reviews := Vector.new();
RFID event loop
def setTitle(newTitle)@Mutator {
title := newTitle;
};
Hardware Abstraction Layer
def addReview(review)@Mutator {
reviews.add(review);
};
} taggedAs: Book;
14

40. Storing Objects on RFID Tags
tag
aBook
RFID event loop
def aBook := thing: { ... };
Hardware Abstraction Layer
when: BlankTag discovered: { |tag|
when: tag<-initialize(aBook)
becomes: { |bookReference|
// ...
}
}
15

41. Storing Objects on RFID Tags
tag
aBook
RFID event loop
def aBook := thing: { ... };
Hardware Abstraction Layer
when: BlankTag discovered: { |tag|
when: tag<-initialize(aBook)
becomes: { |bookReference|
// ...
}
}
15

42. Storing Objects on RFID Tags
tag
aBook
RFID event loop
def aBook := thing: { ... };
Hardware Abstraction Layer
when: BlankTag discovered: { |tag|
when: tag<-initialize(aBook)
becomes: { |bookReference|
// ...
}
}
15

43. Storing Objects on RFID Tags
tag
aBook
bookRe
ference
RFID event loop
def aBook := thing: { ... };
Hardware Abstraction Layer
when: BlankTag discovered: { |tag|
when: tag<-initialize(aBook)
becomes: { |bookReference|
// ...
}
}
15

44. Reactivity to Appearing and Disappearing Things
RFID event loop
whenever: Book discovered: { |book|
// React on appearance
whenever: book disconnected: { Hardware Abstraction Layer
// React on disappearance
};
whenever: book reconnected: {
// React on reappearance
};
}; 16

45. Reactivity to Appearing and Disappearing Things
RFID event loop
whenever: Book discovered: { |book|
// React on appearance
whenever: book disconnected: { Hardware Abstraction Layer
// React on disappearance
};
whenever: book reconnected: {
// React on reappearance
};
}; 16

46. Reactivity to Appearing and Disappearing Things
RFID event loop
whenever: Book discovered: { |book|
// React on appearance
whenever: book disconnected: { Hardware Abstraction Layer
// React on disappearance
};
whenever: book reconnected: {
// React on reappearance
};
}; 16

47. Reactivity to Appearing and Disappearing Things
RFID event loop
whenever: Book discovered: { |book|
// React on appearance
whenever: book disconnected: { Hardware Abstraction Layer
// React on disappearance
};
whenever: book reconnected: {
// React on reappearance
};
}; 16

48. Asynchronous and Fault-tolerant Communication
with Things
RFID event loop
when: book<-getTitle() Hardware Abstraction Layer
becomes: { |title|
system.println(“TITLE: “ + title)
};
system.println(“Here first!”);
17

49. Asynchronous and Fault-tolerant Communication
with Things
RFID event loop
when: book<-getTitle() Hardware Abstraction Layer
becomes: { |title|
system.println(“TITLE: “ + title)
};
system.println(“Here first!”);
17

50. Asynchronous and Fault-tolerant Communication
with Things
RFID event loop
when: book<-getTitle() Hardware Abstraction Layer
becomes: { |title|
system.println(“TITLE: “ + title)
};
system.println(“Here first!”);
17

51. Asynchronous and Fault-tolerant Communication
with Things
RFID event loop
when: book<-getTitle() Hardware Abstraction Layer
becomes: { |title|
system.println(“TITLE: “ + title)
};
system.println(“Here first!”);
17

52. Asynchronous and Fault-tolerant Communication
with Things
RFID event loop
when: book<-getTitle() Hardware Abstraction Layer
becomes: { |title|
system.println(“TITLE: “ + title)
};
system.println(“Here first!”);
17

53. Asynchronous and Fault-tolerant Communication
with Things
RFID event loop
when: book<-getTitle() Hardware Abstraction Layer
becomes: { |title|
system.println(“TITLE: “ + title)
};
system.println(“Here first!”);
17

54. Asynchronous and Fault-tolerant Communication
with Things
RFID event loop
when: book<-getTitle() Hardware Abstraction Layer
becomes: { |title|
system.println(“TITLE: “ + title)
};
system.println(“Here first!”);
17

55. Benchmarks
18

56. Benchmarks
18

57. Summary
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
19

58. Summary
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
19

59. Part III: Node-Centric Ambient-Oriented Dataflow
Programming
20

60. The Ticket Trader Application
21

61. The Ticket Trader Application
Event Signaling Reacting
New ticket trader Automatic notification by
whenever:discovered:
connected AmbientTalk
Ticket trader Automatic notification by
when:disconnected:
disconnected AmbientTalk
Ticket trader Automatic notification by when:reconnected:
reconnected AmbientTalk
notifyTicketForSale notifyTicketForSale
New ticket for sale
asynchronous message callback
Price of ticket notifyPriceChanged notifyPriceChanged
changed asynchronous message callback
Location of ticket notifyLocationChanged notifyLocationChanged
trader changed asynchronous message callback
Own location GPS abstraction invokes Callback registered on
changed callback with new coordinates GPS abstraction
21

62. Reactive Programming in AmbientTalk/R
GUI.centerOn(GPSLocation.latitude, GPSLocation.longitude);
GPSLocation
H
.latitude .longitude
latitude longitude
H+1
GUI.centerOn(_, _)
22

63. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

64. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

65. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

66. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

67. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

68. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

69. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

70. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

71. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

72. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

73. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

74. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

75. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

76. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

77. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

78. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

79. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

80. Node-Centric Ambient-Oriented Dataflow
Programming
subscribe( )
subscribe( )
publish( )
23

81. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocation := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @Any;
GUI.showLocationOnMap(vendorLocation); 24

82. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocation := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @Any;
GUI.showLocationOnMap(vendorLocation); 24

83. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocation := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @Any;
GUI.showLocationOnMap(vendorLocation); 24

84. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocation := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @Any;
GUI.showLocationOnMap(vendorLocation); 24

85. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocation := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @Any;
GUI.showLocationOnMap(vendorLocation); 24

86. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocations := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @All(3.seconds);
vendorLocations.each: { |loc| GUI.showLocationOnMap(loc) }; 24

87. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocations := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @All(3.seconds);
vendorLocations.each: { |loc| GUI.showLocationOnMap(loc) }; 24

88. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocations := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @All(3.seconds);
vendorLocations.each: { |loc| GUI.showLocationOnMap(loc) }; 24

89. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocations := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @All(3.seconds);
vendorLocations.each: { |loc| GUI.showLocationOnMap(loc) }; 24

90. Ambient Behaviors
deftype TicketVendorLocation;
exportBehavior: GPSLocation as: TicketVendorLocation
to: { |buyer| buyer.interestedIn == “Rock Werchter” };
deftype TicketVendorLocation;
def vendorLocations := ambientBehavior: TicketVendorLocation
where: { def interestedIn := “Rock Werchter” } @All(3.seconds);
vendorLocations.each: { |loc| GUI.showLocationOnMap(loc) }; 24

91. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

92. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

93. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
?? ? deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

94. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
? ? ?
deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

95. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

96. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

97. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

98. Reactive Queries
deftype TicketVendor;
export: ticketVendor as: TicketVendor
with: { def event := “Rock Werchter” };
deftype TicketVendor;
def werchterVendors := ambient: TicketVendor
where: { |vendor| vendor.event == “Rock Werchter” };
def locations := werchterVendors<-getLocation()@Refresh(3.seconds);
locations.each: { |loc| GUI.showLocationOnMap(loc) }; 25

99. Quantitative Evaluation
26

100. Quantitative Evaluation
26

101. Quantitative Evaluation
26

102. Qualitative Evaluation
Event Signaling Reacting
New ticket trader Automatic notification by
whenever:discovered:
connected AmbientTalk
Ticket trader Automatic notification by
when:disconnected:
disconnected AmbientTalk
Ticket trader Automatic notification by when:reconnected:
reconnected AmbientTalk
notifyTicketForSale notifyTicketForSale
New ticket for sale
asynchronous message callback
Price of ticket notifyPriceChanged notifyPriceChanged
changed asynchronous message callback
Location of ticket notifyLocationChanged notifyLocationChanged
trader changed asynchronous message callback
Own location GPS abstraction invokes Callback registered on
changed callback with new coordinates GPS abstraction
27

103. Qualitative Evaluation
27

104. Qualitative Evaluation
27

105. Qualitative Evaluation
27

106. Qualitative Evaluation
27

107. Qualitative Evaluation
27

108. Qualitative Evaluation
def allNearbyOffers := ambientBehavior: TicketOffer @All(_timespan_);
allNearbyOffers.filter: { |offer|
(offer.eventName == event).and: {
(offer.price <= maxPrice).and: {
GPSLocation.distanceTo(offer.location) <= maxDistance }}};
27

109. Case Study: The Book Recommender Application
in the Ambient Library
scanned
recommended
recommended in library
28

110. Case Study: The Book Recommender Application
in the Ambient Library
scanned
recommended
recommended in library
28

111. Part IV: Network-Centric Ambient-Oriented
Dataflow Programming
29

112. Network-Centric Visual Dataflow Programming in
AmbientTalk/R V
scanned
recommended
recommended in library
1 1
30

113. Network-Centric Visual Dataflow Programming in
AmbientTalk/R V
BookScanner ->
deftype Book;
/.bridges.rfid.ReactiveRFIDService.scan(Book);
scanned 1 1
recommended books scannedBooks
recommended in library
1 1
BookRecommender -> EBookReader ->
showBooks(books); 1 recommended 1 scannedBooks.map: { |book|
showSimilarBooks(recommended); generateSimilarBooks(book)
showRecommendationsInStock(recommendedInStock); };
1 1
recommendedInStock similarBooks
1 *
Shelf ->
deftype Book;
def booksInstock := /.bridges.rfid.ReactiveRFIDService.scan(Book);
similarBooks.filter: { |book| booksInStock.contains(book) }; 30

114. Deploying an AmbientTalk/RV Dataflow Program
def BookRecommenderApp := extend: OperatorHostInterface with: {
def showBooks(books) { ... };
def showSimilarBooks(books) { ... };
def showRecommendationsInStock(books) { ... };
};
deftype BookRecommender;
export: BookRecommenderApp as: BookRecommender;
AmbientTalk/R VM
JVM
BookRecommender ->
showBooks(books);
showSimilarBooks(recommended);
showRecommendationsInStock(recommendedInStock);
31

115. Dataflow Dependencies
BookScanner ->
deftype Book;
/.bridges.rfid.ReactiveRFIDService.scan(Book);
Fixed dataflow 1
dependency books
1
BookRecommender -> EBookReader ->
showBooks(books); scannedBooks.map: { |book|
showSimilarBooks(recommended); generateSimilarBooks(book)
showRecommendationsInStock(recommendedInStock); };
1
Rebinding dataflow similarBooks
dependency *
Shelf ->
deftype Book;
def booksInstock := /.bridges.rfid.ReactiveRFIDService.scan(Book);
similarBooks.filter: { |book| booksInStock.contains(book) }; 32

116. Dependency Arities
BookRecommender -> EBookReader ->
showBooks(books); scannedBooks.map: { |book|
showSimilarBooks(recommended); generateSimilarBooks(book)
showRecommendationsInStock(recommendedInStock); };
1 1
recommendedInStock similarBooks
1 *
Shelf ->
deftype Book;
def booksInstock := /.bridges.rfid.ReactiveRFIDService.scan(Book);
similarBooks.filter: { |book| booksInStock.contains(book) };
33

117. Dependency Arities
BookRecommender -> EBookReader ->
showBooks(books); scannedBooks.map: { |book|
showSimilarBooks(recommended); generateSimilarBooks(book)
showRecommendationsInStock(recommendedInStock); };
1 1
recommendedInStock similarBooks
* *
Shelf ->
deftype Book;
def booksInstock := /.bridges.rfid.ReactiveRFIDService.scan(Book);
similarBooks.filter: { |book| booksInStock.contains(book) };
33

118. Dependency Semantics
Incoming 1 Incoming *
Signal one value to a Signal one value to all
Outgoing 1 single (rebound or fixed) reachable nodes of same
node role
Signal set of values to a Signal set of values to all
Outgoing * single (rebound or fixed) reachable nodes of same
node role
Binding semantics Arity semantics
34

119. Part V: Conclusion
35

120. Limitations and Avenues for Future Research
• Event-loop based architecture prevents RFID events to be processed in
parallel.
• Security was not considered. For RFID it requires revising the technology
stack down to the hardware level.
• No distributed glitch prevention. It requires consistent distributed message
ordering.
• AmbientTalk/RV needs more tooling (e.g. visual scalability, syntax for content-
based subscriptions...).
36

121. Summarizing the Contributions
1. Addressing physical objects
2. Storing application-specific data on RFID tags
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
37

122. Summarizing the Contributions
1. Addressing physical objects
Ambient-Oriented Programming
2. Storing application-specific data on RFID tags
with Passive RFID
3. Reactivity to appearing and disappearing objects
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
37

123. Summarizing the Contributions
1. Addressing physical objects
Ambient-Oriented Programming
Decoupling in space
2. Storing application-specific data on RFID tags
with Passive RFID
Decoupling in time
3. Reactivity to appearing and disappearing objects
Decoupling in arity
4. Asynchronous, fault-tolerant communication
5. Data consistency
6. Infrastructureless operation
37

124. Summarizing the Contributions
1. Addressing physical objects
Ambient-Oriented Programming
Decoupling in space
2. Storing application-specific data on RFID tags
with Passive RFID
Decoupling in time
3. Reactivity to appearing and disappearing objects
Decoupling in arity
4. Asynchronous, fault-tolerant communication
5. Data consistency
No inversion of control
6. Infrastructureless operation
37

125. Summarizing the Contributions
1. Addressing physical objects
Ambient-Oriented Programming
Decoupling in space
2. Storing application-specific data on RFID tags
with Passive RFID
Decoupling in time
Publish/subscribe
3. Reactivity to appearing and disappearing objects
+ Decoupling in arity
4. Asynchronous, fault-tolerant communication
dataflow programming
=
5. Data consistency
ambient-oriented inversion of control
No dataflow
6. Infrastructureless operation
37

126. Summarizing the Contributions
1. Addressing physical objects
Ambient-Oriented Programming
Decoupling in space
2. Storing application-specific data on RFID tags
Decoupling in time
with Passive RFID
3. Reactivity to appearing and disappearing objects
Decoupling in arity
4. Asynchronous, fault-tolerant communication
Rich representation of events
5. Data consistency
No inversion of control
6. Infrastructureless operation
37

127. Summarizing the Contributions
1. Addressing physical objects
Ambient-Oriented Programming
Decoupling in space
2. Storing application-specific data on RFID tags
Decoupling in time
with Passive RFID
3. Reactivity to appearing and disappearing objects
Decoupling in arity
4. Asynchronous, fault-tolerant communication
Rich representation of events
5. Data consistency
No inversion of control
6. Infrastructureless operation
Global control flow management
37

128. Summarizing the Contributions
1. Addressing physical objects
Ambient-Oriented Programming
Decoupling in space
2. Storing application-specific data on RFID tags
Decoupling in time
with Passive RFID
3. Reactivity to appearing and disappearing objects
Decoupling in arity
4. Asynchronous, fault-tolerant communication
Rich representation of events
5. Data consistency
No inversion of control
6. Infrastructureless operation
Global control flow management
37

129. Why Ambient-Oriented Language Abstractions?
38

130. Why Ambient-Oriented Language Abstractions?
39

131. Why Ambient-Oriented Language Abstractions?
40

132. Why Ambient-Oriented Language Abstractions?
41