Commits

David Barker committed 4c5d541

Dissertation - started the requirements analysis bit and wrote up some background, among other things

Comments (0)

Files changed (8)

ArrowDataBinding.v11.suo

Binary file modified.

Dissertation/Dissertation.aux

 \@writefile{toc}{\contentsline {chapter}{\numberline {2}Preparation}{5}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\@writefile{toc}{\contentsline {chapter}{\numberline {3}Implementation}{7}}
+\@writefile{toc}{\contentsline {section}{\numberline {2.1}Background theory}{5}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1.1}Functional reactive programming}{5}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1.2}Arrows}{5}}
+\@writefile{toc}{\contentsline {section}{\numberline {2.2}Requirements analysis}{6}}
+\@writefile{toc}{\contentsline {section}{\numberline {2.3}Software engineering approach}{7}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {3}Implementation}{9}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\@writefile{toc}{\contentsline {section}{\numberline {3.1}Overview}{7}}
-\@writefile{toc}{\contentsline {section}{\numberline {3.2}Arrows}{7}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.1}Overview}{7}}
-\newlabel{sec:arrows_overview}{{3.2.1}{7}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.2}Simple arrows}{8}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{8}}
-\newlabel{fig:arr_operator}{{3.1}{8}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.2}{\ignorespaces The Combine operator}}{9}}
-\newlabel{fig:combine_operator}{{3.2}{9}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.3}{\ignorespaces The First operator}}{9}}
-\newlabel{fig:first_operator}{{3.3}{9}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.4}{\ignorespaces The And operator}}{10}}
-\newlabel{fig:and_operator}{{3.4}{10}}
-\@writefile{toc}{\contentsline {subsubsection}{Challenges encountered}{10}}
-\newlabel{sec:simple_arrow_challenges}{{3.2.2}{10}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.3}Invertible arrows}{12}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.4}List arrows}{12}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.5}Choice arrows}{14}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.6}Further utility arrows}{14}}
-\newlabel{sec:further_utility_arrows}{{3.2.6}{14}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.7}Feedback in arrows}{14}}
-\@writefile{toc}{\contentsline {section}{\numberline {3.3}Data binding}{14}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.1}Overall architecture}{14}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{15}}
-\newlabel{lst:bindable_source_class}{{3.1}{15}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.1}Creating a bindable source class}{15}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{16}}
-\@writefile{toc}{\contentsline {subsubsection}{Syntax and usage}{17}}
-\newlabel{lst:creating_simple_binding}{{3.2}{17}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.2}Creating a binding between two properties}{17}}
-\@writefile{toc}{\contentsline {subsubsection}{Two-way binding}{17}}
-\@writefile{toc}{\contentsline {subsubsection}{Cycle and conflict detection}{17}}
-\newlabel{lst:cycle_conflict_pseudocode}{{3.3}{18}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.3}Pseudocode for cycle and conflict detection}{18}}
-\@writefile{toc}{\contentsline {subsubsection}{Many-to-many bindings}{19}}
-\@writefile{lof}{\contentsline {figure}{\numberline {3.5}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{20}}
-\newlabel{fig:argument_marshalling}{{3.5}{20}}
-\@writefile{toc}{\contentsline {subsubsection}{Problems encountered}{20}}
-\@writefile{toc}{\contentsline {paragraph}{Type safety}{20}}
-\@writefile{toc}{\contentsline {paragraph}{Binding to lists}{20}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{20}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {4}Evaluation}{21}}
+\@writefile{toc}{\contentsline {section}{\numberline {3.1}Overview}{9}}
+\@writefile{toc}{\contentsline {section}{\numberline {3.2}Arrows}{9}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.1}Overview}{9}}
+\newlabel{sec:arrows_overview}{{3.2.1}{9}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.2}Simple arrows}{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.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:first_operator}{{3.3}{11}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3.4}{\ignorespaces The And operator}}{12}}
+\newlabel{fig:and_operator}{{3.4}{12}}
+\@writefile{toc}{\contentsline {subsubsection}{Challenges encountered}{12}}
+\newlabel{sec:simple_arrow_challenges}{{3.2.2}{12}}
+\@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}Choice arrows}{16}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.6}Further utility arrows}{16}}
+\newlabel{sec:further_utility_arrows}{{3.2.6}{16}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2.7}Feedback in arrows}{16}}
+\@writefile{toc}{\contentsline {section}{\numberline {3.3}Data binding}{16}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.1}Overall architecture}{16}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{17}}
+\newlabel{lst:bindable_source_class}{{3.1}{17}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.1}Creating a bindable source class}{17}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{18}}
+\@writefile{toc}{\contentsline {subsubsection}{Syntax and usage}{19}}
+\newlabel{lst:creating_simple_binding}{{3.2}{19}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.2}Creating a binding between two properties}{19}}
+\@writefile{toc}{\contentsline {subsubsection}{Two-way binding}{19}}
+\@writefile{toc}{\contentsline {subsubsection}{Cycle and conflict detection}{19}}
+\newlabel{lst:cycle_conflict_pseudocode}{{3.3}{20}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.3}Pseudocode for cycle and conflict detection}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{Many-to-many bindings}{21}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3.5}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{22}}
+\newlabel{fig:argument_marshalling}{{3.5}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{Problems encountered}{22}}
+\@writefile{toc}{\contentsline {paragraph}{Type safety}{22}}
+\@writefile{toc}{\contentsline {paragraph}{Binding to lists}{22}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{22}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {4}Evaluation}{23}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\@writefile{toc}{\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{21}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.1}Automated testing}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{Simple arrows}{22}}
-\@writefile{toc}{\contentsline {subsubsection}{Invertible arrows}{22}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{22}}
-\@writefile{toc}{\contentsline {section}{\numberline {4.2}Syntax evaluation}{23}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{Comparison with Haskell}{23}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{Username two-way binding}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{List binding from a mock database}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{23}}
-\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{23}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{24}}
-\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{24}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{25}}
-\newlabel{fig:simple_function_performance}{{4.1}{25}}
-\@writefile{toc}{\contentsline {subsubsection}{List function results}{25}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{26}}
-\newlabel{fig:list_function_performance}{{4.2}{26}}
-\@writefile{toc}{\contentsline {subsubsection}{Overhead due to arrow chaining}{26}}
-\newlabel{sec:arrow_chaining_overhead}{{4.3.1}{26}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{27}}
-\newlabel{fig:arrow_chaining_overhead}{{4.3}{27}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{27}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {5}Conclusion}{29}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{23}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.1}Automated testing}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{Simple arrows}{24}}
+\@writefile{toc}{\contentsline {subsubsection}{Invertible arrows}{24}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{24}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.2}Syntax evaluation}{25}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{Comparison with Haskell}{25}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{Username two-way binding}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{List binding from a mock database}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{25}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{25}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{26}}
+\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{26}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{27}}
+\newlabel{fig:simple_function_performance}{{4.1}{27}}
+\@writefile{toc}{\contentsline {subsubsection}{List function results}{27}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{28}}
+\newlabel{fig:list_function_performance}{{4.2}{28}}
+\@writefile{toc}{\contentsline {subsubsection}{Overhead due to arrow chaining}{28}}
+\newlabel{sec:arrow_chaining_overhead}{{4.3.1}{28}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{28}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{29}}
+\newlabel{fig:arrow_chaining_overhead}{{4.3}{29}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {5}Conclusion}{31}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\@writefile{toc}{\contentsline {section}{\numberline {5.1}Future work}{29}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{29}}
-\newlabel{sec:performance_enhancements}{{5.1.1}{29}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {A}Arrow laws}{31}}
+\@writefile{toc}{\contentsline {section}{\numberline {5.1}Future work}{31}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{31}}
+\newlabel{sec:performance_enhancements}{{5.1.1}{31}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {A}Arrow laws}{33}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\newlabel{sec:arrow_laws}{{A}{31}}
-\@writefile{toc}{\contentsline {section}{\numberline {A.1}Normal arrow laws}{31}}
-\newlabel{sec:simle_arrow_laws}{{A.1}{31}}
-\@writefile{toc}{\contentsline {section}{\numberline {A.2}Invertible arrow laws}{32}}
-\newlabel{sec:invertible_arrow_laws}{{A.2}{32}}
+\newlabel{sec:arrow_laws}{{A}{33}}
+\@writefile{toc}{\contentsline {section}{\numberline {A.1}Normal arrow laws}{33}}
+\newlabel{sec:simle_arrow_laws}{{A.1}{33}}
+\@writefile{toc}{\contentsline {section}{\numberline {A.2}Invertible arrow laws}{34}}
+\newlabel{sec:invertible_arrow_laws}{{A.2}{34}}

