Commits

David Barker  committed 9e98f28

Finished off implementation chapter bar the WPF integration bit, and wrote up key references in the bibliography

  • Participants
  • Parent commits b03597d

Comments (0)

Files changed (11)

File Dissertation/Bibliography.bib

+@article{arrow_calculus,
+  title={The Arrow Calculus (Functional Pearl)},
+  author={Lindley, Sam and Wadler, Philip and Yallop, Jeremy},
+  year={2008}
+}
+
+@Article{hughes_arrows,
+author = {John Hughes},
+title = {Generalising Monads to Arrows},
+year = {1998}
+}
+
+@INPROCEEDINGS{arrows_robots_frp,
+    author = {Paul Hudak and Antony Courtney and Henrik Nilsson and John Peterson},
+    title = {Arrows, Robots, and Functional Reactive Programming},
+    booktitle = {Advanced Functional Programming, 4th International School, volume 2638 of LNCS},
+    year = {2002},
+    pages = {159--187},
+    publisher = {Springer-Verlag}
+}
+
+@INPROCEEDINGS{frp_first_principles,
+    author = {Zhanyong Wan and Paul Hudak},
+    title = {Functional Reactive Programming from First Principles},
+    booktitle = {In ACM SIGPLAN Conference on Programming Language Design and Implementation},
+    year = {2000},
+    pages = {242--252}
+}
+
+@Article{composing_reactive_animations,
+  author       = {Conal Elliott},
+  title        = {Composing Reactive Animations},
+  journal      = {Dr. Dobb's Journal},
+  year         = {1998},
+  note         = {Also in expanded animated form at http://conal.net/fran/tutorial.htm}
+}
+
+@misc{haskell_arrows,
+  author = {Ross Paterson},
+  title = {Arrows: A General Interface to Computation},
+  note = {http://www.haskell.org/arrows (accessed on 24/04/2013)}
+}
+
+@incollection{arrows_and_computation,
+	title = "Arrows and Computation",
+	author = "Ross Paterson",
+	booktitle = "The Fun of Programming",
+	editor = "Jeremy Gibbons and Oege de Moor",
+	url = "http://www.soi.city.ac.uk/~ross/papers/fop.html",
+	publisher = "Palgrave",
+	pages = "201-222",
+	year = 2003
+}
+
+@incollection{hughes_programming_with_arrows,
+  title={Programming with arrows},
+  author={Hughes, John},
+  booktitle={Advanced Functional Programming},
+  pages={73--129},
+  year={2005},
+  publisher={Springer}
+}
+
+@misc{wpf_data_binding_overview,
+  author = {MSDN},
+  title = {Data Binding Overview},
+  note = {http://msdn.microsoft.com/en-us/library/ms752347.aspx (accessed on 24/04/2013)}
+}
+
+@misc{javascript_data_binding,
+  author = {yap.TV},
+  title = {Javascript Frameworks and Data Binding},
+  note = {http://tunein.yap.tv/javascript/2012/06/11/javascript-frameworks-and-data-binding/ (accessed on 24/04/2013)}
+}
+
+@incollection{functional_reactive_programming,
+year={1999},
+isbn={978-3-540-65699-9},
+booktitle={Programming Languages and Systems},
+volume={1576},
+series={Lecture Notes in Computer Science},
+editor={Swierstra, S.Doaitse},
+doi={10.1007/3-540-49099-X_1},
+title={Functional Reactive Programming},
+url={http://dx.doi.org/10.1007/3-540-49099-X_1},
+publisher={Springer Berlin Heidelberg},
+author={Hudak, Paul},
+pages={1-1},
+language={English}
+}
+
+@INPROCEEDINGS{invertible_arrows,
+    author = {Artem Alimarine and Sjaak Smetsers and Arjen Weelden and Marko Eekelen and Rinus Plasmeijer},
+    title = {There and back again: arrows for invertible programming},
+    booktitle = {In Proceedings of the 2005 ACM SIGPLAN workshop on Haskell},
+    year = {2006},
+    pages = {86--97},
+    publisher = {ACM Press}
+}
+
+@inproceedings{arrow_notation,
+	title = "A New Notation for Arrows",
+	author = "Ross Paterson",
+	booktitle = "International Conference on Functional Programming",
+	location = "Firenze, Italy",
+	url = "http://www.soi.city.ac.uk/~ross/papers/notation.html",
+	publisher = "ACM Press",
+	pages = "229-240",
+	month = Sep,
+	year = 2001
+}

File Dissertation/Dissertation.aux

 \newlabel{sec:arrows_overview}{{3.2.1}{9}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.2.2}Simple arrows}{10}}
 \newlabel{sec:simple_arrow_implementation}{{3.2.2}{10}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{10}}
-\newlabel{fig:arr_operator}{{3.1}{10}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{11}}
+\newlabel{fig:arr_operator}{{3.1}{11}}
 \@writefile{lof}{\contentsline {figure}{\numberline {3.2}{\ignorespaces The Combine operator}}{11}}
 \newlabel{fig:combine_operator}{{3.2}{11}}
 \@writefile{lof}{\contentsline {figure}{\numberline {3.3}{\ignorespaces The First operator}}{11}}
 \newlabel{fig:and_operator}{{3.4}{12}}
 \@writefile{toc}{\contentsline {subsubsection}{Challenges encountered}{12}}
 \newlabel{sec:simple_arrow_challenges}{{3.2.2}{12}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3.5}{\ignorespaces Correspondence between Haskell and C$\sharp $ arrow operators}}{13}}
+\newlabel{fig:operator_correspondence}{{3.5}{13}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.2.3}Invertible arrows}{14}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.4}List arrows}{14}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.5}Further utility arrows}{15}}
-\newlabel{sec:further_utility_arrows}{{3.2.5}{15}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.4}List arrows}{15}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.5}Further utility arrows}{16}}
+\newlabel{sec:further_utility_arrows}{{3.2.5}{16}}
 \@writefile{toc}{\contentsline {section}{\numberline {3.3}Data binding}{16}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.3.1}Overall architecture}{16}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.5}{\ignorespaces Overview of the binding method}}{17}}
