Our society depends more and more on well understood and precisely described protocols. For example for
- handling financial transactions,
- negotiating and agreeing upon contracts,
- handling tax forms automatically,
- holding computerized auctions.
We have reached the state where these actions cannot be performed without extensive support from information processing systems. The size of such systems has grown to enormous complexity. Such systems should of course function correctly (are the rules implemented in agreement with current legal rulings), but also in the construction one has to
- plan for the adaptability of such systems to changing requirements (laws change),
- predict the time and effort it takes to construct such systems (tax forms are to be handed in by the first of April),
- define the way such systems interact with other information processing systems (coupling tax forms with other financial programs).
The sheer size of such systems is such that they can no longer be constructed "from scratch"; we are forced to use existing software infrastructures (middle-ware), ready made components and software libraries in the construction process. Furthermore, we have to produce new code more efficiently by
- transforming similar, already existing components,
- designing special purpose languages and generating software by compilation,
- employing better programming techniques in general.
Besides the problems associated with the construction of new software, the fact that we have millions of lines of existing code (legacy software) is increasingly becoming a problem on its own. This software is often not well documented, no longer well understood and ill structured. Nevertheless a lot of the business logic of a company may be embedded inside a legacy system, and thus the product cannot simply be discarded. The increasing knowledge in the area of (global) program analysis can be used to recover those design decisions that are no longer explicitly visible, and program transformation techniques can be used to recycle such legacy code.
The Software Technology (ST) program studies all techniques that may be employed in the production of actual software. We do so by starting from sound theoretical foundations, with a strong focus on real applicability. It includes programming methodology, programming formalisms (languages), programming tools, software architectures, component based programming, specification formalisms and verification techniques (correctness proofs, theorem proving).
The Master Program is internationally oriented: the program is open to foreign students, and courses are taught in English. Students have the opportunity to follow courses and do projects at foreign universities and institutes. There are two streams in the program: a research-oriented track for students with a desire to obtain a PhD position or a research position in a company, and an industry-oriented track for students who are interested in jobs as software designer in industry. The program results in a degree Master of Science in Computer Science. The program is offered by the Center for Software Technology, of the Institute of Information and Computing Sciences at Utrecht University.
Software Technology lives at the core of computer science, and no other specialization area can do entirely without it: in the end the goal of all computer scientists is to produce executable code. Everyone producing software has to answer questions as to how to write software, what other software to use, what tools to use, how to interface with other products, how to specify, verify and test, how to document and how to plan the production process. The ST master program focuses on the following themes: programming methods, programming language design and implementation, software engineering tools, program analysis and program transformation, specification and verification techniques. We strongly believe that theory development, tool construction and application of the tools go hand in hand and are dedicated to integrate all three aspects in all the subjects we study and teach.
Generic Programming and Type Systems
Over the years programming languages have become more and more expressive; we no longer only abstract over statements (procedures) and expressions (functions), but also over types. Recent developments enable us to talk about type indexed functions, kind indexed types etc. This increased expressiveness enables us to write less code, and to reuse the code written in a much more flexible way. Class systems enable us furthermore to abstract over whole collections of design decisions. An additional effect of the use of more general and expressive type systems is that they also provide an implicit correctness proof of the program; as a result far less debugging and testing remains. With the increasing use of XML for encoding all kind of data to be stored and exchanged the ability to handle such data in a generic ways becomes of essential importance. Students learn about generic programming techniques, type analysis, and the application of such techniques in XML based programming, for example in the construction of generic editors.
Programming Language Implementation
As programming languages become more and more expressive their ease of use for the every day user unfortunately does not increase; thus a subset, a special library or even a special purpose language is defined for a specific application area. General programming languages are more and more used as powerful tool sets to support the use of such special purpose formalisms in an efficient way. Polymorphic types and lazy evaluation make it easy to define so-called combinator languages that enable the embedding of a special purpose language into a general purpose language. Such combinator languages support fast and easy construction of programs wherever possible, while maintaining full expressiveness to be used wherever needed. We study the construction of combinator libraries, how to embed global analyses in the implementation, and how type systems help us to define such languages. Special interest is paid to generic implementation techniques that enable us to present error messages stemming from the inner working of the implementation in terms of the special purpose constructor language.
An actual piece of code is the result of many, mostly independent, design decisions that each deal with a different aspect of the specification. Unfortunately the results of such decisions (sometimes expressed in the form of "design patterns") are dispersed all over the program text, and consequently hard to change or undo. The recognition that this is happening over and over again has resulted in the research area coined "aspect oriented programming". Especially in the area of object-oriented programming, with its less well developed abstraction mechanism, the need for such an aspect oriented view towards a product is increasingly important. We study the deficiencies of current programming formalisms, and seek to extend them with support for first- class aspects that can be passed as argument and can be abstracted from.
One way of implementing a program is not by applying a one-step compilation, but by gradually transforming a high-level, but probably inefficient specification into a low-level, but highly efficient implementation. We apply this approach for example in the generation of machine code for digital signal processors. Another area where program transformation is important is in dealing with legacy code: it is in many cases simply not feasible to throw away existing code. We may however try to analyse such code in order to recover parts of its original specification hidden in the outcome of many implementation decisions made in the past, and then transform the program into its new, currently desired form based on the result of such analyses. The group has extensive experience in the design, implementation and use of programming transformation systems.
The holy grail of programming is the construction of code that is guaranteed to function correctly. Normally one tries to achieve this goal by debugging and systematic testing. When dealing with distributed algorithms this is unfortunately no longer possible. A rigorous approach, based on formally defined semantics and specification mechanisms is needed to prove distributed algorithms correct. Even after an algorithm has been proven correct it is not yet guaranteed that the final implementation was made according to the idealized case that was proved correct, whereas on the other hand the formal verification of the final product is far out of reach. We construct environments in which the formal verification and the incorporation of the verified code into a product are integrated; as such this area of research is strongly linked with the areas described above.
To be able to perform program transformation, information must be obtained from source code
efficiently. This is the area, which includes most notably the area of type inferencing and
checking. Other examples of program analysis are dead-code analysis, security analysis,
live variable analysis, control-flow analysis, strictness analysis and binding time analysis.
Center For Software Technology
The ST master program is offered by the Center for Software Technology
of the Institute for Information and Computing Sciences
of Utrecht University
, headed by Prof.dr. Doaitse Swierstra
. The research group focuses its research
on generic programming, compiler construction techniques, program analysis, program transformation and formal verification of distributed algorithms. The center collaborates with many Dutch companies located in the neighborhood, amongst which the Software Engineering Research Center (SERC), a not-for-profit research institute located on the university campus. Researchers of the center are all members of the Dutch research school IPA (Institute for Programming research and Algorithmics: http://www.win.tue.nl/ipa/
). Members of the Center are involved in the international IFIP working group 2.1, and has intensive contacts with researchers from Oxford, Nottingham, the Kestrel research institute (USA), Chalmers (Gothenburg, Sweden), Bonn, New York University and Indiana.
The center forms part of the Institute for Information and Computer Science, which offers a broad range of courses covering most aspects of computer science. Besides the specific ST courses, students can also take some courses in other areas of computer science. Within the center students work together with staff on research projects in an informal, stimulating environment, in continuous contact with other Master and Ph.D. students. Students will get office space in the center and the center features a laboratory with modern computing equipment.
More information about the Center can be found on the web site: http://www.cs.uu.nl/groups/ST
Most of the people employed in the ICT industry can be characterized as software engineers. Unfortunately many of them do not have a formal education in Computer Science. Having followed the ST program, alumni will be able to identify the problems complex organizations have in constructing software and will be able to develop solutions for such problems. We want to emphasize that the program does not focus on specific products or tools from specific vendors; instead we study underlying techniques and methods with a longer lasting value.
For a student who follows the research-oriented P-track, the master degree gives the opportunity to start a PhD research project, leading to a doctorate degree, in any of the related topics, at a university in the Netherlands or abroad. There are a number of such positions within the Center for Software Technology itself and there are ample contacts with other universities, partly through the country wide Dutch Research School IPA. Some of the positions are sponsored by the SERC (http://www.serc.nl
), some by companies, and some by the Dutch research council. A graduate may also find a challenging position in a research-and-development department of an international company, in the government sector, or in the banking- and insurance sector.
A student will be well qualified for a job in many different companies, for example in banking, insurance companies, government, telecommunication and consumer electronics. His or her task could consist of developing new products and applications, or leading such activities. Other possible jobs are in consultancy, or creating a start-up company in an emerging market.
The master program Software Technology takes two years of study and
has a total size of 120 European study points (ECTS).
The academic year is structured into four periods. In each period a students usually takes takes two courses of 7.5 ECTS each.
The structure of a typical program is summarized by the table below. If you need a full overview and schedules over all CS courses see also here: http://www.cs.uu.nl/education/
It is important to realize that the following explanation
of the master curriculum is a general one, and every
study plan that follows it is allowed by default. Depending on
requirements and knowledge of the student, he and the student advisor
can agree to divert from the standard.
It is possible to start the program in February (period 3), but if you
must do the Deficiency course
(this is often the case for foreigners and people
coming from HIO/HBO), then it makes no sense, because that course is only offered in September.
If you have no deficiencies in functional programming, grammars and parsing, then starting in February is no problem.
If you are unsure whether you have deficiencies, contact the student advisor
Seminars are not restricted to period 1: other periods also offers a number
of seminars. Consult the list of seminars below to see what is offered this year.
Courses (75 ECTCS = 10 courses)
Mandatory Courses (15 ECTS = 2 courses)
The following courses are required for all ST students:
If one or more of these courses have already been taken as part of the
bachelor program, or equivalent courses have been taken elsewhere,
courses from the list of Advanced Courses
must be chosen.
Advanced ST Courses (30 ECTS = 4 courses)
At least four of the following courses should be taken from the following list:.
Profiling (22.5 ECTS = 3 courses)
This gives you the space to tailor the master program to fit your academic interest. A small part of this space is also used to compensate for missing background should that be the case. Using this space is bound to the following constraints:
- If you are deficient (see below), you must take the deficiency course (1 course)
- You can fill your Profiling space with any Advanced ST courses
- You can take at most one Experimentation Project (count as 1 course)
- You can take at most one extra ST seminar
- You can take at most 2 courses from other master programmes in Computer Science
- Courses used to substitute for mandatory courses do not count towards filling the credits for this part of the curriculum.
- In the previous version of the curriculum, we have Free Choice and Elective as separate categories. They are now merged into this "Profiling space". Nothing change in terms of content; we just change the way they are explained.
Deficiencies (7.5 ECTS = 1 course)
Students without a computer science bachelor from Utrecht University,
typically lack bachelor courses on functional programming, formal languages,
and compilers. You will need these background to do the ST master programme.
We offer a special 'deficiency course' (7.5 ECTS) to remedy those deficiencies. It is called the course FPLC
which is given in the 1st period.
If you have no deficiencies then you obviously don't need to do the deficiency course.
Seminar (7.5 ECTS, count as 1 course)
Seminars usually take the form of small study groups in which a subject is
studied in depth and may also have a practical component. The subjects
are usually closely linked to the research conducted in the CST and
follow up on earlier courses in the program.
In 2009-2010 (usually for students arrived in 2008) the following seminars
will be given:
Note that Data Base Architecures can be used either as a seminar or as
an advanced ST course, but not both at the same time. The student is free to
choose how he uses it, though.
Thesis Project (45 ECTS)
In the final thesis project a student performs research under the
supervision of one of the staff members of the center. The project can
be conducted in the ST-Lab of the center, in a company, or (partly) in
a related (foreign) research group.
Thesis projects are structured in three phases: colloquium, proposal,
and research. See further below for additional information about this part
of the curriculum if you are a doctoral student.
Software Technology Colloquium (5 ECTS)
In order to prepare for the thesis project and get a broad overview of
ongoing research in the Center and beyond, students attend the weekly
Software Technology Colloquium
. This colloquium provides a broad
overview of interesting results in the ST area by means of research
talks and paper presentations by internal and external speakers. Each
student should attend at least 30 colloquium sessions, give one
colloquium presentation about a topic of choice, and write a literature
study about this topic. Here
you can find a list
of possible papers/programs/libraries to discuss. It is important
that you first find a staff member or PhD student to judge your work, and
start off on your own.
Thesis Proposal (10 ECTS)
After the colloquium obligations have been fulfilled, and with at most 7.5 ECTS op course obligations left, a topic for a thesis project can be chosen. Before actually
starting the research, a student writes a thesis proposal
a problem statement for the proposed research, positioning of the
research with respect to other research, an overview of the literature
in the field, and a planning for the project. The proposal should be
accepted by the thesis committee before the project can start.
Research and Thesis (30 ECTS)
The final part of the project consists of performing the research
according to the plan in the thesis proposal and writing a thesis
about the result. Relevant parts of the proposal will typically find
their way into the thesis. The project is finished with a defense
of the thesis before the thesis committee.
Courses or seminars taught inside the department and not mentioned below may be
approved upon explicit request, especially in relation with the choice of a specific thesis area.
All Courses Taught by the Department
The full list and schedules of all
courses offered our Department of Information and Computing Sciences can be found in the Department's education page
Curricula of Previous Years
At the start of the year
A student first discusses his or her interests with the student advisor
for ST. Together with the student advisor a student chooses an individual program that suits his or her background and interests. This program may be adapted through the years.
It is best if the student first discusses changes to his program with a staff member. This is one of the
roles of the mentor
A student is assigned a mentor who will guide the student through the master program.
His main task is to keep track of the progress of the student, to assist him when he has questions
regarding (changes in) his individual program (especially when it concerns the elective courses)
and other matters related to his study. The name of the mentor for each student can be found on the
pages, following the name of the student.
More specifically, two weeks after the start of the course year, the mentor verifies that the student
has in fact enrolled for (at least) two courses in each period, and that the collection of courses
can lead to a master in ST. This process will be repeated two weeks after the close of each period.
Then the mentor also checks whether the student is doing well enough. If not, he will make an appointment
with the student to talk about it. Naturally, the student can also come to the mentor on his own
During the final thesis project the role of mentor can be taken over by the supervising staff member.
The role of lecturers
The role of the teacher of a course or seminar is that of a supervisor, rather than a lecturer. A student is given room to take initiatives, and is challenged to pose problems, propose solutions, and perform both theoretical and practical experiments. A student writes papers, does assignments, and presents his or her results. The active acquisition of knowledge and experience is central to the master program, for individual students as well as for groups. An exam is often in the form of one or more projects, writing reports, etc. An assignment that has been handed in is evaluated, and feedback is given to the student. The grade often also depends on the number of iterations before a good (not: just acceptable) version is produced.
The thesis project
The final thesis project, when done within the institute, will be conducted in close collaboration with researchers. A student will be assigned a desk in the research group and actively participate in the discussions. A thesis supervisor will monitor the progress and advise the student. When the final project is done in a company, both a local supervisor in the company, and a supervisor in the institute are assigned who together monitor and guide the student.
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.
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
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
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 thesis projects on generic programming
Contact: Prof Dr Johan Jeuring
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: Dr. Jurriaan Hage
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
Projects related to software testing
There are currently several projects open, check them out here
: 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 ESPeranto.pdf
for further details.
: Prof. Dr Doaitse Swierstra, Drs Robert van Herk
The master program is intended for
- a graduate with a (3-year) bachelors in computer science in the Netherlands,
- a graduate with a bachelors in information sciences, or artificial intelligence, with a minor in computer science,
- a graduate with a bachelors in other exact sciences in the Netherlands (acceptance depends on the program of the candidate; see below),
- HIO graduates,
- other HBO graduates (acceptance depends on the program of the candidate; see below),
- a graduate with a bachelors in computer science from other countries (acceptance depends on the program of the candidate; see below).
At the start of the master program, a student should:
- have a basic knowledge of logic
- be able to reason formally
- have a reasonable experience in the use of several programming languages (amongst which functional and object-oriented languages)
- have basic knowledge of grammatical formalisms, parsing and analysis techniques
- have basic knowledge of modern software structures
- have knowledge of the workings of computer systems, networks and operating systems
- have a basic knowledge of algorithms and data structures
- be able to communicate facts and findings verbally and in writing, also using information and communication technology and audio-visual means.
A bachelor student taking the current computer science study at Utrecht University is assumed to have the knowledge and skills corresponding to the courses 'Imperative Programming', 'Datastructures', 'Functional programming, 'Grammars and Parsing', and 'Overdragen van de Informatica'.
In September there is a special 15 ects course offered for those in need to remedy deficiencies in
functional programming, grammars and parsing . If you are deficient in these areas, you must finish this course before taking any other course in the program.
The ST master program starts twice a year, in September and in February. There is no entrance exam but, as indicated above admission depends on the bachelor program of the student. There is no set limit on the number of accepted students. Details of the admission procedure depend on where you got your bachelor degree (or equivalent).
Students in the computer science bachelor or `doctoraal' program at Utrecht University should consult
Students with a bachelor degree (including HBO) from other Dutch educational institutes should consult
International students should consult
The deadline for application for Dutch students is July 1, 2009. Contact us if you encounter problems when applying
for our program.
When to start
As indicated above there are two moments one can start with the Master Program: September and February. For those who are deficient in one or more subjects we teach a special course in English starting in September (7.5 ECTS), which is a combination of the two bachelor courses on:
- Functional Programming (in Haskell)
- Grammars and Parsing
This knowledge presented in this course is a prerequisite for the course on Compiler Construction.
Individual Study Plan
The fact that you are admitted implies that it is possible to define at least one individual study plan within the boundaries set for the Master Program, using the 15 ECTS for solving deficiencies in previous education. In order to make sure that no problems arise in defining your individual study plan all students are required to have an approved study plan within two weeks after the start of their registration as a student in the Master Program. Of course the program may be adapted as need arises, provided it is approved again by the program leader or student advisor
For more information about the contents
of the master program you may contact:
For all questions related to administrative aspects
of the admission procedure contact: