-\glspl{EDSL} can have one or more backends or views.
-Commonly used views are pretty printing, compiling, simulating, verifying and proving the program.
-Embedding techniques can be characterised by at least the following properties:
-\begin{enumerate}
- \item Extendibility of constructs
- \item Extendibility of views
- \item Type safety, the type of a term in the language is typed in the host language
- \item Support for well typed variables
- \item Intensional analyses
- \item Support for partial views, not all views need to support all constructs
-\end{enumerate}
-
-There are two main techniques for creating embedding \glspl{DSL}, deep---also called tagged---embedding and shallow---also called tagless---embedding.
-In the following sections both techniques are explained.
-As an example, a simple language with integers, booleans and some arithmetic operators is used as a running example.
-
-\section{Deep embedding}
-A deep \gls{EDSL} is a language represented as data in the host language.
-Views are functions that transform \emph{something} to the datatype or the other way around.
-Definition~\ref{lst:exdeep} shows an implementation for the example \gls{DSL}.
+Properties such as referential transparency, minimal syntax, powerful type systems and rich data types make \gls{FP} languages excellent candidates for hosting \glspl{EDSL}.
+
+There are two flavours of \gls{DSL} embedding: deep- and shallow embedding~\citep{boulton_experience_1992}.
+Shallow embedding---also called tagless embedding---models language constructs as functions in the host language.
+As a result, adding new language constructs---extra functions---is easy.
+However, the interpretation of the language is embedded in these functions, making it troublesome to add semantics since it requires updating all existing language constructs.
+
+In contrast to shallow embedding, deep embedding---also called tagged embedding---models terms in the language as data types.
+Interpretations are functions over these data types.
+
+Consequently, adding new semantics, i.e.\ novel functions, is straightforward.
+It can be stated that the language constructs are embedded in the functions that form a semantics.
+If one wants to add a language construct, all semantics functions must be revisited and revised to avoid ending up with partial functions.
+
+This juxtaposition has been known for many years~\citep{reynolds_user-defined_1978} and discussed by many others~\citep{krishnamurthi_synthesizing_1998} but most famously dubbed the \emph{expression problem} by Wadler~\citep{wadler_expression_1998}:
+
+\begin{quote}
+ The \emph{expression problem} is a new name for an old problem.
+ The goal is to define a data type by cases, where one can add new cases to the data type and new functions over the data type, without recompiling existing code, and while retaining static type safety (e.g., no casts).
+\end{quote}
+
+Terms in an \glspl{EDSL} can have multiple interpretations\footnote{Interpretations are also called backends or views}, i.e.\ a term in the \gls{DSL} is just an interface.
+Commonly used intepretations are printing, compiling, simulating, optimising, verifying, proving the program\etc.
+There are two main flavours of embedding \glspl{DSL}.
+Deep embedding---also called shallow--- models terms in the language as data types, interpretations are functions over these terms.
+Shallow embedding---also called tagless---models terms in the language as functions, interpretations are embedded in these functions.
+
+Most importantly, the two flavours differ on two axes: extensibility of language constructs and extensibility of interpretations.
+\todo{elaborate}
+
+\Cref{sec:deep_embedding} shows the basics of deep embedding.
+\Cref{sec:shallow_embedding} shows the basics of shallow embedding including tagless embedding.
+\Cref{sec:compare_embedding} compares the embedding technique.
+
+In the following sections the basics of both techniques are explained.
+A simple language with integers, booleans and some arithmetic operators is used as a running example.
+
+\section{Deep embedding}\label{sec:deep_embedding}
+In a deeply embedded \gls{DSL}, the language terms are represented as data type{(s)} in the host language.
+Therefore, interpretations of the terms are functions that operate on these data types.
+\Cref{lst:exdeep} shows an implementation for the example \gls{DSL}.