\documentclass[../thesis.tex]{subfiles}
-\include{subfilepreamble}
+\input{subfilepreamble}
+
+\setcounter{chapter}{9}
\begin{document}
+\input{subfileprefix}
\chapter{Coda}%
\label{chp:conclusion}
-\todo{Or finale}
-\section{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.
+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.
-\section{Future work}
+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}
repositories / phd-thesis.git / blobdiff