pres.intro.tex

   1 \subsection{IoT}
   2 \begin{frame}
   3         \frametitle{Internet of Things (IoT)}
   4         \begin{itemize}[<+->]
   5                 \item Early days, RFID
   6                 \item Devices: Arduino, ESP8266, Raspberry pi\ldots
   7                 \item Peripherals: GPS, Sensors, Actuators\ldots
   8                 \item Wearables: Smart clothing, smart watches\ldots
   9                 \item Connectivity: LoRa (Sigfox, KPN, TTN), BTLE, WiFi, ZigBee\ldots
  10                 \item \ldots
  11         \end{itemize}
  12 \end{frame}
  13
  14 \subsection{iTasks}
  15 \begin{frame}[fragile]
  16         \frametitle{Task Oriented Programming}
  17         \framesubtitle{\ldots and iTasks}
  18         \begin{block}{iTasks}
  19                 \begin{itemize}[<+->]
  20                         \item Basic blocks
  21                         \item Generated web interface
  22                         \item Type driven
  23                 \end{itemize}
  24         \end{block}
  25         \pause{}
  26         \begin{columns}[c]
  27                 \column{.49\linewidth}
  28                         \begin{block}{Tasks}
  29                                 \begin{itemize}[<+->]
  30                                         \item Observables
  31                                         \item Given the state, a \CI{TaskValue} is observed.
  32                                         \item Continuous execution
  33                                         \item Generics
  34                                 \end{itemize}
  35                         \end{block}
  36                 \pause{}
  37                 \column{.49\linewidth}
  38                         \begin{figure}[ht]
  39                                 \centering
  40                                 \includegraphics[width=\linewidth]{fig-taskvalue}
  41                                 \caption{The states of a \CI{TaskValue}}
  42                         \end{figure}
  43         \end{columns}
  44 \end{frame}
  45
  46 \begin{frame}[fragile]
  47         \frametitle{Task Oriented Programming}
  48         \framesubtitle{Example}
  49         \begin{lstlisting}
  50 :: Name = { firstname :: String, lastname :: String }
  51 derive class iTask Name
  52
  53 enterInformation :: String [EnterOption m] -> Task m | iTask m
  54 enterName :: Task Name
  55 enterName = enterInformation "Enter your name" []
  56         \end{lstlisting}
  57
  58         \begin{figure}[H]
  59                 \centering
  60                 \begin{subfigure}{.30\textwidth}
  61                         \centering
  62                         \includegraphics[width=.9\linewidth]{taskex1}
  63                         \caption{Initial interface\\~}\label{fig:taskex1}
  64                 \end{subfigure}
  65                 \begin{subfigure}{.30\textwidth}
  66                         \centering
  67                         \includegraphics[width=.9\linewidth]{taskex2}
  68                         \caption{Incomplete entrance}\label{fig:taskex2}
  69                 \end{subfigure}
  70                 \begin{subfigure}{.30\textwidth}
  71                         \centering
  72                         \includegraphics[width=.9\linewidth]{taskex3}
  73                         \caption{Complete entry\\~}\label{fig:taskex3}
  74                 \end{subfigure}
  75                 \caption{Example of a generated user interface}
  76         \end{figure}
  77 \end{frame}
  78
  79 \begin{frame}[fragile]
  80         \frametitle{Task Oriented Programming (3)}
  81         \framesubtitle{Combinators}
  82         \begin{block}{Sequence}
  83                 \begin{lstlisting}
  84 (>>=)  infixl 1 :: (Task a) (a -> Task b)         -> Task b | iTask a & iTask b
  85 (>>*)  infixl 1 :: (Task a) [TaskCont a (Task b)] -> Task b | iTask a & iTask b
  86 :: TaskCont a b
  87         =     OnValue             ((TaskValue a)  -> Maybe b)
  88         |     OnAction    Action  ((TaskValue a)  -> Maybe b)
  89         | E.e: OnException         (e              -> b)         & iTask e
  90         |     OnAllExceptions     (String         -> b)
  91 :: Action = Action String
  92                 \end{lstlisting}
  93         \end{block}
  94
  95         \begin{block}{Parallel}
  96                 \begin{lstlisting}
  97 (-||-) infixr 3 :: (Task a) (Task a) -> Task a     | iTask a
  98 ( ||-) infixr 3 :: (Task a) (Task b) -> Task b     | iTask a & iTask b
  99 (-|| ) infixl 3 :: (Task a) (Task b) -> Task a     | iTask a & iTask b
 100 (-&&-) infixr 4 :: (Task a) (Task b) -> Task (a,b) | iTask a & iTask b
 101                 \end{lstlisting}
 102         \end{block}
 103 \end{frame}
 104
 105 \begin{frame}[fragile]
 106         \frametitle{Shared Data Sources (SDS)}
 107         \begin{block}{What is an SDS}
 108                 \begin{itemize}[<+->]
 109                         \item Read function
 110                         \item Write function
 111                 \end{itemize}
 112         \end{block}
 113
 114         \begin{lstlisting}
 115 :: RWShared p r w = ...
 116 :: ReadWriteShared r w :== RWShared () r w
 117 :: Shared r :== ReadWriteShared r r
 118
 119 get ::          (ReadWriteShared r w)           -> Task r | iTask r
 120 set :: w        (ReadWriteShared r w)           -> Task w | iTask w
 121 upd :: (r -> w) (ReadWriteShared r w)           -> Task w | iTask r & iTask w
 122
 123 sharedStore :: String a -> Shared a | JSONEncode{|*|}, JSONDecode{|*|}
 124
 125 wait :: String (r -> Bool) (ReadWriteShared r w) -> Task r
 126         \end{lstlisting}
 127 \end{frame}
 128
 129 \begin{frame}[fragile]
 130         \frametitle{SDS (2)}
 131         \framesubtitle{Parametric Lenses}
 132         \begin{block}{What is the \CI{p} for in \CI{RWShared p r w}}
 133                 \pause{}
 134                 \begin{itemize}
 135                         \item Parameter fixed when writing
 136                         \item Used for notifications
 137                 \end{itemize}
 138         \end{block}
 139
 140         \begin{lstlisting}
 141 sdsFocus :: p1 (RWShared p1 r w) -> RWShared p2 r w | iTask p
 142
 143 :: SDSNotifyPred p :== p -> Bool
 144 :: SDSLensRead p r rs     = SDSRead        (p -> rs -> MaybeError TaskException r)
 145                           | SDSReadConst   (p -> r)
 146 :: SDSLensWrite p w rs ws = SDSWrite       (p -> rs -> w -> MaybeError TaskException (Maybe ws))
 147                           | SDSWriteConst  (p -> w -> MaybeError TaskException (Maybe ws))
 148 :: SDSLensNotify p w rs   = SDSNotify      (p -> rs -> w -> SDSNotifyPred p)
 149                           | SDSNotifyConst (p -> w -> SDSNotifyPred p)
 150
 151 sdsLens :: String (p -> ps) (SDSLensRead p r rs) (SDSLensWrite p w rs ws)
 152         (SDSLensNotify p w rs) (RWShared ps rs ws) -> RWShared p r w | iTask ps
 153         \end{lstlisting}
 154 \end{frame}
 155
 156 \begin{frame}
 157         \frametitle{Why add IoT devices to iTasks}
 158         \begin{block}{Why?}
 159                 \begin{itemize}
 160                         \item Execute Tasks
 161                         \item Monitoring
 162                         \item Hardware
 163                 \end{itemize}
 164         \end{block}
 165
 166         \pause{}
 167
 168         \begin{block}{Current possibilities}
 169                 \begin{itemize}
 170                         \item Implement a device as an SDS
 171                         \pause{}
 172                         \item Tailor made SDS for every task
 173                         \item Difficult to get logic in
 174                         \pause{}
 175                         \item Arjan's Distributed iTasks
 176                         \pause{}
 177                         \item Requires fast hardware
 178                         \pause{}
 179                 \end{itemize}
 180         \end{block}
 181 \end{frame}
 182
 183 \begin{frame}
 184         \frametitle{Solution}
 185         \pause{}
 186         \begin{block}{EDSL to the rescue}
 187                 \pause{}
 188                 After the break.
 189         \end{block}
 190 \end{frame}