\Citet{tratt_domain_2008} applies a notion from metaprogramming \citep{sheard_accomplishments_2001} to \glspl{EDSL} to define homogeneity and heterogeneity of \glspl{EDSL} as follows:
\begin{quote}
- \emph{A homogeneous system is one where all the components are specifically designed to work with each other, whereas in heterogeneous systems at least one of the components is largely, or completely, ignorant of the existence of the other parts of the system.
-}
+ \emph{A homogeneous system is one where all the components are specifically designed to work with each other, whereas in heterogeneous systems at least one of the components is largely, or completely, ignorant of the existence of the other parts of the system.}
\end{quote}
Homogeneous \glspl{EDSL} are languages that are solely defined as an extension to their host language.
The \gls{UOD} is explicitly and separately modelled by the data types and relations that exist in the functions of the host language.
\end{description}
-\Cref{fig:tosd} differs from the presented \gls{IOT} architecture shown in \cref{fig:iot-layers} because they represent different concepts.
+\Cref{fig:tosd} differs from the presented \gls{IOT} architecture shown in \cref{fig:iot-layers} because it represents different concepts.
The \gls{IOT} architecture is an execution architecture whereas \gls{TOSD} is a software development model.
E.g.\ from a software development perspective, a task is a task, whether it is executed on a microcontroller, a server, or a client.
Only when a task is executed, the location of the execution becomes important, but this is taken care of by the system.
The individual components in the miniature systems, the tasks, the \glspl{SDS}, are, in the eventual execution, connected to the main system.
\subsection{The iTask system}
-The concept of \gls{TOP} originated from the \gls{ITASK} framework, a declarative language and \gls{TOP} engine for defining interactive multi-user distributed web applications.
-The \gls{ITASK} system is implemented as an \gls{EDSL} in the programming language \gls{CLEAN}\footnote{\Cref{chp:clean_for_haskell_programmers} contains a guide for \gls{CLEAN} tailored to \gls{HASKELL} programmers.} \citep{plasmeijer_itasks:_2007,plasmeijer_task-oriented_2012}.
-It is under development for over fifteen years and has proven itself through use in industry for some time now as well.
+The concept of \gls{TOP} originated from the \gls{ITASK} framework, a declarative \gls{TOP} language for defining interactive distributed web applications.
+The \gls{ITASK} system is implemented as an \gls{EDSL} in the programming language \gls{CLEAN} \citep{plasmeijer_itasks:_2007,plasmeijer_task-oriented_2012}\footnote{\Cref{chp:clean_for_haskell_programmers} contains a guide for \gls{CLEAN} tailored to \gls{HASKELL} programmers.}.
+It is under development for over fifteen years and has proven itself through use in industry as well.
For example, it is the main language of VIIA, an advanced application for monitoring coasts \citep{top_software_viia_2023}.
-From the structural properties of the data types and the current status of the work to be done, the entire \gls{UI} is automatically generated.
Browsers are powering \gls{ITASK}'s presentation layer.
-The framework is built on top of standard web techniques such as JavaScript, HTML, and {CSS}.
The browser runs the actual \gls{ITASK} code using an interpreter that operates on \gls{CLEAN}'s intermediate language \gls{ABC} \citep{staps_lazy_2019}.
+It is built on top of standard web techniques such as JavaScript, HTML, and {CSS}.
+From the structural properties of the data types and the current status of the work to be done, the \gls{UI} and all interaction is automatically generated.
Tasks in \gls{ITASK} have either \emph{no value}, an \emph{unstable} or a \emph{stable} task value.
For example, an editor for filling in a form initially has no value.
-Once the user entered a complete value, its value becomes an unstable value, it can still be changed or even reverted to no value by emptying the editor again.
+Once the user enters a complete value, its value becomes an unstable value.
+It can still be changed or even reverted to no value by emptying the editor again.
Only when for example a continue button is pressed, a task value becomes stable, fixing its value.
The allowed task value transitions are shown in \cref{fig:taskvalue}.
-\begin{figure}
+\begin{figure}[p]
\centering
\includestandalone{taskvalue}
\caption{Transition diagram for task values in \gls{ITASK}.}%
As an example, \cref{lst:todo,fig:todo} show the code and \gls{UI} for an interactive to-do list application.
The user modifies a shared to-do list through an editor directly or using some predefined actions.
Furthermore, in parallel, the length of the list is shown to demonstrate \glspl{SDS}.
-Using \gls{ITASK}, complex collaborations of users and tasks can be described on a high level.
-%In this way, the \gls{ITASK} system is a tierless system taking care of both the presentation and application layer (see \cref{fig:iot}) by running the same code in the browser as on the server and generating all interoperation.
-
-From the data type definitions (\cref{lst:todo_dt}), using generic programming (\cref{lst:todo_derive}), the \glspl{UI} for the data types are automatically generated.
-Then, using the parallel task combinator (\cleaninline{-\|\|}) the task for updating the to-dos (\cref{lst:todo_update}) and the task for viewing the length are combined (\cref{lst:todo_length}, shown as \emph{Length: 2} in the bottom of the image).
-This particular parallel combinator uses the result of the left-hand side task.
-Both tasks operate on the to-do \gls{SDS} (\cref{lst:todo_sds}).
-The task for updating the to-do list is an editor (\cref{lst:todo_editor}) combined using a step combinator (\crefrange{lst:todo_contfro}{lst:todo_contto}).
-The actions either change the value, sorting or clearing it, or terminate the task by returning the current value of the \gls{SDS}, visualised as three buttons on the bottom right of the \gls{UI}.
-Special combinators (e.g.\ \cleaninline{@>>} at \cref{lst:todo_ui}) are used to tweak the \gls{UI} to display informative labels.
+Using \gls{ITASK}, complex collaborations of users and tasks are described on a high level.
+In this way, the \gls{ITASK} system is a tierless system taking care of both the presentation and application layer (see \cref{fig:iot-layers}).
-\cleaninputlisting[float=,firstline=6,lastline=22,tabsize=3,numbers=left,caption={The code for a shared to-do list in \gls{ITASK}.},label={lst:todo}]{lst/sharedlist.icl}
+\cleaninputlisting[float=p,firstline=6,lastline=22,tabsize=3,numbers=left,caption={The code for a shared to-do list in \gls{ITASK}.},label={lst:todo}]{lst/sharedlist.icl}
-\begin{figure}
+\begin{figure}[p]
\centering
\includegraphics[width=.8\linewidth]{todo0g}
\caption{The \gls{UI} for the shared to-do list in \gls{ITASK}.}%
\label{fig:todo}
\end{figure}
+From the data type definitions (\cref{lst:todo_dt}), using generic programming (\cref{lst:todo_derive}), the \glspl{UI} for the data types are automatically generated.
+Then, using the parallel task combinator (\cleaninline{-\|\|}) the task for updating the to-dos (\cref{lst:todo_update}) and the task for viewing the length are combined (\cref{lst:todo_length}, shown as \emph{Length: 2} in the bottom of the figure).
+This particular parallel combinator uses the result of the left-hand side task.
+Both tasks operate on the to-do \gls{SDS} (\cref{lst:todo_sds}).
+The task for updating the to-do list is an editor (\cref{lst:todo_editor}) combined using a step combinator (\crefrange{lst:todo_contfro}{lst:todo_contto}).
+The actions either change the value, sorting or clearing it, or terminate the task by returning the current value of the \gls{SDS}, visualised as three buttons on the bottom right of the \gls{UI}.
+Special combinators (e.g.\ \cleaninline{@>>} at \cref{lst:todo_ui}) are used to tweak the \gls{UI} and display informative labels.
+
\subsection{The mTask system}
The work for \gls{IOT} edge devices can often be succinctly described by \gls{TOP} programs.
Software on microcontrollers is usually composed of smaller basic tasks, are interactive, and share data with other components or the server.
This function on \crefrange{lst:intro:blink_fro}{lst:intro:blink_to} first reads the interval \gls{SDS}, waits the specified delay, writes the state to the \gls{GPIO} pin, and calls itself recursively using the inverse of the state in order to run continuously.
The \cleaninline{>>\|.} operator denotes the sequencing of tasks in \gls{MTASK}.
-\cleaninputlisting[float={!ht},linerange={24-,26-34},firstnumber=11,numbers=left,caption={The \gls{MTASK} code for the interactive blinking application.},label={lst:intro_blink_mtask}]{lst/blink.icl} %chktex 8
+\cleaninputlisting[linerange={24-,26-34},firstnumber=11,numbers=left,caption={The \gls{MTASK} code for the interactive blinking application.},label={lst:intro_blink_mtask}]{lst/blink.icl} %chktex 8
\subsection{Other TOP languages}
While \gls{ITASK} conceived \gls{TOP}, it is no longer the only \gls{TOP} system.
The paper was published at the \ifl{} 2022 in Kopenhagen, Denmark.
\end{enumerate}
-%\paragraph{In preparation}
-%Furthermore, there are some papers either in preparation or under review describing methods for creating \glspl{DSL}.
-%They describe techniques found while developing the \gls{MTASK} \gls{DSL} that have not made it (yet) into the system.
-%Hence, they are not part of the dissertation.
-%
-%\begin{itemize}
-% \item \emph{Strongly-Typed Multi-\kern-2ptView Stack-\kern-1.25ptBased Computations} shows how to create type-safe \glspl{EDSL} representing stack-based computations.
-% Instead of encoding the arguments to a function as arguments in the host language, stack-based approaches use a run time stack that contains the arguments.
-% By encoding the required contents of the stack in the types, such systems can be made type safe.
-%
-% \item \emph{Template Metaprogramming using Two-Stage Generic Functions} shows how a sufficiently rich generic programming system can achieve much of the same functionality as template metaprogramming.
-% The generic programming functionality of \gls{Clean} is built into the compiler.
-% As a result, metadata of the generic types is added to the generic structure.
-% From this metadata, we can destill not only type and constructor names but also arities, fixity, kinds, types, \etc{}.
-% This allows us, by
-%\end{itemize}
-
\paragraph{Contribution:}
The papers are written by me, there were weekly meetings with co-authors in which we discussed and refined the ideas.
shows how a simple imperative variant of \gls{MTASK} was integrated with \gls{ITASK}.
While the language differs a lot from the current version, the integration mechanism is still used.
The paper was published at the \ifl{} 2018 in Lowell, MA, {USA}.
-% \paragraph{Contribution}
-% The research in this paper and writing the paper was performed by me, though there were weekly meetings with Pieter Koopman and Rinus Plasmeijer in which we discussed and refined the ideas.
\item \emph{Multitasking on Microcontrollers using Task Oriented Programming} \citep*{lubbers_multitasking_2019}\footnote{This work acknowledges the support of the \erasmusplus{} project ``Focusing Education on Composability, Comprehensibility and Correctness of Working Software'', no.\ 2017--1--SK01--KA203--035402.}
is a short paper on the multitasking capabilities of \gls{MTASK} comparing it to traditional multitasking methods for \gls{ARDUINO}.
The paper was published at the \fcows{} 2019 in Opatija, Croatia.
-% \paragraph{Contribution}
-% The research in this paper and writing the paper was performed by me, though there were weekly meetings with Pieter Koopman and Rinus Plasmeijer.
\item \emph{Simulation of a Task-\kern-1.25ptBased Embedded Domain Specific Language for the Internet of Things} \citep*{koopman_simulation_2023}\footnotemark[\value{footnote}]
are the revised lecture notes for a course on the \gls{MTASK} simulator provided at the 2018 \gls{3COWS} winter school in Ko\v{s}ice, Slovakia, January 22--26, 2018.
-% \paragraph{Contribution}
-% Pieter Koopman wrote and taught it, I helped with the software and research.
\item \emph{Writing Internet of Things Applications with Task Oriented Programming} \citep*{lubbers_writing_2023}\footnotemark[\value{footnote}]
are the revised lecture notes from a course on programming \gls{IOT} systems using \gls{MTASK} provided at the 2019 \gls{3COWS} summer school in Budapest, Hungary, June 17--21, 2019.
-% \paragraph{Contribution}
-% Pieter Koopman prepared and taught half of the lecture and supervised the practical session.
-% I taught the other half of the lecture, wrote the lecture notes, made the assignments and supervised the practical session.
\item \emph{Interpreting Task Oriented Programs on Tiny Computers} \citep*{lubbers_interpreting_2019}
shows an implementation of the byte code compiler and \gls{RTS} of \gls{MTASK}.
The paper was published at the \ifl{} 2019 in Singapore.
-% \paragraph{Contribution}
-% The research in this paper and writing the paper was performed by me, though there were weekly meetings with Pieter Koopman and Rinus Plasmeijer.
\item \emph{Reducing the Power Consumption of IoT with Task-Oriented Programming} \citep*{crooijmans_reducing_2022}
shows how to create a scheduler so that devices running \gls{MTASK} tasks can go to sleep more automatically and how interrupts are incorporated in the language.
The paper was published at the \tfp{} 2022 in Krakow, Poland (moved to online).
-% \paragraph{Contribution}
-% The research was carried out by \citet{crooijmans_reducing_2021} during his Master's thesis.
-% I did the daily supervision and helped with the research, Pieter Koopman was the formal supervisor and wrote most of the paper.
\item \emph{Green Computing for the Internet of Things} \citep*{lubbers_green_2022}\footnote{This work acknowledges the support of the \erasmusplus{} project ``SusTrainable---Promoting Sustainability as a Fundamental Driver in Software Development Training and Education'', no.\ 2020--1--PT01--KA203--078646.}
are the revised lecture notes from a course on sustainable \gls{IOT} programming with \gls{MTASK} provided at the 2022 SusTrainable summer school in Rijeka, Croatia, July 4--8, 2022.
-
-% \paragraph{Contribution}
-% These revised lecture notes are from a course on sustainable programming using \gls{MTASK} provided at the 2022 SusTrainable summer school in Rijeka, Croatia.
-% Pieter prepared and taught a quarter of the lecture and supervised the practical session.
-% I prepared and taught the other three quarters of the lecture, made the assignments and supervised the practical session
\end{enumerate}
\paragraph{Contribution:}
\end{figure}
\section{Compiler}\label{sec:compiler_imp}
-The byte code compiler for \gls{MTASK} is designed to generate code that runs on resource-constrained edge devices.
-There is no heap avaliable for expressions, only for tasks
-\todo[inline]{Zou je hier niet een prargraafje schrijven over dat dit een beetje speciale compiler is. Alle type checks worden al door Clean gedaan. Dat is voordat deze compiler ooit uitgevoerd gaat worden. Bovendien kan het Clean programma de te compileren byte code dynamisch maken. Dat staat natuurlijk al eerder een keer, maar je make niet aannemen dat iedereen alles leest (en nu nog weet)}
-\todo[inline]{Dit gaat wel hard de diepte in. Zou je niet een kort stukje schrijven over hoe je bytecode machine er uit ziet?
+%The byte code compiler for \gls{MTASK} is an interpretation of the \gls{MTASK} language.
+%In order to compile terms, instances for all \gls{MTASK} type classes are required for the \cleaninline{:: BCInterpret a} type.
+%Terms in \gls{MTASK} are constructed and compiled at run time but type checked at compile time in the host language \gls{CLEAN}.
+%The compiled tasks are sent to the device for interpretation, a detailed overview of the execution process is found in \cref{sec:compiler_rts}.
+%The result of compilation is the byte code, and some metadata regarding the used peripherals and \glspl{SDS}.
+%Interpreting the byte code only uses the stack, hence, all data types are unboxed.
+%
+%The heap is only used to store the task trees that
+%
+%The byte code is interpreted by the interpreter
+%In order to make it work on resource-constrained microcontrollers, some properties of the language are strictly enforced.
+%is designed to generate code that runs on resource-constrained edge devices.
+%There is no heap avaliable for expressions, only for tasks
+\todo[inline]{Zou je hier niet een prargraafje schrijven over dat dit een beetje speciale compiler is. Alle type checks worden al door Clean gedaan. Dat is voordat deze compiler ooit uitgevoerd gaat worden. Bovendien kan het Clean programma de te compileren byte code dynamisch maken. Dat staat natuurlijk al eerder een keer, maar je make niet aannemen dat iedereen alles leest (en nu nog weet)
+Dit gaat wel hard de diepte in. Zou je niet een kort stukje schrijven over hoe je bytecode machine er uit ziet?
Heap: voor de huidige task tree die herschreven wordt.
Function code: sequence of bytecode instructie.
SDSs + Objects
Om de code te maken heb je een intsantie van alle classen in mTask nodig voor BCInterpret a.
Voor veel lezers zou het genoeg zijn om alleen dat te snappen, maak het ze eenvoudig.}
+
\subsection{Compiler infrastructure}
The byte code compiler interpretation for the \gls{MTASK} language is implemented as a monad stack containing a writer monad and a state monad.
The writer monad is used to generate code snippets locally without having to store them in the monadic values.
The context contains arguments from functions and steps that need to be preserved after rewriting.
The evaluated context is combined with the left-hand side task value by means of a \cleaninline{.&&.} combinator to store it in the task tree so that it is available after a rewrite step.
This means that the task tree is transformed as seen in \cref{lst:context_tree}.
-In this figure, the expression \cleaninline{t1 >>=. \v1->t2 >>=. \v2->...} is shown\footnote{%
- \cleaninline{t >>=. e} is a shorthand combinator for \cleaninline{t >>* [OnStable (\_->true) e].}}.
+In this figure, the expression \cleaninline{t1 >>=. \\v1->t2 >>=. \\v2->...} is shown\footnote{%
+ \cleaninline{t >>=. e} is a shorthand combinator for \cleaninline{t >>* [OnStable (\\_->true) e].}}.
Then, the right-hand side list of continuations is converted to an expression using $\mathcal{S}$.
\begin{figure}
Rewriting always starts at the top of the tree and traverses to the leaves, the basic tasks that do the actual work.
The first basic task encountered is the \cleaninline{delay} task, that yields no value until the time, \qty{500}{\ms} in this case, has passed.
When the \cleaninline{delay} task yielded a stable value after a number of rewrites, the task continues with the right-hand side of the \cleaninline{>>\|.} combinator by evaluating the expression (see \cref{fig:blink_tree2})\footnotemark.
-\footnotetext{\cleaninline{t1 >>\|. t2} is a shorthand for \cleaninline{t1 >>*. [IfStable id \_->t2]}.}
+\footnotetext{\cleaninline{t1 >>\|. t2} is a shorthand for \cleaninline{t1 >>*. [IfStable id \\_->t2]}.}
This combinator has a \cleaninline{writeD} task at the left-hand side that becomes stable after one rewrite step in which it writes the value to the given pin.
When \cleaninline{writeD} becomes stable, the written value is the task value that is observed by the right-hand side of the \cleaninline{>>=.} combinator.
-This will call the interpreter to evaluate the expression, now that the argument of the function is known.
+Then the interpreter is used again to evaluate the expression, now that the argument of the function is known.
The result of the call to the function is again a task tree, but now with different arguments to the tasks, e.g.\ the state in \cleaninline{writeD} is inversed.
\begin{figure}
\caption{Task tree after the delay passed}%
\label{fig:blink_tree2}
\end{subfigure}
- \caption{The task trees for a blink task in \cref{lst:blink_code} in \gls{MTASK}.}%
+ \caption{The task trees during reduction for a blink task in \gls{MTASK}.}%
\label{fig:blink_tree}
\end{figure}
\subsection{Client}
The \gls{RTS} of the \gls{MTASK} system runs on resource-constrained microcontrollers and is implemented in portable \ccpp{}.
In order to achieve more interoperation safety, the communication between the server and the client is automated, i.e.\ the serialisation and deserialisation code in the \gls{RTS} is generated.
-\todo[inline]{Dit naar voren halen naar 7.4.0?}
The technique used for this is very similar to the technique shown in \cref{chp:first-class_datatypes}.
However, instead of using template metaprogramming, a feature \gls{CLEAN} lacks, generic programming is used also as a two-stage rocket.
In contrast to many other generic programming systems, \gls{CLEAN} allows for access to much of the metadata of the compiler.
repositories / phd-thesis.git / commitdiff