pres.intro.tex

   1 \subsection{IoT}
   2 \begin{frame}
   3         \frametitle{What is Internet of Things (IoT)}
   4         \begin{block}{History}
   5                 \begin{itemize} \item 1999: \pause{} RFID
   6                         \item Device to device communication
   7                         \pause{}
   8                         \item ESP8266
   9                         \item Estimated 30 billion in 2020
  10                 \end{itemize}
  11         \end{block}
  12         \pause{}
  13         \begin{block}{Tasks performed by IoT}
  14                 \begin{itemize}
  15                         \item Monitoring (Temperature, Electricity, Humidity, Heartbeat)
  16                         \item Acting (Servo's, Motors)
  17                         \item Tracking (GPS, WiFi tracking)
  18                         \item Relaying (SMS, Whatsapp)
  19                         \pause{}
  20                         \item Combinations: e.g. Thermostat
  21                         \item Smart clothing, smart watches
  22                 \end{itemize}
  23         \end{block}
  24 \end{frame}
  25
  26 \begin{frame}
  27         \frametitle{Problems with IoT}
  28         \begin{itemize}
  29                 \item Device $\rightarrow$ Server $\rightarrow$ Application
  30                 \pause{}
  31                 \item Myriads of devices: Arduino, ESP8266, Raspberry pi\ldots
  32                 \pause{}
  33                 \item Tons of languages: C++, Lua, C, python\ldots
  34                 \pause{}
  35                 \item Heaps of communication methods: LoRa (Sigfox, KPN, TTN), BTLE, WiFi, ZigBee\ldots
  36                 \pause{}
  37                 \item But\ldots
  38                 \pause{}
  39                 \item Separated logic
  40                 \item Integration problems
  41                 \item Reprogramming, write cycles
  42         \end{itemize}
  43 \end{frame}
  44
  45 \begin{frame}
  46         \frametitle{And there is TOP/iTasks}
  47         \begin{block}{iTasks}
  48                 \begin{itemize}[<+->]
  49                         \item Basic blocks
  50                         \item Generated web interface
  51                         \item Type driven
  52                         \item EDSL
  53                 \end{itemize}
  54         \end{block}
  55         \pause{}
  56         \begin{block}{Tasks}
  57                 \begin{itemize}[<+->]
  58                         \item Filling in forms
  59                         \item Looking at data (Monitoring, Maps)
  60                         \item Act on data changes
  61                 \end{itemize}
  62         \end{block}
  63 \end{frame}
  64
  65 \begin{frame}
  66         \frametitle{IoT and TOP}
  67         \begin{block}{Overlap}
  68                 \begin{itemize}[<+->]
  69                         \item Tasks often involve humans
  70                         \item Possibly far away
  71                 \end{itemize}
  72         \end{block}
  73         \pause{}
  74         \begin{block}{But how to integrate}
  75                 \begin{itemize}[<+->]
  76                         \item Distributed iTasks
  77                         \item SDS
  78                         \item Swat two flies at once
  79                 \end{itemize}
  80         \end{block}
  81 \end{frame}
  82
  83 \begin{frame}
  84         \frametitle{Solution}
  85         \begin{itemize}[<+->]
  86                 \item Add IoT to iTasks
  87                 \item Solve the integration problem
  88                 \item Extend the reach of iTasks
  89                 \item iTasks server
  90                 \item IoT device client
  91                 \item EDSL to make IoT tasks
  92                 \item Interpreted on the client
  93                 \item No reprogramming
  94         \end{itemize}
  95 \end{frame}
  96
  97 \begin{frame}
  98         \frametitle{Problems overcome}
  99         \begin{itemize}[<+->]
 100                 \item Way to express IoT Tasks
 101                 \item Write client software
 102                 \item Write server software
 103                 \item Connect them up
 104         \end{itemize}
 105 \end{frame}
 106
 107 \subsection{iTasks}
 108 \begin{frame}[fragile]
 109         \frametitle{Task Oriented Programming}
 110         \framesubtitle{\ldots and iTasks}
 111         \begin{block}{iTasks}
 112                 \begin{itemize}[<+->]
 113                         \item Basic blocks
 114                         \item Generated web interface
 115                         \item Type driven
 116                 \end{itemize}
 117         \end{block}
 118         \pause{}
 119         \begin{columns}[c]
 120                 \column{.49\linewidth}
 121                         \begin{block}{Tasks}
 122                                 \begin{itemize}[<+->]
 123                                         \item Observables
 124                                         \item Given the state, a \CI{TaskValue} is observed.
 125                                         \item Continuous execution
 126                                         \item Generics
 127                                 \end{itemize}
 128                         \end{block}
 129                 \pause{}
 130                 \column{.49\linewidth}
 131                         \begin{figure}[ht]
 132                                 \centering
 133                                 \includegraphics[width=\linewidth]{fig-taskvalue}
 134                                 \caption{The states of a \CI{TaskValue}}
 135                         \end{figure}
 136         \end{columns}
 137 \end{frame}
 138
 139 \begin{frame}[fragile]
 140         \frametitle{Task Oriented Programming}
 141         \framesubtitle{Example}
 142         \begin{lstlisting}
 143 :: Name = { firstname :: String, lastname :: String }
 144 derive class iTask Name
 145
 146 enterInformation :: String [EnterOption m] -> Task m | iTask m
 147 enterName :: Task Name
 148 enterName = enterInformation "Enter your name" []
 149         \end{lstlisting}
 150
 151         \begin{figure}[H]
 152                 \centering
 153                 \begin{subfigure}{.30\textwidth}
 154                         \centering
 155                         \includegraphics[width=.9\linewidth]{taskex1}
 156                         \caption{Initial interface\\~}\label{fig:taskex1}
 157                 \end{subfigure}
 158                 \begin{subfigure}{.30\textwidth}
 159                         \centering
 160                         \includegraphics[width=.9\linewidth]{taskex2}
 161                         \caption{Incomplete entrance}\label{fig:taskex2}
 162                 \end{subfigure}
 163                 \begin{subfigure}{.30\textwidth}
 164                         \centering
 165                         \includegraphics[width=.9\linewidth]{taskex3}
 166                         \caption{Complete entry\\~}\label{fig:taskex3}
 167                 \end{subfigure}
 168                 \caption{Example of a generated user interface}
 169         \end{figure}
 170 \end{frame}
 171
 172 \begin{frame}[fragile]
 173         \frametitle{Task Oriented Programming (3)}
 174         \framesubtitle{Combinators}
 175         \begin{block}{Sequence}
 176                 \begin{lstlisting}
 177 (>>=)  infixl 1 :: (Task a) (a -> Task b)         -> Task b | iTask a & iTask b
 178 (>>*)  infixl 1 :: (Task a) [TaskCont a (Task b)] -> Task b | iTask a & iTask b
 179 :: TaskCont a b
 180         =     OnValue             ((TaskValue a)  -> Maybe b)
 181         |     OnAction    Action  ((TaskValue a)  -> Maybe b)
 182         | E.e: OnException         (e              -> b)         & iTask e
 183         |     OnAllExceptions     (String         -> b)
 184 :: Action = Action String
 185                 \end{lstlisting}
 186         \end{block}
 187
 188         \begin{block}{Parallel}
 189                 \begin{lstlisting}
 190 (-||-) infixr 3 :: (Task a) (Task a) -> Task a     | iTask a
 191 ( ||-) infixr 3 :: (Task a) (Task b) -> Task b     | iTask a & iTask b
 192 (-|| ) infixl 3 :: (Task a) (Task b) -> Task a     | iTask a & iTask b
 193 (-&&-) infixr 4 :: (Task a) (Task b) -> Task (a,b) | iTask a & iTask b
 194                 \end{lstlisting}
 195         \end{block}
 196 \end{frame}
 197
 198 \begin{frame}[fragile]
 199         \frametitle{Shared Data Sources (SDS)}
 200         \begin{block}{What is an SDS}
 201                 \begin{itemize}[<+->]
 202                         \item Read function
 203                         \item Write function
 204                 \end{itemize}
 205         \end{block}
 206
 207         \begin{lstlisting}
 208 :: RWShared p r w = ...
 209 :: ReadWriteShared r w :== RWShared () r w
 210 :: Shared r :== ReadWriteShared r r
 211
 212 get ::          (ReadWriteShared r w)           -> Task r | iTask r
 213 set :: w        (ReadWriteShared r w)           -> Task w | iTask w
 214 upd :: (r -> w) (ReadWriteShared r w)           -> Task w | iTask r & iTask w
 215
 216 sharedStore :: String a -> Shared a | JSONEncode{|*|}, JSONDecode{|*|}
 217
 218 wait :: String (r -> Bool) (ReadWriteShared r w) -> Task r
 219         \end{lstlisting}
 220 \end{frame}
 221
 222 \begin{frame}[fragile]
 223         \frametitle{SDS (2)}
 224         \framesubtitle{Parametric Lenses}
 225         \begin{block}{What is the \CI{p} for in \CI{RWShared p r w}}
 226                 \pause{}
 227                 \begin{itemize}
 228                         \item Parameter fixed when writing
 229                         \item Used for notifications
 230                 \end{itemize}
 231         \end{block}
 232
 233         \begin{lstlisting}
 234 sdsFocus :: p1 (RWShared p1 r w) -> RWShared p2 r w | iTask p
 235
 236 :: SDSNotifyPred p :== p -> Bool
 237 :: SDSLensRead p r rs     = SDSRead        (p -> rs -> MaybeError TaskException r)
 238                           | SDSReadConst   (p -> r)
 239 :: SDSLensWrite p w rs ws = SDSWrite       (p -> rs -> w -> MaybeError TaskException (Maybe ws))
 240                           | SDSWriteConst  (p -> w -> MaybeError TaskException (Maybe ws))
 241 :: SDSLensNotify p w rs   = SDSNotify      (p -> rs -> w -> SDSNotifyPred p)
 242                           | SDSNotifyConst (p -> w -> SDSNotifyPred p)
 243
 244 sdsLens :: String (p -> ps) (SDSLensRead p r rs) (SDSLensWrite p w rs ws)
 245         (SDSLensNotify p w rs) (RWShared ps rs ws) -> RWShared p r w | iTask ps
 246         \end{lstlisting}
 247 \end{frame}
 248
 249 \begin{frame}
 250         \frametitle{Why add IoT devices to iTasks}
 251         \begin{block}{Why?}
 252                 \begin{itemize}
 253                         \item Execute Tasks
 254                         \item Monitoring
 255                         \item Hardware
 256                 \end{itemize}
 257         \end{block}
 258
 259         \pause{}
 260
 261         \begin{block}{Current possibilities}
 262                 \begin{itemize}
 263                         \item Implement a device as an SDS
 264                         \pause{}
 265                         \item Tailor made SDS for every task
 266                         \item Difficult to get logic in
 267                         \pause{}
 268                         \item Arjan's Distributed iTasks
 269                         \pause{}
 270                         \item Requires fast hardware
 271                         \pause{}
 272                 \end{itemize}
 273         \end{block}
 274 \end{frame}
 275
 276 \begin{frame}
 277         \frametitle{Solution}
 278         \pause{}
 279         \begin{block}{EDSL to the rescue}
 280                 \pause{}
 281                 After the break.
 282         \end{block}
 283 \end{frame}