>About tadalist, that application is so stupid that I'm wondering how the hell it could have taken him 600 lines to write it.

Rather than talking, why don't you create something real? Give some proof that you can back up what you say.

"And honestly, everything they say is true, it sets itself apart in simplicity. Not difficult to write that in a few weeks."

I've heard people say this so often in working in software. It's never, ever, turned out to be true when they try to go do it. Building something that "sets itself apart in simplicity" is probably the hardest thing you can do in designing and building software, and if you just look around your desktop you'll probably agree.

" The design is independent of the framework that is used, it can be implemented in anything."

I don't know. My experience is that decisions about frameworks *always* have some impact on the design, even though developers and designers agree that they shouldn't.

I have to agree with you that the LoC argument is kind of pointless. There's clearly no correlation between LoC and inherently good or bad products.

I can write a ten line Perl program that is horrible to maintain.

"Writing Ruby code in the middle of your HTML certainly didn't."

See my other comment on that topic on Patrick's blog : http://www.lightbody.net/mt/mtc.cgi?entry_id=144

It's not because you're writing Ruby in your template that you're writing actual business or domain logic in your HTML... Ruby is much more expressive, elegant and less verbose than every single microlanguage you may come with to develop your views in Java (JSP scriptlets and/or tags, velocity, XSLT, ...)

Java web frameworks will always suck as long as they only focus on providing the infrastructure to dispatch and process requests while completely missing the point when it comes to provide an efficient way to build the part of the system that actually interacts with the end-user and which has its own requirements.

Get back to earth guys, XHTML is not hazardous material it's what your user sees and feels!

Cool, now we, bloggars have our blog-se-tbar - http://blogsearchengine.com/blog/index.php?p=123 !

Sure you can build a template system that doesn't require the inclusion of logic. The main approach for that is stop think of a template as something that has only placeholders for values and needs logic for anything else. Ie. stop looking as templates that are only populated, but also make them provisional. Templates can also be blueprints that contain the standard value placeholders but also provide blocks of text that can be retrieved from within your application. If you then make the template engine a bit more functional and add support for intermediate building and construction, add deferred value replacement, add some byte encoding caching, etc etc and you get something very functional without any logic inside. What's the advantage? You can very easily build themes or variations without having to carefully preserve the logic that's inside. More info here: http://rifers.org/wiki/display/RIFE/Bidirectional+template+engine

I'm well aware that many people don't like this approach, but it has worked extremely well for us for almost 5 years. It's 100% possible to conceive a template engine that abolishes logic inside the templates competely.

Geert,

I'm sorry you have to go through this. David is a pretentious, attention-starved asshole - not to mention a cry-baby.

I agree with you. Basecamp is no big deal. TadaList is no big deal. RoR includes some interesting ideas, but it's not ground breaking, and certainly not the revolution in web development that David and his groupies make it out to be. There are plenty of things wrong with it. Both of these apps could have been written in short order by anyone sufficiently skilled in ANY language. I don't see why everyone is particularly impressed with either one.

Thanks for being one of the first to speak up.

Geert, don't take it personally (btw, thanks for the "mindless comment" on Patrick's blog).

It was a more general remark about the Java Web frameworks. Your biditemplate concept looks interresting, altghough I find the description a bit vague and some example could help understanding how it works in real life. But this approach is certainly several order of magnitude more complex to master and use than what Rails has to offer in its default setup just to deal with something I probably Ain't Gonna Need.

I still believe that presentation logic is not evil and shouldn't be considered harmful... it's actually this layer which adds all the value to Basecamp and Tadalist. Of course the model behind is simple but that's all the details in the UI that makes these stand out of the crowd.

Using a templating system is for higher maintainability. However high maintainability does not require a templating system. The only reason there is any urge to put logic in a template is because you can't figure out where else to put it. In Rails, figuring out where to put logic is a very simple task, and it takes no more work to put it where it belongs than within the templates. As a matter of fact, in Rails, it is harder to put logic in the template since you have to add <% and %> signs. In many frameworks, there are so many files to change and so much work required (XML files, Java Beans, recompiling, restarting Tomcat) to add functionality that given the opportunity, a programmer would prefer to put their logic in the template. That is why framework developers have developed templates, in order to prevent the programmers from taking the easy way out. I have been looking at your RIFE templates, and you have as much markup in them as any Rails project I have seen. I write maintainable code in Rails because it is very easy to do so, not because a convoluted templating system requires me to.

Geert, it sounds like you put PRESENTATION logic just another place than directly in your template. I have not looked all the example, but still it seems highly like those logic is just put outside, but it is still there:

...

}

I guess we can easily do this with any template engine by just getting the logic out the template, but it is still part of the presentation/view logic.

No matter what, if you want to output a list, you have to someone tell it to output each element of the list ;-) No matter where you do that job, you have to do it.

