I just read yet another recycling of the old myth of how some esoteric programming language (often Lisp or Haskell) is the secret weapon that allowed a team to outperform expectations by an order of magnitude. Paul Graham has strongly encouraged this myth (see Beating the Averages), but it has been circulating for ages. It is totally false. Worse, it reinforces the intellectual elitism that is the bane of our field. Continue reading “The Myth of the Super Programming Language”
The Greater Apple Co-Prosperity Sphere
Much has been written lately about Apple restricting iPhone and iPad apps to only use Apple programming languages and libraries. This is indeed an alarming development for the future of programming.
Opinion is split as to whether this decision shows Steve Jobs to be a visionary hero seeking only to improve the quality of the user experience, or that he is a megalomaniac Fascist. But I think people are missing what this is really about. It’s about the money. The Ad money.
App Ads are potentially a Google-scale cash flow, and Jobs wants it. He wants to sell ads and inject them into apps on the iPhone/iPad/iDesk, just like Google injects ads into web pages. He can’t do that unless all the apps are using his libraries. If he lets Flash apps in, then Adobe would be able to sell the ads instead. That is why section 3.3.9 of the new developer agreement says “the use of third party software in Your Application to collect and send Device Data to a third party for processing or analysis is expressly prohibited”. Like, for example, Ad networks.
Help me, Google; you’re my only hope.
Coherent Binding
Abstract for my talk at Emerging Languages Camp:
We cannot evolve beyond imperative programming until we solve the problem of coordinating changes to state. Functional programming and transactions segregate the problem, but don’t solve it. I am exploring a new kind of language, inspired by modern “Model-View-Binding” application frameworks. The language uses bidirectional data binding as its fundamental mechanism, generalized into arbitrary change-triggered actions. Bindings propagate changes coherently: execution order is determined automatically based on the interdependencies between bindings. The programmer does not have to worry about execution order. A side benefit is the automatic discovery of parallelism. Unfortunately coherence doesn’t work in a conventional heap of objects with arbitrary dynamic pointers to each other. I propose a data model in which objects and collections of objects are nested to form trees. Pointers are replaced with cursors constrained within a collection. This richer structure permits coherent and deterministic execution of bindings. Coherent binding offers the simplicity of declarative programming while maintaining complex dynamic state.
Comments? The idea is to use data binding as a metaphor that many programmers are already familiar with. Can I assume people will get what “Model-View-Binding” is, even though I just invented the term?
Haskell damage
Per Vognsen suggests a Haskell version of the damage function from my Schematic Tables talk:
data Attack = Magic | Melee hit surprise defense attack = damage where effectiveness = power * (if surprise then 3 else 2) (power, damage) = case attack of Magic -> (5, max 0 (effectiveness - defense)) Melee -> (4, 2 * effectiveness / defense)
This passes pairs of values (power, damage) through conditionals. That allows the conditionals to multiplex more than one value, rather than being repeated. I suspect I could stymie that approach with more complex data flows, but I am happy to acknowledge that Haskell does OK on this example. Thanks, Per.
Emerging Languages Camp
I have been invited to the Emerging Languages Camp. Sounds like fun. Let’s meet up.