renderContentOn: html
50 timesRepeat:
[ html div
class: #SomeStyle;
onClick: (html element hide);
with: 'Who needs HTML?' ]I have to know HTML anyway (because eventually I will have to debug it), so it seems preferable to me to also code the output in HTML.
Another approach against tag soup I have seen is xmlc, which manipulates the DOM tree of the HTML template. The xmlc project doesn't seem to be very active anymore, though.
Also, the logic is going to bleed over into the HTML anyway. Why burden yourself with ugly line noise?
renderContentOn: html
50 timesRepeat:
[ html div
class: #SomeStyle;
onClick: (html element hide);
with: 'Who needs HTML?' ]
vs. <% for x in range(50) %>
<div class="SomeStyle"
onclick="javascript:hide(this);">
Who needs HTML?
</div>
<% endfor %>
In the above example, I'm mixing the JavaScript with the HTML and I also see Python code (the last template engines I've used were Python-based). Three languages mixed into one template.The Seaside/Smalltalk example, on the other hand, has one language with code that generates another language (which I don't have to touch at all, it knows how to generate a valid DIV element). So I just have to analyze the logic of the Smalltalk code and not the HTML or JavaScript unless there is a specific reason for me to do so (such as adding a new type of HTML element).
I mean, it seems we're stuck here. Either we use tag soup templates, or we use some abstraction to express the structure of the page in the language of the generator code. The former requires less training and discipline, but complicates maintenance. The latter is a framework to which you'll need to adhere. No free lunch.
Overall, I guess web development is always ugly :-(
- embedding client-side markup as a DSL in the language to generate HTML (Markaby/Seaside)
- component/control-based systems (ASP.NET, JSF I guess)
I prefer the first.
And 20 years from now, when Microsoft releases an ASP.NET with the better way ("say goodbye to templates with the new Unity Code Components (UCC)™"), Atwood will be blogging about it.
Edit: Jeff is no doubt a nice guy and it's clear he means well. Yet every time I read his stuff I feel driven to burst out with sarcasm. I think it's an allergic reaction: I know the world he represents, I spent too much time in it for my own good, and now I'm hypersensitive.
Check out ParenScript (http://common-lisp.net/project/parenscript/).
So just like regular expressions have first-class syntax, i.e., in JavaScript you can write either of:
myRx = /somePattern/g;
myRx = new RegExp('somePattern','g');
So with E4X you can write either of: greeting = <b>Hello, {user.name}!</b>;
greeting = new XML("<b>Hello, "+user.name+"!</b>");
Though those really aren't equivalent since the second might be a XSS vulnerability, whereas the first is automatically escaped.E4X only works in Mozilla-based browsers, but it also works just fine in Rhino, so you can use it in Helma (http://helma.org/) or any of the other Rhino-based frameworks or in Jaxer (http://aptana.com/jaxer).
The answer is a language that can use a unified syntax for both generating markup and server-side functionality at the same time. There's probably only one candidate at the moment, and that's Lisp with a special set of macros that translate to HTML tags on output. The beauty of it is that S-expressions nicely map to markup and can execute stuff on the server. This macro library does exist and I think I saw it here at YCnews. It was a video and unfortunately I can't find it now.
There's one bit missing in this solution though: the client side. Can Lisp be translated to JavaScript? Something suggests that's perfectly possible.