From 35591e39c83f658310c07ad580d19b2a53910a72 Mon Sep 17 00:00:00 2001
From: Matthijs Kooijman <matthijs@stdin.nl>
Date: Sat, 5 Dec 2009 21:24:41 +0100
Subject: [PATCH] Add some references to the context chapter.

---
 Chapters/Context.tex | 10 +++-------
 Report.bib           | 24 +++++++++++++++++++++++-
 2 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/Chapters/Context.tex b/Chapters/Context.tex
index 3c09d95..1b02689 100644
--- a/Chapters/Context.tex
+++ b/Chapters/Context.tex
@@ -34,7 +34,6 @@
       and ability to abstract away  common patterns.  This is largely enabled
       by features like an advanced type system with polymorphism and higher
       order functions.
-      \todo{Does this apply to FHDLs equally?}
       \item Type-safer. Functional programs typically have a highly expressive
       type system, which makes it harder to write incorrect code.
       \item Easy to process. Functional languages have nice properties like
@@ -51,7 +50,7 @@
       \stopalignment
       \blank[medium]
      
-      \startcitedquotation[hudak96]
+      \startcitedquotation[deursen00]
       A domain-specific language (\small{DSL}) is a program-
       ming language or executable specification language
       that offers, through appropriate notations and ab-
@@ -59,8 +58,6 @@
       ally restricted to, a particular problem domain.
       \stopcitedquotation
 
-      \todo{ref: http://portal.acm.org/citation.cfm?id=352035\&dl=}
-      
       An embedded \small{DSL} is a \small{DSL} that is embedded in
       another language. Haskell is commonly used to embed \small{DSL}s
       in, which typically means a number of Haskell functions and types
@@ -72,7 +69,7 @@
       applicative, subset of Haskell where the library functions are the
       primitives. Sometimes advanced haskell features such as
       polymorphism, higher order values or type classes can be used in
-      the embedded language.
+      the embedded language. \cite[hudak96]
       \stopframedtext
     }
 
@@ -89,8 +86,7 @@
       variables (\eg, using the same variable twice while only calculating it
       once) and cycles in circuits are non-trivial to properly and safely
       translate (though there is some work to fix this, but that has not been
-      possible in a completely reliable way yet.  \todo{ref
-      http://www.ittc.ku.edu/~andygill/paper.php?label=DSLExtract09}
+      possible in a completely reliable way yet. \cite[gill09]
       \item Some things are verbose to express. Especially ForSyDe suffers
       from a lot of notational overhead due to the Template Haskell approach
       used. Since conditional statements are not supported, a lot of Haskell's
diff --git a/Report.bib b/Report.bib
index eecde8e..7e9dd00 100644
--- a/Report.bib
+++ b/Report.bib
@@ -7,5 +7,27 @@
  doi = {http://doi.acm.org/10.1145/242224.242477},
  publisher = {ACM},
  address = {New York, NY, USA},
- }
+}
 
+@article{deursen00,
+ author = {van Deursen, Arie and Klint, Paul and Visser, Joost},
+ title = {Domain-specific languages: an annotated bibliography},
+ journal = {SIGPLAN Not.},
+ volume = {35},
+ number = {6},
+ year = {2000},
+ issn = {0362-1340},
+ pages = {26--36},
+ doi = {http://doi.acm.org/10.1145/352029.352035},
+ publisher = {ACM},
+ address = {New York, NY, USA},
+}
+
+@inproceedings{gill09,
+  author = {Andy Gill},
+  title = {Type-Safe Observable Sharing in {H}askell},
+  booktitle = {Proceedings of the 2009 {ACM} {SIGPLAN} {H}askell Symposium},
+  year = {2009},
+  month = {Sep},
+  abstract = {Haskell is a great language for writing and supporting embedded Domain Specific Languages (DSLs). Some form of observable sharing is often a critical capability for allowing so-called deep DSLs to be compiled and processed. In this paper, we describe and explore uses of an IO function for reification which allows direct observation of sharing.}
+}
-- 
2.30.2