Slashdot Mirror
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?"
Functional Programming, not First Post!
The dangers of excessive individualism are nothing compared to the oppressiveness of excessive collectivism
Nothing is permanent. However, after so long you're gonna start getting rehashed methods. It's like a big circle everyone is running around in, looking for the absolute best. Yes, there are ones better than others, but there is no perfect one. Need OO for a simple 10 line php script? Hell no, unless you're relying on a lot of 3rd party libraries. Need Ruby on Rails for a statistics generator with no front end what so ever? Nope. It all changes, but there is some good stuff we take along the way. But I don't think we'll ever find something that is just "perfect", more of a never ending quest to find the better one, and to stay on top of all the ones from the past.
No new 'paradigms' until we get all the other 'salvations' under control.
Who are the next programming models?
That's the first one I learned. Now I'm in to the lasagna model, with nice layers. Anything beyond that? Well, not me.
Here's a new model who can program:
"Prior to being crowned Miss Universe 2005, Natalie was a motivational speaker, model and a fundraiser. She recently received a Bachelor's Degree in Information Technology Management and Marketing from Ryerson University..."
Life is like a web application. Sometime you need cookies just to get by.
I have heard marvels of Embryo Enlightenment version of SMALL
the Cocoa/Objective-C implementation might be worth talking about, especially as how it has evolved from it's roots in next step.
www.omglolh4x.com
In a specification oriented programming model, you specify the behaviour, not all the million little steps that are needed to perform it. A specification oriented programming model is independent of the underlying techniques, such a networking protocols and marshalling techniques. I think such a specification oriented programming model should be data oriented, meaning that data is the starting point, not an event driven GUI front-end, as it is now with most programming models.
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
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
Actually, he missed the anti-pattern. It's really: One of the common anti-patterns is over-relying on tools and frameworks and programming paradigms and processes instead of improving the skills and knowledge of the people doing the programming.
I've been programming for a long time too, and I don't think that new programming models do all that much for productivity compared to finding good people or investing in improving the people you have. The recent Joel on Software article discusses this at length. This is one of the big reasons I'm so interested in agile methods and principles.
Helping with organizational effectiveness is our job.
Rich Internet Applications are hardly the next "new" thing. The idea of doing asynchronous applications HTML/DHTML has been around since at least 1997. It's only the recent broad-based browser support that has led to the growth of AJAX, etc. However, trying to program an RIA that targets multiple browsers is like trying to write portable C code all over again. Thought CSS was screwed up between Firefox and IE? Try looking at the JavaScript implementation differences between the two platforms. Throw in a bit of Safari and Opera and you have all the makings of some super-gross client code.
Well lets see now, programming metaphors for the modern age?
Theres oil-oriented programming (everything is a pipeline), terror-oriented programming (everything is a suicide bomber) and dollar-oriented programming (everything has a mandatory dollar sign at the beginning), to name but a few.
In the free world the media isn't government run; the government is media run.
http://www.nwcpp.org/Downloads/2005/Lock-Free.pdf
-- -pjk Perry Kundert perry@kundert.ca http://kundert.2y.net
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...
What on earth? This article is tripe unfit for anyone but managers. He's put new buzzwords on the things he's describing here, but not one of them is actually new.
.net", and . We have some new and better tools for RPC-based programming, what with WDSL or WSDL or whatever and all these other new acronyms, but we're still doing the exact same thing in the exact same way that we were doing in the 80s with CORBA and Distributed Objects.
First off, the "rich internet application" model he harps on is at this point about ten years old, since CGI programming first appeared. It hasn't changed that much since then. We figured out the idioms and patterns to make that work very quickly, and we've been using them since then. The only new development here is the "on rails" type stuff-- but that is nothing more, or less than the same model as all CGI has used, only now it runs faster. It is an optimization. Not anything new.
Second off, what the hell is a "composite application"? Seriously? It sounds like he's just describing an application which embeds a client server model. Well lah de frickin dah. This is not new, this is not at ALL linked to "java and
If when this guy says "recent" he means "the last 20 years", then yes, that is a good coverage of the improvements in programming we have had since 1980. But since he seems to mean things a bit more recent than that, it looks like he's just playing the old analyst game of putting a new name on an old concept and pretending it's the most important thing ever. Unfortunately, giving something a buzzword isn't the same thing as inventing it.
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.
You are lost in a twisty maze of little standards, all different.
Pick a good language/environment, even a not so good one, say C and a text editor, and then use some engineering discipline to really DESIGN THE DAMN application. Don't just throw features at it, don't just hack the code. Think about the real world problem you are supposedly trying to solve and work your way through it. Build it right, you don't have to worry about operation, maintenance, or longevity. Build it wrong, and you make a career of fixing it.
Ooops, maybe I've stumbled onto the real secret of IT...
Behold, this dreamer cometh. Come now, and let us slay him... and we shall see what will become of his dreams.
To my mind what we need is not more models, but some FINAL model - i.e. a way to impliment programming logic in such a way that it will never need to be implimented again.
Think about it - how much programming out there is a duplication of some other effort, at least in some of its logical components? I'd say what we need is two things:
a) A database of implimented programming logic - maybe not a database proper, but something that contains the ability to say "given this, do this" exists.
b) A programming method that involves designing an application such that you break each top level logical component/ability down until you a) know that you have to impliment it or b) it is found to have already been done. I'm guessing b will be the norm, and as more and more logical components are added to the database the point at which b) is found should get higher and higher in the design stage.
And the programming language bias should, at the database level, be a moot point. The database itself should define its algorithms and logic in such a way as to be workable in automatic proof assistants like acl2 and HOL4, and generate code in the required language as needed. Surely for a properly specified algorithm there must be some well defined way to generate it as code, provided the language specs are up to par. This is deterministic behavior, after all. Perhaps different algorithms for the same function can be added, and a choice made on a per language basis, but I'm dubious that this would be needed in an ideal world.
In a world with open source as a working reality, there should never be a need to impliment anything non-trivial. Design should be specifying only things that don't already exist. Object oriented programming is a nice step in that direction, but that doesn't let people know a) what's out there and b) what the quality of it is. I say let's bring formal methods to their full potential, and reduce the amount of work the programmer must do to the irreducable minimum. Programmer time is too valuable to waste on re-implimenting things. Standardize everything that can be done "right", and have the human being do ONLY the part he/she is good at - deciding what needs to be done from a USER standpoint - i.e. WHAT to do. How to do it should be, as much as possible, decided once and correctly, and then not again.
"I object to doing things that computers can do." -- Olin Shivers, lispers.org
I'm increasingly finding that web programers ( and their managers ) can be like that. Meaning that they're increasingly trying to find ways to make "HTML-server based application with some client interaction" sound new and exciting.
Not that using advanced Javascript||.NET||Java||C||Objective-C||Python||wh atever on the client to communicate to a server running Perl||C||Python||Java||.NET||Ruby||Objective-C||wh atever using XML( or whatever ) isn't interesting or useful, it's just... like calling a personal log-format web page a 'weblog'; it's not really something new in the abstract, it's a new way of doing something that's been done before. In other words, it's marketing hype to make you think you're seeing something truly new. At least in general, the implementations are new, not the ideas.
Functional programming and continuations. One present day example is the UnCommon Web, which is a web application framework implemented with continuations.
I totally agree with you. I won't get into details about why I think the FA was referring to the latter (or even better -- how naive programmers don't even know the difference). Instead, I will mention two ideas that I think will keep nibbling on the edge of expanding our understanding of programming.
1) Generative programming. OOD is a relative good technique for representing the design of an a program. Especially combined with some of the recent (in the last 15 years, say) understanding of OO design patterns. However, OOP does not allow effective reuse of code without compromising the flexibility of the design. Enter generative programming. Essentially you write computer programs that can generate the code you need in different circumstances. A simple example of generative programming is using C++ templates to generate a sorting algorithm for various different types of objects.
2) I know some work is being done in this next area, but I don't know what it's commonly called. Basically allowing the programmer to manipulate the code based on the AST using a refactoring browser. This is essentially a literate programming technique. The "source code" is merely the output of the program that the programmer can use to read the program. However, all interaction with the code is done using a refactoring browser.
So why do I think these are new programming techniques rather than just technological gimmicks? First, I think it is important to distinguish between design techniques (such as design patterns, or OOD) and programming techniques. Programming techniques are how we use technical tools to solve our problems (e.g., using a virtual function table to give us polymorphism).
I would like to also make a distinction between programming techniques and technical tools. For instance, a class library is merely a technical tool. It might reduce my work, but it doesn't give me flexibility to use a language to express different ideas than are in the library. Using templates (or generics) is a programming technique that allows me to do some generative programming (i.e. represent my ideas in a more efficient form), while an "event" in C# is merely a tool that saves me from having to implement the observer pattern.
One can see that a language designed around generative programming ideas, as well as a language that is designed to be manipulated using a refactoring browser can lead to a difference in the way I think about programming. It will change the way I communicate with the computer and my fellow programmers. RIA appears to me to be just a set of tools that might save me time. But perhaps I just don't understand what the FA was talking about.
Let's have a look at programming languages http://www.linuks.mine.nu/gnustep/langs.txt
And an excerpt from a book (I can find you the title and ISBN if you want): Although both Objective-C and C++ derive from C, C++ is a systems-level language, whereas Objective-C is an applications-level language. The distinction can be summarized by saying that C++ was designed with program efficiency in mind, while Objective-C is geared more toward programmer efficiency. The difference is substantial--C++ is driven by a philosophy of efficiency and compatibility with existing C which, while necessary for a low-level language, proves quite restrictive in other contexts.
And now, the almighty Allen-Booze study: Quote of the Booz-Allen Study
* took 100+ senior programmers and trained them on NeXTstep, then asked them to write the same app on both NeXT and their previous system.
* First application written was written 2 - 5 times faster.
* Savings were 90%
* 83% less lines of code in the NEXTstep version
* 82% said NeXTstep was better in ALL categories
* It isn't faster to code on NeXTstep; you just have to write less of it. The revolution is "getting rid of software".
more about all this stuff, here: http://livecd.gnustep.org/
Windoze not found: (C)heer, (P)arty or (D)ance
-Don
Take a look and feel free: http://www.PieMenu.com
Wow! You're not joking. My preferred programming language for personal projects is Haskell these days. But I'd hardly say I could 'just tell' my code worked by looking at it. And a piece of functional code is a proof of something (by Curry-Howard), but it's not a proof that the program does what a specification says it should do.
Doesn't it make you feel good to know that our freedoms are protected by politicans, lawyers and journalists.
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.
Raise your children as if you were teaching them to raise your grandchildren, because you are.
nobody seems to be interested in developing.
I program console games. We've got very strict RAM limits - from 384kb on the GBA to 64mb on the amazingly spacious XBox. (With some curious design decisions that can make it feel smaller than the 32+4mb PS2, but I digress.)
On systems like this you've got to track pretty much every byte. One meg of garbage collector overhead means one meg you don't have available for useful stuff. I generally don't use standard dynamic allocation - at all - it's just too expensive. Maybe one big pool to load files into on the PS2 that can be cleared entirely between levels. Nothing like that on the GBA of course.
As far as I can see, there's three languages that provide this necessary feature - ASM, C, and C++. So I use C++.
I'd love to see an "improved" C++. But it seems like every time someone decides to improve C++, the first thing they do is tack on a garbage collector and get rid of direct memory access. And, you know, those are features I desperately need. Frequently those unwanted features are the only way I can even display graphics.
And yes, it's possible to write modern games in languages with garbage collectors (as I understand it, the entire Jak and Daxter series was written in Lisp) but I know what lengths I go to to squeeze performance out of these systems - I really don't need a garbage-collected albatross hanging off my shoulder.
And before anyone says "garbage collectors are faster than deallocating things manually!" - if I don't *allocate* anything, what makes you think I need *deallocation*? There is no heap. Move on.
Breaking Into the Industry - A development log about starting a game studio.
The winner is...
b ench.html
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/languageWork
http://intentsoft.com/
All improvements I have seen the last 10 years in programming language have already been done in Smalltalk from the beginning.
/visual-basic (user-interface) (skipped many ST examples)
That is because everything is an object, even the programming constructs (like classes which are objects, and if/then which are called #ifTrue:ifFalse).
The future languages might even be more dynamic, and include Lisp (or Hascell) like constructions that solve problems by defining the answer (functional and logic programming).
Which is in the smalltalk-syntax: [i][:x| x*x=5.0] SolveFor: #x.[/i]
While smalltalk (ST) is advanced, it also encounters the problem of managing 60,000 classes (or more). And everyone can see that simply grouping the classes in seperate modules does not help, which is done in Java. Even the Object-class should be redefinable, preferably on local level. There are some programs on top of ST that help a bit, but I would personnaly like to see it a bit better
Another problem is that there are so many interfaces to different storages and systems. So we need C-interfaces, C++-interfaces, SQL-interfaces, XML-interfaces... etc..
So any future programming model should have:
- objects everywhere. (ST)
- Be very simple and compact. (ST)
- Easy to use and understand. (ST)
- allow scripting (or runtime compilation) possibilities (ST)
- easy modularizing of classes, methods and objects.
- Allow distributed data and execution. (ST)
- Allow easy interfaces to different storages and systems.
- Integrate easily in the system
Any future Object-system will be graphical and allow different programming models (logical, functional, procedural, storage, user-interface) to be build in graphical building-blocks..
Already we can see some of this happening in:
* XML-tools (data-definitions and interfacing),
* visual-age (procedural program definition, ST again).
* net-beans / delphi
* web-tools (ruby-on-rails (ruby is based on ST), seaside (build in ST))
I once read a paper written by Cristina Videira Lopes, a pioneer of aspect oriented programming, in it she stated that AOP is a significant breakthroug, but that the next step is to include elements of natural language in programming languages.
She says that natural language is not suited to write computer programs, but it has powerful elements that can be useful in transferring ideas more closely to the way we think. An example of such elements are temporal references such as before and after.
You can read the abstract to one of her papers here. Very interesting stuff.
These 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.
.NET framework)
.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.
On the runtime part:
- plugins (see Eclipse and OSGi technology)
- assemblies/libraries (see
- 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
And yes, this is also an opinion piece, as is the parent.