Project requirements

The project allows passing this course with 3–6 credits. In that case, you will not take an exam. Instead of the project, you may take a 2-credit exam.

Your project must be able to execute (either using translation or interpretation) programs written in some source language. The credit total for the project will be computed based on the following requirements by summing the credits due to the source language and the credits due to the implementation techniques (maximum of 6 credits in total).

Excess credits not counted due to rounding or due to the maximum will be compensated in the course grade.

Source language

Mandatory features (3 cr)

• readable (no binary blobs)
• comments
• at least two different data types (type errors must be caught at runtime at the latest)
• integer arithmetic
• choices (e.g. if)
• repetition (e.h. loops or recursion)
• parametrizable subroutines (e.g. functions or methods), in which local variables can be used

Additional features

• records and variants (0,5 cr)
• generic (static) types (0,5 cr)
• classes with late binding (0,5 cr)
• first-class functions (0,5 cr)
• garbage collection (completely your own work) (1 cr)
• recursive pattern matching similar to Haskell (0.5 cr)

You may also propose your own features (AJK and VT will estimate credits on request).

Implementation techniques

Credits listed here will be summed with the credits due to source language features.

• direct interpreter based on a parse tree 0 op
• generating intermediate code (e.g. your own, JVM, or LLVM) 1 op
• generating machine code (e.g. AMD64 tai ARM) from intermediate code
  • naive register allocation 1 op
  • smart register allocation (e.g. by graph coloring) 2 op

Grading principles

An acceptable project

• is submitted for grading following submission instructions (TBA)
• incldues all the parts typically found in a compiler (deviations are documented with acceptable reasoning)
• has been prepared in accordance with the principles of academic honesty

When grading a project, the following areas will be specifically noted (in decreasing order of importance):

• Degree of completion
  • 1 – works with one example
  • 2 – works with a handful of examples
  • 3 –
  • 4 – works largely without problems
  • 5 – works without issues
• Originality
  • 1 – composed mainly of code snippets taken from elsewhere (which have been used in accordance with the principles of academic honesty)
  • 3 – composed mainly out of modified example code without using directly quoted code snippets
  • 5 – not based on formulaic reuse of example code
• The difficulty and applicability of algorithms used (each algorithm assessed separately)
  • 1 – the chosen algorithm is not very suitable for what it is being used
  • 3 – an applicable simple algorithm
  • 5 – an applicable difficult algorithm
• The degree of documentation of module interfaces
  • 1 – no interface documentation
  • 3 – interfaces have been largely documented, but there are issues
  • 5 – all interfaces of importance have been documented
• Clarity of code
  • 1 – it is difficult to follow the logic of the program for example when hunting a bug
  • 3 – the structure of the program is clear, and it is easy to locate where a specific thing is done
  • 5 – as 3, and additionally, the internals of each subroutine and module are clear

The final grade of a project is based on a whole-project assessment, where the points mentioned above are taken into account. The grade takes into account also the general feel of the project and the number of students participating in its construction. The grade will not be mechanically computed from the assessments of the subareas mentioned above. A written statement giving reasons for the grade will be provided.