There are many possibilities for smaller projects in the context of SaC.
As an inspiration, we have listed several ideas for projects below.
However, we are interested in all kinds of new ideas!
If you have a nice idea for a project or would like to do one of the listed
below, please do not hesitate to contact us.
Although all the projects can be done purely for the fun of it,
they can also serve as a basis / be scaled to suit various
academic degrees such as:
- BSC / final year projects
- MSC projects
- 3 month placement / term break projects
Alternative Storage Layouts for High-Performance Computing
this challenge is taken up by :
[ Kamala Pitta (2008) ]
The arrival of multi-core processors in the mainstream forebodes a general
shift into distributed computing. An effective utilization of such systems
requires the software to be used on such systems to consist of chunks of
work that can be operated on independently and locally. For large data
structures such as arrays a reorganisation of the way the data is stored in
memory may have a vast effect on the localality of data and, thus, on the
runtime efficiency that can be achieved.
This project investigates the effectiveness of alternative layouts by using
the high-performance array language SaC. The
intended approach is to re-write several SaC programs in a way that mimicks
alternative layouts. Extensive performance comparisons will then give an
indication of the effectiveness of the layouts investigated.
Introducing Controlled Forms of Non-Determinism
-- Side-Effects within With-Loops
this challenge is taken up by :
[ Theo van Klaveren (2006)/ Torben Gerhards (2007)]
The central language for data parallelism in SaC, the With-Loop,
is side-effect-free. Although this is essential when it comes to
concurrent executions, in some situations, this restriction is rather
Examples for such situations include:
- dbug output within the body of a With-Loop
- pixel-wise output of computer generated images
- arrays of random numbers
In all these cases, we are not interested in the exact order the output /
side-effect happens. Instead, we want as much concurrency as possible.
However, the non-determinism should be confined within With-Loop boundaries.
Optimizing the optimization cycle
Over the years many standard and non-standard optimizations have been
integrated into the SaC compiler sac2c.
Most of the optimizations benefit from or even rely on the application of
As there exist mutual dependencies, the current compiler applies its
optimizations by means of several subsequent optimization cycles.
However, the dependencies between the individual optimizations have
never been fully analysed.
Instead the order of their application has been chosen in a rather ad-hoc fashion.
Another problem of the existing optimization cycle is the fact that the optimizations
have been developed over a rather long period of time during which some of
the side-conditions (such as restrictions on the AST etc) have changed.
As a consequence, some of the optimizations rely on assumptions that are only
partially true in today's setting, e.g., some well-formedness assumptions
do not hold anymore which -- strictly speaking -- may require some extensions
of these optimizations.
The challenge of this project is to analyse all optimisations for correctness
in the given setting and for relationship to other optimizations.
Building up on that information, correctness-issues should be resolved and
an attempt to optimize the order of optimization application should be
A SaC-frontend for Doxygen
Doxygen (for details see www.doxygen.org )
is a documentation system for programs specified in one of various
It provides facilities for deriving html documentations from source code
without requiring any program modification.
However, adding Doxygen-style comments provides a rich set of facilities
for enhancing the derived html documents.
While Doxygen is being used in the sac2c compiler project, it cannot yet be used
for SaC programs itself.
The idea of tis project is to make SaC a possible source language for
Due to the syntactical proximity of SaC to C, most likely, the main
challenge of this project is to come up with a strip-down parser for
SaC function signatures and to integrate it into the doxygen system.
An Eclipse plug-in for SaC
The Eclipse project
(for details see www.eclipse.org)
provides a multi-platform
framework for creating IDEs (Integrated Development Environments). It has been
successfully used for many different programming languages. A key to its
success is the clear separation between the non-language related core
facilities and the language specific parts which are kept in so-called
plug-ins. This concept allows new IDEs to be created with rather small
programming effort by efficiently making use of the core functionality of
The central idea of the project is to make use of the Eclipse infrastructure to
generate an IDE for SaC. A good starting point for doing so is the
web-site of Eclipse. It contains several tutorials on how to create new
plug-ins for Eclipse.
Visualising Array Programming by Spreadsheets
Array programming as provided by languages such as APL, J, or SaC allows for a
high level of abstraction. Most operations of these languages are applicable to
arrays of arbitrary rank (number of axes) and arbitrary shape (extends wrt.
individual axes). This generality of operators combined with the linearised
form of traditional programming style creates difficulties for novice array
programmers as not only values of expressions but their shapes as well have to
be kept in mind. A graphical programming tool for displaying arrays and for
composing simple non-recursive array operations would help overcoming this
problem as the shapes and the content of arbitrary intermediate expressions
could be visualised.
The idea of this project is to display individual arrays in separate windows in
a spreadsheet-style manner. These windows should be linked by means of
functional array expressions that define how one window's content is computed
from one or several other window's contents. The graphical user interface
preferably is created as a Java applet (see java.sun.com
for details and tutorials) as this eases portability.
While the graphical parts of this tool
have to be created from scratch, the underlying array programming machinery
can directly make use of one of the existing array programming languages. The
compiled array programming language SaC due to its side-effect free core
language as well as its C interface seems to be particularly suitable for this
A Universal Benchmarking Tool
this challenge is taken up by :
[ Maxime Castelein and Julien Viera (2005)/ Daniel Rolls (2008) ]
A prototype has been developed
by Maxime and Julien.
However, first experiences indicate room for some improvements to make
the tool applicable on a larger scale.
Dan tries to put these into action.
Benchmarking programs is always a time consuming task, in particular, when comparing
programs specified in different programming languages:
comparable versions of the same program need to be collected,
compilers need to be installed, compiler flags need to be identified,
program parameters need to be adjusted to the performance / capabilities
of the executing hardware etc.
The situation becomes even more annoying if measurements need to be redone
on a slightly different platform as it usualy requires all ad-hoc mechanisms
for measuring, such as makefiles or scripts, to be adjusted.
The core idea of this project is to develop an automated benchmarking system
which keeps all relevant measurement parameters in a database and automatically
deploys measurements whenever a new benchmark or executing platform is added.
SaC Server Pages
The idea of embedding programming languages in html is not new. For the java programming language there exist java server pages and even for Pascal pascal server pages have been developed. The aim of this project is to do the same for the SaC programming language. It is meant as an introduction into compiler construction and thus especially suitable for term break projects.
The project can be split into two orthogonal tasks:
- developing a ssp (SaC Server Pages) to sac compiler
- developing the SaC runtime support to allow for cgi programming in SaC
For the former, the implementation language can be freely chosen as long as it is portable among different platforms. The latter task has obviously to be implemented in SaC.
SaC Web Services
This project aims at bridging web service technology and the SaC programming language. The idea is to create a flexible framework that allows to input and process data gathered from web services and to write methods for web services in SaC. The project includes:
- designing SOAP representations for SaC datatypes and implementing the necessary runtime support
- developing a tool to generate SaC stubs from wsdl service descriptions
A Database Interface for SaC
Array visualisation in SaC
The array visualisation projects offers a wide range of possibilities. It can be anything from generating X3D to smart text output, from using OpenGL to using plotting libraries like DISLIN. The only constraint is your imagination and
- the ability to visualise arrays
- a smooth integration into SaC
- a portable implementation
Data Mining in SaC