I think he was simply pointing out the fact that we've stagnated at the same level of abstraction in the web space for a long time. Cappuccino is just the example he's using to point out where we were relative to where we are and in that light it's almost a regression.
For the purposes of his larger argument, the way that Cappuccino delivered its abstractions (Objective-J) isn't as important as what it allowed you to do with the web.
You have solutions like gwt, cappucino and extjs which build custom ui components that behave properly, ad the infrastructure to tie them together. This works, but only if you never step outside the framework, and only if you're willing to deal with bloat, which sucks. Then you have frameworks which just give you the infrastructure, not the custom ui components, like ember or backbone. That also works, but because html's core controls are horrible the only way to get a great ui out of that is to build really custom ui, essentially rebuilding what the complicated frameworks already provide out of the box, which sucks. And then you have one-shot solutions that try to bring just one or a few ui elements to the web, trying their best to fit into the raw platform. That also works, but because the raw platform is so painful to use, it doesn't scale.
Really, the problem is that html/css/js is the wrong base for building abstractions on. I have great hopes for shadow dom and web components, but that's only the beginning of what we need. The platform itself needs to evolve a great deal to make building high-quality ui something that doesn't lock you into a vendor's toolset.
Personally i chose extjs and am waiting it out until the platform matures underneath it. I'd like to see the extjs codebase evaporate as parts of it get replaced by native code, until it's nothing but syntactical sugar on top of a rich base platform. That's going to be a while though.
It pains me that Cappuccino has received so little interest, for despite all its possible drawbacks it represents a very interesting path for future web programming.
That applies in the opposite direction too. Native programming seems to involve jumping through insane hoops just to do simple things:
Like "put some text on the screen, this part is bold".
Or "open this web page".
Or "put these things next to each other, with 10px in between, unless the screen is a little narrower, then put the second one below with no margins".
Or "I want to play with the layout of this every day for the next month, have the new layout download every time someone uses this app".
I can write complete, ready-to-distribute web apps that do those things in 1-3 lines of code. Doing so in iOS takes many layers of indirection.
Look at something like Ember.js. The abstractions being put in place are fascinating. Or CSS. It's is an incredibly powerful abstraction on something that iOS just scratches the surface of.
The truth is, both the web and iOS have evolved to deal with specific pain points. Some things that are easy on one are hard on the other.
This idea that web programming is under-abstracted seems really narrow-minded to me.
Let's remember that even as recently as 2-3 years ago, top end phones and tablets were single core ARM processors clocked at ~1GHz. And devices of that spec are still in wide spread use even now.
The point of the HTML is that it's an open standard which should work on any internet device regardless of platform, patents and what not. While I admire the ambition of the guys who push the envelope of what the web can do, they often forget that everyday sites also need to cater for low end devices used by everyday folk.
The idea right now for telecoms and device manufacturers is more about getting their stuff in as many people's hands as possible, not about whether they can replace a screaming desktop with a handheld.
Let make information available to everyone; then we can worry about making those sites fancier than a strippers underwear draw.
Low end devices are a good point, my main gripe with all these frameworks is that they make it very easy to break many conventions of the web (URLs no longer work as intended, extra efforts is needed to make the pages crawlable etc.).
Another related example, I recently learned of H2 (http://www.h2database.com/html/main.html) and I honestly had to ask myself, why is this needed? If you want an embedded SQL DB why not just use SQLite? If you want a full featured enterprise SQL DB, why not just use PostgreSQL? And don't even get me started about Walyand/Mir as opposed to Xorg, or the whole debacle of disabling separate /usr because of rewriting things like init to use glib and other non-base system dependencies. The hubris, lack of knowledge of history, lack of foresight, and just plain lack of professionalism (to put it politely) are staggering.
SQLite is native C, H2 is Java. There are significant deployment and potential stability advantages to not using native binaries in your Java software.
There have been some neat hacks to get sqlite running under Java, including using a tool that translates MIPS binaries to run under the JVM, allowing the use of libsqlite as 'native Java' code: http://nestedvm.ibex.org/
This is, however, not something you'd likely want to use unless you absolutely need to interoperate with sqlite's data format.
Fully native java and an in-memory implementation mean that we can very quickly implement it in our systems.
Randy's probably right about how silly all the tiny reinventions of UI frameworks are. And, though I'm generally unsympathetic to claims that a project is a failure because people don't want to learn the tools, I think it's safe to say here that asking people to use a language that's only marginally less horrible than JavaScript is not going to be a win from any perspective.
But he fails to realize that doing UI in a Cocoa-like framework is totally fucked (to be clear, I do Cocoa touch for a living; I'm speaking from experience).
I'd be making an understatement if I said I was unexcited about Cappuccino because it fails to even approach solving any of the truly important problems of UI work, which are (as you hinted) less about "can I make the table scroll quickly" and more about "can I decouple this monstrous mess of data, dependent requests, and presentation". As you note, FRP looks like a step in the right direction toward solving that problem. Traditional Cocoa-like approaches are a step backwards in that area, not forwards.