pres.intro.tex

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