Dissertation/Dissertation.lof

 \addvspace {10\p@ }
 \addvspace {10\p@ }
 \addvspace {10\p@ }
-\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{8}
-\contentsline {figure}{\numberline {3.2}{\ignorespaces The Combine operator}}{9}
-\contentsline {figure}{\numberline {3.3}{\ignorespaces The First operator}}{9}
-\contentsline {figure}{\numberline {3.4}{\ignorespaces The And operator}}{10}
-\contentsline {figure}{\numberline {3.5}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{20}
-\addvspace {10\p@ }
-\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{25}
-\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{26}
-\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{27}
+\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{10}
+\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 Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{22}
+\addvspace {10\p@ }
+\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{27}
+\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{28}
+\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{29}
 \addvspace {10\p@ }
 \addvspace {10\p@ }

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)  18 MAR 2013 17:34
+This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  29 MAR 2013 18:30
 entering extended mode
 **Dissertation.tex
 
 Chapter 2.
 [5
 
-] [6
+] [6] [7] [8
 
 ]
 Chapter 3.
-[7
+[9
 
 ] ("C:\Program Files\MiKTeX 2.9\tex\latex\listings\lstlang1.sty"
 File: lstlang1.sty 2004/09/05 1.3 listings language file
 )
 LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <10> not available
-(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 198.
+(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 228.
 
-<fig/ArrOperator.pdf, id=64, 259.19409pt x 106.89937pt>
+<fig/ArrOperator.pdf, id=72, 259.19409pt x 106.89937pt>
 File: fig/ArrOperator.pdf Graphic file (type pdf)
 
 <use fig/ArrOperator.pdf>
-Package pdftex.def Info: fig/ArrOperator.pdf used on input line 203.
+Package pdftex.def Info: fig/ArrOperator.pdf used on input line 233.
 (pdftex.def)             Requested size: 142.26378pt x 58.67412pt.
- [8 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Diss
-ertation/fig/ArrOperator.pdf>]
-<fig/CompositionOperator.pdf, id=78, 349.81836pt x 107.12521pt>
+ [10 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/ArrOperator.pdf>]
+<fig/CompositionOperator.pdf, id=85, 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 216.
+Package pdftex.def Info: fig/CompositionOperator.pdf used on input line 246.
 (pdftex.def)             Requested size: 142.26378pt x 43.56526pt.
 
-<fig/FirstOperator.pdf, id=79, 262.49013pt x 219.44516pt>
+<fig/FirstOperator.pdf, id=86, 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 235.
+Package pdftex.def Info: fig/FirstOperator.pdf used on input line 265.
 (pdftex.def)             Requested size: 142.26378pt x 118.93391pt.
 
-<fig/AndOperator.pdf, id=80, 565.02242pt x 248.2334pt>
+<fig/AndOperator.pdf, id=87, 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 250.
+Package pdftex.def Info: fig/AndOperator.pdf used on input line 280.
 (pdftex.def)             Requested size: 142.26378pt x 62.50134pt.
- [9 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Diss
-ertation/fig/CompositionOperator.pdf> <C:/Users/David/Documents/Visual Studio 2
-010/Projects/ArrowDataBinding/Dissertation/fig/FirstOperator.pdf>] [10 <C:/User
-s/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dissertation/fig
-/AndOperator.pdf>] [11] [12]
+ [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]
 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 312.
-LaTeX Font Info:    Try loading font information for OMS+cmr on input line 341.
+(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 342.
+LaTeX Font Info:    Try loading font information for OMS+cmr on input line 371.
 
 
 ("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 341.
- [13] [14] [15]
-[16]
+(Font)              Font shape `OMS/cmsy/m/n' tried instead on input line 371.
+ [15] [16] [17]
+[18]
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
- [17] [18]
-<fig/ArgumentMarshalling.pdf, id=142, 511.24123pt x 147.77261pt>
+ [19] [20]
+<fig/ArgumentMarshalling.pdf, id=148, 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 452.
+Package pdftex.def Info: fig/ArgumentMarshalling.pdf used on input line 482.
 (pdftex.def)             Requested size: 411.93877pt x 119.07281pt.
- [19]
+ [21]
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
- [20 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [22 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/ArgumentMarshalling.pdf>]
 Chapter 4.
-[21
+[23
 
 
-] [22] [23] [24]
-<fig/SimpleFunctionPerformanceChart.pdf, id=171, 496.44887pt x 258.75552pt>
+] [24] [25] [26]
+<fig/SimpleFunctionPerformanceChart.pdf, id=177, 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 590.
+ine 620.
 (pdftex.def)             Requested size: 411.93877pt x 214.71175pt.
 
-<fig/ListFunctionPerformanceChart.pdf, id=172, 496.4172pt x 244.72725pt>
+<fig/ListFunctionPerformanceChart.pdf, id=178, 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 601.
+e 631.
 (pdftex.def)             Requested size: 411.93877pt x 203.08247pt.
- [25 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [27 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/SimpleFunctionPerformanceChart.pdf>] <fig/IdentityChains.pdf, id=
-246, 496.51498pt x 216.57913pt>
+253, 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 617.
+Package pdftex.def Info: fig/IdentityChains.pdf used on input line 645.
 (pdftex.def)             Requested size: 411.93877pt x 179.69122pt.
- [26 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [28 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/ListFunctionPerformanceChart.pdf>]
-[27 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Diss
-ertation/fig/IdentityChains.pdf>] [28
+[29 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Diss
+ertation/fig/IdentityChains.pdf>] [30
 
 ]
 Chapter 5.
-[29
+[31
 
-] [30
+] [32
 
 ]
 Appendix A.
-[31
+[33
 
-] [32]
+] [34]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 ation\Dissertation.aux") ) 
 Here is how much of TeX's memory you used:
  2767 strings out of 494045
  39825 string characters out of 3148387
- 185461 words of memory out of 3000000
+ 185503 words of memory out of 3000000
  6054 multiletter control sequences out of 15000+200000
  12602 words of font info for 44 fonts, out of 3000000 for 9000
  715 hyphenation exceptions out of 8191
 nts/cm/cmsy10.pfb><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/c
 mti12.pfb><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt10.pf
 b><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt12.pfb>
-Output written on Dissertation.pdf (42 pages, 392067 bytes).
+Output written on Dissertation.pdf (44 pages, 399346 bytes).
 PDF statistics:
- 517 PDF objects out of 1000 (max. 8388607)
+ 524 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 500000)
  41 words of extra memory for PDF output out of 10000 (max. 10000000)
 

Dissertation/Dissertation.pdf

Binary file modified.

Dissertation/Dissertation.synctex.gz

Binary file modified.

Dissertation/Dissertation.tex

 
 \chapter{Preparation}
 
-This chapter is empty still!
+\section{Background theory}
 
--Explain FRP here
--Explain arrows here
--Software engineering approach - iterations at first, issue-driven Agile
+\subsection{Functional reactive programming}
+
+Functional reactive programming (FRP) was one of the initial inspirations for the project. A good introduction is given by [http://conal.net/fran/tutorial.htm], which demonstrates how the principles can be applied to animation. In essence, functional reactive programming is a declarative way of specifying the relationships between different values. 'Signals' which change over time are created and passed around as first-class values, and other values can then be defined as functions of these signals.
+
+One of the main advantages of FRP is that it removes the need for explicitly defining how values are to be kept consistent and writing code to make this so. This is clearly solving a very similar problem to data binding, and so inspired the idea of making data binding more like FRP.
+
+\subsection{Arrows}
+
+Arrows were introduced by Hughes as a generalisation of \texttt{monads}. A monad takes the form \texttt{m a}, representing some computation which will give a result of type \texttt{a}. These are often useful in representing sequences of operations and those which involve side-effects. The basic monad type interface provides an identity function, which gives a monad returning whatever its input was, and a means of chaining monadic functions together. One way of viewing these is as a way of letting the programmer chain together functions in a way controlled by the monad -- for instance, the monad could be written to ensure that some form of global state is passed through along with the function results, or it could be used to handle error conditions without the programmer needing to write extra code for this. In all cases it is essentially handling some side-effect or background operation for the programmer, allowing them to chain various operations together without explicitly handling the side-effects.
+
+Arrows represent a generalisation of monads, in the sense that any monad can be equivalently implemented as an arrow. However, an arrow is of the form \texttt{a b c}, taking an input of type \texttt{b} and transforming it into an output of type \texttt{c}.
+
+Arrows were selected for this project as the semantic nature of an \texttt{arrow a b} is simply a transformation from an input of type \texttt{a} to an output of type \texttt{b}, an interpretation which works well as a generalised model of the nature of data binding.
+
+\section{Requirements analysis}
+
+From the outset, the main objectives of the project were to make the data binding framework syntactically clear and free from boilerplate, and to make the arrows as powerful and easy to use as possible. Therefore, some time was spent at the beginning of the project establishing what could be done to achieve this and just what sort of functionality would likely be needed.
+
+To start off, I spent some time understanding how data binding is already done in .NET's WPF framework. It was clear that the existing approach involved a lot of repetitive coding from the programmer to set up bindable sources and destinations, and there were several different conflicting ways of actually creating the binding -- either in the XAML code describing the user interface or in the code-behind. Thus I decided a good first objective would be to find a way of making the framework completely general, with one consistent way of creating bindings which handles all the situation-specific details itself. I also focussed on ways of removing the usual boilerplate code for creating sources and destinations, replacing it with a base class which manages events and interactions and an attribute which can be placed on properties the programmer wishes to bind.
+
+I also investigated what sort of features modern data binding frameworks implement, and which would be most useful for an arrow-based one. Binding through functions is not a new concept by any means, and indeed two-way binding is already implemented in .NET. However, in most cases these are fairly messy to set up -- in .NET, for instance, large \texttt{ValueConverter} classes have to be written to perform the transformation. It was decided that the cleanest way of handling this would be simply requiring that all bindings have an arrow attached. This way, the syntax is consistent whether the binding is direct or functional, and of course it is easy to pass in an identity arrow for a non-functional binding.
+
+Exploring existing libraries highlighted a couple of extra features which I had not previously thought would be necessary: arbitrary many-to-many bindings, which are useful in a variety of situations, and list bindings. The latter refers to the situation where the data source is actually a list of data, and would have been possible with normal arrows. However, it would have been fairly messy to do, and simple tasks like filtering and mapping would have required large loops. Given list binding is done fairly often in reality, I decided it would make sense to add an arrow type for handling them and a variety of list processing methods.
+
+[Arrow requirements...]
+
+\section{Software engineering approach}
+
+The implementation work was roughly done in two phases. In the early stages, a spiral model was used as it was unclear what the best way of implementing the arrows and binding framework would be. The first iteration was completed before the beginning of the project, and featured a very limited arrow class which worked on integers and supported only the basic combinators, and a binding framework which couldn't yet use arrows and required the sources and destinations to be special \texttt{BindingSource} and \texttt{BindingDestination} objects. Over several iterations the approach was refined until I found a suitable general and extensible implementation.
+
+From there, development was issue-driven Agile with sprints defined to be the work packages designated at the start of the project (though many of these work packages were altered and expanded slightly). The FogBugz\footnote{\texttt{www.fogcreek.com/fogbugz}} issue tracker was used to manage this and keep track of the various milestones. The project was tested throughout development with a series of unit tests, and I frequently tried implementing complex data bindings to ensure that new features being added were compatible with what was already there and the syntax was still reasonably clean.
+
+The entire project (dissertation included) was stored in a Git repository which was backed up on external storage and online with BitBucket\footnote{\texttt{www.bitbucket.org}}.
 
 \cleardoublepage
 
 In this example, the Filter extension method takes \texttt{listArrow} and the function \texttt{(int x) => x > 3}, creates a \texttt{FilterArrow<int>} out of the function, and returns a list arrow which is the original arrow and the filter arrow combined. Whole chains of list arrows can be quickly set up in this way:
 
 \begin{lstlisting}[language={[Sharp]C}]
-var filtered = listArrow
+var listArrow = listArrow
                    .OrderBy((x, y) => y - x)
                    .Filter(x => x > 3)
                    .Map(x => "Number"+x)
 \subsubsection{Overhead due to arrow chaining}
 \label{sec:arrow_chaining_overhead}
 
-Explanation of the problem (which will have been highlighted in earlier results) along with test results for increasingly long chains of identity functions. Suggest reasons for this and potential solutions (or maybe the solutions should come in later?)
-
 As was discovered earlier on, complex arrow chaining imposes a performance overhead. To establish how severe the effects of this are, a test was set up in which the execution times of chains of identity arrows were compared. In an ideal world, fifty identity arrows chained end-to-end would run in the same time as a single one, but in reality the implementation leads to longer chains taking considerably longer to execute. A set of identity chains with lengths ranging from one to twenty was created, and each one was timed over 1,000,000 executions.
 
 Fortunately, it was found that the execution time is linear in the length of the chain -- that is, each arrow combination adds only a constant extra overhead. The results can be seen in Figure \ref{fig:arrow_chaining_overhead}. Aside from small random variations, the timings clearly follow a linear trend. As noted earlier on, the overhead is far less pronounced when the function implemented is more complex than identity or incrementing, and so it is likely that for the majority of use cases combination overhead won't be significant enough to noticeably harm performance.
 	\item Messiness caused by use of Tuples - would be better with a custom tree type?
 	\item Feedback arrows
 	\item Better integration with WPF
-	\item etc...
+	\item Syntax enhancements, perhaps through Roslyn
 \end{itemize}
 
 \subsection{Performance enhancements} \label{sec:performance_enhancements}

Dissertation/Dissertation.toc

 \contentsline {section}{\numberline {1.2}Data binding in .NET}{2}
 \contentsline {section}{\numberline {1.3}Project inspirations}{2}
 \contentsline {chapter}{\numberline {2}Preparation}{5}
-\contentsline {chapter}{\numberline {3}Implementation}{7}
-\contentsline {section}{\numberline {3.1}Overview}{7}
-\contentsline {section}{\numberline {3.2}Arrows}{7}
-\contentsline {subsection}{\numberline {3.2.1}Overview}{7}
-\contentsline {subsection}{\numberline {3.2.2}Simple arrows}{8}
-\contentsline {subsubsection}{Challenges encountered}{10}
-\contentsline {subsection}{\numberline {3.2.3}Invertible arrows}{12}
-\contentsline {subsection}{\numberline {3.2.4}List arrows}{12}
-\contentsline {subsection}{\numberline {3.2.5}Choice arrows}{14}
-\contentsline {subsection}{\numberline {3.2.6}Further utility arrows}{14}
-\contentsline {subsection}{\numberline {3.2.7}Feedback in arrows}{14}
-\contentsline {section}{\numberline {3.3}Data binding}{14}
-\contentsline {subsection}{\numberline {3.3.1}Overall architecture}{14}
-\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{15}
-\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{16}
-\contentsline {subsubsection}{Syntax and usage}{17}
-\contentsline {subsubsection}{Two-way binding}{17}
-\contentsline {subsubsection}{Cycle and conflict detection}{17}
-\contentsline {subsubsection}{Many-to-many bindings}{19}
-\contentsline {subsubsection}{Problems encountered}{20}
-\contentsline {paragraph}{Type safety}{20}
-\contentsline {paragraph}{Binding to lists}{20}
-\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{20}
-\contentsline {chapter}{\numberline {4}Evaluation}{21}
-\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{21}
-\contentsline {subsection}{\numberline {4.1.1}Automated testing}{21}
-\contentsline {subsubsection}{Simple arrows}{22}
-\contentsline {subsubsection}{Invertible arrows}{22}
-\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{22}
-\contentsline {section}{\numberline {4.2}Syntax evaluation}{23}
-\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{23}
-\contentsline {subsubsection}{Comparison with Haskell}{23}
-\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{23}
-\contentsline {subsubsection}{Username two-way binding}{23}
-\contentsline {subsubsection}{List binding from a mock database}{23}
-\contentsline {subsubsection}{Some other demo}{23}
-\contentsline {section}{\numberline {4.3}Performance testing}{23}
-\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{23}
-\contentsline {subsubsection}{Measuring technique}{24}
-\contentsline {subsubsection}{Simple function results}{24}
-\contentsline {subsubsection}{List function results}{25}
-\contentsline {subsubsection}{Overhead due to arrow chaining}{26}
-\contentsline {subsection}{\numberline {4.3.2}Binding performance}{27}
-\contentsline {chapter}{\numberline {5}Conclusion}{29}
-\contentsline {section}{\numberline {5.1}Future work}{29}
-\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{29}
-\contentsline {chapter}{\numberline {A}Arrow laws}{31}
-\contentsline {section}{\numberline {A.1}Normal arrow laws}{31}
-\contentsline {section}{\numberline {A.2}Invertible arrow laws}{32}
+\contentsline {section}{\numberline {2.1}Background theory}{5}
+\contentsline {subsection}{\numberline {2.1.1}Functional reactive programming}{5}
+\contentsline {subsection}{\numberline {2.1.2}Arrows}{5}
+\contentsline {section}{\numberline {2.2}Requirements analysis}{6}
+\contentsline {section}{\numberline {2.3}Software engineering approach}{7}
+\contentsline {chapter}{\numberline {3}Implementation}{9}
+\contentsline {section}{\numberline {3.1}Overview}{9}
+\contentsline {section}{\numberline {3.2}Arrows}{9}
+\contentsline {subsection}{\numberline {3.2.1}Overview}{9}
+\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}Choice arrows}{16}
+\contentsline {subsection}{\numberline {3.2.6}Further utility arrows}{16}
+\contentsline {subsection}{\numberline {3.2.7}Feedback in 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.3}Creating bindings}{18}
+\contentsline {subsubsection}{Syntax and usage}{19}
+\contentsline {subsubsection}{Two-way binding}{19}
+\contentsline {subsubsection}{Cycle and conflict detection}{19}
+\contentsline {subsubsection}{Many-to-many bindings}{21}
+\contentsline {subsubsection}{Problems encountered}{22}
+\contentsline {paragraph}{Type safety}{22}
+\contentsline {paragraph}{Binding to lists}{22}
+\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{22}
+\contentsline {chapter}{\numberline {4}Evaluation}{23}
+\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{23}
+\contentsline {subsection}{\numberline {4.1.1}Automated testing}{23}
+\contentsline {subsubsection}{Simple arrows}{24}
+\contentsline {subsubsection}{Invertible arrows}{24}
+\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{24}
+\contentsline {section}{\numberline {4.2}Syntax evaluation}{25}
+\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{25}
+\contentsline {subsubsection}{Comparison with Haskell}{25}
+\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{25}
+\contentsline {subsubsection}{Username two-way binding}{25}
+\contentsline {subsubsection}{List binding from a mock database}{25}
+\contentsline {subsubsection}{Some other demo}{25}
+\contentsline {section}{\numberline {4.3}Performance testing}{25}
+\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{25}
+\contentsline {subsubsection}{Measuring technique}{26}
+\contentsline {subsubsection}{Simple function results}{26}
+\contentsline {subsubsection}{List function results}{27}
+\contentsline {subsubsection}{Overhead due to arrow chaining}{28}
+\contentsline {subsection}{\numberline {4.3.2}Binding performance}{28}
+\contentsline {chapter}{\numberline {5}Conclusion}{31}
+\contentsline {section}{\numberline {5.1}Future work}{31}
+\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{31}
+\contentsline {chapter}{\numberline {A}Arrow laws}{33}
+\contentsline {section}{\numberline {A.1}Normal arrow laws}{33}
+\contentsline {section}{\numberline {A.2}Invertible arrow laws}{34}