It's worth noting that those 400 lines are not what's sent over the wire. Generally, you'll send something like this as a little snippet of JSON then tear it apart on the client and construct whatever HTML you need to render it nicely.<p>I suspect the author had a look in Firebug and came to the wrong conclusion.<p>So no, it's not bloat. It's just presentation.
when you work on something significantly more complicated than a run of the mill django/rails type website, you quickly find out that a lot of the "bad practices" you taught yourself out of, can actually be actually completely necessary<p>inline styles and javascript are really really fast, innerhtml can be a lot faster than dom methods, doing everything with fancy css selectors is a good way to completely kill a page and destroying your markup by adding html over the place and id='' attribute on everything, can actually be the right thing to do.
<p><pre><code> #include <stdio.h>
int main()
{
printf("Hello World!");
return 0;
}
</code></pre>
Becomes:<p><pre><code> .cstring
LC0:
.ascii "Hello World!\0"
.text
.globl _main
_main:
pushl %ebp
movl %esp, %ebp
pushl %ebx
subl $20, %esp
call L3
"L00000000001$pb":
L3:
popl %ebx
leal LC0-"L00000000001$pb"(%ebx), %eax
movl %eax, (%esp)
call L_printf$stub
movl $0, %eax
addl $20, %esp
popl %ebx
leave
ret
.section __IMPORT,__jump_table,symbol_stubs,
self_modifying_code+pure_instructions,5
L_printf$stub:
.indirect_symbol _printf
hlt ; hlt ; hlt ; hlt ; hlt
.subsections_via_symbols
</code></pre>
Look at all that bloat! I just want to write out "Hello World" to the screen. Why do I need to create a function stack of 20 whole bytes? What a waste! And when I do that, I have to go through the onerous effort of saving my stack pointer to a whole 'nother register. What a waste of my system resources.<p>It's bad enough I have to call printf in the first place when I really could just use the write system call, but look how it doesn't even call printf right away! First I have to call some locally defined function which has to allocate even <i>more</i> space for <i>another</i> stack. More waste and bloat. And look at how all of this is organized, these sections are completely unnecessary. I just want to write out something to the screen! I don't need this level of organization and abstraction to do this simple task.
Who cares, if it works? I don't personally consider HTML and CSS either elegant or efficient, so if they've abstracted over it in order to do things, and it works, what's the big deal? HTML by hand seems mostly like a waste of time, to me. Most of the impressive web apps don't do much markup and styling by hand. Cappuccino/Objective-J is an extreme (and good) example of this.
I'm the author, this is definitely sent over the wire as I'm building code that is scraping it right now (which I'll opensource soon). Since I deal in the mobile world, its especially critical to keep bloat minimal so people don't pay data charges for your poor coding. I hate fatty, fat code.
Given the choice between elegant high-level code that generates verbose and ugly HTML versus complicated and ugly high-level code that generates very tight HTML, I know which I'd choose.
If one will inspect a blip in the google wave, one cannot think how many Wikipedia's articles could those bytes feed.<p>I suspect it has allot to do with the GWT.<p>a .NET DataGrid or whatever it is called these days would looks just the same comparing to a simple HTML table structure.