Templates

Lecture Notes for CS349W
Fall Quarter 2008
John Ousterhout

The most common building block, available in virtually all Web development frameworks: ASP, PHP, JSP, Rails, Django, ...
Problem addressed by templates:
- Must generate HTML for dynamic Web pages.
- Part of the content is computed specially for each page.
- Much of the HTML is boilerplate that's the same in every instance of the page.
- If the entire page is generated by a program, the structure of the boilerplate gets lost in a sea of "print" statements.
Template mechanism:
- Write an HTML document containing the parts that are always the same: headings, table captions, etc.
- Introduce bits of code into the document to generate the parts that differ from request to request.
- When the template is "expanded", the code gets executed and its results are substituted into the document in place of the code.

Basic Rails example: hello.rhtml

<html>
  <head>
    <title>Hello, User </title>
  </head>
  <body>
    <p>
    This page was fetched at <%= Time.now() %>
    </p>
  </body>
</html>

Basic features in templating:
- Execute code, substitute result (<%= ... %> in Rails).
- Execute code but don't substitute (<% ... %> in Rails). (Can always print to the page in the code)
- Control structures can be interleaved with HTML. Example from loop.rhtml:
```
<table>
  <% i = 1
  while (i <= 10) %>
    <tr>
      <td>Value of <%= i %>*<%= i %>:</td>
      <td class="value"><%= i*i %></td>
    </tr>
    <% i = i+1
  end %>
</table>
```
- Some templating systems (e.g. JSP) provide a large collection of features in the templating mechanism:
```
<%@ page session="true" %>
```
  Most systems keep the templating simple and let you invoke methods in the language for the additional functions.
Advantages of templates:
- Clarify the structure of the HTML.
- Allow non-programmer Web page designers to create templates? In practice, not really.
Problems with templates:
- If the structure of the page is highly dynamic (lots of alternatives chosen from at run-time), the code structure becomes complicated; it gets lost in all the HTML (even in loop.rhtml).
- All interesting generated pages have non-trivial conditional structure.
- Templates focus attention on the low-level HTML of the page.
- Templates distract from modular page design (reusable page sections).
- More important to focus on the high-level structure of the page
- HTML should be spit out the back end automatically; page designers shouldn't spend much time thinking about it.
How templating systems deal with these problems:
- Putting large amounts of code in templates is discouraged; call out to other packages for nontrivial computations.
- Template components: high-level templates show the page structure, call out to nested templates for the details. Example: "partial templates" in Ruby.
  - But, templating doesn't add much value at the top level (no HTML).
  - Even in partial templates there is still the problem of too much code.