Here is a first bunch of links concerning the perspectives of your Master Project. As you might remember we're talking about concepts like "Middleware", "Tangible Computing", "Programming", "Live Coding", "Digital Performance" etc..
It turned out that this is a much more time consuming task than I expected - partly, because it should be a GENERAL overview which at the same time shouldn't distract you from your main focus; partly, because such an overview is always personally biased, and I'll be trying to be as objective as possible 
Therefore, in my first "bunch of links" I will focus on Programming. Additional bunches will follow.
Programming:
There is an endless number of different programming languages, but only some basic "paradigms"; also - as usual - there are "fashions" ...
Some of the main programming paradigms are (en.wikipedia.org is a good starting point for all of them):
• Functional Programming
• Imperative Programming
• Object Oriented Programming
• Declarative Programming
• Constraint Based Programming
Many languages are multi-paradigm, like Java or Lisp. We also have to distinguish between sequential programming and parallel (distributed) programming.
For mostly historical reasons, the most widespread paradigm is sequential imperative programming; hence it looks very "intuitive" to most people. Unfortunately, it's very error prone and not very robust; in particular, if you start to expand the imperative style to distributed programming it's getting really bad.
The other extreme is "functional programming". It's inherently parallel and very robust; for most people it looks (at least at the beginning) not that intuitive (except for people with a strong mathematical background).
Object Oriented Programming (OOP) is probably the most familiar paradigm right now. It sits somehow between the imperative style and distributed programming; with "pure" OO languages (like Smalltalk), the focus of computation is on "message passing".
In order to get the most exciting experience, and getting most productive, there are - IMHO - two basic features a programming language/environment should have: (1) dynamic, realtime interactivity (ideally: capability of live coding), and (2) programmability, i.e. it should be a "programmable" programming language. The latter means - roughly - the possibility to build domain specific languages (DSL) on top of the "main" language. Some people think that Language Oriented Programming (LOP) turns out to be the next big "Programming Paradigm".
Another important aspect for choosing a language is the availability of a professional integrated development environment (IDE), with features like code completion, syntax-sensitive editors, class- and library browsers, version management etc. etc.. Ideally, all this would be Open Source and cross-platform.
Finally, there should be a powerful "foreign function interface", and an appropriate set of domain specific libraries ("middleware", Multimedia APIs and appropriate Frameworks). In our case this means probably a C/C++ interface, and strong libraries for image processing, graphics, audio, video, networking, and physical computing.
With all this in mind, we should have a closer look at the following languages/IDEs (or better: language families):
This is the "oldest" OOP language - it somehow introduced the concept into the community. There is only a remote similarity to current OOP languages like C++ or Java; Smalltalk - in this respect similar to Lisp, and unsimiliar to most other languages - has a theory behind it (Actors), and is essentially based on so-called "message passing". Insofar it's much closer to distributed languages like Erlang.
Having a strong theoretical background results in a lean, consistent implementation. One of the best supported implementations at the moment is Squeak, which is also part of the just launched OPCL project. Despite the fact that it looks (with its standard image) rather "childish", Squeak is a full-featured, powerful language and IDE, and has very good support for multimedia and networking. It's Open Source, and there are at least three interesting big applications right now, eToys, Seaside and Croquet. (For the latter one, see also here).
Other implementations are VisualWorks, GNU Smalltalk, etc.
There is also a Smalltalk "wrapper" around Cocoa - one of the main OSX Programming APIs - called F-Script, which somehow enables developers to programm OSX applications directly in Smalltalk.
A similiar, interesting implementation for the .NET Framework is Vistascript.
Lisp (== List Processing Language) is the second oldest "high-level" programming language (1958), invented as a tool for implementing lambda-calculus-based computer programming. There exist a lot of different "dialects"; the two main implementations right now are Common Lisp and Scheme.
"Pure Lisp" was a functional programming language. Today, both Common Lisp and Scheme are multi-paradigm languages, supporting functional, object-oriented, and imperative programming styles.
The real power of Lisp is its DSL-capacities, in particular its ability to get written in itself! There is a nice, short paper by Paul Graham, where this aspect of Lisp is discussed.
For a long time Lisp was considered as an AI-Language (Artificial Intelligence), and with the rise and fall of the AI-Hype, Lisp was - transitorily - forgotten. Today, there is a sort of revival, and more and more people realize the immense power of this programming language (You will find an excellent starting point here - read the comments!).
Whether Lisp (Common Lisp or Scheme) itself will survive, or some (new) developments like Qi or NewLisp, or whether none of them but one of the upcoming Metaprogramming Systems - who knows?
It's at least interesting, that in recent times several Lisp-based media programming tools have been (and are still) developed (like fluxus, impromptu, PWGL - more on these later), and - right now - Lisp seems a very reasonable choice for doing DSL-oriented prototyping.
A good starting point for Common Lisp is PCL (by P. Seibel - a free download is available) and the "Road to Lisp Survey"; for Scheme it's DrScheme.
Besides Ruby and Python, which integrated a lot of Lisp language constructs, there is also Clojure - a young, new scripting language targeting the JVM (Java Virtual Machine), meaning that you can write Lisp, and run Java ...
Java
So here we go.
"The real romance is out ahead and yet to come. The computer
revolution hasn't started yet. Don't be misled by the enormous
flow of money into bad defacto standards for unsophisticated
buyers using poor adaptations of incomplete ideas."
- Alan Kay