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 Tasks can be performed by IoT
  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         \pause{}
  96         Internalship
  97 \end{frame}
  98
  99 \begin{frame}
 100         \frametitle{Problems overcome}
 101         \begin{itemize}[<+->]
 102                 \item Way to express IoT Tasks
 103                 \item Write client software
 104                 \item Write server software
 105                 \item Connect them up
 106         \end{itemize}
 107 \end{frame}
 108
 109 \subsection{iTasks}
 110 \begin{frame}[fragile]
 111         \frametitle{Task Oriented Programming}
 112         \framesubtitle{\ldots and iTasks}
 113         \begin{block}{iTasks}
 114                 \begin{itemize}[<+->]
 115                         \item Basic blocks
 116                         \item Generated web interface
 117                         \item Type driven
 118                 \end{itemize}
 119         \end{block}
 120         \pause{}
 121         \begin{columns}[c]
 122                 \column{.49\linewidth}
 123                         \begin{block}{Tasks}
 124                                 \begin{itemize}[<+->]
 125                                         \item Observables
 126                                         \item Given the state, a \CI{TaskValue} is observed.
 127                                         \item Continuous execution
 128                                         \item Generics
 129                                 \end{itemize}
 130                         \end{block}
 131                 \pause{}
 132                 \column{.49\linewidth}
 133                         \begin{figure}[ht]
 134                                 \centering
 135                                 \includegraphics[width=\linewidth]{fig-taskvalue}
 136                                 \caption{The states of a \CI{TaskValue}}
 137                         \end{figure}
 138         \end{columns}
 139 \end{frame}
 140
 141 \begin{frame}[fragile]
 142         \frametitle{Task Oriented Programming}
 143         \framesubtitle{Example}
 144         \begin{lstlisting}
 145 :: Name = { firstname :: String, lastname :: String }
 146 derive class iTask Name
 147
 148 enterInformation :: String [EnterOption m] -> Task m | iTask m
 149 enterName :: Task Name
 150 enterName = enterInformation "Enter your name" []
 151         \end{lstlisting}
 152
 153         \begin{figure}[H]
 154                 \centering
 155                 \begin{subfigure}{.30\textwidth}
 156                         \centering
 157                         \includegraphics[width=.9\linewidth]{taskex1}
 158                         \caption{Initial interface\\~}\label{fig:taskex1}
 159                 \end{subfigure}
 160                 \begin{subfigure}{.30\textwidth}
 161                         \centering
 162                         \includegraphics[width=.9\linewidth]{taskex2}
 163                         \caption{Incomplete entrance}\label{fig:taskex2}
 164                 \end{subfigure}
 165                 \begin{subfigure}{.30\textwidth}
 166                         \centering
 167                         \includegraphics[width=.9\linewidth]{taskex3}
 168                         \caption{Complete entry\\~}\label{fig:taskex3}
 169                 \end{subfigure}
 170                 \caption{Example of a generated user interface}
 171         \end{figure}
 172 \end{frame}
 173
 174 \begin{frame}[fragile]
 175         \frametitle{Task Oriented Programming (3)}
 176         \framesubtitle{Combinators}
 177         \begin{block}{Sequence}
 178                 \begin{lstlisting}
 179 (>>=)  infixl 1 :: (Task a) (a -> Task b)         -> Task b | iTask a & iTask b
 180 (>>*)  infixl 1 :: (Task a) [TaskCont a (Task b)] -> Task b | iTask a & iTask b
 181 :: TaskCont a b
 182         =     OnValue             ((TaskValue a)  -> Maybe b)
 183         |     OnAction    Action  ((TaskValue a)  -> Maybe b)
 184         | E.e: OnException         (e              -> b)         & iTask e
 185         |     OnAllExceptions     (String         -> b)
 186 :: Action = Action String
 187                 \end{lstlisting}
 188         \end{block}
 189
 190         \begin{block}{Parallel}
 191                 \begin{lstlisting}
 192 (-||-) infixr 3 :: (Task a) (Task a) -> Task a     | iTask a
 193 ( ||-) infixr 3 :: (Task a) (Task b) -> Task b     | iTask a & iTask b
 194 (-|| ) infixl 3 :: (Task a) (Task b) -> Task a     | iTask a & iTask b
 195 (-&&-) infixr 4 :: (Task a) (Task b) -> Task (a,b) | iTask a & iTask b
 196                 \end{lstlisting}
 197         \end{block}
 198 \end{frame}
 199
 200 \begin{frame}[fragile]
 201         \frametitle{Shared Data Sources (SDS)}
 202         \begin{block}{What is an SDS}
 203                 \begin{itemize}[<+->]
 204                         \item Read function
 205                         \item Write function
 206                 \end{itemize}
 207         \end{block}
 208
 209         \begin{lstlisting}
 210 :: RWShared p r w = ...
 211 :: ReadWriteShared r w :== RWShared () r w
 212 :: Shared r :== ReadWriteShared r r
 213
 214 get ::          (ReadWriteShared r w)           -> Task r | iTask r
 215 set :: w        (ReadWriteShared r w)           -> Task w | iTask w
 216 upd :: (r -> w) (ReadWriteShared r w)           -> Task w | iTask r & iTask w
 217
 218 sharedStore :: String a -> Shared a | JSONEncode{|*|}, JSONDecode{|*|}
 219
 220 wait :: String (r -> Bool) (ReadWriteShared r w) -> Task r
 221         \end{lstlisting}
 222 \end{frame}
 223
 224 \begin{frame}[fragile]
 225         \frametitle{SDS (2)}
 226         \framesubtitle{Parametric Lenses}
 227         \begin{block}{What is the \CI{p} for in \CI{RWShared p r w}}
 228                 \pause{}
 229                 \begin{itemize}
 230                         \item Parameter fixed when writing
 231                         \item Used for notifications
 232                 \end{itemize}
 233         \end{block}
 234
 235         \begin{lstlisting}
 236 sdsFocus :: p1 (RWShared p1 r w) -> RWShared p2 r w | iTask p
 237
 238 :: SDSNotifyPred p :== p -> Bool
 239 :: SDSLensRead p r rs     = SDSRead        (p -> rs -> MaybeError TaskException r)
 240                           | SDSReadConst   (p -> r)
 241 :: SDSLensWrite p w rs ws = SDSWrite       (p -> rs -> w -> MaybeError TaskException (Maybe ws))
 242                           | SDSWriteConst  (p -> w -> MaybeError TaskException (Maybe ws))
 243 :: SDSLensNotify p w rs   = SDSNotify      (p -> rs -> w -> SDSNotifyPred p)
 244                           | SDSNotifyConst (p -> w -> SDSNotifyPred p)
 245
 246 sdsLens :: String (p -> ps) (SDSLensRead p r rs) (SDSLensWrite p w rs ws)
 247         (SDSLensNotify p w rs) (RWShared ps rs ws) -> RWShared p r w | iTask ps
 248         \end{lstlisting}
 249 \end{frame}
 250
 251 \begin{frame}
 252         \frametitle{Why add IoT devices to iTasks}
 253         \begin{block}{Why?}
 254                 \begin{itemize}
 255                         \item Execute Tasks
 256                         \item Monitoring
 257                         \item Hardware
 258                 \end{itemize}
 259         \end{block}
 260
 261         \pause{}
 262
 263         \begin{block}{Current possibilities}
 264                 \begin{itemize}
 265                         \item Implement a device as an SDS
 266                         \pause{}
 267                         \item Tailor made SDS for every task
 268                         \item Difficult to get logic in
 269                         \pause{}
 270                         \item Arjan's Distributed iTasks
 271                         \pause{}
 272                         \item Requires fast hardware
 273                         \pause{}
 274                 \end{itemize}
 275         \end{block}
 276 \end{frame}
 277
 278 \begin{frame}
 279         \frametitle{Solution}
 280         \pause{}
 281         \begin{block}{EDSL to the rescue}
 282                 \pause{}
 283                 After the break.
 284         \end{block}
 285 \end{frame}