Microcontrollers are equipped with a lot of connectivity for integrating peripherals such as sensors and actuators.
The connectivity makes them very suitable to interact with their surroundings.
These miniature computers contain integrated circuits that accommodate a microprocessor designed for use in embedded applications.
-As a consequence, microcontrollers are cheap; tiny; have little memory; and contain a slow, but energy-efficient processor.
+As a consequence, microcontrollers are cheap, tiny, have little memory, and contain a slow, but energy-efficient processor.
When coordinating an orchestra of edge devices, there is room for little error.
Edge devices come and go, perform their own pieces, or are sometimes instructed to perform a certain piece, they might even operate without a central authority.
This dissertation describes the research carried out around orchestrating these complex \gls{IOT} systems using \gls{TOP}.
\Gls{TOP} is an innovative tierless programming paradigm for interactive multi-layered systems.
By utilising advanced compiler technologies, much of the internals, communication, and interoperation between the tiers or layers of the applications are automatically generated.
-The compiler makes an application controlling all interconnected components from a single declarative specification of the required work.
+The compiler generates an application controlling all interconnected components from a single declarative specification of the required work.
For example, the \gls{TOP} system \gls{ITASK} is used to program all layers of multi-user distributed web applications from a single source specification.
It is implemented in the general-purpose lazy functional programming language \gls{CLEAN}, and therefore requires relatively powerful hardware.
The inflated hardware requirements are no problem for regular computers but impractical for the average edge device.
This is where an additional \glspl{DSL} must play its part.
\Glspl{DSL} are programming languages tailored to a specific domain.
-Consequently, jargon is not expressed in terms of the language itself, but are built-in language features.
+Consequently, jargon is not expressed in terms of the language itself, but is built into the language.
Furthermore, the \gls{DSL} can eschew language or system features that are irrelevant for the domain.
Using \glspl{DSL}, hardware requirements can be drastically lowered, even while maintaining a high abstraction level for the specified domain.
\section{Reading guide}%
\label{lst:reading_guide}
This work is structured as a purely functional rhapsody.
-The \citet{wikipedia_contributors_rhapsody_2022} define a musical rhapsody is defined as follows:
+The \citet{wikipedia_contributors_rhapsody_2022} define a musical rhapsody as follows:
\begin{quote}\emph{%
A \emph{rhapsody} in music is a one-movement work that is episodic yet integrated, free-flowing in structure, featuring a range of highly contrasted moods, colour, and tonality.}
\end{quote}
Hence, the chapters in this episode are best read in order.
It introduces \gls{IOT} edge device programming, shows the complete \gls{MTASK} language, provides details on how \gls{MTASK} is integrated with \gls{ITASK}, shows how the byte code compiler is implemented, presents a guide for green computing with \gls{MTASK}, and ends with a conclusion and overview of future and related work.
\Cref{prt:tvt} consists of a single chapter that is based on a journal article.
-The chapter provides a qualitative and quantitative comparison of traditional tiered \gls{IOT} programming and tierless programming using a real-world application.
+The chapter provides a qualitative and quantitative comparison of traditional tiered \gls{IOT} programming and tierless programming using a real-world application.
The chapter is readable independently.
The following sections in this prelude provide background material on the \gls{IOT}, \glspl{DSL}, and \gls{TOP} after which a detailed overview of the contributions is presented.
\emph{The \glsxtrlong{IOT}, or \glsxtrshort{IOT}, is the integration of people, processes and technology with connectable devices and sensors to enable remote monitoring, status, manipulation and evaluation of trends of such devices.}
\end{quote}
-Much later, CISCO states that the \gls{IOT} started when there were as many connected devices as there were people on the globe, i.e.\ around 2008 \citep{evans_internet_2011}.
+Much later, CISCO stated that the \gls{IOT} started when there were as many connected devices as there were people on the globe, i.e.\ around 2008 \citep{evans_internet_2011}.
Today, \gls{IOT} is the term for a system of devices that sense the environment, act upon it, and communicate with each other and the world they operate in.
These connected devices are already in households all around us in the form of smart electricity meters, fridges, phones, watches, home automation, \etc.
In some applications this is implemented using conventional networking techniques such as \gls{WIFI} or Ethernet.
However, network technology that is tailored to the needs of the specific interconnection between two layers is increasingly popular.
Examples of this are BLE, LoRa, ZigBee, and LTE-M as a communication protocol for connecting the perception layer to the application layer using \gls{IOT} transport protocols such as \gls{MQTT}.
-Protocols such as HTTP, AJAX, and WebSocket connecting the presentation layer to the application layer that are designed for the use in web applications.
+Furthermore, protocols such as HTTP, AJAX, and WebSocket are designed for the use in web applications and connect the presentation layer to the application layer.
Across the layers, the devices are a large heterogeneous collection of different platforms, protocols, paradigms, and programming languages.
As a result, impedance problems or semantic friction occurs between layers and the maintainability is severely hampered \citep{ireland_classification_2009}.
-Even more so, the perception layer itself is often a heterogeneous collection of microcontrollers in itself, each having their own peculiarities, programming language of choice, and hardware interfaces.
+Even more so, the perception layer often is a heterogeneous collection of microcontrollers in itself, each having their own peculiarities, programming language of choice, and hardware interfaces.
As edge hardware needs to be cheap, small scale, and energy efficient, the microcontrollers used to power them do not have a lot of computational power, only a smidge of memory, and little communication bandwidth.
Typically, these devices are unable to run a full-fledged general-purpose \gls{OS}.
Rather they employ compiled firmware written in imperative languages that combines all tasks on the device in a single program.
\section{Domain-specific languages}%
\label{sec:back_dsl}
% General
-Programming languages can be divided up into two categories: \glspl{DSL} and \glspl{GPL} \citep{fowler_domain_2010}.
+Programming languages can be divided into two categories: \glspl{DSL} and \glspl{GPL} \citep{fowler_domain_2010}.
Where \glspl{GPL} are not made with a demarcated area in mind, \glspl{DSL} are tailor-made for a specific domain.
Writing idiomatic domain-specific code in a \gls{DSL} is easier and requires less \gls{GPL} knowledge for a domain expert.
This does come at the cost of the \gls{DSL} being sometimes less expressive to an extent that it may not even be Turing complete.
\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.
For example, \citet{elliott_compiling_2003} describe the language Pan, for which the final representation in the host language is a compiler that will, when executed, generate code for a completely different target platform.
Both \gls{ITASK} and \gls{MTASK} are \glspl{EDSL}.
-Programs written in \gls{ITASK} run in the host language, and it is a homogeneous \gls{DSL}.
+Programs written in \gls{ITASK} run in the host language, and hence \gls{ITASK} is a homogeneous \gls{DSL}.
Tasks written using \gls{MTASK} are dynamically compiled to byte code for an edge device, making it a heterogeneous \gls{DSL}.
The interpreter running on the edge device has no knowledge of the higher level task specification.
It just interprets the byte code it was sent and takes care of the communication.
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 has been under development for over fifteen years and has proven itself through use in industry.
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.
+Using \gls{ITASK}, complex collaborations of users and tasks are described on a high level.
-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.
-
-\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.
+Software on microcontrollers is usually composed of smaller basic tasks, is interactive, and shares data with other components or the server.
The \gls{ITASK} system seems an obvious candidate for bringing \gls{TOP} to \gls{IOT} edge devices.
However, an \gls{ITASK} application contains many features that are not needed on \emph{edge devices} such as higher-order tasks, support for a distributed architecture, a multi-user web server, and facilities to generate \glspl{GUI} for any user-defined type.
Furthermore, \gls{IOT} edge devices are in general not powerful enough to run or interpret \gls{CLEAN}\slash\gls{ABC} code, they just lack the processor speed and memory.
The \gls{MTASK} language is written in \gls{CLEAN} as a multi-view \gls{EDSL} and hence there are multiple interpretations possible.
This thesis mostly discusses the byte code compiler.
From an \gls{MTASK} task constructed at run time, a compact binary representation of the work that needs to be done is compiled.
-And while the byte code for \gls{MTASK} is generated at run time, the type system of the host language \gls{CLEAN} prevents type errors in the generated code.
+While the byte code for \gls{MTASK} is generated at run time, the type system of the host language \gls{CLEAN} prevents type errors in the generated code.
This byte code is then sent to a device that running the \gls{MTASK} \gls{RTS}.
This feather-light domain-specific \gls{OS} is written in portable \gls{C} with a minimal device specific interface and it executes the tasks using interpretation and rewriting.
To illustrate \imtask{}, an example application is shown.
-The application is an interactive application for blinking \pgls{LED} on the microcontroller at a certain frequency that can be set and updated at run time.
+It is an interactive program for blinking \pgls{LED} on the microcontroller at a certain frequency that can be set and updated at run time.
\Cref{lst:intro_blink,fig:intro_blink} show the \gls{ITASK} part of the code and a screenshot.
Using \cleaninline{enterInformation}, the connection specification of the \gls{TCP} device is queried through a web editor (\cref{lst:intro_enterDevice,fig:intro_blink_dev}).
\Cref{lst:intro_withshared} defines \pgls{SDS} to communicate the blinking interval between the server and the edge device.
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.
-Some \gls{TOP} languages were created to fill a gap encountered in practise.
+Some \gls{TOP} languages were created to fill a gap encountered in practice.
Toppyt \citep{lijnse_toppyt_2022} is a general purpose \gls{TOP} language written in \gls{PYTHON} used to host frameworks for modelling command \& control systems.
The hTask system is a \gls{TOP} system written in \gls{HASKELL} used as a vessel for experimenting with asynchronous \glspl{SDS} \citep{lubbers_htask_2022}.
Furthermore, some \gls{TOP} systems arose from Master's and Bachelor's thesis projects.
%The engine is the software or hardware that executes these specifications as a ready-for-work application.
%Defining comparable semantics for the \gls{MTASK} language is in progress \citep{antonova_mtask_2022}.
+\subsection{Tierless programming}
+Both \gls{ITASK} and \imtask{} are so called tierless systems.
+Tierless programming is an entirely different development paradigm compared to traditional, tiered, programming.
+In tiered programming, every component\slash{}tier is separately developed, possibly in different programming languages and programming paradigms, and integrated in the system as a whole.
+On the one hand, it is an advantage to be able to choose the most suitable programming language for the specific tier.
+But on the other, it increases the amount of integration work that needs to be done and it may increase the semantic friction between the tiers.
+In contrast, tierless programming languages synthesise all tiers of a software stack from a single high-level specification.
+Hence, reducing the semantic friction, increasing the maintainability costs, and reducing the possibility for runtime errors.
+The term tierless programming originated from the web programming system Links \citep{cooper2006links}.
+In Links, code for each tier simultaneously checked by the compiler, and compiled to HTML and JavaScript for the web client and to SQL on the server to interact with the database system.
+The \gls{ITASK} system is a tierless system taking care of both the presentation and application layer (see \cref{fig:iot-layers}).
+When \gls{ITASK} is used in conjunction with \gls{MTASK}, all layers of an \gls{IOT} system can be programmed from a single source and hence they are a tierless \gls{IOT} system.
+
\section{Contributions}%
\label{sec:contributions}
This section provides a thorough overview of the relation between the scientific publications and the contents of this thesis.
\subsection{\Fullref{prt:dsl}}
-The \gls{MTASK} system is an \gls{EDSL} and during the development of it, several novel basal techniques for embedding \glspl{DSL} in \gls{FP} languages have been found.
-This paper-based episode contains the following papers:
+The \gls{MTASK} system is an \gls{EDSL} and during the development of it, several novel basal techniques for embedding \glspl{DSL} in \gls{FP} languages were found.
+This paper-based episode is based on the following papers:
\begin{enumerate}
\item \emph{Deep Embedding with Class} \citep*{lubbers_deep_2022} is the basis for \cref{chp:classy_deep_embedding}.
It shows a novel deep embedding technique for \glspl{DSL} where the resulting language is extendible both in constructs and in interpretation just using type classes and existential data types.
\item \emph{First-\kern-1ptClass Data Types in Shallow Embedded Domain-Specific Languages} \citep*{lubbers_first-class_2022}\label{enum:first-class} is the basis for \cref{chp:first-class_datatypes}.
It shows how to inherit data types from the host language in \glspl{EDSL} using metaprogramming by providing a proof-of-concept implementation using \gls{HASKELL}'s metaprogramming system: \glsxtrlong{TH}.
The chapter also serves as a gentle introduction to, and contains a thorough literature study on \glsxtrlong{TH}.
- The paper was published at the \ifl{} 2022 in Kopenhagen, Denmark.
+ The paper was published at the \ifl{} 2022 in Copenhagen, 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:}
repositories / phd-thesis.git / blobdiff