Maybe if I had some hours or days to analyze a very good example of why your method shine... however it just seem to me at first glance that you just put the logic out the template but you still do the same job...

What I like about just pushing the data, it is that you give the data, and could use a lot of different template that threat that data with whetever presentation logic it wants.

"That is why framework developers have developed templates, in order to prevent the programmers from taking the easy way out."

No, because they want to be able to cleanly seperate out the presentation content and put them into replacable templates. If you can't see the benefit of that, then maybe you never needed it. We have for instance a whole collection of modules that I just plug together in a site structure description and I provide a totally different set of HTML/CSS/Image files and baaaam ... I made a new fully functional site for a customer. If I need to fix a bug, or add a feature, I do it in the central module repository and they all get the updated version. If I need to override logic, I just implement or extend one or several elements (smallest modular RIFE building block) and iject that one into the site structure of the modules. Like this I can set up fully functional sites with little more than the time needed to make the design.

"I have been looking at your RIFE templates, and you have as much markup in them as any Rails project I have seen."

Where did I say anything about markup?

"I write maintainable code in Rails because it is very easy to do so, not because a convoluted templating system requires me to."

If you find it convoluted, that's your right, that's why there are so many different technologies for this. I find it convenient and easy to use.

Hi Christian,

first, also for the record, I've got nothing against Ruby, hey I'm even mentioned on the JRuby site (http://jruby.sourceforge.net/credits.shtml). My post has 100% been about naive lies being spread through out-of-context statements that list number of code lines and other things like that as proof of the superiority of a technology. I can't help that many RoR users seem to think that I attack them or hate them, or something else, in any case it says more about those people than about me. I wrote a lot of Bash, Perl, Python, Java, C, C++, Php, etc etc, I have nothing against other languages than Java, I have something about decietful public statements.

Now about your templating problem. All your scenarios are indeed possibilities that exist and that are being used. The main flaw seems to be that you only talk about getting data into template files and not about getting data out of there or to externally manipulate the structure of a template instance. So instead of putting a loop inside the template, you declare blocks that define the snippets of content that you will use in the loop. Inside those snippets, you of course still provide placeholders for values. Now, I don't write the loop inside the template anymore, I write it in my view layer together with all the other logic, and it's not longer than the code I would write inside the template. The only thing I do is using the snippets to construct a larger chunk of content.

I don't see where you might get the idea from that I want to parse the resulting document. I parse the template file, that's it. I don't think RIFE's template system falls into either of the categories you mention.

The number one reason I don't want code to go into my template is because I package all logic into reusable jars and templates into others. I can quickly build new solutions by just reusing modules from the logic-containing jars, by just putting in new templates and not having to worry about integrating the correct logic statements.

"All template languages, including RIFE's, add logic to presentation, no matter how much you try to disguise it. It seems to me that you are in denial of this aspect of web development."

Show me the loops in RIFE's templates.

"Also, in my humble opinion, I think you are confused about why you have so many Railers mad at you."

I'm not confused about it at all, would be very difficult since it was the title of David's blog post. Maybe you love hugging all together and chant about how marvelous and wonderfully ingenious you are, but outside there are people don't happen to not find that there's something to chant about. If you write a simple application with very limited features and without anything going on besides basic crud operations, and then shout very loud that it only took 600 lines ... and you shouted even louder before that your technology is incredibly terse, then I do wonder how the hell it took 600 lines. Don't worry, I'll come through with my version, I just happen to have a family to take care off and a business to run. Since I'm already totally overbooked for a couple of years, it's difficult to free up a bit of time when customers keep on calling for more projects that have to be done for yesterday.

I was afraid of that. The template code didn't show up, but you can easily find it in the URLs provided.

On the point of yelling, there are polite ways to yell where people respect each-other (even if you think you are better or could do better work than others), and there are impolite ways to yell.

If you yell impolitely, you will get people angry. If you tell politely, you will get an interesting and civil conversation. I am not saying that you should yell politely, I am just saying that if you yell impolitely, you shouldn't be surprised when others are impolite.

No, this is not logic. There is nowhere written according to which conditions a loop will continue, how many times, which limits, what concrete data, when it breaks out forcibly, etc etc etc. These is pure markup, don't try to disguise it as something it isn't. Next you're gonna say that pure XHtml contains logic.

Your Ruby example is again overly simplified, what if I conditionally want to show different rows, or break out of the loop, ... etc etc

You can start discussing about semantics, but in my book this is logic. Programming is the general act of writing a program.

No you don't get it, the template engine is totally markup and does nothing, only an external source intervenes with it and can manipulate it. Just like you can manipulate XHtml's DOM structure.

And there are no conditionals either, these are just marked up content blocks that are used by something outside the template engine, in this case the form builder.

.radio or television programs that are scheduled or broadcast:the station is to expand its late-night programming.

Yeah! Now you start redefining the English language ... great going!

Juliet, to use the words of the Rails community, you clearly just make assumptions from looking at a piece of code without trying anything out. The template engine doesn't make those errors appear. You seem to have a terribly hard time just thinking about different concepts than those you already know.

Indeed, that sentence should have read 'the template is totally markup'.

Now, get your facts straight because you make a further fool of yourself.

What the hell is RAFB?

... your argument fails miserably since the RIFE template code you pasted doesn't do anything, if I put that in a template and print the template, you just get empty content.

Sorry, RAFB == RIFE

None of the templates DO anything without context. Not the eRuby template, not the Smarty template, and not the RIFE template. None of them do anything without context provided by the controller and view.

For that matter, no Java code DOES anything. Not without a Java compiler (and even then you need an interpreter for compiled Java code).

That does not mean that the templates don't encapsulate some logic.

Imagine for a second that you don't know the specifics of how any of those example templates gave you the same HTML in the end... you just knew they all did. Now you were told that 2 of those templates had logic and 1 didn't. Nobody would be able to tell which one of those was the odd one. That is because none of them is odd, they all have logic.

So you are saying that providing data does not mean writing additional code?

"Imagine for a second that you don't know the specifics of how any of those example templates gave you the same HTML in the end... you just knew they all did. Now you were told that 2 of those templates had logic and 1 didn't. Nobody would be able to tell which one of those was the odd one. That is because none of them is odd, they all have logic."

It's because you put a red dot on certain things and then independently decide to put them in a certain order, that they move into that order by themselves. They just have a red dot. I could totally independently decide that the red dots don't have to be put into a certain order, but just not appear, or by duplicated, or ... They're still just numb things with just a red dot.

Juliet, take a look at it from another perspective.

Pretend that this is XHTML:

[p]these are some [em]important words[/em][/p]

Without CSS, you will just get bog standard non-italic text. What the markup does is give semantic value to the text "important words" which says that they should be emphisised. It is up to the CSS rendering engine to use italics to show the emphasis.

Geert's template comments do to the markup what XHTML does to the text. It says that a chunk of markup can be used to represent a "row", but it is up to the template engine (=CSS in this case) to say what to do with that markup.

If you want to have a look at the Ruby way to do this, take a look at Amrita: http://amrita.sourceforge.jp/docs/QuickStart.html

It has much much much nicer syntax than Geert's templates, but does the same thing. An advantage over Geert's code is that it uses generic code to put the data into the template, you don't need to code the loops, ever. Not even in the View layer, Amrita handles that. (Well, you could say that Amrita is part of the View layer, but it isn't part of the view layer you have to write yourself :)

