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?"
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.
...we stop creating new languages and use what's out there to do something useful for a bit.
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.
Functional programming is awesome, and I'm thoroughly convinced that it will take over just about everything its feasible for it to take over. There is nothing like the feeling of writing a program, having it type check, and not having to test it because you can look at the code and tell that it proves its own correctness.
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.
It's not a programming model, it's a delivery model. As near as I can make out they're just web apps that rudely offload processing onto the client. The actual programming model stays the same whether it's a desktop application, webapp or RIA.
Don't blame me, I didn't vote for either of them!
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
Sounds like the mindset of the place I used to work. It went something like this.
"Hey! If we write a whole bunch of spaghetti code that only we can read, and that breaks a lot, then people will see us doing stuff all the time and we will have job security."
The sad part is that it seems to have worked in that company instead of them getting fired for incompetence.
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.
Mod me down as flamebait for pointing this out, but did anyone else notice that the posted link for .NET went to the Mono homepage? Yeah, they deserve all of the credit for .NET. As a counterpoint, the Java link went to the Sun homepage...what's the deal?
Those who can, do. Those who can't, go into business for themselves.
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.
-Don
Take a look and feel free: http://www.PieMenu.com
It turns out there's this Python-based application server/templating language called SkunkWeb (http://www.skunkweb.org/) which seems to be the Holy Grail for me of, well, a Python-based web framework that doesn't completely suck (Okay, I know 1995 and CGI was awesome and everything, but no one should be writing "print '<html><head>'..." statements within Python code to make web pages, and don't get me started on Zope.) And no, I'm not affiliated with the project or its developers.
I don't know about Ruby/Ruby on Rails, but I'd rather write in Python which, to me, has a more accessible syntax and a truly badass standard library. And doesn't make you want to jump blindfolded off of tall buildings.
Skunkweb lets you combine the best of Python and PHP -- you create real Python classes to do the heavy lifting/DB accesses/app logic (and you can unit test those separately) without the PHP spaghetti code mess, and then you use Skunkweb's refreshingly sane blend-of-HTML-and-Python template language (contrived example -- need a list of usernames? It's this easy) to tie it all together. The win is that this way you can separate logic (standalone Python modules) from presentation (templated HTML/Python) in a much cleaner manner than other web development frameworks.
In addition, it was built from the ground up for scalability (ok, the application server itself is probably slower than Apache/PHP, but I don't notice the difference, and you can use psyco or other methods to speed things up) and has caching and db connection pooling and other performance-oriented features built in.
I've been doing web development for nearly a decade, and Skunkweb has recently been my best-kept secret and a big competitive advantage. It's at the core of two companies I'm starting (one of which is a comprehensive online SAT prep course and is already profitable, the other which is earlier stage but angel-funded) It lends itself to clean and quick development and if it didn't have the stupid name (good luck convincing your boss to bet the farm on something with "skunk" in the name) it would have taken over the world by now.
Anyway, you heard it here first, folks. If anyone else out there is using Skunk, drop me a line (houston at mit.edu) because it would be nice to start a little community.
-fren
"Where are we going, and why am I in this handbasket?"
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
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").
That's why I'm advocating a formal approach - done correctly, the idea would be that you COULD NOT SPECIFY a problem properly without giving the database the ability to determine whether it has been done or not. You still need intelligent people to specify the requirements, but the idea would be that once you DO fully specify them it would be immediately clear what exists, courtesy of the searchable central archive.
That's one of the problems that needs to be attacked - too many problems have been solved only in old code, or an obscure library, or only in one language. We need to make programming solutions both general and searchable, which requires a rigorous system.
Now I agree that it might sometimes be faster to just code the darn thing than learn to use such a system (probably quite often, really), BUT. Once learned, it would make all future tasks both easier and FAR more robust.
It's the same old problem - it takes effort to learn an app/language/system, and people will always take the shortest path, generally speaking. What I'm saying is that we should use organization, education in schools/college, and formal methods to make a system so powerful and robust it will be wasteful and expensive to use anything ELSE. Do it Right once and build off of it. Most of the work in an application design is designing the solution - most of the pieces, logically speaking, should already exist. So once you know WHAT you want (I know, that can change, but if you're going to do it you've got to have some idea) the actual DOING of it should reuse proven, solid parts. Creating that system will be really, really hard but would allow us to build much more powerful software - think about it as using steel beams and architects to create a skyscraper instead of knocking together a wood hut to keep the rain off. The skyscraper requires a heck of a lot more supporting industry and design, but look at what it achieves.
"I object to doing things that computers can do." -- Olin Shivers, lispers.org
I started on BASIC, then learned PASCAL. Moved on to C, then C++. At some point I did scheme, Java, korn shell scripting, bash scripting, Perl, PHP, jsp, javascript, etc. Many of those languages are not alike.
This is not about similarity. This is about an *aweful* syntax. Just plain bad IMHO.
"Ignorance more frequently begets confidence than does knowledge"
- Charles Darwin
LISP: Lots of Irritating Silly Parentheses.
In practice it has a very clean and elegant syntax though. If your editor doesn't do bracket matching you might have a few issues, but then what sort of half assed editor are you using?
Besides you can always try ML or Haskell which are much more pure functional than LISP and have hardly any parentheses (which I actually find occasionally irritating).
Jedidiah.
Craft Beer Programming T-shirts
What I like about these new programming models such as Ruby, Ruby on Rails etc. etc. is how much like Lisp they are.
If you've never done a real programming course you've never been taught Lisp...
Yippee, less bluffers in the pool, more fish for those who can hunt.
threadeds blog
What's wrong with parenthesis? If you hate parenthesis, then do you hate XML twice as much as Lisp?
Lisp syntax is excellent because it's simple and consistent, and that's the reason Lisp macros are so powerful. Perl syntax is absolutely awful, and that's the reason Perl will never have macros like Lisp.
-Don
Take a look and feel free: http://www.PieMenu.com
hold on, you're saying that reading:
<1><2><3><4><5>this</5></4></3></2></1>
is easier than reading:
(((((this)))))
??
I'd rather read the lisp, there's just one thing to read: 'this' whereas the xml has all those numbers, and they have to match, and they have to be in order, what matters 'this' is now buried and do not stand out whatsoever; what the?
Sure, I don't want to count parenthesis, that is why the editor takes care of it; a tool to do a boring repetitive task, nothing new here.
Also, not unlike Python, you somewhat need to indent your lisp code to make it readable (correct in python). It's really not unlike xml, pretty unreadable if not indented properly. So all in all, the parenthesis issue is really not worth getting scared of, and is usually bypassed after a day or two.
Among Ruby, Python, and Javascript, none provide currying and all are strongly oriented to using side effects; in particular, one of Ruby's strongest features is that it is truely object oriented, and OO is side effects. They all provide some support for closures, but only Javascript can claim to treat functions as first-class objects. Consequently, none of those languages are anywhere close to being functional in nature, and although you might make be able to make a case for Javascript, purists will tell you that any language that has variables (as in, able to re-assign the value of it) isn't functional.
That said, you're not the first person I've heard say that all languages are, ultimately, Lisp machines, and there's some merit to that. You can do procedural, OO, or functional style programming in almost any language, if you bend over backwards far enough; however, the term "functional programming language" does have meaning and shouldn't be applied arbitrarily just because you can write code that looks functional -- perhaps moreso than other paradigms because functional languages are often more strict about purity than other languages.
The exception being O'Caml, which is a mutant.
--- SER
I think the most promising thick-client app development model is the Model-View-Controller paradigm, as seen in such well-designed app frameworks as Cocoa for OS X, and of course Ruby on Rails, and although I see Skunkworks improving the "typical" drudgery of web-app dev, I would wonder what it provides in the way of code management when it comes time to test your controller without worrying about how the view renders it or the model stores it.
And I know this is a personal preference and all, but... Python's significant whitespace? Yuck... I hope you don't copy/paste much, you might forget a tab somewhere (not to mention, copying from webpages is an adventure in itself...) To me this is like drinking cider instead of beer. Why would anyone consider such a thing worthwhile? Just to avoid some begin/ends or curly braces?
Python does have a more complete library but I am pretty sure Ruby and friends are catching up (and of course, no real word on Parrot yet...) Ruby also just seems to do the whole object-oriented thing nicer (abbreviated getter/setters, everything is an object, no self-referential hacks or whatever...)
Stop me when you see the pattern. The problem is getting tougher.
In modern times ('90s), recently, we've...
Umm. We're starting to pick low-hanging fruit if you ask me. We will not proceed farther until we address what we sweat over working on:
And of course....
We have not abstracted out everything not necessary to accurately determine the minimum amount needed to convey a functional output from input.
Until 90% of the programming is essentially a library of "compiler hints" that get some code to work in the proper balance of optimisation, we have no choice but to spew an endless surf of compiler-required arbitrary drool-proof-paper decisions that we can barely keep in our skulls.
In sum.. we need to automate the hard parts of programming without errors. That's all. (Hint: we're not done yet.)
Nietzsche is dead - God
"Javascript has been called Lisp in C's clothing."
So the ways Javascript differs from C are due to being LISP like? I find it hard to imagine a more damning indictment of a language.
"All things being equal, you should generally choose the most powerful language you can all the time"
But all things are not equal. Being able to use that power is important too. Sure, LISP is powerful, in theory. But writing it makes me yearn for the straightforward simplicity of C++!
LISP fanatics bug me. If everyone just acnowledges that LISP had every language feature possible way before any thing else, can you give it a rest? Or at least stick to explaining why a language that is the greatest one ever, and has been since the 50s still has about as many users as it did in the 50s.
All the "new" features of today's languages have been available for decades in LISP, as well as in every other turing-complete language; it's a matter of how easy it is to use those features.
I've written code in a bunch of languages, including quite a bit of LISP. LISP is great if you want to do a mental puzzle resulting in aesthetically beautiful code. If you want to get stuff done, LISP blows big hairy chunks.
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.
<tag2>
some data
</tag1>
</tag2> ; OOPS
(tag1 (tag2 some data))
I'll take the second one thanks. My editor can show me which closing paren corresponds to which opening one.
With other languages, a compiler 'parses' your code into an Abstract syntax tree, in Lisp, your code is that tree.
"A language that doesn't affect the way you think about programming, is not worth knowing" - Alan Perlis