Programming Languages & Paradigms

There are many programming languages out there, with different features for solving different problems. Most of them can be roughly categorized in what paradigms, i.e., approaches to programming, they support. Three well-known paradigms are:

Note, however, that many programming languages support more than one paradigm, or are somewhere in between. For example, Python also supports functional programming, and C++ and Java have evolved from purely imperative languages to also support functional features, like lambda abstractions. An overview of many paradigms and languages can be found in this video, which is based on Peter van Roy's overview.

Alternatively, depending on their application domain, programming languages can be categorized as:

In this topic, we cover questions about programming languages, including their design, features, and implementations. Typical projects in this topic

Prerequisites

Related Modules

Available Project Proposals

If you are interested in the general topic of Programming Languages, or if have your own project idea related to the topic, please contact us directly. Alternatively, you can also work on one of the following concrete project proposals:

  • Automate the Automaton (Zaytsev)

    Design a notation to write a particular class of automata/languages/grammars between the regular and the context-free class, implement your own generator of parsing automata for it.

    See the full project description. Get in touch with your potential future supervisor to discuss details!

  • Design Your Own PL (Peter Lammich)

    Design your own programming language, trying to combine fancy features from recent modern programming languages in a reasonable way. Use LLVM as back-end, to get all standard optimizations and code-generation (almost) for free.

  • Platform independent LLVM IR (Peter Lammich)

    Modify the LLVM Intermediate Representation to be platform independent.

    Motivation and Problem Description: 

    The LLVM project provides an infrastructure to build compilers. In particular, it defines an easy to use intermediate representation (LLVM-IR), that serves as the interface between compiler front ends and back ends. It comes in a binary and textual syntax. This makes developing new compilers easy, as all the hard optimization and machine code generation work is done by the backend, and a new compiler only needs to generate (unoptimized) IR. However, the LLVM-IR is platform dependent and generating it depends on using the LLVM libraries, which restricts the implementation language for your compiler to those that have (well-maintained) bindings for these libraries.

    Example: Unions

    A union type overlays several types in memory. It is an important low-level concept required for the implementation of many high-level features (e.g. Haskell's algebraic datatypes or C++'s variants).

    To implement a union datatype in LLVM-IR (e.g. union { i32, float, i8* }), you have to define a type whose size equals the biggest member type. Which one that is can depend on the platform, e.g., the size of a pointer. Using the LLVM library, it's easy to obtain the size of a type, and define, e.g., a byte array with that many elements: 

    %t = type [ 4 x i8 ]

    However, LLVM-IR has no syntax to symbolically express this size, e.g., there is nothing like:

    %t = type [ max_sizeof(i32,float,i8*) x i8 ]

    However, the latter would still be correct on any platform (while the former only works for platforms with 32 bit pointers). Moreover, without bindings to LLVM's libraries, a correct size computation is difficult and error prone (it depends on platform ABI, alignment, etc).

    Your Tasks

    1. Identify platform or library dependencies in LLVM-IR
    2. Propose modifications to make LLVM-IR (more) platform and library independent
    3. Implement and evaluate a prototype

    Interested? Drop me an email: p.lammich@utwente.nl

    Interested in something similar, having your own ideas? Even better!: p.lammich@utwente.nl

  • Help Rich Info Get Richer (Lathouwers, Zaytsev)

    ProVerB, or Program Verification Book, is a project collecting information about software tools for program verification of all kinds. Each entry contains data and metadata, describing what the tool does, what are its inputs and outputs, how formal are certain kinds of artefacts that it requires, when was it published, is the source code available, etc.

    This BSc final project involves reviewing, enriching and, if necessary, redesigning the data model of the project, and coevolving the existing entries accordingly. For example, now many entries contain a link to a GitHub repository with the tool's source code: one can easily imaging writing a helper script that follows that link, checks for its availability, records the timestamp of the last commit and improves the entry by explicitly stating when was the source code last updated. The project is open and can be extended or refined to the wishes and creative ideas of the student.

    See the full project description. Get in touch with your potential future supervisors to discuss details!

  • Is My Network Safe? (Caltais, Hahn)

    We live in a network-­centric world where communication supported by robust and reliable network systems is of real importance. For an example, in 2012, the Google server crashed for 40 minutes which, in turn, caused Gmail and Chrome to crash all around the world, leaving millions of users without access to their data. Troubleshooting the issue and identifying the root cause of the event revealed a faulty load balancing configuration which was eventually fixed.

    If you are interested in programming languages and frameworks for the rigorous design and analysis of (software defined) networks, take a look at the project description and get in touch with us!


  • If There Is a WITH, There Is a Way (Zaytsev)

    There are many different constructs in existing programming languages: conditional (IF, COND, EVALUATE, SWITCH, CASE, etc), iterative (FOR, FOREACH, DO, WHILE, PERFORM, etc), and many others. However, there is always space to add another one! In this project, you implement a WITH construct in some way on top of a language of your choice.

    See the full project description. Get in touch with your potential future supervisor to discuss details!

  • There Can Be Only (the Fastest) One (Zaytsev)

    There are many data structures known to humankind, some more popular than others. It can be said that each data structure has two sides: the external side with visible commitments (like a list that promises to keep the order in which the elements are stored and retrieved, but a set does not save the order but promises each element uniqueness instead), and the internal side with the implementation details (something behaving like a set can be implemented based on an array, a list, a bit map, etc). Pick a data structure family, identify its externally visible set of operations, find possible internal implementations, conduct experiments, visualise results.

    See the full project description. Get in touch with your potential future supervisor to discuss details!

  • Unlikely Friendship Among Tools (Lathouwers, Zaytsev)

    ProVerB, or Program Verification Book, is a project collecting information about software tools for program verification of all kinds. Each entry contains data and metadata, describing what the tool does, what are its inputs and outputs, how formal are certain kinds of artefacts that it requires, when was it published, is the source code available, etc.

    This BSc final project involves using the dataset behind ProVerB to find matches among the tools that are not currently explicitly expressed. For example, two completely unrelated tools may be using the same format for some information: if one of them uses it as input format and the other as output format, it should be useful to link them since they can be used in together in a pipeline.

    See the full project description. Get in touch with your potential future supervisors to discuss details!

ContacT