Thesis Project

Master
The Master Program Software Technology is concluded with a thesis project (45 ects). The project involves an exercise in scientific research and results in a Master's thesis. Projects can be done externally or internally.

Here are some useful information related to getting your thesis project started:

   * *Finding a topic*. Here are some [[Thesis.FindingATopic][tips]]. We try to maintain a list of our current research areas, see below. 
   * *[[Thesis.WebHome][Planning your thesis project]]* : procedures, milestones, and tips. 
   * [[Final steps]] to your thesis defense. 
   * You also need to *register* for your final exam; check out the procedure [[http://www.cs.uu.nl/education/advies/master.html][here]].

For general information about graduating in the ST Master Program contact <!-- the student advisor-->  prof. dr. Doaitse Swierstra.

---

---++ List of Current Research Areas

%TOC%

%STARTINCLUDE%

External projects are done in companies such as SERC (Afstudeeropdrachten), Philips Research Laboratories, De Belastingdienst, Software Improvement Group, Ordina, and Baan. Internal projects are done at the Center for Software Technology in close collaboration with one of the research projects of the Software Technology Group. Below a general description of the research areas is given. Some include links to projects within the area, else feel free to approach the contact person mentioned to find out whether a project in the area is available and would be of interest to you. 

<!--
There is also another list of [[http://www.cs.uu.nl/intra/Thesis/WebHome][more detailed thesis projects]], maintained separately on our secure wiki server.
-->

----++ Advanced Functional Programming

Besides developing new programming languages, building compilers, and thinking about type systems, we also think that one of our tasks is to demonstarte  how functional programming languages, and especially Haskell, can be applied in real-life situations. By using languages to build actual systems, we get insight in their strengths and weaknesses. So under this heading we have identified a number of problems which can be worked on separately, without having to delve deeply into compilers of type systems. Some projects merely apply Haskell in a new application area, or are aimed to show how to do things "differently". Examples of such projects might be the use of partial evaluation in building support systems for designers of Bayesian networks, applying incremental evaluation techniques, or designing some (Embedded) Domain Specific Language

Contact: anyone in the ST group

<!--
[[http://www.cs.uu.nl/intra/Thesis/AdvancedFunctionalProgramming][Specific subjects for/ongoing theses projects]] (restricted access)
-->

----++ Compiler Tools

There are various projects possible in the design, implementation and application of functional compiler components such as attribute grammars, parser combinators, and virtual machines. Areas of particular interest are efficient machine models, use of program analysis techniques from the attribute grammar world in the optimized implementation of functional languages, program refactoring and componentized attribute grammar systems. In general we try to operate in a fully typed world, and as such this research provides ample inspiration for thinking about what type systems can do in checking the correctness of your model and implementation.


Contact: Prof. Dr Doaitse Swierstra, Dr Atze Dijkstra, Drs Jeroen Fokker

<!--
[[http://www.cs.uu.nl/intra/Thesis/CompilerConstruction][Specific subjects for theses projects]] (restricted access)
-->

-----++ Generic Programming

Generic programming is about making programs more adaptable by making them more general. Generic programs often embody non-traditional kinds of polymorphism; ordinary programs are obtained from them by suitably instantiating their parameters. In contrast with normal programs, the parameters of a generic programs are often quite rich in structure. For example they may be other programs, types or type constructors, class hierarchies, or even programming paradigms. At Utrecht, generic programming has been studied since the end of the nineties. We have worked on Generic Haskell, a generic programming language extension of Haskell, on several domain-specific libraries for generic programming, and on applications of generic programming. We have created a separate page for ideas about [[http://www.cs.uu.nl/wiki/bin/view/GenericProgramming/MastersProjects][thesis projects on generic programming]].

Contact: Prof Dr Johan Jeuring

----++ Program Analysis

Before optimizing transformations can be applied to computer programs, it is first necessary to analyse a program to compute various properties of a program. For example, a compiler only needs to generate code for lines that can be reached from the beginning of the program. However, it is not always obvious whether some part of the code is reachable or not. Another example is type checking and type inferencing. This is also an analysis of a program, which should lead to more efficient generated code. In both cases it also gives some idea of the correctness of the program.

Another application of automatic program analysis has to do with verifying that written code adheres to certain programming guidelines. For instance: in a company people might be wary of memory leaks. For this reason, there is a programming guide line that says that memory allocated in a given procedure ought to be released before the end of the procedure.

The basic idea of program analysis is to compute information from programs automatically in finite time. In many cases we run into the limits of what is computable (like the Halting Problem), so our answers will only be approximate. We do generally insist that answers are sound: if some definite answer is given, then it must be true. However, in some projects this demand was relaxed,
for example in a recent project on soft typing of PHP.

Projects in this theme will typically involve developing and implementing one or more analyses for a programming (or other) language (Java, Python, Scheme, Haskell,...). In case a parser is not yet available, constructing a parser will be a part of the assignment. In the choice of subject language and type of analysis there is potentially a lot of freedom.

Contact: [[Hage.WebHome][Dr. Jurriaan Hage]]

<!--
[[http://www.cs.uu.nl/intra/Thesis/ProgramAnalysis][Specific subjects for theses projects]] (restricted access)
-->



-----++ Proxima: A generic presentation-oriented XML editor

The Proxima project is concerned with the design and development of a generic presentation-oriented XML editor. Proxima can be used for arbitrary XML document types, described by DTDs or Schemas. The two most important features are

   * support for specifying editable presentations of documents
   * support for specifying computations.

Topics on which you can write a thesis:

   * Develop two or more instances of the generic editor in order to find patterns that often occur in the specification of editors. Develop a small (embedded) language for specifying editors;
   * Develop an editor for Learning Design: an XML Schema for specifying digital learning material.

Contact: Prof Dr Doaitse Swierstra, Dr. M. Schrage

<!--
----++ Object-Oriented Programming

*Program Understanding*

Understanding existing programs is often difficult because the structure is hidden within
the code and dependencies between various parts of a program are not easy to understand.
Tools for understanding existing (legacy) code are essential to make such code maintainable.
There are typically two approaches to this: static analysis and dynamic analysis. Projects
in this area would investigate the program understanding tools for Java (or other OO) programs,
in particular by determining the relationships between objects and classes and the different 
roles which objects play over their lifetimes. This could be done either via static analysis of
code, dynamic analysis of evolving object graphs, or via some combination of these techniques.
Projects along this line have quite a lot of scope for experimentation.

*Confinement related projects*

   * *Confinement in Java Card.*
   Java Card is touted as the technology for writing secure smartcard applications. Part of the
   security mechanism involves using a shared object library and firewalls to protect Java Card
   applications from each other. This project would involve replacing this technology with
   an appropriate static analysis of the Java bytecode using ideas from Confined Types.

   * *Confinement-Safe Reflection for Java.*
   The reflection mechanisms in Java enables existing object boundaries to be
   crossed, potentially subverting any security mechanisms which are in place.
   Some of the potential holes have been plugged, but for more advanced
   security policies, weaknesses remain. We wish to see them eliminated too.
   This project will involve first investigating what means for controlling reflection
   already exist and developing further techniques to impose the constraints
   required by confinement schemes. Techniques involved will included 
   stack inspection, static analysis of Java bytecode and bytecode rewriting.

   * *Cheap, scalable confinement.*
   Explore confinement by adding protected classes to the 
   experimental OO language Scala.

*Component based development*

Quinity is a successful developmer of custom-built software systems for companies operating in the financial world, such as banks and insurance companies. These are produced quickly from standard components, using not just technical design patterns (!GoF and J2EE) but also functional design patterns, a concept developed at Quinity itself. In cooperation with several universities the theoretical concepts behind the Quinity development process are investigated further and tool support is being produced. Technologies used include Java/J2EE, SOAP/web services, XML/XSLT, !WebSphere/Tomcat, and relational databases, while AJAX is being introduced.

[[http://www.cs.uu.nl/intra/Thesis/QuinityCom][Please see here for details]]

Contact: Dr Lex Bijlsma
-->

-----++ Projects related to software testing 

There are currently several projects open, [[WP.MasterProjects][check them out here]]. 

*Contact persons*: [[WP.WebHome][Dr Wishnu Prasetya]]



-----++ Projects at Philips Research Eindhoven

At Philips Research, we have a number of projects in the field of sensor-based toys. These projects involve language design and/or software architecture. See [[%ATTACHURL%/ESPeranto.pdf][ESPeranto.pdf]] for further details.


*Contact persons*: Prof. Dr Doaitse Swierstra, [[Main.RobertVanHerk][Drs Robert van Herk]]


   * Set ALLOWTOPICCHANGE = Main.StGroup, Main.RobertVanHerk