Tim Berners-Lee on the Principle of Least Power:
This is a companion discussion topic for the original blog entry at: http://www.codinghorror.com/blog/2007/07/the-principle-of-least-power.html
Tim Berners-Lee on the Principle of Least Power:
I agree with Jeff.
It’s a bit like Lego - lots of simple, small, reusable pieces allows you to build all sorts of structures, whereas a house is just a house.
You’re right about it being everything…
Well, my favourite weather website recently changed it’s UI from good old HTML to Flash. Now instead of opening a bookmark, I have to go through menus every time I want to knows something about weather. So we get slower, harder to use, but “prettier”(for some value of pretty). I wouldn’t say they won anything powerwise…
A perfect illustration of Atwood’s Law:
I don’t get it. Presenting data in a usable form has nothing to do with the expressive power of a programming language. In fact, I’d say the inverse applies. If you’re stuck in a contorted language you’re more likely to output some horrid, contorted thing, while if you’re in a clean language, it should be straightforwards to get a clear output of your data structures.
Putting weather data up in a fancy Java applet instead of as straightforwards data doesn’t reflect power of a programming language. It reflects idiocy of a programmer.
I have read quite a bit lately about the perceived bloat that is occurring with other languages. I find your less is more take to be quite interesting. Thanks for sharing.
Oh, and by the way, I’ll never forgive Tim Berners-Lee for not enforcing the simple rule that every tag should be closed. Ugh. We’re still paying the price for that one… (Tell me if my hatred is misplaced…)
VIC-20 Basic… now there was a language that knew what a semicolon was really all about…
10 PRINT "STEVE IS SKILL " ; 20 GOTO 10
and then, more and more people have to re-write their beautiful ajax apps on every new browser release.
seems to be what silverlight seems to be addressing right now.
and following a standard seems to be exactly what all browsers (except mozilla) has been doing since the very beginning
Jesse McNelis: “This has nothing to do with language, it has to do with data structures.
Programming languages should be powerful, data structures should be accessible.”
Yes, exactly. The linked article conflates “power” with “data transparency”. There are a LOT of languages which would be called quite not-powerful, but which are also quite data-opaque. For instance, Word 2.0’s BASIC language was, quite undeniably, very very weak. However, if it was displaying a dialog box, do you think any other application would be able to see that data?
In the linked article, the “Principle” is “Powerful languages inhibit information reuse.” However, the body of the article then talks about being able to determine what a program will do via code analysis (“powerful” languages, it is argued, will be harder to decipher in this way and will require running … not sure if I agree with that either.) In other words, the “information reuse” is the algorithm or process, NOT the data.
Fundamentally, I think the article is not allowing for multi-tiered applications at the client (ie, a web service shoots down raw data; the client displays it all prettified (and copy/pasteable). That type of an architecture allows the individual user to get at the data, AND an automated tool to get at the data without having to run the prettifier.
Example: given the raytracer link. Is its data more, or less, accessible (meaning, algorithms, raw data, and produced results) than a similar project in Java or C++? I would guess that the “more powerful” languages might allow for a much more transparent process and results.
IMHO, it all boils down to the simple and well-known law: “Use the right tool for the job.” If you are conveying text information, use a text markup language. If you are performing complex mathematical operations, use a language capable of doing those. If you are dealing with complex data structures, a language with more than laughable support for complex data structures would be advised.
Sorry, Mr Berners-Lee.
Tim Berners-Lee (obviously no dummy) seems to be conflating simplicity of syntax and program structure with a lack of power, which simply isn’t the case, as many previous commentators have noted.
Maybe this rule should be restated as: “Programs/data should be as simple as possible, and no simpler.” (with apologies to Einstein).
I find Atwood’s law interesting, though I don’t know what you mean. I assume your law is somewhat tongue in cheek, but I’m not sure what you’re getting at. Are you saying that people will run everything possible in a browser? Or that programmers are moving to simpler, more permissive languages? Or that programmers like showing off, building space shuttles out of popsicle sticks just to show they can?
One of my biggest complaints with Windows is how Windows has taken what in the Unix world would be straight forward ASCII text and made it “object oriented”. In Unix, everything is a file stream while in Windows it is an object.
I understand why the Object model is so powerful, except that means I can’t simply parse through the data without the appropriate API and linking the DLL to my code. Even if I can do that, I have to go through dozens of pages of documentation to delve into the information I need. What I thought is just some straight forward data is really pieces of two different objects which are members of a particular sub-class that is a member of two meta-classes.
And, about half the time, the API was designed, so that the two pieces of data really have no relationship to each other. So, not only do I have to learn the entire class structure of the model, but I still end up doing a lot of hacking to get what I want.
People make fun of me because I still code so much in Perl – that’s so 20th century!. However, you give me some data in straight, plain text, and with Perl, I’ll get that information to dance.
Wait a second… Al Gore didn’t invent the world wide web?