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 Communication (SMS, Whatsapp)
  19                         \pause{}
  20                         \item Combinations: e.g. Thermostat, Smart Clothing, Smart Watches
  21                 \end{itemize}
  22         \end{block}
  23 \end{frame}
  24
  25 \begin{frame}
  26         \frametitle{Problems with IoT}
  27         \begin{itemize}
  28                 \item Device $\rightarrow$ Server $\rightarrow$ Application
  29                 \pause{}
  30                 \item Myriads of devices: Arduino, ESP8266, Raspberry pi\ldots
  31                 \pause{}
  32                 \item Tons of languages: C++, Lua, C, python\ldots
  33                 \pause{}
  34                 \item Heaps of communication methods: LoRa (Sigfox, KPN, TTN), BTLE, WiFi, ZigBee\ldots
  35                 \pause{}
  36                 \item Separated logic
  37                 \item Integration problems
  38         \end{itemize}
  39 \end{frame}
  40
  41 \begin{frame}
  42         \frametitle{And there is TOP/iTasks}
  43         \begin{block}{iTasks}
  44                 \begin{itemize}[<+->]
  45                         \item Tasks are basic blocks
  46                         \item Generated web interface
  47                         \item Type driven
  48                         \item EDSL
  49                 \end{itemize}
  50         \end{block}
  51         \pause{}
  52         \begin{block}{Tasks}
  53                 \begin{itemize}[<+->]
  54                         \item Filling in forms
  55                         \item Looking at data (Monitoring, Maps)
  56                         \item Act on data changes
  57                 \end{itemize}
  58         \end{block}
  59 \end{frame}
  60
  61 \begin{frame}
  62         \frametitle{IoT and TOP}
  63         \begin{block}{Overlap}
  64                 \begin{itemize}[<+->]
  65                         \item Tasks often involve humans
  66                         \item Tasks can be performed by IoT
  67                 \end{itemize}
  68         \end{block}
  69         \pause{}
  70         \begin{block}{But how to integrate}
  71                 \begin{itemize}[<+->]
  72                         \item Distributed iTasks
  73                         \item SDS
  74                         \item Swat two flies at once
  75                 \end{itemize}
  76         \end{block}
  77 \end{frame}
  78
  79 \begin{frame}
  80         \frametitle{Solution}
  81         \begin{itemize}[<+->]
  82                 \item Add IoT to iTasks
  83                 \item Solve the integration problem
  84                 \item Extend the reach of iTasks
  85                 \item iTasks server
  86                 \item IoT device client
  87                 \item EDSL to make IoT tasks
  88                 \item Internalship
  89         \end{itemize}
  90 \end{frame}
  91
  92 \begin{frame}
  93         \frametitle{Problems overcome}
  94         \begin{itemize}[<+->]
  95                 \item Way to express IoT Tasks
  96                 \item Write client software
  97                 \item Write server software
  98                 \item Connect them up
  99                 \item But first some theory
 100                 \item Reprogramming, write cycles
 101         \end{itemize}
 102 \end{frame}
 103
 104 \subsection{iTasks}
 105 \begin{frame}[fragile]
 106         \frametitle{Task Oriented Programming}
 107         \framesubtitle{\ldots and iTasks}
 108         \begin{block}{iTasks}
 109                 \begin{itemize}[<+->]
 110                         \item Basic blocks
 111                         \item Generated web interface
 112                         \item Type driven
 113                 \end{itemize}
 114         \end{block}
 115         \pause{}
 116         \begin{columns}[c]
 117                 \column{.49\linewidth}
 118                         \begin{block}{Tasks}
 119                                 \begin{itemize}[<+->]
 120                                         \item Observables
 121                                         \item Given the state, a \CI{TaskValue} is observed.
 122                                         \item Continuous execution
 123                                         \item Generics
 124                                 \end{itemize}
 125                         \end{block}
 126                 \pause{}
 127                 \column{.49\linewidth}
 128                         \begin{figure}[ht]
 129                                 \centering
 130                                 \includegraphics[width=\linewidth]{fig-taskvalue}
 131                                 \caption{The states of a \CI{TaskValue}}
 132                         \end{figure}
 133         \end{columns}
 134 \end{frame}
 135
 136 \begin{frame}[fragile]
 137         \frametitle{Task Oriented Programming}
 138         \framesubtitle{Example}
 139         \begin{lstlisting}[language=Clean]
 140 :: Name = { firstname :: String, lastname :: String }
 141 derive class iTask Name
 142
 143 enterInformation :: String [EnterOption m] -> Task m | iTask m
 144 enterName :: Task Name
 145 enterName = enterInformation "Enter your name" []
 146         \end{lstlisting}
 147
 148         \begin{figure}[H]
 149                 \centering
 150                 \begin{subfigure}{.30\textwidth}
 151                         \centering
 152                         \includegraphics[width=.9\linewidth]{taskex1}
 153                         \caption{Initial interface\\~}\label{fig:taskex1}
 154                 \end{subfigure}
 155                 \begin{subfigure}{.30\textwidth}
 156                         \centering
 157                         \includegraphics[width=.9\linewidth]{taskex2}
 158                         \caption{Incomplete entrance}\label{fig:taskex2}
 159                 \end{subfigure}
 160                 \begin{subfigure}{.30\textwidth}
 161                         \centering
 162                         \includegraphics[width=.9\linewidth]{taskex3}
 163                         \caption{Complete entry\\~}\label{fig:taskex3}
 164                 \end{subfigure}
 165                 \caption{Example of a generated user interface}
 166         \end{figure}
 167 \end{frame}
 168
 169 \begin{frame}[fragile]
 170         \frametitle{Task Oriented Programming (3)}
 171         \framesubtitle{Combinators}
 172         \begin{block}{Sequence}
 173                 \begin{lstlisting}[language=Clean]
 174 (>>=)  infixl 1 :: (Task a) (a -> Task b)         -> Task b | iTask a & iTask b
 175 (>>*)  infixl 1 :: (Task a) [TaskCont a (Task b)] -> Task b | iTask a & iTask b
 176 :: TaskCont a b
 177         =     OnValue             ((TaskValue a)  -> Maybe b)
 178         |     OnAction    Action  ((TaskValue a)  -> Maybe b)
 179         | E.e: OnException         (e              -> b)         & iTask e
 180         |     OnAllExceptions     (String         -> b)
 181 :: Action = Action String
 182                 \end{lstlisting}
 183         \end{block}
 184
 185         \begin{block}{Parallel}
 186                 \begin{lstlisting}[language=Clean]
 187 (-||-) infixr 3 :: (Task a) (Task a) -> Task a     | iTask a
 188 ( ||-) infixr 3 :: (Task a) (Task b) -> Task b     | iTask a & iTask b
 189 (-|| ) infixl 3 :: (Task a) (Task b) -> Task a     | iTask a & iTask b
 190 (-&&-) infixr 4 :: (Task a) (Task b) -> Task (a,b) | iTask a & iTask b
 191                 \end{lstlisting}
 192         \end{block}
 193 \end{frame}
 194
 195 \begin{frame}[fragile]
 196         \frametitle{Shared Data Sources (SDS)}
 197         \begin{block}{What is an SDS}
 198                 \begin{itemize}[<+->]
 199                         \item Read function
 200                         \item Write function
 201                         \item Both have access to the world
 202                 \end{itemize}
 203         \end{block}
 204
 205         \begin{lstlisting}[language=Clean]
 206 :: RWShared p r w = ...
 207 :: ReadWriteShared r w :== RWShared () r w
 208 :: Shared r :== ReadWriteShared r r
 209
 210 get ::          (ReadWriteShared r w)           -> Task r | iTask r
 211 set :: w        (ReadWriteShared r w)           -> Task w | iTask w
 212 upd :: (r -> w) (ReadWriteShared r w)           -> Task w | iTask r & iTask w
 213
 214 sharedStore :: String a -> Shared a | JSONEncode{|*|}, JSONDecode{|*|}
 215
 216 wait :: String (r -> Bool) (ReadWriteShared r w) -> Task r
 217         \end{lstlisting}
 218 \end{frame}
 219
 220 \begin{frame}
 221         \frametitle{But not all Tasks or SDSs are suitable for microcontrollers\ldots}
 222         \pause\centering\Large EDSLs to the rescue
 223 \end{frame}