What are the Next Programming Models?

jg21 writes "In this opinion piece, Simeon Simeonov contemplates what truly new programming models have emerged recently, and nominates two: RIAs and what he calls 'composite applications' (i.e. using Java, .NET or any other programming language). He notes that Microsoft will be trying to achieve RIAs in Avalon, but that it's late out of the gate. He also cites David Heinemeier Hansson's Ruby on Rails project as showing great promise. 'As both a technologist and an investor I'm excited about the future,' Simeonov concludes. It's a thoughtful piece, infectious in its quiet enthusiasm. But what new models are missing from his essay?"

Comments

What about Small

[mu22le]

I have heard marvels of Embryo Enlightenment version of SMALL

Don't forget the ways of Apple

[kinkadius]

the Cocoa/Objective-C implementation might be worth talking about, especially as how it has evolved from it's roots in next step.

funny AND interesting, but yeah FP...

[MarkEst1973]

Paul Graham has written extensively on how languages are becoming more and more like one from yesteryear: LISP.

See Beating the averages for a well-written and thoughtful essay.

In a nutshell, languages themselves vary in power. No one disputes that. All things being equal, you should generally choose the most powerful language you can all the time. As we move more and more to server-hosted software, your choice of language is incredibly important because a) it's your choice, not forced on your by being the language of the OS and b) it can be a huge competitive advantage.

Matz (Ruby's creator) acknowledges ripping off ideas from Lisp (but putting a friendlier face to it). Python is Lispy. Javascript has been called Lisp in C's clothing. These are all functional languages, or can be used functionally.

Graham noted how all languages are trending more towards Lisp in terms of features (see the essay linked above). Want further proof? C# 2.0 is getting lexical closures. Innovation from Microsoft! These were available in Lisp for 30 years, javascript for 10 (since it was created), they're in Perl 5, Ruby, I can go on...

If languages continue to become higher and higher level, wouldn't we need to investigate this weird AI language from 1958 and see what features it doesn't have in order to do more meaningful research? 'cause these days, all the "new" features of today's languages are decades old...

Re:funny AND interesting, but yeah FP...

[GCP]

For newbies to Lisp, the parentheses don't vanish because of some mystical enlightenment. They vanish primarily because you've written your code according to a standard that specifies how it is to be indented. You parenthesize correctly when writing then simply ignore the parens when reading and look at the indentation level.

Of course I'm doing some handwaving here about the writing it correctly part. Until you memorize the major idioms, you'll often experience starting something with a single paren when it really needs to start with two, for example, and you'll get weird behavior that ends up driving you to randomly adding and removing parens until it seems to work. Admittedly that's a bit of a hurdle at first, but after some experience, that part gets easy. (Like glancing at for (int x=0; x10; x++) and reading "do it ten times" without having to think about it. A lot of people forget how much thinking a newbie has to do to parse such an expression the first few times.)

The real problem with Lisp isn't the parens. Once you get over the initial hurdle, you just look at the indentation. The problem is that dev platforms these days are so much more than just a language. The basic concepts underlying a Lispy language are almost timeless. The whole rest of the dev system, though, has a shelf life of about a decade or less, after which time the way it is made available, the libraries, the editors you have to use, the string model, the constraints it's optimized for, the compromises it has made, its interaction with other technologies, etc., are all out of touch with current realities. Such is Lisp today.

(Paul Graham once seemed like the guy who could rejuvenate Lisp, but each year that passes makes that less likely. Speaking of out of touch with current realities.... Even Microsoft's secret projects are more open.)

Functional Programming: Haskell

[Paul Johnson]

See Haskell.

Functional programming greatly simplifies the task of the programmer by removing execution order from the things that programmers have to keep track of. Just as garbage collection in Java got rid of the need to recycle memory manually, so in Haskell the execution order is a matter for the compiler to optimise rather than for the programmer to worry about.

Historically functional programming has had problems doing IO: languages have had to admit impure side effects to do IO. Haskell has a wonderful solution to this problem, which unfortunately this post is too small to contain (really: go see!).

Paul.

PLOP

[lheal]

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.

Domain Specfic Languages/Language Oriented Prgmng

[MilesParker]

The winner is...
I think DSLs are going to radically change the way that people code. DSLs potentially provide the meta-prgramming ccapabilities of LISP with the transparency and idiot-proofing of a language like Java. We may even see a hierarchy of software engineeringh develop, with one type of hihg-level coder deveoping DSLs and others able to use these languages easily within their own areas of expertise. For more, check the following links:

http://www.jetbrains.com/mps//
http://www.martinfowler.com/articles/languageWorkb ench.html
http://intentsoft.com/

Re:The best web dev framework you've never heard o

[sammy baby]

So, in that model, you have an abstracted version of your database logic mixed in with the presentation stuff. Meh, pass. RoR defers the "which database objects will I need on this page?" question to the controller. This allows you to put only the barest minimum of stuff in the actual template for the web page: just exactly enough to get the presentation right:

<table>
<%= render_collection_of_partials, "user_list", @users %>
</table>

In your users_controller.rb file:

def list
@users = Users.find_all
end

And in a seperate file called _user_list.rhtml:

<tr><td><%=h user_list["username"] %></tr></td>

Of course, if you prefer, you can iterate over the list right in the page, but if you're doing more than a single line or have some hairy presentation html in there, you have the option of just dumping it in another file, as demonstrated.

Re:Afraid of parenthesis? Stay away from XML!

[mrchaotica]

Here's why. Take this LISP code example:

)

Now tell me what it means. Specifically, tell me what expression it ends.

In contrast, take this XML example:

</p>

Now tell me what expression it ends. See how much easier it is?

See, that's the difference: In XML, the angle brackets aren't units really units of syntax in and of themselves; tags as a whole are. Moreover, in XML these units of syntax are self-discribing. Also, angle brackets are never nested; they always occur in "" pairs without any more brackets between them.