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

\input{subfilepreamble}

\setcounter{chapter}{9}

\begin{document}
\input{subfileprefix}
\chapter{Coda}%
\label{chp:conclusion}%
\begin{chapterabstract}
	This chapter concludes the dissertation and reflects on the work.
\end{chapterabstract}
\section{Reflections}
While the term \gls{IOT} has already been known for almost thirty years, the exponential growth of the number of \gls{IOT} edge devices is really ramping up recently.
\todo{chap\-ter\-ab\-stract weg?}
Programming layered systems such as \gls{IOT} systems is very complex because on each layer of the system, different computers, hardware architectures, programming languages, programming paradigms, and abstraction levels are required.
This generates a lot of semantic friction.
Furthermore, \gls{IOT} systems are very 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 traditional \gls{TOP} systems.
This thesis shed light on orchestrating complete \gls{IOT} system using \gls{TOP}, specifically filling in the knowledge gap for edge devices in three episodes.

\Cref{prt:dsl} presented two novel techniques for embedding \glspl{DSL} in \gls{FP} languages: the classy deep \gls{EDSL} embedding technique and a way of generating boilerplate for data types using template metaprogramming.
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.
Furthermore, when embedding a \gls{DSL} in a language, much of the machinery can be inherited.
However, data types are not automatically useable in the \gls{DSL} because the interfaces such as constructors, deconstructors and constructortests 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.

\Cref{prt:top} gave an overview of the \gls{MTASK} system, it's design, integration with \gls{ITASK}, implementation, and green computing facilities.
Using advanced \gls{DSL} embedding technique, a \gls{TOP} \gls{DSL} for the \gls{IOT} edge devices can be created that allows programming the small microcomputers according to the same high abstraction level as on the server.
The \gls{MTASK} system is a \gls{TOP} system for edge devices.
It is fully integrated with \gls{ITASK} and hence allows the programmer to specify all layers of an \gls{IOT} system in a single specification.
The \gls{MTASK} \gls{DSL} is set up in such a way that it is possible to create high-level \gls{TOP} programs performing common \gls{IOT} edge devices work dynamically and send them to the edge device at run time.

\Cref{prt:tvt} qualitatively and quantitatively compared traditional \gls{IOT} system programming, tiered programming, to the tierless programming.
We have shown that programming such complex systems using a tierless approach such as using \gls{MTASK} or even \gls{ITASK} reduces the development effort required to making these systems.
Concretely, it results in fewer \gls{SLOC}, files, programming languages and programming paradigms.

However, it is not a silver bullet.
Tierless languages are novel, and hence lacking tooling and community support.
They contain many high-level tierless abstractions that the programmer has to master.
The low-level specific semantics of the final application may become more difficult to destill from the specification.
Finally, the system is quite monolithic.
Changing a components within the system is easy if it already exists in the host language.
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}
