\documentclass[../thesis.tex]{subfiles}

\input{subfilepreamble}

\setcounter{chapter}{9}

\begin{document}
\input{subfileprefix}
\chapter{Coda}%
\label{chp:conclusion}%
\ifSubfilesClassLoaded{\glsunsetall}{}%
\begin{chapterabstract}
	This chapter concludes the dissertation and reflects on the work.
\end{chapterabstract}
\section{Reflections}

This dissertation shed light on orchestrating complete \gls{IOT} systems using \gls{TOP}.

The term \gls{IOT} refers to the interconnected network of physical devices that are connected to each other and the internet.
The edge, or perception, layer of an \gls{IOT} systems is often powered by microcontrollers.
These small and cheap computers do not have powerful hardware but are energy efficient and support many sensors and actuators.
While the term \gls{IOT} has already been known for almost thirty years, only recently, the exponential growth of the number of \gls{IOT} edge devices is really ramping up.
Programming \gls{IOT} systems is very complex because each layer of the system is built with different computers, hardware architectures, programming languages, programming paradigms, and abstraction levels.
This generates a lot of semantic friction.
Furthermore, \gls{IOT} systems become convoluted because they are dynamic, multi-tiered, multi-user, multitasking, interactive, distributed, and collaborative.
\Gls{TOP} proves a suitable programming paradigm that allows the declarative specification of exactly such systems.
However, edge devices are often too computationally restricted to be able to run a full-fledged \gls{TOP} system such as \gls{ITASK}.

The dissertation is structured as a purely functional rhapsody in three episodes.
It shows different techniques that aid crafting the tools required, i.e.\ creating the programming languages.
Then it shows the tool, \gls{MTASK}, a \gls{TOP} system for \gls{IOT} edge devices.
Finally it compares how this tool compares to existing tools.

\subsection{Tool craft}
First some techniques for tool crafting are presented in \cref{prt:dsl} that are useful for creating \gls{TOP} languages for \gls{IOT} edge devices.
It presents two novel techniques for embedding \glspl{DSL} in \gls{FP} languages:
Classy deep embedding is a novel \gls{EDSL} embedding technique.
In \gls{DSL} embedding techniques, one always has to make concessions.
Either it is easy to extend the language in language constructs or in interpretations but never both.
Tagless-final embedding offers a way of extending a shallowly embedded \gls{DSL} both in constructs and interpretations.
Classy deep embedding is the organically grown counterpart for deep embedding a \gls{DSL}.
It allows orthogonal extension of language constructs and interpretations with minimal boilerplate and no advanced type system extensions.

When embedding a \gls{DSL} in a language, much, but not all, of the machinery is inherited
For example, data types are not automatically useable in the \gls{DSL} because the interfaces such as constructors, deconstructors and constructor predicates are not inherited.
I show how to automatically generate boilerplate for \glspl{DSL} in order to make data types first-class citizens in the \gls{DSL}.
The scaffolding is generated using template metaprogramming and quasiquotation is used to alleviate the programmer from the syntax burden.

\subsection{Tools}
General-purpose \gls{TOP} systems cannot run on edge devices due to their sizeable hardware requirements.
However, using advanced \gls{DSL} embedding techniques, \glspl{DSL} can be created that can be executed on edge devices while maintaining the high abstraction level.
By embedding domain-specific knowledge into the language and execution platform, and leaving out general-purpose functionality \gls{TOP} languages can be made suitable for edge devices.

\Cref{prt:top} contains a complete overview of such a tool: the \gls{MTASK} system.
Its design, integration with \gls{ITASK}, implementation, and green computing facilities are shown.
The \gls{MTASK} language is a unique domain-specific \gls{TOP} \gls{EDSL} designed system for edge devices.
The \gls{MTASK} system is fully integrated with the \gls{ITASK} system, a \gls{TOP} system for programming distributed web applications.
In the \gls{ITASK} system, there are abstractions for details such as user interfaces, data storage, client-side platforms, and persistent workflows.
The \gls{MTASK} language abstracts away from edge device specific details such as sensor and actuator access, heterogeneity in hardware, and multitasking and scheduling.
Tasks in the \gls{MTASK} system are compiled at run time and sent to the device dynamically in order to support create dynamic systems where tasks are tailor-made for the current work requirements.
This tight integration makes programming full \gls{IOT} systems using \gls{TOP} possible without major compromises.
Using only three simple functions, devices are connected to \gls{ITASK} servers, \gls{MTASK} tasks are integrated in \gls{ITASK}, and \gls{ITASK} \glspl{SDS} accessed from within \gls{MTASK} tasks.

\subsection{Comparison}
Previous episodes show that it is possible to program all layers of an \gls{IOT} systems using \gls{TOP}.
Using tierless programming, many issues that arise with tiered programming are mitigated.
This has already been observed in web applications.
The question whether this novel approach to programming tiered systems also reduces the develop grief is answered in \cref{prt:tvt}.
This episode presents a four-way qualitatively and quantitatively comparison of the following systems:
\begin{enumerate*}
	\item \gls{PRS}, a tiered system based on resource-rich edge devices powered by \gls{PYTHON};
	\item \gls{PWS}, a tiered system based on resource-constrained edge devices by \gls{MICROPYTHON};
	\item \gls{CRS}, a tierless system based on resource-rich edge devices powered by \gls{ITASK};
	\item \gls{CWS}, a tierless system based on resource-constrained edge devices powered by \imtask{}.
\end{enumerate*}

This comparison shows that when using a programming paradigm that is available both for resource-rich and resource-constrained edge devices, there is little difference in developer grief.
On the other hand, using a tierless system compared to a tiered system reduces the developer grief significantly.

Using either \imtask{} when dealing with resource-constrained devices such as microcontrollers or just \gls{ITASK} for all layers all layers of the entire \gls{IOT} system are specified in a single source, the same strong type system, and similar high abstraction level.
The tierless approach results in fewer \gls{SLOC}, files, programming languages and programming paradigms.
All code is simultaneously checked by a single compiler, reducing interoperability problems.
Furthermore, all communication and integration is automatically generated, reducing interoperability issues even more.
%
However, it is not a silver bullet, there are some disadvantages as well.
Tierless languages are novel, and hence often lack tooling and community support.
They contain high-level tierless abstractions that the programmer has to master.
The low-level specific semantics of the final application may become more difficult to distill from the specification.
Finally, the system is more monolithic compared to tiered approaches.
Changing components within the system is easy if it already is supported in the \gls{EDSL}.
Adding new components to the system requires the programmer to add it to all complex components of the languages such as the compiler, and \gls{RTS}.

\input{subfilepostamble}
\end{document}
