Non-classical paradigms and languages


I may be the happiest computer-science teacher in the world: in less than three months, I will start teaching a whole new class called “non-classical paradigms and languages”. The goal is to let students pursuing their masters degree discover and manipulate concepts that they haven’t had a chance to play with when using mainstream languages (C, C**, Java and Ada being the ones they have been taught so far).
I do not want my students to know every language on the earth. However, I want them to be able to recognize that the problem they have in their hands could be more elegantly solved using continuations, or that embedding a Forth-like interpreter would make their program easier to test and extend.
Now comes the difficult part: what languages should I teach and what paradigms should I show? I have 60 hours at my disposal that I can freely dispatch between theory and practice . Since I will be leaving tomorrow for one week, I thought it would be a good idea to let people comment, either publicly or privately, on some of the ideas I got so far.

The students already know C, C** and Java quite well, and most of them have already played with Ada, Lisp (although only at a very basic level) or Prolog.

Below you can find an HTML export of the Freemind map I used to structure my thoughts. I did it in 10 minutes, so it is neither complete nor well organized. Do not hesitate to throw in new ideas or languages. The main constraint is that the students must be able to get the same environment at home as in the labs, meaning that a good Free Software implementation must exist (and will be used in labs). The only exception might be J if it gets included in the course as the language itself is very interesting (and simpler to use than APL on modern machines), and a free (gratis) implementation exists and runs on most platforms.

  • Concepts
    • Continuations

    • Stack-based languages

    • Image-based languages

    • Portable environments

    • Parsing, interpretation, compilation
      • Macros

      • Compile-time evaluation

      • Creation of domain-specific languages

      • Reflexivity

      • Code is data is code is data

    • System integration
      • Transparent parallelism

      • Live code update

      • Message passing and mailbox system

    • Functional programming
      • Lambda expressions

      • Closures

      • Lazy evaluation

      • Promises

    • Other flavours
      • Declarative languages

      • Languages working on arrays

    • Embedded interpreter

  • Languages
    • Common Lisp

    • Scheme

    • Smalltalk

    • J

    • Forth

    • Factor

    • Haskell

    • Erlang

    • LUA

    • Python

  • Open questions
    • Common Lisp or Scheme ?

    • Forth or Factor ?

  • Various

    • Implementations should be free software

    • No brainfuck, intercal, befunge, etc.

blog comments powered by Disqus