-\newlabel{fig:binding_framework}{{3.5}{17}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{17}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3.6}{\ignorespaces Overview of the binding method}}{17}}
+\newlabel{fig:binding_framework}{{3.6}{17}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{18}}
 \newlabel{lst:bindable_source_class}{{3.1}{18}}
 \@writefile{lol}{\contentsline {lstlisting}{\numberline {3.1}Creating a bindable source class}{18}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{19}}
-\@writefile{toc}{\contentsline {subsubsection}{Syntax and usage}{19}}
+\@writefile{toc}{\contentsline {subsubsection}{Syntax and usage}{20}}
 \newlabel{lst:creating_simple_binding}{{3.2}{20}}
 \@writefile{lol}{\contentsline {lstlisting}{\numberline {3.2}Creating a binding between two properties}{20}}
 \@writefile{toc}{\contentsline {subsubsection}{Two-way binding}{20}}
 \@writefile{toc}{\contentsline {subsubsection}{Cycle and conflict detection}{21}}
-\newlabel{lst:cycle_conflict_pseudocode}{{3.3}{21}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.3}Pseudocode for cycle and conflict detection}{21}}
+\newlabel{lst:cycle_conflict_pseudocode}{{3.3}{22}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.3}Pseudocode for cycle and conflict detection}{22}}
 \@writefile{toc}{\contentsline {subsubsection}{Many-to-many bindings}{22}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.6}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{23}}
-\newlabel{fig:argument_marshalling}{{3.6}{23}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3.7}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{23}}
+\newlabel{fig:argument_marshalling}{{3.7}{23}}
 \@writefile{toc}{\contentsline {subsubsection}{Problems encountered}{23}}
 \@writefile{toc}{\contentsline {paragraph}{Type safety}{23}}
-\@writefile{toc}{\contentsline {paragraph}{Binding to lists}{23}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.4}Explicitly reassigning a list to trigger a binding update}{23}}
+\@writefile{toc}{\contentsline {paragraph}{Binding to lists}{24}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.4}Explicitly reassigning a list to trigger a binding update}{24}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{24}}
 \@writefile{toc}{\contentsline {chapter}{\numberline {4}Evaluation}{25}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{toc}{\contentsline {subsection}{\numberline {B.1.1}Creating the bindable data source}{39}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {B.1.2}Creating the functionality for splitting the name}{41}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {B.1.3}Creating the binding}{43}}
