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


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:

  • Design Your Own PL (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.

  • DSL for CPS (Zaytsev)

    Cyber-physical systems (CPS) are complex systems of intertwined physical and software components. Autonomously driving vehicles, smart electrical grids, medical monitoring systems, secure access systems with electronic keys, and many other examples are all around us. In the scope of an ongoing large industrial-supported Zorro project aimed at reaching zero downtime in cyber-physical systems by devising and implementing smart diagnostics methods for them, we are interested in a way to encapsulate the knowledge about a cyber-physical system and express it in a compact yet powerful specification/program/model. How do you write down that there is a sensor? An actuator? How do you write down a rule that if a sensor is down, its value can be approximated by a computation formula based on two other sensor's values? How do you express a wish that the lights should go out ten minutes after the last person leaves the room? Time for you to get creative and make those decisions!

    The minimal contribution of this project…

  • 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!

  • Platform independent LLVM IR (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:

    Interested in something similar, having your own ideas? Even better!: