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.
+\todo[inline]{chap\-ter\-ab\-stract weg?}
+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 layered systems such as \gls{IOT} systems is very complex.
+The complexity mainly arises from the fact that each layer of the system is built up using different computers, hardware architectures, programming languages, programming paradigms, and abstraction levels.
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.
+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 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.
+This thesis sheds light on how to orchestrate complete \gls{IOT} systems using \gls{TOP}.
+It specifically fills in the knowledge gap for edge devices.
+The contributions are split up into 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 \cref{prt:dsl}, two novel techniques for embedding \glspl{DSL} in \gls{FP} languages are presented: 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.
+Furthermore, when embedding a \gls{DSL} in a language, much of the machinery is 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:top} contains a complete overview of the \gls{MTASK} system: its design, integration with \gls{ITASK}, implementation, and green computing facilities.
+The \gls{MTASK} language is a unique domain-specific \gls{TOP} \gls{EDSL} designed system for edge devices.
+The 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.
+All layers of the entire \gls{IOT} system are specified in a single source, the same strong type system, and similar high abstraction level.
+Therefore, they are simultaneously checked by a single compiler, reducing interoperability problems.
+Furthermore, all communication and integration is automatically generated, reducing the interoperability even more.
+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.
+\todo[inline]{benoem geïntroduceerde semantische wrijving? Het feit dat mTask strikter is?}
-\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.
+In \Cref{prt:tvt}, traditional \gls{IOT} system programming, tiered programming, is qualitatively and quantitatively compared to tierless programming.
+The comparison demonstrates 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.
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.
+Changing 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}
repositories / phd-thesis.git / blobdiff