Douglas

Douglas, Amrita's syntax is maybe nicer in XHtml (though you can't mark up something that's not a tag), but it doesn't work in text, sql, java, ... We use the template engine for many other things than generating web pages, and using the comment syntax for invisible tags or the short tags for convenience makes it possible to apply it to any text format. I also prefer to have the template markup be clearly isolated from the actual text format syntax to be able to identify it easily with highlighters like this for instance: http://rifers.org/05_friends_basic/src/templates/add.html.html. Of course, that's all a matter of taste.

You say that you don't ever have to write logic in the view layer, put you still have to write logic to populate your list datastructure. We prefer to do this directly from database resulset processors without putting large data structures in memory. Amrita's approach seems handy for simple stuff though.

> Douglas, it's RIFE, not RAFB

Sorry about that, copied Juliet's example code.

> apply it to any text format

If you attach the id attribute to a span, then Amrita will not place the span in the final output. That way you can generate any text format you like. Example template:

My first "[span id="data"][/span]" app.

Ruby code:

tmpl.expand(STDOUT, data)

Will give:

My first "hello world" app.

... just testing since Douglas had problems with placing a comment ...

One backdated comment:

> but that's taste again ;-)

Yes, that's probably true. I never like having single capital letters just hanging around which turned me off right from the start.

http://rafb.net/paste/results/7BQvat75.html

http://rafb.net/paste/results/O3iPWS12.html

I guess any arguments about about which template syntax is better are moot: both act in the same way. Both are language independant, but the Amrita implementation is in Ruby and the RIFE one in Java... and we all know that Ruby is the better language :-P

> There is absolutely NOTHING in a template

I've snipped the qualifier because with it it could apply to any template. The key to the templates isn't that there is NOTHING in them, quite the opposite. The key is that the template is MARKED UP, so that the template engine knows what the tags in the template mean. It's the solution to the "googolplex of templates spread over one googol of directories" problem, where this same markup data is stored in file names.

RIFE doesn't use SGML/XML templates (the alternative syntax is plain text) so you have to write a custom parser (unlike Amrita which just uses a standard XML parser) but the data is still there if you know what to look for. It isn't a "dumb template", it is a marked-up template.

Douglas