+\citation{arrow_calculus}
 \@writefile{toc}{\contentsline {section}{\numberline {B.2}List binding from a mock database}{45}}
 \newlabel{sec:case_study_list}{{B.2}{45}}
 \@writefile{toc}{\contentsline {section}{\numberline {B.3}Some other demo}{47}}
+\citation{hughes_arrows}
+\citation{arrows_robots_frp}
+\citation{frp_first_principles}
+\citation{composing_reactive_animations}
+\citation{haskell_arrows}
+\citation{arrows_and_computation}
+\citation{hughes_programming_with_arrows}
+\citation{wpf_data_binding_overview}
+\citation{functional_reactive_programming}
+\citation{invertible_arrows}
+\citation{arrow_notation}
+\bibstyle{plain}
+\bibdata{Bibliography}
+\bibcite{invertible_arrows}{1}
+\bibcite{composing_reactive_animations}{2}
+\bibcite{functional_reactive_programming}{3}
+\bibcite{arrows_robots_frp}{4}
+\bibcite{hughes_arrows}{5}
+\bibcite{hughes_programming_with_arrows}{6}
+\bibcite{arrow_calculus}{7}
+\bibcite{wpf_data_binding_overview}{8}
+\bibcite{haskell_arrows}{9}
+\bibcite{arrow_notation}{10}
+\bibcite{arrows_and_computation}{11}
+\bibcite{frp_first_principles}{12}

File Dissertation/Dissertation.bbl

-\begin{thebibliography}{}
+\begin{thebibliography}{10}
+
+\bibitem{invertible_arrows}
+Artem Alimarine, Sjaak Smetsers, Arjen Weelden, Marko Eekelen, and Rinus
+  Plasmeijer.
+\newblock There and back again: arrows for invertible programming.
+\newblock In {\em In Proceedings of the 2005 ACM SIGPLAN workshop on Haskell},
+  pages 86--97. ACM Press, 2006.
+
+\bibitem{composing_reactive_animations}
+Conal Elliott.
+\newblock Composing reactive animations.
+\newblock {\em Dr. Dobb's Journal}, 1998.
+\newblock Also in expanded animated form at http://conal.net/fran/tutorial.htm.
+
+\bibitem{functional_reactive_programming}
+Paul Hudak.
+\newblock Functional reactive programming.
+\newblock In S.Doaitse Swierstra, editor, {\em Programming Languages and
+  Systems}, volume 1576 of {\em Lecture Notes in Computer Science}, pages 1--1.
+  Springer Berlin Heidelberg, 1999.
+
+\bibitem{arrows_robots_frp}
+Paul Hudak, Antony Courtney, Henrik Nilsson, and John Peterson.
+\newblock Arrows, robots, and functional reactive programming.
+\newblock In {\em Advanced Functional Programming, 4th International School,
+  volume 2638 of LNCS}, pages 159--187. Springer-Verlag, 2002.
+
+\bibitem{hughes_arrows}
+John Hughes.
+\newblock Generalising monads to arrows.
+\newblock 1998.
+
+\bibitem{hughes_programming_with_arrows}
+John Hughes.
+\newblock Programming with arrows.
+\newblock In {\em Advanced Functional Programming}, pages 73--129. Springer,
+  2005.
+
+\bibitem{arrow_calculus}
+Sam Lindley, Philip Wadler, and Jeremy Yallop.
+\newblock The arrow calculus (functional pearl).
+\newblock 2008.
+
+\bibitem{wpf_data_binding_overview}
+MSDN.
+\newblock Data binding overview.
+\newblock http://msdn.microsoft.com/en-us/library/ms752347.aspx (accessed on
+  24/04/2013).
+
+\bibitem{haskell_arrows}
+Ross Paterson.
+\newblock Arrows: A general interface to computation.
+\newblock http://www.haskell.org/arrows (accessed on 24/04/2013).
+
+\bibitem{arrow_notation}
+Ross Paterson.
+\newblock A new notation for arrows.
+\newblock In {\em International Conference on Functional Programming}, pages
+  229--240. ACM Press, September 2001.
+
+\bibitem{arrows_and_computation}
+Ross Paterson.
+\newblock Arrows and computation.
+\newblock In Jeremy Gibbons and Oege de~Moor, editors, {\em The Fun of
+  Programming}, pages 201--222. Palgrave, 2003.
+
+\bibitem{frp_first_principles}
+Zhanyong Wan and Paul Hudak.
+\newblock Functional reactive programming from first principles.
+\newblock In {\em In ACM SIGPLAN Conference on Programming Language Design and
+  Implementation}, pages 242--252, 2000.
 
 \end{thebibliography}

