Nice article. I've linked to some articles which you might find interesting. It includes a paper I prepared on creating evolvable programming languages encoded in a binary format called Argot. The language is still in early development, but I strongly believe that solutions similar to it is where future languages need to move.

I won't discount the importance of Ajax and "RIAs" as a deployment model -- even as a kind of domain within in which system architectures could be grouped. But these aren't new programming models. We use the same old programming models to build new kinds of apps.

Examples of Programming Models:
0) Hardware based programming (plugboards etc)
1) Stored program (program as data)
2) Assembly programming
3) High level language programming
4) Structured
5) Functional
6) Object oriented
7) Aspect oriented

RIA (Rich Internet Applications) is a marketing term Macromedia (Flash, Cold Fusion) conjured up as a way to get people looking at their development products. Even googling on the term only points you back to one vendor. Not exactly what I would call a model...

Avalon != Ajax. Avalon will be a system for declaratively defining a rich ui. The design will presumably allow for what is called a RIA here, but isn't limited to that. More analogous is Microsoft's 'Atlas' - which will probably be released much sooner, and be more cross-platform.

>>> Microsoft will try to catch up to with
>>> Avalon in Longhorn (now Windows Vista).

Late != unsuccessful. It matters little when Microsoft controls the browser and the operating system. They could start deploying RIAs (Avalon web apps) tomorrow and have broad support for it in the browser and OS if they wanted.

One thing's for sure: I have yet to see a web UI framework look as good as Avalon web apps. Aeroglass over the web looks great. I wonder how well it will be accepted by the public.

Better runtime environments and IDE's will be more important than any programming language. The way Java or .NET handle components should be an eye opener. What you want is code you can control, what does what you expect it to do.

On the runtime part:
- plugins (see Eclipse and OSGi technology)
- assemblies/libraries (see .NET framework)
- VM support (garbage collection, overflow handling, exception handling, bounds checking etc.)
- runtime information (reflection)
- supporting components (application servers, message services)

On the IDE part:
- parsing editors (see Eclipse)
- code analyzers (PMD)
- semantic links from code to design tools (needs a parsing editor to function best)
- unit testing

I see a mayor shift towards runtime technologies coming up ahead. I can see more flexibility coming up in how programs are run and objects are used. Compilers are already running in the background to use Java both as script and as compile time language, for instance. Java may be to strict on some issues however.

For programs, components, OO and the imperative model will probably be here to stay. Other languages will be used for their respective domains, but the language wars seem to be over for now (as each programming language looks more and more like its siblings). Lets focus on the runtime and supportive technologies. And getting the things running reliably, for crying out loud.

I don't think using multiple languages that try to accomplish the same thing is such a good idea (see .NET C++, C#, VB7 and J#). You end up learning all of them (see MSDN). Mixing with languages that use other programming paradigms could be usefull though.

ColdFusion got it right a long time ago. Sure, its a commercial platform, but being able to leverage C/C++, Java, and .NET and of course AJAX and Flash through simple, tag-based markup, really speeds things up. It can run on any major platform too.

I am amazed at the complexity level that you are writing about, when there has been thin clients (X Windows, ...) for a long time, and now NX which has the greatest of potentials. Investing in the network instead of redeveloping your applications is so much more efficient and cost effective!

Your web site truly sucks. I'm sure the story is great, but the audio multimedia which is on by default just makes me want to hit the back button straight away. All the animated adverts distract from the content too.

PS the e-mail address is a real one in spite of the gratuitously insulting user name :)

I guess when I think of 'models of programming' I think about things like Object Oriented or Functional programming categories. This article seems to confuse the idea of 'models of programming' with actual types of applications: desktop vs. Web apps or perhaps a fusion of the two. Now one could program either a desktop or web app (or an RIA) using either an Object-Oriented approach, declarative, functional or even a combination of them. Let's not confuse the application with the programming model (or perhaps programming metaphor would work here?)

If the question is what will the next model of programming be (beyond the current reigning Object Oriented model) then the answer could probably lie in the direction of Aspect Oriented Programming. RIA's may be implemented usian an AOP approach, but I don't think it's right to say that RIA's will be the new programming model. RIA's may be the new application model.

The trend towards RIA's/webapps has traditionally been restricted to those in a database centric role, but with the increasing use of AJAX and the like, the webapp is pushing further into the desktop application space. Obviously the centralization and server-side nature of the applications helps deployment and maintainance, but developers are basically trading the platform of an operating system for the platform of a web browser, with all the intricacies and compatibility issues that follow both.

Webapps are a good direction to take for data access apps, but where the line becomes less clear cut and extreme amounts of javascript/dhtml are needed to achieve behaviours, the apps can become somewhat clunky and difficult to use. To me, it's essential that the designers of today's webapps realise the limitations of what they're working with and when to use traditional desktop apps.

RIA is not a programming model. RIA is more of a type of architectural pattern...it is definately not a programming model like modular programming, object oriented programming, etc... Although I guess "programming model" could mean just about anything.

The author of the article should not have mixed something very specific ("framework") with something very general ("programming model").

>>> What we need is a parallel programming
>>> language that makes it easy and natural
>>> to take advantage of multi-core
>>> processors.

These have been around for ages, but mainly for scientific computing. For example Fortran 90 and later versions, but there are also variants of C++ and others. Usually they take advantage of obvious parallelity in the data, for example matrix multiplication, and make the processors handle the separate bits without bothering the programmer with threads etc. It's also the kind of computation that takes place in graphics cards with their multiple pipelines.

I don't see any easy way to do the same for general programming. For example, separate threads for user interface and the actual processing is a good idea, but a very high-level one, not the kind of thing that would be done automatically by a compiler.

I hope that the existing parallel programming languages would be more widely used for the computationally intensive parts. It seems so silly that home computers have focused on pushing single processor performance for all this time, while 'real computer science' has been reaping the benefits of parallel processing for years.

I'm pretty sure it will never be the rage, but I like Programming Language Oriented Programming for difficult problems that don't seem doable in C/++ or something similar.

Most programs can be written practally in most languages, since all you really need is "if", "decrement" and "goto". Some problems aren't a good fit for a given language. That's why there's more than one.

Any program that breaks its problem into chunks is in effect creating its own mini-language. Whether you call it Abstact Data Typing or Object Orientation or Functional Programming or even Top Down Design, what it comes down to is dividing the problem into manageable chunks and working with those chunks until done.

I wish all CS students were taught from day one, or maybe day fifteen, how to create their own programming language. Usually you have to take a compilers course to get that.

Creating a new language is not that hard. It gets a bad rap because people think they have to write a backend for a given architecture, but writing the backend to generate C++ or some other HLL is just as good, since they've already done the heavy lifting and you can automate the compile train with your favorite maker.

The best programming models are the ones from the past, as usual. Lisp, Forth, these languages created a community of best-practices that we are all reinventing all over again.

Ruby on Rails is great, not because it's something NEW, but because it wraps up all these best practices with a friendly face.

Creating simple domain-specific languages is how talented programmers do things already, with powerful languages like Lisp. However languages like PHP, Python, Java, TOOK AWAY this ability because language designers thought it was "unnecessary" or "too complicated" for the average programmer.

Along comes Ruby, which gives you back some of that power. And a talented programmer took it and "did the right thing" by creating a tight domain-specific language. Now everybody is so excited. Great, whatever makes programs simpler and more expressive is fine by me.

But can we please stop talking about the "next" great thing, when hardly anybody remembers the great things from the past?

If there's any problem in this industry, it's that programmers have ZERO knowledge of fundamentals. Instead of standing on the shoulders of giants, they constantly re-invent wheels.