-
Brian Leibig
Compiler Optimizations with LLVM
(Independent Study)
Q20121; Independent Study Report
-
Alexander Dean
Memory Models and Determinism for Concurrent/Parallel Programming Languages
(Independent Study)
Q20113; Independent Study Report
-
Kyle Theriault
Software Testing
(Independent Study)
Q20104; Independent Study Report
-
Ben Holm
Evaluation of RSL History as a Tool for Assistance in the Development and Evaluation of Computer Vision Algorithms
(MS Thesis; co-advised)
A revision of Recognition Strategy Language (RSL), a
domain-specific language for pattern recognition algorithm
development, is in development. This language provides several
tools for pattern recognition algorithm implementation and
analysis, including composition of operations and a detailed
history of those operations and their results. This research
focuses on that history and shows that for some problems it
provides an improvement over traditional methods of gathering
information.
When designing a pattern recognition algorithm, bookkeeping code
in the form of copious logging and tracing code must be written
and analyzed in order to test the effectiveness of procedures and
parameters. The amount of data grows when dealing with video
streams; new organization and searching tools need to be designed
in order to manage the large volume of data. General purpose
languages have techniques like Aspect Oriented Programming
intended to address this prob- lem, but a general approach is
limited because it does not provide tools that are useful to only
one problem domain. By incorporating support for this bookkeeping
work directly into the language, RSL provides an improvement over
the general approach in both development time and ability to
evaluate the algorithm being designed for some problems.
The utility of RSL is tested by evaluating the implementation
process of a computer vision algorithm for recognizing American
Sign Language (ASL). RSL history is examined in terms of its use
in the development and evaluation stages of the algorithm, and the
usefulness of the history is stated based on the benefit seen at
each stage. RSL is found to be valuable for a portion of the
algorithm involving distinct steps that provide opportunity for
comparison. RSL was less beneficial for the dynamic programming
portion of the algorithm. Compromises were made for performance
reasons while implementing the dynamic programming solution and
the inspection at every step of what amounts to a brute-force
search was less informative. We suggest that this investigation
could be continued by testing with a larger data set and by
comparing this ASL recognition algorithm with another.
Defended: August 8, 2011; MS Thesis
-
Justin Cady
Functional Programming Applied to Web Development Templates
(MS Project)
In most web applications, the model-view-controller (MVC) design
pattern is used to separate concerns of a system. However, the
view layer, also referred to as the template layer, can often
become tightly coupled to the controller. This lack of separation
makes templates less flexible and reusable, and puts more
responsibility in the controller's hands than what is ideal. A
better solution is to give the template layer more control over
the data it presents and limit the controller's influence on
presentation. The jtc template engine uses elements of functional
programming to empower templates by treating templates as
functions.
Defended: May 31, 2011; MS Project
-
Edward Amsden
Functional Reactive Programming
(Independent Study)
Q20103; Independent Study Report
-
Justin Cady
Functional Programming & Web Frameworks
(Independent Study)
Q20102; Independent Study Report
-
Karl Voelker
Practical Programming with Total Functions
(MS Thesis)
Functional programming offers an advantage over imperative
programming: functional programs are easier to reason about and
understand, which makes certain classes of errors less
common. Yet, the two disciplines have some pitfalls in common: any
computation, functional or not, may be non-terminating, or may
terminate in a run-time error. Turner describes a discipline
called "Total Functional Programming" (TFP) in which these
pitfalls are impossible, due to some easily-checked rules which
require all recursion to be done structurally.
In this report, I detail my findings about the practical benefits
and limitations of total functional programming, as well as the
interactions which arise between TFP and the design and
implementation of a rich functional programming language. These
findings are the result of implementing a TFP compiler as a
modification of the Glasgow Haskell Compiler (GHC), as well as a
total standard library and a variety of total example programs.
Defended: July 27, 2010; MS Thesis