File Dissertation/Dissertation.blg

 This is BibTeX, Version 0.99dThe top-level auxiliary file: Dissertation.aux
 The style file: plain.bst
-I found no \citation commands---while reading file Dissertation.aux
-I found no \bibdata command---while reading file Dissertation.aux
-(There were 2 error messages)
+Illegal, another \bibstyle command---line 134 of file Dissertation.aux
+ : \bibstyle
+ :          {plain}
+I'm skipping whatever remains of this command
+Database file #1: Bibliography.bib
+Warning--empty journal in hughes_arrows
+Warning--empty journal in arrow_calculus
+(There was 1 error message)

File Dissertation/Dissertation.lof

 \addvspace {10\p@ }
 \addvspace {10\p@ }
 \addvspace {10\p@ }
-\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{10}
+\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{11}
 \contentsline {figure}{\numberline {3.2}{\ignorespaces The Combine operator}}{11}
 \contentsline {figure}{\numberline {3.3}{\ignorespaces The First operator}}{11}
 \contentsline {figure}{\numberline {3.4}{\ignorespaces The And operator}}{12}
-\contentsline {figure}{\numberline {3.5}{\ignorespaces Overview of the binding method}}{17}
-\contentsline {figure}{\numberline {3.6}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{23}
+\contentsline {figure}{\numberline {3.5}{\ignorespaces Correspondence between Haskell and C$\sharp $ arrow operators}}{13}
+\contentsline {figure}{\numberline {3.6}{\ignorespaces Overview of the binding method}}{17}
+\contentsline {figure}{\numberline {3.7}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{23}
 \addvspace {10\p@ }
 \contentsline {figure}{\numberline {4.1}{\ignorespaces The username two-way binding application}}{28}
 \contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{31}

File Dissertation/Dissertation.log

-This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  23 APR 2013 21:01
+This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  24 APR 2013 13:42
 entering extended mode
 **Dissertation.tex
 
 <use fig/ArrOperator.pdf>
 Package pdftex.def Info: fig/ArrOperator.pdf used on input line 235.
 (pdftex.def)             Requested size: 142.26378pt x 58.67412pt.
- [10 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
-sertation/fig/ArrOperator.pdf>]
-<fig/CompositionOperator.pdf, id=86, 349.81836pt x 107.12521pt>
+
+<fig/CompositionOperator.pdf, id=73, 349.81836pt x 107.12521pt>
 File: fig/CompositionOperator.pdf Graphic file (type pdf)
 
 <use fig/CompositionOperator.pdf>
 Package pdftex.def Info: fig/CompositionOperator.pdf used on input line 248.
 (pdftex.def)             Requested size: 142.26378pt x 43.56526pt.
-
-<fig/FirstOperator.pdf, id=87, 262.49013pt x 219.44516pt>
+ [10]
+<fig/FirstOperator.pdf, id=78, 262.49013pt x 219.44516pt>
 File: fig/FirstOperator.pdf Graphic file (type pdf)
 
 <use fig/FirstOperator.pdf>
 Package pdftex.def Info: fig/FirstOperator.pdf used on input line 267.
 (pdftex.def)             Requested size: 142.26378pt x 118.93391pt.
-
-<fig/AndOperator.pdf, id=88, 565.02242pt x 248.2334pt>
+ [11 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/ArrOperator.pdf> <C:/Users/David/Documents/Visual Studio 2010/Pro
+jects/ArrowDataBinding/Dissertation/fig/CompositionOperator.pdf> <C:/Users/Davi
+d/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dissertation/fig/First
+Operator.pdf>]
+<fig/AndOperator.pdf, id=107, 565.02242pt x 248.2334pt>
 File: fig/AndOperator.pdf Graphic file (type pdf)
 
 <use fig/AndOperator.pdf>
 Package pdftex.def Info: fig/AndOperator.pdf used on input line 282.
 (pdftex.def)             Requested size: 142.26378pt x 62.50134pt.
- [11 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
-sertation/fig/CompositionOperator.pdf> <C:/Users/David/Documents/Visual Studio 
-2010/Projects/ArrowDataBinding/Dissertation/fig/FirstOperator.pdf>] [12 <C:/Use
-rs/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dissertation/fi
-g/AndOperator.pdf>] [13] [14]
+ [12 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/AndOperator.pdf>] [13] [14]
 LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <12> not available
-(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 344.
- [15] [16]
-<fig/BindingFramework.pdf, id=135, 568.86269pt x 261.31383pt>
+(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 361.
+ [15]
+[16] <fig/BindingFramework.pdf, id=134, 568.86269pt x 261.31383pt>
 File: fig/BindingFramework.pdf Graphic file (type pdf)
 
 <use fig/BindingFramework.pdf>
-Package pdftex.def Info: fig/BindingFramework.pdf used on input line 402.
+Package pdftex.def Info: fig/BindingFramework.pdf used on input line 419.
 (pdftex.def)             Requested size: 411.93877pt x 189.23434pt.
  [17 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/BindingFramework.pdf>] [18]
 [19] [20]
-LaTeX Font Info:    Try loading font information for OMS+cmr on input line 467.
+LaTeX Font Info:    Try loading font information for OMS+cmr on input line 484.
 
  ("C:\Program Files\MiKTeX 2.9\tex\latex\base\omscmr.fd"
 File: omscmr.fd 1999/05/25 v2.5h Standard LaTeX font definitions
 )
 LaTeX Font Info:    Font shape `OMS/cmr/m/n' in size <12> not available
-(Font)              Font shape `OMS/cmsy/m/n' tried instead on input line 467.
+(Font)              Font shape `OMS/cmsy/m/n' tried instead on input line 484.
  [21]
-<fig/ArgumentMarshalling.pdf, id=177, 511.24123pt x 147.77261pt>
+[22] <fig/ArgumentMarshalling.pdf, id=179, 511.24123pt x 147.77261pt>
 File: fig/ArgumentMarshalling.pdf Graphic file (type pdf)
 
 <use fig/ArgumentMarshalling.pdf>
-Package pdftex.def Info: fig/ArgumentMarshalling.pdf used on input line 499.
+Package pdftex.def Info: fig/ArgumentMarshalling.pdf used on input line 516.
 (pdftex.def)             Requested size: 411.93877pt x 119.07281pt.
- [22] [23 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBindin
-g/Dissertation/fig/ArgumentMarshalling.pdf>]
+ [23 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/ArgumentMarshalling.pdf>]
 [24]
 Chapter 4.
 [25
 
 
-] [26] <fig/CaseStudyNameBinding.png, id=204, 283.0575pt x 210.7875pt>
+] [26] <fig/CaseStudyNameBinding.png, id=203, 283.0575pt x 210.7875pt>
 File: fig/CaseStudyNameBinding.png Graphic file (type png)
 
 <use fig/CaseStudyNameBinding.png>
-Package pdftex.def Info: fig/CaseStudyNameBinding.png used on input line 594.
+Package pdftex.def Info: fig/CaseStudyNameBinding.png used on input line 612.
 (pdftex.def)             Requested size: 283.0568pt x 210.78699pt.
  [27] [28 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBindin
 g/Dissertation/fig/CaseStudyNameBinding.png>] [29]
-<fig/SimpleFunctionPerformanceChart.pdf, id=215, 496.44887pt x 258.75552pt>
+<fig/SimpleFunctionPerformanceChart.pdf, id=214, 496.44887pt x 258.75552pt>
 File: fig/SimpleFunctionPerformanceChart.pdf Graphic file (type pdf)
 
 <use fig/SimpleFunctionPerformanceChart.pdf>
 Package pdftex.def Info: fig/SimpleFunctionPerformanceChart.pdf used on input l
-ine 660.
+ine 678.
 (pdftex.def)             Requested size: 411.93877pt x 214.71175pt.
  [30] [31 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBindin
 g/Dissertation/fig/SimpleFunctionPerformanceChart.pdf>]
-<fig/ListFunctionPerformanceChart.pdf, id=292, 496.4172pt x 244.72725pt>
+<fig/ListFunctionPerformanceChart.pdf, id=291, 496.4172pt x 244.72725pt>
 File: fig/ListFunctionPerformanceChart.pdf Graphic file (type pdf)
 
 <use fig/ListFunctionPerformanceChart.pdf>
 Package pdftex.def Info: fig/ListFunctionPerformanceChart.pdf used on input lin
-e 679.
+e 697.
 (pdftex.def)             Requested size: 411.93877pt x 203.08247pt.
  [32 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
-sertation/fig/ListFunctionPerformanceChart.pdf>] <fig/IdentityChains.pdf, id=36
-0, 496.51498pt x 216.57913pt>
+sertation/fig/ListFunctionPerformanceChart.pdf>] <fig/IdentityChains.pdf, id=35
+9, 496.51498pt x 216.57913pt>
 File: fig/IdentityChains.pdf Graphic file (type pdf)
 
 <use fig/IdentityChains.pdf>
-Package pdftex.def Info: fig/IdentityChains.pdf used on input line 693.
+Package pdftex.def Info: fig/IdentityChains.pdf used on input line 711.
 (pdftex.def)             Requested size: 411.93877pt x 179.69122pt.
  [33 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/IdentityChains.pdf>] [34
 \pc@column@2=\box30
 \pc@column@width@2=\dimen120
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 800.
+ne 818.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 800.
+ne 818.
 [39
 
 
 ] [40]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 857.
+ne 875.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 857.
+ne 875.
  [41
 
 ] [42]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 904.
+ne 922.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 904.
+ne 922.
  [43
 
 ] [44
 
 ]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
+ation\Dissertation.bbl"
+Underfull \hbox (badness 5417) in paragraph at lines 46--50
+[]\OT1/cmr/m/n/12 MSDN.  Data bind-ing overview.  http://msdn.microsoft.com/en-
+
+ []
+
+
+Underfull \hbox (badness 6461) in paragraph at lines 52--55
+[]\OT1/cmr/m/n/12 Ross Pa-ter-son.  Ar-rows: A gen-eral in-ter-face to com-pu-t
+a-tion.
+ []
+
+[49
+
+]) [50]
+("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 ation\Dissertation.aux") ) 
 Here is how much of TeX's memory you used:
- 2883 strings out of 494045
- 42065 string characters out of 3148387
+ 2899 strings out of 494045
+ 42566 string characters out of 3148387
  216622 words of memory out of 3000000
- 6158 multiletter control sequences out of 15000+200000
+ 6171 multiletter control sequences out of 15000+200000
  12938 words of font info for 46 fonts, out of 3000000 for 9000
  715 hyphenation exceptions out of 8191
- 27i,8n,40p,1132b,1506s stack positions out of 5000i,500n,10000p,200000b,50000s
+ 27i,8n,40p,1132b,1520s stack positions out of 5000i,500n,10000p,200000b,50000s
 <C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfo
 nts/cm/cmbx12.pfb><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/c
 mitt10.pfb><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmmi10.p
 ogram Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt10.pfb><C:/Program Fi
 les/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt12.pfb><C:/Program Files/MiKT
 eX 2.9/fonts/type1/public/amsfonts/cm/cmtt8.pfb>
-Output written on Dissertation.pdf (58 pages, 483252 bytes).
+Output written on Dissertation.pdf (60 pages, 495326 bytes).
 PDF statistics:
- 605 PDF objects out of 1000 (max. 8388607)
+ 610 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 500000)
  51 words of extra memory for PDF output out of 10000 (max. 10000000)
 

File Dissertation/Dissertation.pdf

Binary file modified.

File Dissertation/Dissertation.synctex.gz

Binary file modified.

File Dissertation/Dissertation.tex

 
 Many useful ideas for data binding come from the area of functional programming. Functional reactive programming (FRP), for example, is a paradigm which nicely models the concept of data binding in a general way. Another useful concept is that of the `arrows' implemented in Haskell. An `arrow from type A to type B' essentially represents a process taking an input of type A and returning something of type B, and these can be arbitrarily combined in interesting ways to build up complex functions. More detail on both will be given in the next chapter.
 
-The FRP paradigm was the inspiration for the project, which sought to implement a general-purpose data binding framework in C$\sharp$ using concepts derived from functional programming. I successfully implemented a framework which provides data binding in both directions, through arbitrary functions with arbitrary numbers of inputs and outputs, all with a simple syntax based on lambda expressions. Minimal boilerplate code is required to set up bindable properties - the containing class should extend Bindable, and from there marking arbitrary member variables and properties with the [Bindable] tag will make it possible to create bindings to and from them with a single function call. I also implemented a large variety of arrow types and arrow operators along with a number of utility functions to make creating and combining them simple.
+The FRP paradigm was the inspiration for the project, which sought to implement a general-purpose data binding framework in C$\sharp$ using concepts derived from functional programming. I successfully implemented a framework which provides data binding in both directions, through arbitrary functions with arbitrary numbers of inputs and outputs, all with a simple syntax based on lambda expressions. Minimal boilerplate code is required to set up bindable properties - the containing class should extend \texttt{Bindable}, and from there marking arbitrary member variables and properties with the \texttt{[Bindable]} tag will make it possible to create bindings to and from them with a single function call. I also implemented a large variety of arrow types and arrow operators along with a number of utility functions to make creating and combining them simple.
 
 \cleardoublepage
 
 
 \section{Overview}
 
-Give a general overview
+The implementation work consisted of two main parts: the arrows and the binding framework. As mentioned, these were both initially developed through repeated iterations as different strategies were being investigated and new options discovered. This chapter describes the main development work and highlights the various difficulties encountered along the way.
 
 
 \section{Arrows}
 
 A further problem was how best to allow arrows from multiple inputs to multiple outputs. Simply having a \texttt{Func} with multiple inputs would not have worked as the arrow would have had to be rewritten for every given number of inputs, and to make matters worse \texttt{Func} is limited to one output. For some time I debated writing a generic binary-tree-structured type\footnote{All arrows work on nested pairs} to handle this, but on discovering C$\sharp$'s built-in \texttt{Tuple<T1, T2>} type I felt this would be the simplest option. This ended up complicating the data binding (as I will discuss later), but was entirely sufficient for supporting the arrow implementation.
 
-[Maybe mention arrow intercompatibility?]
+%Maybe mention arrow intercompatibility?
 
 \subsection{Simple arrows} \label{sec:simple_arrow_implementation}
 
 
 This is equivalent to the \texttt{***} operator in Haskell, and executes the two arrows in parallel. This allows a number of complex operations to be conveniently parallelised in one arrow, which could likely be useful when working with data bindings between complex objects. The \texttt{Fanout} operator makes good use of this: given one input arrow of type \texttt{Arrow<A, B>} and two following arrows of types \texttt{Arrow<B, C>} and \texttt{Arrow<B, D>}\footnote{Note that the input types of the two arrows have to match the output type of the first arrow}, it returns an arrow which executes the input arrow, splits the result and then passes it through the two following arrows in parallel yielding a pair of results.
 
-Given a pair result, it is then possible to recombine the two elements using a \texttt{Func<A, B, C>} operator using \texttt{Unsplit}. The following example recombines the tuple by adding its elements together:
+Given a pair result, it is then possible to recombine the two elements with a binary operator (passed as a \texttt{Func<A, B, C>}) using \texttt{Unsplit}. The following example recombines the tuple by adding its elements together:
 
 \begin{lstlisting}[language={[Sharp]C}]
 var unsplitArrow = arrowOnPairs.Unsplit((x, y) => x + y);
 
 An example of a fairly elaborate composite operator is \texttt{LiftA2}. This essentially performs the same function as \texttt{Fanout}, but also takes a function for recombining the two results and so is effectively a \texttt{Fanout} arrow with an \texttt{Unsplit} operation at the end.
 
-Figures~\ref{fig:arr_operator},~\ref{fig:combine_operator},~\ref{fig:first_operator} and~\ref{fig:and_operator} give a visual representation of some of the arrow operators, to make their effects more clear.
-
-Include table showing correspondence between C$\sharp$ arrow operators and Haskell ones?
+Figures~\ref{fig:arr_operator},~\ref{fig:combine_operator},~\ref{fig:first_operator} and~\ref{fig:and_operator} give a visual representation of some of the arrow operators, to make their effects more clear. A correspondence between Haskell arrow operators and the C$\sharp$ equivalents is given in Figure \ref{fig:operator_correspondence}.
+
+%Include table showing correspondence between C$\sharp$ arrow operators and Haskell ones?
+
+\begin{figure}
+\centering
+\begin{tabular}{| l | l |}
+\hline
+Haskell & C$\sharp$ \\
+\hline
+\texttt {arr f} & \texttt{f.Arr()} \\
+\texttt{a >>> b} & \texttt{a.Combine(b)} \\
+\texttt{first arrow} & \texttt{arrow.First(default(T))} \\
+\texttt{second arrow} & \texttt{arrow.Second(default(T))} \\
+\texttt{a *** b} & \texttt{a.And(b)} \\
+\hline
+\end{tabular}
+\caption{Correspondence between Haskell and C$\sharp$ arrow operators}
+\label{fig:operator_correspondence}
+\end{figure}
 
 \subsubsection{Challenges encountered} \label{sec:simple_arrow_challenges}
 
 
 \subsection{Integration work with WPF}
 
-Mention difficulties with the value converter and inability to properly integrate it into XAML and stuff.
+%Mention difficulties with the value converter and inability to properly integrate it into XAML and stuff.
+Todo
 
 \cleardoublepage
 
 
 \section{List binding from a mock database} \label{sec:case_study_list}
 
-Todo
+Todo\cite{arrow_calculus}
 
 \cleardoublepage
 
 \cleardoublepage
 
 
+\nocite{hughes_arrows}
+\nocite{arrows_robots_frp}
+\nocite{frp_first_principles}
+\nocite{composing_reactive_animations}
+\nocite{haskell_arrows}
+\nocite{arrows_and_computation}
+\nocite{hughes_programming_with_arrows}
+\nocite{wpf_data_binding_overview}
+\nocite{functional_reactive_programming}
+\nocite{invertible_arrows}
+\nocite{arrow_notation}
+
+\bibliographystyle{plain}
+\bibliography{Bibliography}
+
 \end{document}

File Dissertation/Dissertation.toc

 \contentsline {subsection}{\numberline {3.2.2}Simple arrows}{10}
 \contentsline {subsubsection}{Challenges encountered}{12}
 \contentsline {subsection}{\numberline {3.2.3}Invertible arrows}{14}
-\contentsline {subsection}{\numberline {3.2.4}List arrows}{14}
-\contentsline {subsection}{\numberline {3.2.5}Further utility arrows}{15}
+\contentsline {subsection}{\numberline {3.2.4}List arrows}{15}
+\contentsline {subsection}{\numberline {3.2.5}Further utility arrows}{16}
 \contentsline {section}{\numberline {3.3}Data binding}{16}
 \contentsline {subsection}{\numberline {3.3.1}Overall architecture}{16}
-\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{17}
+\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{18}
 \contentsline {subsection}{\numberline {3.3.3}Creating bindings}{19}
-\contentsline {subsubsection}{Syntax and usage}{19}
+\contentsline {subsubsection}{Syntax and usage}{20}
 \contentsline {subsubsection}{Two-way binding}{20}
 \contentsline {subsubsection}{Cycle and conflict detection}{21}
 \contentsline {subsubsection}{Many-to-many bindings}{22}
 \contentsline {subsubsection}{Problems encountered}{23}
 \contentsline {paragraph}{Type safety}{23}
-\contentsline {paragraph}{Binding to lists}{23}
+\contentsline {paragraph}{Binding to lists}{24}
 \contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{24}
 \contentsline {chapter}{\numberline {4}Evaluation}{25}
 \contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{25}

File Dissertation/texput.log

+This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  24 APR 2013 13:37
+entering extended mode
+**Bibliography.tex
+
+! Emergency stop.
+<*> Bibliography.tex
+                    
+*** (job aborted, file error in nonstop mode)
+
+ 
+Here is how much of TeX's memory you used:
+ 2 strings out of 494045
+ 22 string characters out of 3148387
+ 48890 words of memory out of 3000000
+ 3399 multiletter control sequences out of 15000+200000
+ 3640 words of font info for 14 fonts, out of 3000000 for 9000
+ 715 hyphenation exceptions out of 8191
+ 0i,0n,0p,1b,6s stack positions out of 5000i,500n,10000p,200000b,50000s
+!  ==> Fatal error occurred, no output PDF file produced!