PageRenderTime 86ms CodeModel.GetById 12ms RepoModel.GetById 0ms app.codeStats 1ms

/site/ucw-boxset/ucw_ajax/docs/ucw-intro/ucw-intro.html

https://github.com/vikram/lisplibraries
HTML | 1448 lines | 1402 code | 19 blank | 27 comment | 0 complexity | bbd353aeba5610d7e4175fbb3d19ecb0 MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-2.1, CC-BY-SA-3.0, LGPL-3.0, BSD-3-Clause, GPL-2.0 
    

  1. <html>
    2. 

  2.   <head>
    3. 

  3.     <title>UCW intro</title>
    4. 

  4.     <link rel='stylesheet' type='text/css' href='style.css'>
    5. 

  5.   </head>
    6. 

  6.     <!--Creative Commons License-->
    7. 

  7.     <a rel="license"
    8. 

  8.       href="http://creativecommons.org/licenses/by-nc-sa/2.5/"><img
    9. 

  9.       alt="Creative Commons License"
    10. 

  10.       align='right'
    11. 

  11.       src="http://creativecommons.org/images/public/somerights20.png"
    12. 

  12.       border="0">
    13. 

  13.     </a>
    14. 

  14.     <!--/Creative Commons License--><!-- <rdf:RDF xmlns="http://web.resource.org/cc/" xmlns:dc="http://purl.org/dc/elements/1.1/"
    15. 

  15.     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    16. 

  16.     <Work rdf:about="">
    17. 

  17.     <license rdf:resource="http://creativecommons.org/licenses/by-nc-sa/2.5/" />
    18. 

  18.     <dc:title>UCW intro</dc:title>
    19. 

  19.     <dc:date>2006</dc:date>
    20. 

  20.     <dc:description>You don't have to mention
    21. 

  21.     my name or where you got the content from if you want to use this
    22. 

  22.     work for your own purposes, just keep by this license (why would of
    23. 

  23.     course be another question ;)). If you want
    24. 

  24.     to use any of this for commercial use or in another way that's not
    25. 

  25.     covered by the licence, just send me an email (see somewhere on the
    26. 

  26.     page if present) and we can probably work something out.</dc:description>
    27. 

  27.     <dc:creator><Agent><dc:title>Ties Stuij</dc:title></Agent></dc:creator>
    28. 

  28.     <dc:rights><Agent><dc:title>Ties Stuij</dc:title></Agent></dc:rights>
    29. 

  29.     <dc:source rdf:resource="www.fallenfrukt.com" />
    30. 

  30.     </Work>
    31. 

  31.     <License
    32. 

  32.     rdf:about="http://creativecommons.org/licenses/by-nc-sa/2.5/"><permits
    33. 

  33.     rdf:resource="http://web.resource.org/cc/Reproduction"/><permits
    34. 

  34.     rdf:resource="http://web.resource.org/cc/Distribution"/><requires
    35. 

  35.     rdf:resource="http://web.resource.org/cc/Notice"/><requires
    36. 

  36.     rdf:resource="http://web.resource.org/cc/Attribution"/><prohibits
    37. 

  37.     rdf:resource="http://web.resource.org/cc/CommercialUse"/><permits
    38. 

  38.     rdf:resource="http://web.resource.org/cc/DerivativeWorks"/><requires
    39. 

  39.     rdf:resource="http://web.resource.org/cc/ShareAlike"/></License></rdf:RDF> -->
    40. 

  40.   <body>
    41. 

  41.     <h1>UCW intro</h1>
    42. 

  42.     <p>advertisement: ucw is now easily installable!! (experimental) 
    43. 

  43.     <br>
    44. 

  44.     
    45. 

  45.     Get <a href='http://common-lisp.net/project/ucw/ucw-boxset.tar.gz'>http://common-lisp.net/project/ucw/ucw-boxset.tar.gz</a>, untar it, cd into the dir and execute:</p>
    46. 

  46.     <pre>
    47. 

  47. YOURLISPHERE (-)-load start.lisp
    48. 

  48.     </pre>
    49. 

  49.     <p>last modified 4th of may 2006</p>
    50. 

  50.     <p>- added ucw-boxset info 
    51. 

  51.     <br>
    52. 

  52.     
    53. 

  53.     - added debugging tools chapter 
    54. 

  54.     <br>
    55. 

  55.     
    56. 

  56.     - added tabbed pane info in the templating chapter 
    57. 

  57.     <br>
    58. 

  58.     
    59. 

  59.     - added info on slightly changed startup procedure 
    60. 

  60.     <br>
    61. 

  61.     
    62. 

  62.     - fixed bugs concerning variable passing between pages in basics.lisp 
    63. 

  63.     <br>
    64. 

  64.     
    65. 

  65.     - fixed little bug in the spliced-href slot</p>
    66. 

  66.     <p>table of content: 
    67. 

  67.     
    68. 

  68.     <ul>
    69. 

  69.       <li><a href='#intro'>Introduction</a></li>
    70. 

  70.       <li><a href='#install'>Installation</a></li>
    71. 

  71.       <li><a href='#extra'>Add-ons</a></li>
    72. 

  72.       <li><a href='#testing'>Testing/Quickstart</a></li>
    73. 

  73.       <li><a href='#configure'>Configuration</a></li>
    74. 

  74.       <li><a href='#environment'>Setting up the environment (and a hello world on the side)</a></li>
    75. 

  75.       <li><a href='#mechanics'>Basic ucw mechanics</a></li>
    76. 

  76.       <li><a href='#templating'>Templating: nested components, containers and TAL</a></li>
    77. 

  77.       <li>Login sessions</li>
    78. 

  78.       <li>Downloading files</li>
    79. 

  79.       <li>Advanced form handling</li>
    80. 

  80.       <li>To backtrack or not to backtrack</li>
    81. 

  81.       <li>Ajax</li>
    82. 

  82.       <li>Really, really, really cool example application</li>
    83. 

  83.       <li><a href='#debugging'>Debugging tools</a></li>
    84. 

  84.       <li><a href='#source'>Source</a></li>
    85. 

  85.       <li><a href='#miscellaneous'>Miscellaneous</a></li>
    86. 

  86.     </ul>
    87. 

  87.     </p>
    88. 

  88.     <p><span id='intro'></span></p>
    89. 

  89.     <h2>Introduction</h2>
    90. 

  90.     <p>This text will introduce you in a mild mannered pace to the ways of this as of yet UnCommon Web
    91. 

  91.     framework, which is a framework to write web applications as you would write normal applications; e.g. with state. Check ucw's
    92. 

  92.     <a href='http://common-lisp.net/project/ucw/features.html'>features page</a> to get an impression of its features. Ucw is an
    93. 

  93.     open source project. Various people donate code on a regular basis. Check the
    94. 

  94.     <a href='http://common-lisp.net/cgi-bin/mailman/listinfo/bese-devel'>mailing list</a> for a flavour of the current topics. If you're
    95. 

  95.     wondering about the merits and weaknesses of either state or stateless web development check
    96. 

  96.     <a href='http://common-lisp.net/project/ucw/docs/html/rest/rest.html'>this rather nice one-page email conversation</a>
    97. 

  97.     between the creator of ucw and a non-believer. If you want to use ucw on a windows machine, I have got no experience or information on
    98. 

  98.     workability, but i would very much like to hear about your experiences.</p>
    99. 

  99.     <p>This introduction wants to introduce UCW in a slow and concise manner. We will start with
    100. 

  100.     the installation and an initial setup. Then slowly, through simple examples, the reader will be introduced to the
    101. 

  101.     various components. We will delve from the outside in and will perhaps some day hit upon the burning hot core. For the
    102. 

  102.     brilliant and the impatient this pace will just be to damn slow. Them I advice to read and watch some
    103. 

  103.     other tutorials and documentation. They are:</p>
    104. 

  104.     <ul>
    105. 

  105.       <li><a href='http://www.cliki.net/ucw%20Tutorial'>UCW Tutorial</a> - a cliki tutorial in progress, not dissimilar to mine, which
    106. 

  106.       sets up a quick working environment and explains the different components with a lot of code.</li>
    107. 

  107.       <li><a href='http://common-lisp.net/project/ucw/documentation.html'>the ucw documentation page</a> - diverse documentation sources
    108. 

  108.       which are a bit out of date. The email conversations are very interesting to get a good grasp of the use and limitations of ucw, and the
    109. 

  109.       video, although out of date, is interesting because you get to see ucw in action. Be warned: the source-code and the wiki example are a bit
    110. 

  110.       out of date last time I checked. Better to just download the source code, in which you will also find the wiki example.</li>
    111. 

  111.       <li>the source code  - the docs section of the source code unlocks apache setup code, two quickstarts which may be a bit out of date, and
    112. 

  112.       more. Also check the examples directory relative to the root. It gives you a good idea how to code up various aspects of ucw and it harbors
    113. 

  113.       the wiki-example. It might just be a bit obvious but in the source code you can also read the source code; it offers great insight in the way ucw is put together.</li>
    114. 

  114.     </ul>
    115. 

  115.     <p><span id='install'></span></p>
    116. 

  116.     <h2>Installation</h2>
    117. 

  117.     <p>First off UCW doesn't do version numbers. Some people may remember it did and it did, but it doesn't anymore. Still there are two versions
    118. 

  118.     of UCW to choose from: ucw_dev and ucw_public, both held in a Darcs repository. ucw_dev is controlled by Marco Baringer, creator of
    119. 

  119.     ucw. Ucw_public is world writable. At the moment I would advise to go with ucw_dev which is also the focus of this intro. _public is not always in sync with _dev, although lately it does a good job of keeping up.</p>
    120. 

  120.     <h3>The (experimental) easy way</h3>
    121. 

  121.     <p>There's a shortcut nowadays.  Marco Baringer made a UCW candybox
    122. 

  122.     with all the dependencies boxed up and ready to fire. At the moment
    123. 

  123.     it's quite experimental, but if it doesn't work at least you've got all
    124. 

  124.     the dependencies in one go. Try:</p>
    125. 

  125.     <p>wget <a href='http://common-lisp.net/project/ucw/ucw-boxset.tar.gz'>http://common-lisp.net/project/ucw/ucw-boxset.tar.gz</a>
    126. 

  126.     tar -zxf ucw-boxset.tar.gz
    127. 

  127.     cd ucw-boxset
    128. 

  128.     YOURLISPHERE (-)-load start.lisp</p>
    129. 

  129.     <p>This will start UCW with the built in httpd server backend. But if you
    130. 

  130.     want to get the dependencies seperately or want a different initial setup,
    131. 

  131.     read and get some of the following:</p>
    132. 

  132.     <h3>The (old and boring) hard way</h3>
    133. 

  133.     <p>To get _dev or _public, install Darcs on your computer and execute:</p>
    134. 

  134.     <pre>
    135. 

  135. darcs get http://common-lisp.net/project/ucw/repos/ucw_dev
    136. 

  136.     </pre>
    137. 

  137.     <p>or</p>
    138. 

  138.     <pre>
    139. 

  139. darcs get http://common-lisp.net/project/ucw/repos/ucw_public
    140. 

  140.     </pre>
    141. 

  141.     <p>Daily snapshots for ucw_dev are available at
    142. 

  142.     <a href='http://common-lisp.net/project/ucw/tarballs/ucw_dev-latest.tar.gz'>http://common-lisp.net/project/ucw/tarballs/ucw_dev-latest.tar.gz</a></p>
    143. 

  143.     <p>Daily snapshots for ucw_public are available at
    144. 

  144.     <a href='http://common-lisp.net/project/ucw/tarballs/ucw_public-latest.tar.gz'>http://common-lisp.net/project/ucw/tarballs/ucw_public-latest.tar.gz</a></p>
    145. 

  145.     <p>Now it is time for the dependencies. A word of caution: ucw has it's own versions for a number of libraries so even if
    146. 

  146.     you already have the latest version of some package, check this documentation or the readme supplied with the
    147. 

  147.     sources. As a rule of thumb, get the latest of everything and the ucw version if supplied.</p>
    148. 

  148.     <p>At the moment UCW requires the following
    149. 

  149.     dependencies:</p>
    150. 

  150.     <ul>
    151. 

  151.       <li><a href='#implementation'>a lisp implementation - one of the following: sbcl, cmucl, allegro, lispworks, openmcl</a></li>
    152. 

  152.       <li><a href='#arnesi'>arnesi - an all purpose lisp toolkit</a></li>
    153. 

  153.       <li><a href='#yaclml'>yaclml - yet another common lisp markup language</a></li>
    154. 

  154.       <li><a href='#parenscript'>parenscript - javascript in common-lisp</a></li>
    155. 

  155.       <li><a href='#iterate'>iterate - a lispy loop</a></li>
    156. 

  156.       <li><a href='#rfc2388'>rfc2388 - implements multipart/form specification</a></li>
    157. 

  157.       <li><a href='#rfc2109'>rfc2109 - implements cookie specification</a></li>
    158. 

  158.       <li><a href='#split-sequence'>split-sequence - splits sequences</a></li>
    159. 

  159.       <li><a href='#slime'>slime - Superior Lisp Interaction Mode for Emacs</a></li>
    160. 

  160.       <li><a href='#cl-ppcre'>cl-ppcre - regular expressions lib</a></li>
    161. 

  161.       <li><a href='#trivial-sockets'>trivial-sockets - handles stream sockets for undemanding network applications</a></li>
    162. 

  162.       <li><a href='#puri'>net.uri or PURI - parses URI's according to the RFC 2396 specification</a></li>
    163. 

  163.       <li><a href='#cl-fad'>cl-fad - a portable pathname library based on code from PCL</a></li>
    164. 

  164.       <li><a href='#cl-launch'>cl-launch - invokes lisp code from the command line</a></li>
    165. 

  165.       <li><a href='#detachtty'>detachtty - a screen-like detachment tool to be able to detach and reattach the lisp server from and to a console</a></li>
    166. 

  166.       <li><a href='#backend'>a server backend - be it mod_lisp (apache 1 or 2), araneida, allegroserve, portable aserve or the built in httpd server</a></li>
    167. 

  167.       <li><a href='#asdf'>asdf - a package loader facility</a></li>
    168. 

  168.     </ul>
    169. 

  169.     <p>A note on compatibility: Some configurations of implementation and server work better than others. Just report your bugs in the
    170. 

  170.     <a href='http://common-lisp.net/cgi-bin/mailman/listinfo/bese-devel'>mailinglist</a>, the list is quite responsive. As a pointer, an
    171. 

  171.     implementation/server-pair of sbcl or openmcl and mod_lisp seem too see the heaviest testing. The built-in httpd server also works well but
    172. 

  172.     isn't fit for production use.</p>
    173. 

  173.     <p><span id='implementation'></span></p>
    174. 

  174.     <h4>Implementation.</h4>
    175. 

  175.     <p>Pick one in the list above.</p>
    176. 

  176.     <h4>Debian</h4>
    177. 

  177.     <p>Someone from Debian (Luca Capello) is working hard to to support ucw out of the box, but he is not quite there yet. Keep an eye on the
    178. 

  178.     cl-debian mailing list
    179. 

  179.     (<a href='http://common-lisp.net/pipermail/cl-debian/2006-March/001113.html'>UCW status, seeing the light at the end of the tunnel</a>) for the latest developments.</p>
    180. 

  180.     <p><span id='arnesi'></span></p>
    181. 

  181.     <h4>Dependencies</h4>
    182. 

  182.     <h5>arnesi</h5>
    183. 

  183.     <p>Arnesi is a Common Lisp utility suite. It contains various "bits 'n 
    184. 

  184.     pieces" of code which were useful while developing other code. It can
    185. 

  185.     be found on <a href='http://common-lisp.net/project/bese/arnesi.html'>http://common-lisp.net/project/bese/arnesi.html</a>.</p>
    186. 

  186.     <p>You will need the latest version:</p>
    187. 

  187.     <pre>
    188. 

  188. darcs get http://common-lisp.net/project/bese/repos/arnesi_dev/
    189. 

  189.     </pre>
    190. 

  190.     <p>Daily snapshots are available at
    191. 

  191.     <a href='http://common-lisp.net/project/bese/tarballs/arnesi_dev-latest.tar.gz'>http://common-lisp.net/project/bese/tarballs/arnesi_dev-latest.tar.gz</a></p>
    192. 

  192.     <p><span id='yaclml'></span></p>
    193. 

  193.     <h5>yaclml</h5>
    194. 

  194.     <p>yaclml is a collection of macros and utilities for generating XML/HTML
    195. 

  195.     like markup from lisp code. It can be found on
    196. 

  196.     <a href='http://common-lisp.net/project/bese/yaclml.html'>http://common-lisp.net/project/bese/yaclml.html</a>. </p>
    197. 

  197.     <p>You will need the latest version:</p>
    198. 

  198.     <pre>
    199. 

  199. darcs get http://common-lisp.net/project/bese/repos/yaclml/
    200. 

  200.     </pre>
    201. 

  201.     <p>Daily snapshots are available at: <a href='http://common-lisp.net/project/bese/tarballs/yaclml-latest.tar.gz'>http://common-lisp.net/project/bese/tarballs/yaclml-latest.tar.gz</a></p>
    202. 

  202.     <p><span id='parenscript'></span></p>
    203. 

  203.     <h5>parenscript - ucw version</h5>
    204. 

  204.     <p>Parenscript is a javascript compiler. You will need to get the latest development version:</p>
    205. 

  205.     <pre>
    206. 

  206. darcs get http://common-lisp.net/project/ucw/repos/parenscript/
    207. 

  207.     </pre>
    208. 

  208.     <p>Daily snapshots are available at: <a href='http://common-lisp.net/project/ucw/tarballs/parenscript-latest.tar.gz'>http://common-lisp.net/project/ucw/tarballs/parenscript-latest.tar.gz</a></p>
    209. 

  209.     <p><span id='iterate'></span></p>
    210. 

  210.     <h5>iterate</h5>
    211. 

  211.     <p>Iterate is an iteration construct for Common Lisp. It can be found on</p>
    212. 

  212.     <a href='http://common-lisp.net/project/iterate/'>http://common-lisp.net/project/iterate/</a>
    213. 

  213.     <p>Download link: <a href='http://common-lisp.net/project/iterate/releases/iterate-current.tar.gz'>http://common-lisp.net/project/iterate/releases/iterate-current.tar.gz</a></p>
    214. 

  214.     <p><span id='rfc2388'></span></p>
    215. 

  215.     <h5>rfc2388 - ucw version</h5>
    216. 

  216.     <p>Rfc2388 is a lisp implemantation of RFC 2388, which is used to process form
    217. 

  217.     data posted with HTTP POST method using enctype "multipart/form-data".</p>
    218. 

  218.     <p>UCW uses its own fork of rfc2388. You can get the latest code from the
    219. 

  219.     darcs repository located at
    220. 

  220.     <a href='http://common-lisp.net/project/ucw/repos/rfc2388'>http://common-lisp.net/project/ucw/repos/rfc2388</a>:</p>
    221. 

  221.     <pre>
    222. 

  222. darcs get http://common-lisp.net/project/ucw/repos/rfc2388/
    223. 

  223.     </pre>
    224. 

  224.     <p>Daily snapshots are available at <a href='http://common-lisp.net/project/ucw/tarballs/rfc2388-latest.tar.gz'>http://common-lisp.net/project/ucw/tarballs/rfc2388-latest.tar.gz</a></p>
    225. 

  225.     <p><span id='rfc2109'></span></p>
    226. 

  226.     <h5>rfc2109 - ucw version</h5>
    227. 

  227.     <p>Rfc2109 is the lisp implementation of the cookie protocol. You can get
    228. 

  228.     it at:
    229. 

  229.     <a href='http://common-lisp.net/project/rfc2109'>http://common-lisp.net/project/rfc2109/</a>:</p>
    230. 

  230.     <pre>
    231. 

  231. darcs get http://common-lisp.net/project/rfc2109/rfc2109
    232. 

  232.     </pre>
    233. 

  233.     <p>Daily snapshots are available at
    234. 

  234.     <a href='http://www.common-lisp.net/project/rfc2109/release/rfc2109-latest.tar.gz '>http://www.common-lisp.net/project/rfc2109/release/rfc2109-latest.tar.gz </a></p>
    235. 

  235.     <p><span id='split-sequence'></span></p>
    236. 

  236.     <h5>split-sequence</h5>
    237. 

  237.     <p>splits sequences</p>
    238. 

  238.     <p>info: <a href='http://www.cliki.net/SPLIT-SEQUENCE'>http://www.cliki.net/SPLIT-SEQUENCE</a></p>
    239. 

  239.     <p>download: <a href='http://ww.telent.net/cclan/split-sequence.tar.gz'>http://ww.telent.net/cclan/split-sequence.tar.gz</a>
    240. 

  240.     (you might have to select a mirror first)</p>
    241. 

  241.     <p>If said link is dead, go to <a href='http://ww.telent.net/cclan-choose-mirror'>http://ww.telent.net/cclan-choose-mirror</a>
    242. 

  242.     to delete your CCLAN-SITE cookie and choose another mirror. At least some of them are definitely working. </p>
    243. 

  243.     <p><span id='slime'></span></p>
    244. 

  244.     <h5>SLIME</h5>
    245. 

  245.     <p>The Superior Lisp Interaction Mode for Emacs.</p>
    246. 

  246.     <p>Download and install the latest CVS version of SLIME from
    247. 

  247.     <a href='http://common-lisp.net/project/slime'>http://common-lisp.net/project/slime</a>.</p>
    248. 

  248.     <p>To checkout from CVS you must first login to the repository:</p>
    249. 

  249.     <pre>
    250. 

  250. export CVSROOT=:pserver:anonymous@common-lisp.net:/project/slime/cvsroot
    251. 

  251. cvs login
    252. 

  252.     </pre>
    253. 

  253.     <p>Enter anonymous when prompted for the password. You can then check out the latest version with:</p>
    254. 

  254.     <pre>
    255. 

  255. cvs checkout slime
    256. 

  256.     </pre>
    257. 

  257.     <p>It's swank you want to add to your asd systems dir. To solve a current problem
    258. 

  258.     with cl-launch you might want to overwrite your swank.asd file with this one:</p>
    259. 

  259.     <a href='http://cl-debian.alioth.debian.org/repository/pvaneynd/slime/debian/swank.asd'>http://cl-debian.alioth.debian.org/repository/pvaneynd/slime/debian/swank.asd</a>
    260. 

  260.     <p>Check the description on cl-launch to see why.</p>
    261. 

  261.     <p><span id='cl-ppcre'></span></p>
    262. 

  262.     <h5>cl-ppcre</h5>
    263. 

  263.     <p>Edi Weitz's regular expression library:  <a href='http://www.weitz.de/cl-ppcre/'>http://www.weitz.de/cl-ppcre/</a>.</p>
    264. 

  264.     <p>Download the latest version: <a href='http://weitz.de/files/cl-ppcre.tar.gz'>http://weitz.de/files/cl-ppcre.tar.gz</a></p>
    265. 

  265.     <p><span id='trivial-sockets'></span></p>
    266. 

  266.     <h5>trivial-sockets</h5>
    267. 

  267.     <p>Networking library to create small server applications. Download the latest version from:
    268. 

  268.     <a href='http://ww.telent.net/cclan/trivial-sockets.tar.gz'>http://ww.telent.net/cclan/trivial-sockets.tar.gz</a>
    269. 

  269.     (you might have to select a mirror first.</p>
    270. 

  270.     <p>If said link is dead, go to <a href='http://ww.telent.net/cclan-choose-mirror'>http://ww.telent.net/cclan-choose-mirror</a>
    271. 

  271.     to delete your CCLAN-SITE cookie and choose another mirror. At least some of them are definitely working. </p>
    272. 

  272.     <p>Or use asdf install.</p>
    273. 

  273.     <p><span id='puri'></span></p>
    274. 

  274.     <h5>net.uri/PURI</h5>
    275. 

  275.     <p>All of the backends (except araneida) depend on Franz's open-source
    276. 

  276.     net.uri library. It only works on Allegro but Kevin Rosenberg has made a portable version called PURI.</p>
    277. 

  277.     <p>For allegro users, NET.URI can be downloaded from here (it may be included in your
    278. 

  278.     version of acl):
    279. 

  279.     <a href='http://opensource.franz.com/uri/index.html'>http://opensource.franz.com/uri/index.html</a> </p>
    280. 

  280.     <p>If you're not using allegro you'll need puri which can be
    281. 

  281.     downloaded from <a href='http://puri.b9.com/download.html'>http://puri.b9.com/download.html</a></p>
    282. 

  282.     <p><span id='cl-fad'></span></p>
    283. 

  283.     <h5>cl-fad</h5>
    284. 

  284.     <p>A portable pathname library based on code from Peter Seibels book Practical Common Lisp. </p>
    285. 

  285.     <p>info: <a href='http://www.cliki.net/CL-FAD'>http://www.cliki.net/CL-FAD</a></p>
    286. 

  286.     <p>download: <a href='http://weitz.de/files/cl-fad.tar.gz'>http://weitz.de/files/cl-fad.tar.gz</a></p>
    287. 

  287.     <p><span id='cl-launch'></span></p>
    288. 

  288.     <h5>cl-launch</h5>
    289. 

  289.     <p>A bash script to make your Lisp software easily invokable from the shell command-line.</p>
    290. 

  290.     <p>info: <a href='http://www.cliki.net/cl-launch'>http://www.cliki.net/cl-launch</a></p>
    291. 

  291.     <p>download page: <a href='http://fare.tunes.org/files/cl-launch/'>http://fare.tunes.org/files/cl-launch/</a></p>
    292. 

  292.     <p>Download and add to your shell executable search path so ucw can find it while loading. Cl-launch can either be called cl-launch or
    293. 

  293.     cl-launch.sh, ucw will check for both. Also cl-launch depends on swank behavior other than that of the current cvs code, at least under sbcl, eg via swank-loader it looks for files under the load path, which is not what you want if you made a symbolic link to another dir. The easiest way to get around this problem is to overwrite your swank.asd file (in the slime directory root), with this one:</p>
    294. 

  294.     <a href='http://cl-debian.alioth.debian.org/repository/pvaneynd/slime/debian/swank.asd'>http://cl-debian.alioth.debian.org/repository/pvaneynd/slime/debian/swank.asd</a>
    295. 

  295.     <p>The downside might be that swank won't work anymore as it should, although i haven't heard anyone about this yet. Another approach is to copy your swank*.fasls from the slime directory to the relevant shadow directory under ~/.cache/...</p>
    296. 

  296.     <p>Check this thread for more info:</p>
    297. 

  297.     <a href='http://common-lisp.net/pipermail/slime-devel/2006-March/004664.html'>http://common-lisp.net/pipermail/slime-devel/2006-March/004664.html</a>
    298. 

  298.     <p>Yes, ucw is bleeding edge ;)</p>
    299. 

  299.     <p><span id='detachtty'></span></p>
    300. 

  300.     <h5>detachtty - ucw version</h5>
    301. 

  301.     <p>A screen-like detachment tool to be able to detach and re-attach the lisp server from and to a console. 
    302. 

  302.     Ucw uses a custom detachtty version, e.g. detachtty-9 plus a patch by Kevin Rosenberg. It accepts an eval argument when
    303. 

  303.     invoking a lisp, with obvious benefits. Get it through Darcs:</p>
    304. 

  304.     <pre>
    305. 

  305. darcs get http://common-lisp.net/project/bese/repos/detachtty/
    306. 

  306.     </pre>
    307. 

  307.     <p>Go to the directory root and compile and install:</p>
    308. 

  308.     <pre>
    309. 

  309. make
    310. 

  310. make install
    311. 

  311.     </pre>
    312. 

  312.     <p><span id='backend'></span></p>
    313. 

  313.     <h4>the backend</h4>
    314. 

  314.     <p>Ucw supports all the popular lisp backends. Whichever floats your boat. If you've got no clue which to choose I'd advice
    315. 

  315.     to go for mod_lisp. It works well with other languages, you get the benefit of apaches options and extras and all it does
    316. 

  316.     is pump the code straight to ucw so there's no trouble with quirks in the intermediate layer. Apache requires some work
    317. 

  317.     to function correctly, read the text below. The other backends should work out of the box, as long as they're recognized by
    318. 

  318.     asdf. aserve as well as portable aserve are in the package systems of gentoo and debian. Gentoo also supports mod_lisp
    319. 

  319.     and mod_lisp2 for apache and araneida. Read <a href='http://bc.tech.coop/blog/051219.html'>this blog post</a> by
    320. 

  320.     Bill Clementson to form a more balanced opinion.</p>
    321. 

  321.     <h5>mod_lisp/mod_lisp2 for apache</h5>
    322. 

  322.     <p>You can choose between apache 1 and 2. First of course you have to have a Apache web
    323. 

  323.     server up and runnnig; then you have to add the mod-lisp module by Marc
    324. 

  324.     Battyani which you find at <a href='http://www.fractalconcept.com/asp/html/mod_lisp.html'>http://www.fractalconcept.com/asp/html/mod_lisp.html</a></p>
    325. 

  325.     <p>First download the mod_lisp c file. Watch out, don't follow the logic of the website. Except for the windows version the
    326. 

  326.     info is outdated concerning the apache 1 version and info about apache 2 is non-existent. Go to subversion from the
    327. 

  327.     download page or click the links below:</p>
    328. 

  328.     <ul>
    329. 

  329.       <li>apache 1 .c file -
    330. 

  330.       <a href='http://www.fractalconcept.com:8000/public/open-source/mod_lisp/mod_lisp.c'>mod_lisp.c</a></li>
    331. 

  331.       <li>apache 1 binaries for windows - there is a link on the site for version 2.32 but it leads to nowhere</li>
    332. 

  332.       <li>apache 2 .c file - <a href='http://www.fractalconcept.com:8000/public/open-source/mod_lisp/mod_lisp2.c'>mod_lisp2.c</a></li>
    333. 

  333.       <li>apache 2 windows binary -
    334. 

  334.       <a href='http://www.fractalconcept.com:8000/public/open-source/mod_lisp/windows/mod_lisp2.zip'>mod_lisp2.zip</a></li>
    335. 

  335.     </ul>
    336. 

  336.     <p>As stated in the intro, if you want to use ucw on a windows machine you're on your own. I have got no experience or information.</p>
    337. 

  337.     <p>If you went for the c module on a unix clone, use the command.</p>
    338. 

  338.     <pre>
    339. 

  339. apxs -i -c mod_lisp.c
    340. 

  340.     </pre>
    341. 

  341.     <p>or</p>
    342. 

  342.     <pre>
    343. 

  343. apxs2 -i -c mod_lisp2.c
    344. 

  344.     </pre>
    345. 

  345.     <p>for respectively apache 1 or 2. This will install the module in the appropriate apache directory. Debian users using apt-get should get one
    346. 

  346.     of the apache dev versions to get apxs(2) installed. Then add the following lines to 'httpd.conf' or other relevant configure file in your
    347. 

  347.     apache configuration directory for both apache 1 and 2. Just be sure to change mod_lisp.so to mod_lisp2.so for apache 2.</p>
    348. 

  348.     <pre>
    349. 

  349. LoadModule lisp_module /path/to/modules/directory/mod_lisp.so
    350. 

  350.     </pre>
    351. 

  351.     <pre>
    352. 

  352. LispServer 127.0.0.1 3001 ucw
    353. 

  353.     </pre>
    354. 

  354.     <pre>
    355. 

  355. &lt;LocationMatch "/path/.*\.ucw"&gt;
    356. 

  356.                SetHandler lisp-handler
    357. 

  357. &lt;/LocationMatch&gt;
    358. 

  358.     </pre>
    359. 

  359.     <p>This means that ucw INTERNALLY talks to apache on port 3001 at the internet address 127.0.0.1 (so in this case your
    360. 

  360.     localhost). The locationmatch part redirects all traffic from (in this case) 127.0.0.1 with prefix "/path/" and files ending
    361. 

  361.     on .ucw to ucw. So http://127.0.0.1/path/something.ucw as well as
    362. 

  362.     http://127.0.0.1/path/anotherpath/somethingelse.ucw will be redirected, but not http://127.0.0.1/somethingfaulty.ucw or
    363. 

  363.     http://127.0.0.1/path/somethingfaulty.html .</p>
    364. 

  364.     <h5>allegroserve or portableaserve</h5>
    365. 

  365.     <p>Should you want to use the aserve backend you will need to download
    366. 

  366.     and install either the AllegroServe if you use acl or portableaserve for any other. AllegroServe doesn't seem to have an
    367. 

  367.     asdf file, you're going to have to load it manually or however AllegroServe handles it's own files. Portableaserve does however.</p>
    368. 

  368.     <p>AllegroServe can be downloaded from here (it may be included in
    369. 

  369.     your version of acl): <a href='http://opensource.franz.com/aserve/'>http://opensource.franz.com/aserve/</a></p>
    370. 

  370.     <p>portableaserve is hosted on sourceforge: <a href='http://portableaserve.sf.net'>http://portableaserve.sf.net</a></p>
    371. 

  371.     <p>portableaserve download: <a href='http://constantly.at/lisp/aserve.tar.gz'>http://constantly.at/lisp/aserve.tar.gz</a></p>
    372. 

  372.     <p>To use portableaserve you'll also need the Allegro Common Lisp compatibility package (acl-compat). It's part of
    373. 

  373.     portableaserve and so it's home is also the before-mentioned sourceforge site.</p>
    374. 

  374.     <p>acl-compat download: <a href='http://constantly.at/lisp/acl-compat.tar.gz'>http://constantly.at/lisp/acl-compat.tar.gz</a></p>
    375. 

  375.     <h5>araneida</h5>
    376. 

  376.     <p>Should you want to use the araneida backend you will need to download araneida. Get the latest version just to be on the
    377. 

  377.     safe side. Originally araneida was meant to live behind apache and it can of course still be configured as
    378. 

  378.     such. Explaining this is beyond the scope of this document but have a look at this
    379. 

  379.     <a href='http://www.accela.net/~dankna/guide.html'>site</a> for more info.</p>
    380. 

  380.     <p>info: <a href='http://www.cliki.net/Araneida'>http://www.cliki.net/Araneida</a>}</p>
    381. 

  381.     <p>download: <a href='http://common-lisp.net/project/araneida/release/araneida-latest.tar.gz'>http://common-lisp.net/project/araneida/release/araneida-latest.tar.gz</a></p>
    382. 

  382.     <p>or use darcs, although the connection seems a bit slow:</p>
    383. 

  383.     <pre>
    384. 

  384. darcs get http://verisons.telent.net/araneida/
    385. 

  385.     </pre>
    386. 

  386.     <h5>httpd</h5>
    387. 

  387.     <p>Ucw's in-house server. It's a simple server bundled with ucw. Nice for testing.</p>
    388. 

  388.     <p><span id='asdf'></span></p>
    389. 

  389.     <h3>asdf</h3>
    390. 

  390.     <p>To download it or read up on it go to  <a href='http://cliki.net/ASDF'>http://cliki.net/ASDF</a></p>
    391. 

  391.     <p>Asdf makes sure common lisp packages and the files in those packages get loaded in the correct order. I would
    392. 

  392.     suggest you read the manual at
    393. 

  393.     <a href='http://constantly.at/lisp/asdf/'>http://constantly.at/lisp/asdf/</a>. Really the first
    394. 

  394.     <a href='http://constantly.at/lisp/asdf/Using-asdf-to-load-systems.html#Using%20asdf%20to%20load%20system'>link</a>
    395. 

  395.     is all you need to know right now.</p>
    396. 

  396.     <p>Basically every lisp package you downloaded so far has defined an .asd file. Usually in the root of the directory. This
    397. 

  397.     file has to appear in the search path of asdf, which is a list of directories defined by the special variable
    398. 

  398.     asdf:*central-registry*. The directories are typically called "systems". Under a unix clone, make a symbolic link to a systems dir
    399. 

  399.     as described in the document or as shown below. If a package defines
    400. 

  400.     more than one .asd file, just shove the whole dir on the *central-registry*, again as described in the document or as shown below.</p>
    401. 

  401.     <p>For example: on some linux installations the directory /usr/share/common-lisp/systems is in the list of asdf:*central-registry*.
    402. 

  402.     Now create a symlink from a particular .asd file to
    403. 

  403.     /usr/share/common-lisp/systems :</p>
    404. 

  404.     <pre>
    405. 

  405. ln -s /path/to/library/lib.asd /usr/share/common-lisp/systems
    406. 

  406.     </pre>
    407. 

  407.     <p>To shove a whole directory on the *central-registry* do the following in your lisp startup file or in the repl:</p>
    408. 

  408.     <pre>
    409. 

  409. (push #P"/path/to/asd/files/" asdf:*central-registry*)
    410. 

  410.     </pre>
    411. 

  411.     <p>All the required packages need to be recognized by asdf if you don't want to load every file by yourself.</p>
    412. 

  412.     <p><span id='extra'></span></p>
    413. 

  413.     <h2>Add-ons</h2>
    414. 

  414.     <p>Ucw also provides some packages which are kept out of the core so as not to bloat the program. Well two to be exact: the ucw presentations package and the ucw forms package.</p>
    415. 

  415.     <h5>presentations</h5>
    416. 

  416.     <p>An advanced CRUD interface for UCW.</p>
    417. 

  417.     <pre>
    418. 

  418. darcs get http://common-lisp.net/project/ucw/repos/ucw-presentations
    419. 

  419.     </pre>
    420. 

  420.     <h5>forms</h5>
    421. 

  421.     <p>A more advanced HTML form toolkit for ucw than the one that is used in the core package, uses yaclml and dojo.</p>
    422. 

  422.     <pre>
    423. 

  423. darcs get http://common-lisp.net/project/repos/ucw-forms
    424. 

  424.     </pre>
    425. 

  425.     <p><span id='testing'></span></p>
    426. 

  426.     <h2>Testing/Quickstart (for the non-boxset way)</h2>
    427. 

  427.     <p>When you have set up all your dependencies correctly, you can test ucw by first creating the directory /etc/ucw/applications.d, firing up your favorite distribution and:</p>
    428. 

  428.     <pre>
    429. 

  429. (load "/path/to/ucw/etc/start.lisp")
    430. 

  430.     </pre>
    431. 

  431.     <p>If all went well, you have started ucw with the httpd backend. Surf to
    432. 

  432.     <a href='http://127.0.0.1:8080'>http://127.0.0.1:8080</a> and again if all went well you should see the example page. That's it! Start hacking!!</p>
    433. 

  433.     <p><span id='configure'></span></p>
    434. 

  434.     <h2>Configuration</h2>
    435. 

  435.     <p>At the moment the methods to configure and start ucw are a bit under development. But things seem to be stabling out. The elegant production compliant way of starting ucw is by launching ucwctl, found in /path/to/ucw/bin/ucwctl. This will start your lisp as a deamon. To let ucw find the proper configuration files, copy the files under /path/to/ucw/etc/ to either /your/home/.ucw or /etc/ucw.</p>
    436. 

  436.     <p>Ucwctl depends on cl-launch, to which a number of ucwtl's configure options are passed. It provides a suite of launch options to invoke lisp from the command-line. Be sure to put a link to cl-launch somewhere in your application search path. For general cl-launch understanding, read the cl-launch documentation.</p>
    437. 

  437.     <p>It's of course convenient to put ucwctl in the *nix executable search path but contrary to cl-launch it is not mandatory. Here's the configuration part of the ucwctl help output; -a, -c, -l, -k, -s and -t are passed to cl-launch:</p>
    438. 

  438.     <pre>
    439. 

  439. -a, --asdf-root DIRECTORY   Register asdf search DIRECTORY
    440. 

  440. -c, --config-file FILE      Read FILE as config file.
    441. 

  441. -h, --help                  Display this help and exit.
    442. 

  442. -k, --stop-file FILE        Use FILE as stop file.
    443. 

  443. -l, --lisp NAME             Use NAME (without PATH) as Common Lisp
    444. 

  444.                             implementation.
    445. 

  445.     --log-root DIRECTORY    Save the logs in DIRECTORY, overriding the
    446. 

  446.                             --var-root option.
    447. 

  447.     --run-root DIRECTORY    Created pid/socket in DIRECTORY, overriding the
    448. 

  448.                             --var-root option.
    449. 

  449. -s, --start-file FILE       Use FILE as start file.
    450. 

  450. -t, --timeout SECONDS       Set timeout in SECONDS when trying to stop a
    451. 

  451.                             a running session.
    452. 

  452. -u, --ucwctl-file FILE      Read FILE as the ucwctl.conf file.
    453. 

  453.     --var-root DIRECTORY    Save the logs in DIRECTORU/log/ucw and create
    454. 

  454.                             pid/socket in DIRECTORY/run/ucw, if the two
    455. 

  455.                             options --log-root and --run-root are not set.
    456. 

  456.     </pre>
    457. 

  457.     <p>In /path/to/configdir/ucwctl.conf default values are provided except for the lisp implementation and the .asd directory. So at the least you'd want to change them to point to the proper lisp and dir, or just specify those on the commandline. If you want to specify different paths for --log-root and --run-root in your config file, add LOGROOT=/path/to/log-root and RUNROOT=/path/to/run-root, leaving VARROOT empty.  If you run ucwctl as user and didn't change ucwctl or supplied different paths for log-root and run-root (which default to paths under /var) on the commandline, they will default to paths under /your/home/dir/var. You can also specify a different ucwctl.conf file instead of /path/to/config-dir.</p>
    458. 

  458.     <p>To be clear this is the hierarchy of where ucwctl will pick its configuration from. Higher up the list will be chosen over lower on the list:</p>
    459. 

  459.     <p>1) command line options 
    460. 

  460.     <br>
    461. 

  461.     
    462. 

  462.     2) -u|--ucwctl-file (if specified, exit if it cannot be read) 
    463. 

  463.     <br>
    464. 

  464.     
    465. 

  465.     3) ~/.ucw/ucwctl.conf (if it exists) 
    466. 

  466.     <br>
    467. 

  467.     
    468. 

  468.     4) /etc/ucw/ucwctl.conf (if it exists)</p>
    469. 

  469.     <p>A deeper discussion is available at:</p>
    470. 

  470.     <p>http://common-lisp.net/pipermail/bese-devel/2006-April/001932.html 
    471. 

  471.     <br>
    472. 

  472.     
    473. 

  473.     http://common-lisp.net/pipermail/bese-devel/2006-April/001961.html 
    474. 

  474.     <br>
    475. 

  475.     </p>
    476. 

  476.     <p>Now you can start ucw by invoking:</p>
    477. 

  477.     <pre>
    478. 

  478. ucwctl start
    479. 

  479.     </pre>
    480. 

  480.     <p>Without having configured anything (in /path/to/conf.lisp) this will start ucw with the built-in httpd server, just as with cl-launch. But
    481. 

  481.     now you have log files and more importantly you are not tied to a particular console. Point your browser at
    482. 

  482.     <a href='http://127.0.0.1:8080/'>http://127.0.0.1:8080/</a> and hope for the best. Hook up slime through port 4005 if you also actually want to code something.</p>
    483. 

  483.     <p>To stop ucw type:</p>
    484. 

  484.     <pre>
    485. 

  485. ucwctl stop
    486. 

  486.     </pre>
    487. 

  487.     <p>To attach to a running ucw server type:</p>
    488. 

  488.     <pre>
    489. 

  489. ucwctl attach
    490. 

  490.     </pre>
    491. 

  491.     <p>This calls attachtty, installed alongside detachtty, and passes attachy the socket, the path of which is defined in the ucwctl startup script. De-attach attachtty by giving it a sighup signal, eg by closing your terminal window or by pressing ctl-\. Note that you should be a bit careful when you attach to a socket and you start typing away at the repl. By default cl-launch will terminate the running process when the debugger is invoked. This behavior is changeable; check the cl-launch script (or not, someone on the mailing-list pointed out a bug).</p>
    492. 

  492.     <p>To test if ucw works with your chosen backend open /path/to/conf.lisp (to be found in /etc/ucw/conf.lisp if you copied it from
    493. 

  493.     /path/to/ucw_dev/bin/etc/) and change:</p>
    494. 

  494.     <pre>
    495. 

  495. (setf *ucw-backend-type* ':httpd)
    496. 

  496. (setf *ucw-backend-host* "127.0.0.1")
    497. 

  497. (setf *ucw-backend-port* 8080)
    498. 

  498.     </pre>
    499. 

  499.     <p>to:</p>
    500. 

  500.     <pre>
    501. 

  501. (setf *ucw-backend-type* ':mod-lisp)
    502. 

  502. (setf *ucw-backend-host* "127.0.0.1")
    503. 

  503. (setf *ucw-backend-port* 3001)
    504. 

  504.     </pre>
    505. 

  505.     <p>or to:</p>
    506. 

  506.     <pre>
    507. 

  507. (setf *ucw-backend-type* ':araneida)
    508. 

  508. (setf *ucw-backend-host* "127.0.0.1")
    509. 

  509. (setf *ucw-backend-port* 8080)
    510. 

  510.     </pre>
    511. 

  511.     <p>or to:</p>
    512. 

  512.     <pre>
    513. 

  513. (setf *ucw-backend-type* ':aserve)
    514. 

  514. (setf *ucw-backend-host* "127.0.0.1")
    515. 

  515. (setf *ucw-backend-port* 8080)
    516. 

  516.     </pre>
    517. 

  517.     <p>Repeat your chosen startup procedure for ucwctl with th note that if you use mod_lisp you have
    518. 

  518.     to point your browser at
    519. 

  519.     <a href='http://127.0.0.1/index.ucw'>http://127.0.0.1/path/you/specified/in/apache/this/link/goes/to/the/root/index.ucw</a>, without
    520. 

  520.     the 8080 (defaults to the server root here).</p>
    521. 

  521.     <p>note also that the default conf.lisp configuration defaults to the configuration in /path/to/ucw_dev/src/default.lisp which is the default
    522. 

  522.     configuration ;-) So if you don't change anything in conf.lisp you might just as well omit it. </p>
    523. 

  523.     <p>The variables in conf.lisp that we didn't cover yet are:</p>
    524. 

  524.     <pre>
    525. 

  525. (setf *ucw-swank-port* 4005)
    526. 

  526.     </pre>
    527. 

  527.     <p>- used to connect to emacs, et al.</p>
    528. 

  528.     <pre>
    529. 

  529. (setf *ucw-server-class* 'standard-server)
    530. 

  530.     </pre>
    531. 

  531.     <p>- leave as is. I'm not even sure if there is a non-standard server we should be interested in.</p>
    532. 

  532.     <pre>
    533. 

  533. (setf *ucw-inspector* t)
    534. 

  534.     </pre>
    535. 

  535.     <p>- let's you inspect ucw inside the html pages you made when set to t. Seeing is believing. Set to nil to see the page as normal.</p>
    536. 

  536.     <pre>
    537. 

  537. (setf *ucw-debugger* t)
    538. 

  538.     </pre>
    539. 

  539.     <p>- sends debugging html to the client when set to t. Seeing is believing. Set to nil to not send debugging info to the client and to invoke the debugger in your editor.</p>
    540. 

  540.     <pre>
    541. 

  541. (setf *ucw-log-level* '+INFO+)
    542. 

  542.     </pre>
    543. 

  543.     <p>- Sets the log-level threshold for the information that will be logged by the base ucw logger and which will be pumped to the ucw.log
    544. 

  544.       file. these are the log levels to choose from, together with their value:</p>
    545. 

  545.     <p>+dribble+ = 0
    546. 

  546.     <br>
    547. 

  547.     
    548. 

  548.     +debug+  = 1
    549. 

  549.     <br>
    550. 

  550.     
    551. 

  551.     +info+   = 2
    552. 

  552.     <br>
    553. 

  553.     
    554. 

  554.     +warn+   = 3
    555. 

  555.     <br>
    556. 

  556.     
    557. 

  557.     +error+  = 4
    558. 

  558.     <br>
    559. 

  559.     
    560. 

  560.     +fatal+  = 5</p>
    561. 

  561.     <p>So in our example debug info and dribble will not be logged to ucw.log.</p>
    562. 

  562.     <pre>
    563. 

  563. (setf *ucw-applications-directory* "/etc/ucw/applications.d/")
    564. 

  564.     </pre>
    565. 

  565.     <p>- sets the applications directory, see next chapter</p>
    566. 

  566.     <pre>
    567. 

  567. (setf *ucw-systems* '(:ucw.admin :ucw.examples))
    568. 

  568. (setf *ucw-applications* '(it.bese.ucw::*admin-application*
    569. 

  569. 	   		       it.bese.ucw-user::*example-application*))
    570. 

  570.     </pre>
    571. 

  571.     <p>- supply ucw applications to load. See next chapter.</p>
    572. 

  572.     <p><span id='environment'></span></p>
    573. 

  573.     <h2>Setting up the environment (and a hello world on the side)</h2>
    574. 

  574.     <p>Note that this procedure is not strict necessary, you could just fiddle around in ucw-user, but you will want to have
    575. 

  575.     your own proper environment sooner or later. To get the best of both worlds (being lazy and having a proper set up
    576. 

  576.     environment), just download the <a href='ucw-intro_source.tar'>code</a> we're going to create below (mod_lisp
    577. 

  577.     users, check the www-dir stuff below for a correct setup). For the less lazy, create a directory where you want
    578. 

  578.     to keep your application code. (halfway ripped from the cliki tutorial. thanks ;-)).</p>
    579. 

  579.     <p>Create an asdf file called ucw-intro.asd will contain:</p>
    580. 

  580.     <pre>
    581. 

  581. (defpackage :ucw.intro.system
    582. 

  582.   (:use :cl :asdf))
    583. 

  583.     </pre>
    584. 

  584.     <pre>
    585. 

  585. (in-package :ucw.intro.system)
    586. 

  586.     </pre>
    587. 

  587.     <pre>
    588. 

  588. (defsystem ucw-intro
    589. 

  589.   :version "0.0.0.0.1"
    590. 

  590.   :depends-on (:ucw)
    591. 

  591.   :author "a lonely clown"
    592. 

  592.   :components ((:file "packages")
    593. 

  593.                (:file "config"      :depends-on ("packages"))
    594. 

  594.                (:file "hello-world" :depends-on ("config"))))
    595. 

  595.     </pre>
    596. 

  596.     <p>and a package file called packages.lisp:</p>
    597. 

  597.     <pre>
    598. 

  598. (in-package :cl-user)
    599. 

  599.     </pre>
    600. 

  600.     <pre>
    601. 

  601. (defpackage :ucw-intro
    602. 

  602.   (:use :common-lisp
    603. 

  603.         :it.bese.ucw
    604. 

  604.         :it.bese.arnesi
    605. 

  605.         :it.bese.yaclml))       
    606. 

  606.     </pre>
    607. 

  607.     <p>make a symlink from your asd file to the applications.d dir you defined in the last chapter.</p>
    608. 

  608.     <p>Important:  when ucw loads it checks this directory for .asd files of your ucw applications. To let them load
    609. 

  609.     correctly you have to synchronize four names in your applications with standard pre- and suffixes:
    610. 

  610.     
    611. 

  611.     <ul>
    612. 

  612.       <li>the name of your applications asd file: name.asd (in this case ucw-intro.asd)</li>
    613. 

  613.       <li>the name of your applications package: :name (in this case :ucw-intro)</li>
    614. 

  614.       <li>the name of your application: *name-application* (in this case *ucw-intro-application*, see below in the ucw-intro.lisp code)</li>
    615. 

  615.       <li>the asdf system name of your package as defined with defsystem: :name (in this case :ucw-intro)</li>
    616. 

  616.     </ul>
    617. 

  617.     </p>
    618. 

  618.     <p>This procedure might be streamlined in the future, but for now we have to deal with it.</p>
    619. 

  619.     <p>There is also an alternative way of loading your applications when loading ucw. In  /etc/ucw/conf.lisp (or where-ever you decided
    620. 

  620.     to put the file), push the name of your applications asd system name on *ucw-systems* and push it's application name (see below in the
    621. 

  621.     ucw-intro.lisp code), on *ucw-applications* like it's done for the ucws example applications:</p>
    622. 

  622.     <pre>
    623. 

  623. (defvar *ucw-systems* '(:ucw.admin :ucw.examples))
    624. 

  624. (defvar *ucw-applications* '(it.bese.ucw::*admin-application*
    625. 

  625. 	    		         it.bese.ucw-user::*example-application*))
    626. 

  626.     </pre>
    627. 

  627.     <p>If you don't want them to load, take them away from both conf.lisp and /path/to/ucw_dev/src/default.lisp.</p>
    628. 

  628.     <p>Just loading the three files we define(d) in this chapter while ucw is running will also register them correctly, no matter how we name the
    629. 

  629.     before-mentioned names.</p>
    630. 

  630.     <p>We also need a www root directory. This is the directory where we store static files for the http server to see: css and
    631. 

  631.     javascript files, pictures and the like. Lisp servers handle the www directory a bit different than mod_lisp so we have
    632. 

  632.     to make apt provisions. Lisp servers can themselves map a path from an incoming uri to the underlying directories on a
    633. 

  633.     server. When we use mod_lisp we have to tell apache as well as lisp where to go.</p>
    634. 

  634.     <p>When you use a lisp server backend, just create a directory in the tutorial root and call it www if you
    635. 

  635.     want to be in sync with this tutorial. With mod_lisp make a link from a directory somewhere in the apache www tree and in range of
    636. 

  636.     the mod_lisp search path as explained in the installation section. With apache 2 a typical path would be
    637. 

  637.     /var/www/locahost/htdocs/. The apache 1 www root normally also lies somewhere within that vicinity.</p>
    638. 

  638.     <pre>
    639. 

  639. ln -s /path/to/ucw-intro/www var/www/localhost/htdocs/ucw-intro
    640. 

  640.     </pre>
    641. 

  641.     <p>Or link the other way around. </p>
    642. 

  642.     <p>Now we create two new file in our example application root called ucw-intro.lisp and config.lisp. config.lisp:</p>
    643. 

  643.     <pre>
    644. 

  644. (in-package :ucw-intro)
    645. 

  645.     </pre>
    646. 

  646.     <pre>
    647. 

  647. (defvar *www-root*
    648. 

  648.   (merge-pathnames
    649. 

  649.    (make-pathname :directory '(:relative "www"))
    650. 

  650.    (asdf:component-pathname (asdf:find-system :ucw-intro))))
    651. 

  651.     </pre>
    652. 

  652.     <pre>
    653. 

  653. (defparameter *ucw-intro-application*
    654. 

  654.   (make-instance 'cookie-session-application
    655. 

  655.                  :url-prefix "/ucw-intro/"
    656. 

  656.                  :www-roots (list *www-root*)
    657. 

  657.                  :dispatchers (list (make-instance 'ucw::action-dispatcher)
    658. 

  658.                                     ;; hello world
    659. 

  659.                                     (url-dispatcher "hello-world.ucw"
    660. 

  660.                                       (call 'hello-world)))
    661. 

  661.                  :debug-on-error t))
    662. 

  662.     </pre>
    663. 

  663.     <p>hello-world.lisp:</p>
    664. 

  664.     <pre>
    665. 

  665. (in-package :ucw-intro)
    666. 

  666.     </pre>
    667. 

  667.     <pre>
    668. 

  668. (defcomponent hello-world (simple-window-component) ()
    669. 

  669.               (:default-initargs :title "hi"
    670. 

  670.               :stylesheet '("stylesheet.css" "stylesheet2.css")
    671. 

  671.               :content-type "text/html; charset=utf-8;"
    672. 

  672.               :javascript '((:src "dojo.js")
    673. 

  673.                             (:js (dojo.require "dojo.event.*"))
    674. 

  674.                             (:script "var foo = 3;")))
    675. 

  675. ;;            (:entry-point "hello-world.ucw" (:application *ucw-intro-application* :class url-dispatcher))
    676. 

  676.               (:render () (&lt;:as-html "hello world")))
    677. 

  677.     </pre>
    678. 

  678.     <p>Load the files into your image and surf to http://127.0.0.1(:8080)/ucw-intro/hello-world.ucw, cross your fingers... and... now you've printed "hello world"! (If the heavens are willing).</p>
    679. 

  679.     <p>In the next chapter we will see what applications actually are, and  we will examine the contents of ucw-intro.lisp. Also we will discuss
    680. 

  680.     the mechanics of ucw. Actually the next chapter is the most important chapter of this intro. Finally the foreplay is
    681. 

  681.     over.</p>
    682. 

  682.     <p><span id='mechanics'></span></p>
    683. 

  683.     <h2>Basic ucw mechanics</h2>
    684. 

  684.     <p>In the course of this chapter we will take a flight through website-making history. We begin with traditional website-making
    685. 

  685.     techniques and we will quickly work our way up. In the process you
    686. 

  686.     can't help but be introduced to the basic building blocks of a ucw program: components, actions, entry-points, applications and
    687. 

  687.     render methods. <a href='ucw-intro_source.tar'>Ready made source</a> is available.</p>
    688. 

  688.     <h4>Components, render methods, applications and entry points</h4>
    689. 

  689.     <h5>Components</h5>
    690. 

  690.     <p>Component have more than one role. First they act as your
    691. 

  691.     basic storage unit. They are classes and you can define them in the same way, but they have added
    692. 

  692.     functionality given through meta object protocol modifications. To explain these modifications we need some background
    693. 

  693.     on the inner workings of ucw:  When ucw receives a http request it checks if the request is a part of user session
    694. 

  694.     already in progress. If not it creates a new one. Such a session is made up of frames. Every new request makes a new
    695. 

  695.     frame which is referenced by a random string. Every frame copies the values of relevant components and their slots from
    696. 

  696.     the frame before, except of course when the values of a given class have changed. If a user wants to go back to a
    697. 

  697.     previous page, the appropriate frame is looked up with the help of the identifier string (be it through get or a cookie),
    698. 

  698.     and the original values are restored. So frames are the memory of a ucw session. Some of the modifications made to
    699. 

  699.     components facilitate this process of getting and setting values in frames under the cover.</p>
    700. 

  700.     <p>Components are also clothes-hangers for html output. You generate html by defining render methods on them. In the case of
    701. 

  701.     our example the method renders (as you say) the simple-window-component hello-world, which is a pre-defined component to create an empty
    702. 

  702.     canvas. You can nest render methods of other components, in which case you piece the data together to form a complete page. With this
    703. 

  703.     information we can step through conf.lisp and hello-world.lisp from the last chapter:</p>
    704. 

  704.     <p>config.lisp:</p>
    705. 

  705.     <pre>
    706. 

  706. (in-package :ucw-intro)
    707. 

  707.     </pre>
    708. 

  708.     <pre>
    709. 

  709. (defvar *www-root*
    710. 

  710.   (merge-pathnames
    711. 

  711.    (make-pathname :directory '(:relative "www"))
    712. 

  712.    (asdf:component-pathname (asdf:find-system :ucw-intro))))
    713. 

  713.     </pre>
    714. 

  714.     <pre>
    715. 

  715. (defparameter *ucw-intro-application*
    716. 

  716.   (make-instance 'cookie-session-application
    717. 

  717.                  :url-prefix "/ucw-intro/"
    718. 

  718.                  :www-roots (list *www-root*)
    719. 

  719.                  :dispatchers (list (make-instance 'ucw::action-dispatcher)
    720. 

  720.                                     ;; hello world
    721. 

  721.                                     (url-dispatcher "hello-world.ucw"
    722. 

  722.                                       (call 'hello-world)))
    723. 

  723.                  :debug-on-error t))
    724. 

  724.     </pre>
    725. 

  725.     <pre>
    726. 

  726. (in-package :ucw-intro)
    727. 

  727.     </pre>
    728. 

  728.     <p>hello-world.lisp:</p>
    729. 

  729.     <pre>
    730. 

  730. (defcomponent hello-world (simple-window-component) ()
    731. 

  731.               (:default-initargs :title "hi"
    732. 

  732.               :stylesheet '("stylesheet.css" "stylesheet2.css")
    733. 

  733.               :content-type "text/html; charset=utf-8;"
    734. 

  734.               :javascript '((:src "dojo.js")
    735. 

  735.                             (:js (dojo.require "dojo.event.*"))
    736. 

  736.                             (:script "var foo = 3;")))
    737. 

  737. ;;            (:entry-point "hello-world.ucw" (:application *ucw-intro-application* :class url-dispatcher))
    738. 

  738.               (:render () (&lt;:as-html "hello world")))
    739. 

  739.     </pre>
    740. 

  740.     <h5>Applications</h5>
    741. 

  741.     <p>First we define the filesystem directory which is going to function as www-root for static data such as images, style-sheets and
    742. 

  742.     the like. We feed it to the definition of our
    743. 

  743.     first application object. An application is an arbitrary conceptual construct with which you define a number of
    744. 

  744.     options for a block of web-pages/site-logic. It lets you specify if you want to use cookies, what charset you want to use,
    745. 

  745.     etc. A quick tour of the chosen options: In this instance we want to use cookies, which means that ucw starts searching
    746. 

  746.     for certain cookie information after it has looked for information in other places. The url
    747. 

  747.     prefix is the browser path relative to the server root. Www-roots is a list of pathnames the application searches to get
    748. 

  748.     to static data relative to the the APPLICATION root. They are set relative to the
    749. 

  749.     url-prefix, eg in this example from the outside the www-root of ucw-intro is 127.0.0.1/ucw-intro/. Debug-on-error will or will not throw you in the debugger when things go wrong in this application, depending on if it is set to t or nil. The dispatchers we will cover later on.</p>
    750. 

  750.     <h5>defcomponent and render methods</h5>
    751. 

  751.     <p>The simple-window-component class and the defmethod macro that defines it can together be seen as as a convenience layer which
    752. 

  752.     constructs the underlying building blocks a standard application wants to have. In this section you will learn the
    753. 

  753.     semantics of both and you will learn how to define the building blocks without them.</p>
    754. 

  754.     <p>A simple-window-component sets up your basic html layout. You can feed a title, stylesheets, content-types, and
    755. 

  755.     different ways to insert javascript to :default-initargs.  All of them accept a list as well as a
    756. 

  756.     basic unit suitable for the keyword, although you probably don't want to pass a list to the title argument as that will just print a quoted
    757. 

  757.     list. You can specify one or more javascript source files with the :src key, using :script lets you insert javascript as
    758. 

  758.     is and :js lets you insert javascript in parenscript syntax. With this information it sets up a whole page, except for
    759. 

  759.     the body. That's left for the render method.</p>
    760. 

  760.     <p>Defcomponent defines components almost the same as defclass defines classes. :default-initargs, slots, etc... are simply passed
    761. 

  761.     to the underlying defclass. But it has some extra options. You can supply a default backtrack function with :default-backtrack, you can supply a render method with :render, you can supply an entry-point with
    762. 

  762.     :entry-point and you can supply an action with :action. More on those last two in the next section, and more on :default-backtrack in a future chapter.</p>
    763. 

  763.     <p>As stated before, a render method is a regular method that specializes on a given component to output html. It is called when the program
    764. 

  764.     decides when it's time to put together a page to show the user. More on program flow in the next section of this chapter. The
    765. 

  765.     defcomponent macro passes the arguments from the :render form to a defmethod and let's it specialize on the name given
    766. 

  766.     to defcomponent. If no name is given the name defaults to the name given to defclass. There are two standard ways to
    767. 

  767.     output html in a render method. First you can use the &lt;:as-html (or &lt;:ah) macro and just type big slabs of html-escaped text or use &lt;:as-is (or &lt;:ai) to produce un-html-escaped text, but you know as well as I that lispers would rather be tortured for weeks by the US government than not lispify foreign syntax. Ucw uses yaclm for this, which is the in-house html markup lispifier. Html tag names start with &lt;:, attributes are keywords followed by their value. The standard html format that ucw spits out is xhtml 1 (eg html 4 but more strict). The whole of xhtml 1 is defined in yaclml and work has just started on svg tags. That's all there is to it.</p>
    768. 

  768.     <p>Without defcomponent and simple-window-component you could have written the code like this:</p>
    769. 

  769.     <pre>
    770. 

  770. (defclass hello-world () ()
    771. 

  771.   (:metaclass standard-component-class))
    772. 

  772.     </pre>
    773. 

  773.     <pre>
    774. 

  774. (defentry-point "hello-world.ucw"
    775. 

  775.   (:application *ucw-intro-application* :class url-dispatcher)
    776. 

  776.   () (call 'hello-world))
    777. 

  777.     </pre>
    778. 

  778.     <pre>
    779. 

  779. (defmethod render ((hello-world hello-world))
    780. 

  780.   (&lt;:as-is "&lt;!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/transitional.dtd\"&gt;"
    781. 

  781. 	       #\Newline)
    782. 

  782.   (&lt;:html
    783. 

  783.    (&lt;:head
    784. 

  784.     (&lt;:meta :http-equiv "Content-Type" :content "text/html; charset=utf-8;")
    785. 

  785.     (&lt;:title (&lt;:as-html "hi"))
    786. 

  786.     (&lt;:link :rel "stylesheet"
    787. 

  787.             :href "stylesheet.css"
    788. 

  788.             :type "text/css")
    789. 

  789.     (&lt;:link :rel "stylesheet"
    790. 

  790.             :href "stylesheet2.css"
    791. 

  791.             :type "text/css")
    792. 

  792.     (&lt;:script
    793. 

  793.      ;; most browsers (firefox, safari and ie at least) really,
    794. 

  794.      ;; really, really don't like empty script tags. The "" forces
    795. 

  795.      ;; yaclml to generate a seperate closing tag.
    796. 

  796.      :type "text/javascript" :src "dojo.js" "")
    797. 

  797.     (&lt;:script :type "text/javascript" (&lt;:as-is (js:js* '(dojo.require "dojo.event.*"))))
    798. 

  798.     (&lt;:script :type "text/javascript" (&lt;:as-is "var foo = 3;")))
    799. 

  799.    (&lt;:body (&lt;:as-html "hello world"))))
    800. 

  800.     </pre>
    801. 

  801.     <p>What we have omitted in this example is giving the components extra slots. Declaring slots in components is like defining slots for regular
    802. 

  802.     classes with two extra options which are :component and :backtrack. The former is for nesting components, the latter for backtracking values
    803. 

  803.     in other frames. Both will be discussed in future chapters. </p>
    804. 

  804.     <h5>Entry points, actions, forms and control flow</h5>
    805. 

  805.     <p>You might have heard some fellow that touted ucw as being hard. Well,
    806. 

  806.     this is the hard part. That is, to figure out how it ticks. But we don't need to know that right now. We just
    807. 

  807.     need a working model of basic control mechanics.</p>
    808. 

  808.     <p>First, to clear some confusion. You have already seen the :dispatchers part of cookie-session-application, the commented out :entry-point part of defcomponent and the commented out defentry-point. They all do the same thing. :entry-point and defenty-point are the old way of adding a new page to an application. The :dispatcher way centralizes things a bit and is intended to replace defentry-point. The old way was reintroduced as a macro to not break existing applications to much. In this tutorial :dispatchers is used as default in explanations with commented out defentry-points and :entry-point to show the alternative way.</p>
    809. 

  809.     <p>When a user calls a ucw page for the first time, without being redirected by
    810. 

  810.     another ucw page and without information by some ucw cookie that hasn't timed out yet, the machinery checks the last
    811. 

  811.     form you just typed at the :dispathers part of your application constructor, in this case (call 'hello-world). It calls the component hello-world, which means it locks that component as being the main component to be rendered to the
    812. 

  812.     user. Whenever ucw gets user input it makes a new frame and after the preliminaries are over, it calls the render method on the component
    813. 

  813.     that's at that moment the main component and the page is served. The end part of the :dispathers thingy and so called actions handle the control flow of a ucw program between page calls. You can type any number of forms, which will be parsed as a body.</p>
    814. 

  814.     <p>Btw, at the end part of defentry-points you have an empty form before the last one. We will turn to it later.</p>
    815. 

  815.     <p>On the face of it that call to hello-world doesn't seem to do so much out of the ordinary, and that's the whole point. As you might know the
    816. 

  816.     web poses some problems for standard program execution because web-pages slash your flow in pieces. Those pieces have to be pieced together
    817. 

  817.     again somehow. It turns out that cps (continuation programming style) is quite handy for this purpose. Basically it means being able to
    818. 

  818.     capture the state of your program anywhere you want in a function. You can call that function again whenever you want and how often you want
    819. 

  819.     to pick up the execution of your program where you left off. Some languages have facilities built in to just capture a program state like that but lisp doesnt. You have
    820. 

  820.     to transform the code to be able to do this. You could do this by hand if you're mad, but ucw has a cps transformer on board that does it for
    821. 

  821.     you. This information might be a bit vague. If you want to read up on the subject i suggest you read
    822. 

  822.     <a href='http://www.bookshelf.jp/texi/onlisp/onlisp_20.html'>chapter 20 of On Lisp</a>.</p>
    823. 

  823.     <p>Now all of this transforming is done under the cover so you
    824. 

  824.     won't have so much to do with cps transformation but there is actually also a practical purpose for
    825. 

  825.     knowing this, and to explain that we need yet some more theory. A cps transformer must sort of understand the semantics of the code it's
    826. 

  826.     working with so it needs a code walker to interpret for example if forms are macros or how to keep track of environment variables. Every
    827. 

  827.     implementation obviously has one but language users don't have access to it. You have to roll your own and ucw did. But walking code ain't
    828. 

  828.     as easy as it not sounds. Code walkers usually don't capture lisp perfectly and the ucw one is no exception. Usually stuff works out fine
    829. 

  829.     but don't be surprised if your code doesn't do what it should at the end of a dispatcher in the :dispatchers list or inside an action. When you have to handle a
    830. 

  830.     lot of code inside an action, try to delegate as much as possible to function calls, because functions outside an action are not subject to
    831. 

  831.     these laws of an alternate lisp universe.</p>
    832. 

  832.     <p>Just some more theory so you fully appreciate the example beneath. At some point a dispatcher should call a component with
    833. 

  833.     (call ... , which initializes the component with initargs passed to it and the component is set as THE component for that frame. It is
    834. 

  834.     rendered, perhaps together with sub-components it specifies to render in it's render method. As the user is presented with a page,
    835. 

  835.     she/he gets her/his first chance to interact with the program through the usual mechanics: forms, links, buttons. The user clicks or writes
    836. 

  836.     something and another request is inbound. The traditional (some whisper 'pre-ucw') way to handle a request is to check get and post values
    837. 

  837.     and act on them. Ucw sports this facility. In our example the form before the call to hello-world is empty. In that form you could have
    838. 

  838.     specified which parameters from the page you want to use. If you want to give the parameter a default value you can put parameter and
    839. 

  839.     default between parenthesis. These values are now available for use in the forms you write after them.</p>
    840. 

  840.     <p>But of course ucw has more tricks up it's sleeve. For some html tags ucw has it's own yaclml equivalent with extended functionality: a,
    841. 

  841.     area, button, form, select, option, textarea and input. For convenience ucw gives the input attributes text, password and submit their own
    842. 

  842.     tag. Furthermore ucw sports such outlandish tag-names as integer-range-select, month-day-select, render-component and script. These last
    843. 

  843.     ones we will cover in a later chapter. All these tags become invocable macro-forms by putting &lt;ucw: in front of them. See the example.</p>
    844. 

  844.     <p>The extra functionality comes from the extra keywords you can pass them: :action, :accessor, :reader and writer. The macro's can handle
    845. 

  845.     one or more of these, depending on the macro, but the keywords are mutually exclusive. With the :action keyword you can specify an action
    846. 

  846.     form which will be executed with the relevant parameters when the form returns. With :accessor you can specify a place. It's value is the
    847. 

  847.     initial value of the specified tag. If the tag returns a value, the place will store it. :reader and :writer are used as a
    848. 

  848.     team to provide more flexibility than :accessor does. If provided, the value of :reader is used as the initial value of
    849. 

  849.     place. The value of writer should be a function which accepts one argument: the value returned by the tag.</p>
    850. 

  850.     <p>Continuing our control flow we assume the user uses one of the before-mentioned ucw forms to once again bother the server with info. If the
    851. 

  851.     user hasn't sparked off one of the ucw forms with one of those so-called actions attached to them, the current component stays in
    852. 

  852.     place. When a new page is rendered, the render method will again specify on this component. When an action is called it can do a lot of
    853. 

  853.     things but seen through this prism, the options split up in three: an action can execute code without ever calling a call to another component, it can somewhere along the line call another component or it can answer a component. When it never calls</p>
    854. 

  854.     <pre>
    855. 

  855. (call ...
    856. 

  856.     </pre>
    857. 

  857.     <p>or answer</p>
    858. 

  858.     <pre>
    859. 

  859. (answer ....
    860. 

  860.     </pre>
    861. 

  861.     <p>the component stays in place. When it calls another component, that component gets focus and ucw stores a continuation of where
    862. 

  862.     that action got interrupted in that component. When an action answers, ucw restores the component that was in focus before it called the
    863. 

  863.     component that just answered (heh). The continuation that was stored in that component is called with an optional value which is the value
    864. 

  864.     that's returned by the call form. The action in which the call was made continues untill it either calls a component, answers a
    865. 

  865.     component or ends, in which case the component connected to the action gets rendered.</p>
    866. 

  866.     <p>'But how should i interpret dispatchers', you might wonder. Well dispatchers are called when ucw tries to figure out what to do with an incoming request. You specify what ucw should look at when you construct an application (or when you use a defentry-point. You can use them in conjunction.) First on your list should be an action-dispatcher, e.g.: (make-instance 'ucw::action-dispatcher). It will check if an action parameter is present in the url. If so it will try to look if it can match it against a relevant action and if it finds one it will execute it. Furthermore you should add a url-dispatcher or a regexp-dispatcher to the list for every page you want to use as an entry-point into you application. You specify url-dispatcher or regexp-dispatcher for plain url names or regular expressions relative to the application root, the string of the url or the regular expression and the set of forms you want it to execute, which should at some point at least call one component to render. Since the dispatchers (and entry-points) are the entry-points into your application they have no component to answer to. When the set of forms finishes it returns to the first form, and again, and again, e.g. they are in an infinite loop.</p>
    867. 

  867.     <p>It's high noon for an example. Add these to the dispather list of your config.lisp file:</p>
    868. 

  868.     <pre>
    869. 

  869. ;; basics
    870. 

  870. (regexp-dispatcher "^(basics.ucw|)$"
    871. 

  871.   (call 'basics))
    872. 

  872. (regexp-dispatcher "^(get.ucw|)$"
    873. 

  873.   (with-request-params ((cow "moo"))
    874. 

  874.       (context.request *context*)
    875. 

  875.     (let ((cow (concatenate 'string "mighty " cow)))
    876. 

  876.       (call 'basics :cow cow))))
    877. 

  877.     </pre>
    878. 

  878.     <p>Add this to your ucw-intro.asd file:</p>
    879. 

  879.     <pre>
    880. 

  880. (:file "basics"      :depends-on ("config"))
    881. 

  881.     </pre>
    882. 

  882.     <p>And define the file basics.lisp like so:</p>
    883. 

  883.     <pre>
    884. 

  884. (in-package :ucw-intro)
    885. 

  885.     </pre>
    886. 

  886.     <pre>
    887. 

  887. (defcomponent basics (simple-window-component)
    888. 

  888.   ((cow :initarg :cow :accessor cow :initform "aspacia")
    889. 

  889.    (pig :initarg :pig :accessor pig :initform "knorrie"))
    890. 

  890.   (:default-initargs :title "hi")
    891. 

  891.   (:render ()
    892. 

  892.            (with-slots (cow pig)
    893. 

  893.                basics
    894. 

  894.              (&lt;:as-is "in the old days, to update the name of your lovely cow named &lt;b&gt;" #\Newline)
    895. 

  895.              (&lt;:as-html cow)
    896. 

  896.              (&lt;:as-is "&lt;/b&gt; you would update it like so: ")
    897. 

  897.              (&lt;:form :action "get.ucw"
    898. 

  898.                      :method "GET"
    899. 

  899.                      (&lt;:text :name "cow")
    900. 

  900.                      (&lt;:submit :value "name your cow"))
    901. 

  901.              (&lt;:p (&lt;:a :href "get.ucw" "go to get without any value to get to the default value of the entry point"))
    902. 

  902.              (&lt;:p
    903. 

  903.               (&lt;:as-html "but we have left them behind. In the brave new world we will update the name of our lovely pig like: ")
    904. 

  904.               (&lt;ucw:form :method "POST"
    905. 

  905.                          :action (refresh-component basics)
    906. 

  906.                          (&lt;ucw:text :accessor pig)
    907. 

  907.                          (&lt;:submit :value "name your pig")))
    908. 

  908.              (&lt;:p
    909. 

  909.               (&lt;:as-html "to pass a value and control to another component we do like so:")
    910. 

  910.               (let ((stuff-to-say ""))
    911. 

  911.                 (&lt;ucw:form :action (get-stuff-to-say basics stuff-to-say)
    912. 

  912.                            :method "POST"
    913. 

  913.                            (&lt;ucw:textarea :accessor stuff-to-say)
    914. 

  914.                            (&lt;:br)
    915. 

  915.                            (&lt;:submit :value "have something to say")))))))
    916. 

  916.     </pre>
    917. 

  917.     <pre>
    918. 

  918. ;;(defentry-point "get.ucw"
    919. 

  919. ;;    (:application *ucw-intro-application*)
    920. 

  920. ;;    ((cow "moo"))
    921. 

  921. ;;  (+ 2 2)
    922. 

  922. ;;  (let ((cow (concatenate 'string "mighty " cow)))
    923. 

  923. ;;    (call 'basics :cow cow)))
    924. 

  924.     </pre>
    925. 

  925.     <pre>
    926. 

  926. (defaction get-stuff-to-say ((basics basics) stuff-to-say)
    927. 

  927.   (let ((stuff-to-say (concatenate 'string stuff-to-say " (boring!!!)")))
    928. 

  928.     (setf (cow basics) (call 'the-other-one :stuff-to-say stuff-to-say))))
    929. 

  929.     </pre>
    930. 

  930.     <pre>
    931. 

  931. (defaction ok ((c component) &amp;optional (value c))
    932. 

  932.   (answer value))
    933. 

  933.     </pre>
    934. 

  934.     <pre>
    935. 

  935. (defcomponent the-other-one (simple-window-component)
    936. 

  936.   ((stuff-to-say :initarg :stuff-to-say :accessor stuff-to-say))
    937. 

  937.   (:default-initargs :title "hi"
    938. 

  938.     :content-type "text/html; charset=utf-8;")
    939. 

  939.   (:render ()
    940. 

  940.            (&lt;:p
    941. 

  941.             (&lt;:as-html "- "(stuff-to-say the-other-one)))
    942. 

  942.            (&lt;:p
    943. 

  943.             (&lt;:as-html "yeah, very 'enlightning'. Dazzle me some more: "))
    944. 

  944.            (&lt;ucw:form :method "POST"
    945. 

  945.                       :action (refresh-component the-other-one)
    946. 

  946.                       (&lt;ucw:textarea :reader (stuff-to-say the-other-one)
    947. 

  947.                                      :writer #'(lambda (x)(setf (stuff-to-say the-other-one) (concatenate 'string x " (boring  
    948. 

  948.                                      !!!!!)"))))
    949. 

  949.                       (&lt;:br)
    950. 

  950.                       (&lt;:submit :value "have something to say"))
    951. 

  951.            (&lt;:br)
    952. 

  952.            (&lt;ucw:a :action (ok the-other-one "nice to be back") "back to the last component")))
    953. 

  953.     </pre>
    954. 

  954.     <p>First we observe the added slot to the basics component called cow. We use it to store the values passed by our forms. The first form shows the old
    955. 

  955.     way: The name cow is picked up by the relevant url dispatcher, which we also let calculate 2 + 2 for no reason at all and in which we add
    956. 

  956.     mighty or puny to cow. The link below it shows that if no parameter named cow turns up the value of cow is set to moo. Notice
    957. 

  957.     however that if an empty form is submitted the name of cow is set to zero and our cow is nameless but still mighty or puny. Our second form
    958. 

  958.     has to be an ucw form if we want the &lt;ucw:text tag to work. The text tag only needs :accessor and a refresh-component action to work correctly; no need for pages to redirect to and no need for a name. The submit button could have been omitted, just as with the normal form. The :accessor method circumvents the entry-point for the value of pig and the refresh component action refreshes the current component. The form method could have been either get or post. For the correct working of ucw it doesn't matter which you choose. If you click the back to entry point link, you pass control back to the entry-point action. which proceeds to it's next call. The ok defaction is already provided by ucw.</p>
    959. 

  959.     <p>The third form shows how to pass control
    960. 

  960.     to another component. We (I at least) want to fill the slot stuff-to-say of component the-other-one with a value passed by the form. Since
    961. 

  961.     they of course don't share the same slot we make a temporary variable to have something to hang on to. When we submit the form we execute
    962. 

  962.     the action get-stuff-to-say which passes control to stuff-to-say with the slightly modified stuff-to-say. So now we can contain
    963. 

  963.     the generalized behavior of an entry-point within a function which can be tailor-made to fit one tag. Notice it doesn't matter if you call
    964. 

  964.     the next component in either hello-world.ucw or get.ucw. The only interesting thing in the form on the the-other-one page is that it uses reader and writer. The link  below it gives control back to basics.  As you can see you can give ok and answer an extra value which will be
    965. 

  965.     the value returned by the call form. Notice the value of pig is how you left it. If you hadn't changed the name of your cow it would also still be the same.</p>
    966. 

  966.     <p>Btw, as you can see, the way to specify parameters to be picked up in a dispatch method is a bit more complicated than when you use a defentry-point. The defentry-point simply lets you specify the parameters in it's third argument. The parameter is transformed into the with-parameters macro that is called in the dispatch way. The parameters can be supplied as a symbol if you don't care about giving it an initial value or as a list of a symbol and a string if you do want to give it an initial value.</p>
    967. 

  967.     <p>There you have it. You mastered the basic ucw mechanics, but of course you would like some more tools in your kit to let ucw work on code in
    968. 

  968.     stead of you. As you saw in the index: templating, extended form handling, login code and more is provided. This kind of
    969. 

  969.     functionality is the subject of the next few chapters.</p>
    970. 

  970.     <p><span id='templating'></span></p>
    971. 

  971.     <h2>Templating: nested components, containers and tal</h2>
    972. 

  972.     <p>There are two ways of templating in this chapter that scramble for the same namespace. The first is concerned with component manipulation;
    973. 

  973.     this includes nested components and containers. The second, the ucw TAL (Template Attribute Language) implementation, is a tool used by ucw
    974. 

  974.     to insert (almost) plain html into ucw code so that non-lispers (for example designers) can easily contribute to a ucw project. Get the
    975. 

  975.     <a href='ucw-intro_source.tar'>code</a>.</p>
    976. 

  976.     <h3>nested components</h3>
    977. 

  977.     <p>Nested components are components that occupy the slot of another component. They are not that different from regular slot values except for
    978. 

  978.     that you want them to inherit the proper values from past frames. To set these values, nested components use :component as their
    979. 

  979.     initialization keyword when placed in a component's slot. In day to day use they behave just as other slot values. If you want to use them
    980. 

  980.     to nest html layout, define a render method on them and invoke it in their parents render method.</p>
    981. 

  981.     <h5>containers</h5>
    982. 

  982.     <p>Containers are used to store components. Their main use is to be able to select one of those components as the
    983. 

  983.     component to be rendered to the user. The components in the container are stored as a list and can be referenced by key or index. This is
    984. 

  984.     done through several methods associated with containers to manipulate their contents.</p>
    985. 

  985.     <p>Containers come in three flavors: container, simple-container and list-container. A bog-standard container is a component with three extra
    986. 

  986.     slots:
    987. 

  987.     
    988. 

  988.     <ul>
    989. 

  989.       <li>contents - An alist of (key . component) holding the components - accessor = container.contents</li>
    990. 

  990.       <li>key-generator - A lambda that generates the keys from a component when they are not specified. Defaults to identity - accessor = container.key-generator</li>
    991. 

  991.       <li>key-test - A function used to compare two keys which defaults to eql - accessor = container.key-test</li>
    992. 

  992.     </ul>
    993. 

  993.     </p>
    994. 

  994.     <p>Containers are very nice for letting people navigate a site. You nest one inside a window-component with :component and present the user
    995. 

  995.     with a list of navigation links to which you attach a switch-component action (already provided by ucw) which accepts a so called switching-container and a key name as an argument. The action sets the key of the component which is associated by key as the
    996. 

  996.     current-component-key. </p>
    997. 

  997.     <p>The switching-container component class is generally used as the super class for navigatation components and tabbed-pane like components. it's like the regular container but serves to manage a set of components which share the same place in the user interface. It provides an implementation of render which simply renders its current component. It adds one extra slot called current-component-key, which is referenced to render the appropriate component.</p>
    998. 

  998.     <p>A list-container is a child of container-component as well as widget-component. It's render method renders the components in the container as an ordered list. A list container has a custom initialize-instance method defined on it, which accepts an additional orientation
    999. 

  999.     keyword which can be set to either :horizontal or :vertical. If one of these keywords is supplied, it is added to that component's css
    1000. 

  1000.     class list (see the widget-component documentation in chapter to-be-written). </p>
    1001. 

  1001.     <p>The container-manipulating methods are in order of appearance:
    1002. 

  1002.     
    1003. 

  1003.     <ul>
    1004. 

  1004.       <li>clear-container - accepts a container - clears contents of container</li>
    1005. 

  1005.       <li>find-component - accepts a container and a key - returns the component and t if the component is present. Otherwise nil and nil.</li>
    1006. 

  1006.       <li>(setf find-component) - (setf (container key) component) - sets a component at the position of key. If no such key exists,
    1007. 

  1007.       the key and component are added at the end of the contents list.</li>
    1008. 

  1008.       <li>add-component - accepts a container a component and an optional symbol as key name - adds a component to the end of the contents
    1009. 

  1009.       list. If key is supplied, key is used as key for component, otherwise the index of the component in the contents list is used.</li>
    1010. 

  1010.       <li>component-at - accepts a container and an index. If a component is set at the index of integer in the contents list, the component is
    1011. 

  1011.       returned, together with t, otherwise nil and nil are returned.</li>
    1012. 

  1012.       <li>(setf component-at) - (setf (container index optional-key) component) - Overrides the current component in list if it's available. In
    1013. 

  1013.       which case key isn't used. If the provided index is one past the last component, component is set at end of list with key as key if
    1014. 

  1014.       provided, otherwise index is used as key. If the index given is two or more past the last item in the list, a recoverable
    1015. 

  1015.       error is signaled.</li>
    1016. 

  1016.       <li>container.current-component - accepts a container - returns component with key of current-component-name as with find-component</li>
    1017. 

  1017.       <li>ensure-valid-component-key - accepts a container and a key - Returns t if key names one of the components in container,
    1018. 

  1018.       otherwise a restartable error is signaled.</li>
    1019. 

  1019.       <li>map-contents - accepts a function and a container - applies a two argument function to the key and the component of every
    1020. 

  1020.       key-component pair in contents of container.</li>
    1021. 

  1021.     </ul>
    1022. 

  1022.     </p>
    1023. 

  1023.     <p>The following example demonstrates the use of a simple-container, nested in a window-component. It's a simple mock tragic adventure
    1024. 

  1024.     fragment. When all drawers are checked, a new component is shoved onto the containers contents list. The flet at the end and the
    1025. 

  1025.     simple-container initialization in the room class are the most interesting. The switching-container mechanics code is mostly
    1026. 

  1026.     taken from the example application, bundled with ucw. Start it up to see a more traditional use of containers.</p>
    1027. 

  1027.     <p>First add this to your ucw-intro.asd file:</p>
    1028. 

  1028.     <pre>
    1029. 

  1029. (:file "containers"      :depends-on ("config"))
    1030. 

  1030.     </pre>
    1031. 

  1031.     <p>Add this to the list of dispatchers in your config.lisp file:</p>
    1032. 

  1032.     <pre>
    1033. 

  1033. ;; containers
    1034. 

  1034. (regexp-dispatcher "^(containers.ucw|)$"
    1035. 

  1035.   (call 'office))
    1036. 

  1036.     </pre>
    1037. 

  1037.     <p>And then define containers.lisp like so:</p>
    1038. 

  1038.     <pre>
    1039. 

  1039. (in-package :ucw-intro)
    1040. 

  1040.     </pre>
    1041. 

  1041.     <pre>
    1042. 

  1042. (defcomponent timeline (widget-component)
    1043. 

  1043.   ((history :initarg :history :accessor history))
    1044. 

  1044.   (:render () (&lt;:as-html (history timeline))))
    1045. 

  1045.     </pre>
    1046. 

  1046.     <pre>
    1047. 

  1047. (defcomponent drawer (widget-component)
    1048. 

  1048.   ((contents :initarg :contents :accessor contents))
    1049. 

  1049.   (:render () (&lt;:as-html (contents drawer))))
    1050. 

  1050.     </pre>
    1051. 

  1051.     <pre>
    1052. 

  1052. (defcomponent office (simple-window-component)
    1053. 

  1053.   ((what-happened :initform '(0 0 0) :accessor what-happened)
    1054. 

  1054.    (closet :component (switching-container
    1055. 

  1055.                        :current-component-key 'in-office
    1056. 

  1056.                        :contents
    1057. 

  1057.                        `((in-office       . ,(make-instance 'timeline :history "You stand alone in the office of your evil boss. In
    1058. 

  1058.                        front of you you see a closet in which you are sure you will find valuables with which you can pay off your
    1059. 

  1059.                        insurmountable debts."))
    1060. 

  1060.                          (top-drawer    . ,(make-instance 'drawer
    1061. 

  1061.                                                           :contents "you find memoirs of a broken soul"))
    1062. 

  1062.                          (middle-drawer . ,(make-instance 'drawer
    1063. 

  1063.                                                           :contents "you find an agenda of grinding daily chores"))
    1064. 

  1064.                          (bottom-drawer . ,(make-instance 'drawer
    1065. 

  1065.                                                           :contents "you find an ointment to take the edge off"))))
    1066. 

  1066.            :accessor closet))
    1067. 

  1067.   (:render ()
    1068. 

  1068.            (with-slots (what-happened closet)
    1069. 

  1069.                office
    1070. 

  1070.              (unless (find-component closet 'leave) 
    1071. 

  1071.                (case (container.current-component-key closet)
    1072. 

  1072.                  ('top-drawer (setf (car what-happened) 1))
    1073. 

  1073.                  ('bottom-drawer (setf (cadr what-happened) 1))
    1074. 

  1074.                  ('middle-drawer (setf (caddr what-happened) 1)))
    1075. 

  1075.                (when (and (= (car what-happened) 1)
    1076. 

  1076.                           (= (cadr what-happened) 1)
    1077. 

  1077.                           (= (caddr what-happened) 1))
    1078. 

  1078.                  (add-component closet
    1079. 

  1079.                                 (make-instance 'timeline :history "You leave the office ashamed and angry. You know now your evil boss
    1080. 

  1080.                                is also a human being and you will have to feel compassion for him forever.")
    1081. 

  1081.                                 'leave)))
    1082. 

  1082.              (render closet)
    1083. 

  1083.              (&lt;:br)
    1084. 

  1084.              (&lt;:as-html "What will you do next?")
    1085. 

  1085.              (&lt;:br)
    1086. 

  1086.              (if (eql (container.current-component-key closet) 'leave)
    1087. 

  1087.                (flet ((drawer-link (name text)
    1088. 

  1088.                         (&lt;ucw:a :action (switch-component (closet office) name)
    1089. 

  1089.                                 (&lt;:as-html text))))
    1090. 

  1090.                  (&lt;:ul
    1091. 

  1091.                   (&lt;:li (drawer-link 'top-drawer "inspect top drawer"))
    1092. 

  1092.                   (&lt;:li (drawer-link 'middle-drawer "inspect middle drawer"))
    1093. 

  1093.                   (&lt;:li (drawer-link 'bottom-drawer "inspect bottom drawer"))
    1094. 

  1094.                   (&lt;:li (drawer-link 'in-office "recall what your doing here"))
    1095. 

  1095.                   (when (find-component closet 'leave)
    1096. 

  1096.                     (&lt;:li (drawer-link 'leave "leave")))))
    1097. 

  1097.                (&lt;:ai "&lt;br/&gt;Nothing, just stand here a bit")))))
    1098. 

  1098.     </pre>
    1099. 

  1099.     <h4>Tabbed-panes</h4>
    1100. 

  1100.     <p>UCW also has a convenience class on board to quickly render different components/pages in a tabbed-pane, which builds upon switching-container. It basically spits out a main wintod and an options row/colomn of choosable components, all wrapped in divs, so you can style them every way you want. An example that wraps all the components we made thus far, and the tal components later in this chapter in a tabbed pane:</p>
    1101. 

  1101.     <pre>
    1102. 

  1102. (defcomponent pane (tabbed-pane simple-window-component) ()
    1103. 

  1103.               (:default-initargs
    1104. 

  1104.                 :title "pane"
    1105. 

  1105.                 :stylesheet "sheet.css"
    1106. 

  1106.                 :contents `(("hello world" . ,(make-instance 'hello-world))
    1107. 

  1107.                             ("basics" . ,(make-instance 'basics))
    1108. 

  1108.                             ("tal" . ,(make-instance 'tal-component))
    1109. 

  1109.                             ("more tal" . ,(make-instance 'more-tal)))
    1110. 

  1110.                 :current-component-key "hello world")
    1111. 

  1111.               (:render ()
    1112. 

  1112.                        (call-next-method)))
    1113. 

  1113.     </pre>
    1114. 

  1114.     <p>There you go. We also let our component inherit from the simple-window-component so it will render a whole page and not just a div. The initialization part is the same as a normal switching-container, but it has a render-method defined on it that wraps the divs, and assigns actions. So we just call the next method in our render method. Use the sheet.css in the supplied sources to conjure up a nicely formatted tabbed-pane. This example is a bit wasteful cause now you're wrapping whole html pages in divs, but you get the picture.</p>
    1115. 

  1115.     <h3>TAL</h3>
    1116. 

  1116.     <p>Ucw's template attribute language is loosely based on
    1117. 

  1117.     <a href='http://www.zope.org/Wikis/DevSite/Projects/ZPT/TAL'>Zope's TAL</a>. It also uses xml to express it's intentions and it uses a few of it operators. Moreover it uses its idea: a way to embed a few programming constructs in xml so that the xml can be parsed back into the language as a design template with some flexibility. Programmers can easily modify the html/xml that designers present to make it fit for code. As can the designers themselves up until a point.</p>
    1118. 

  1118.     <h5>How it works</h5>
    1119. 

  1119.     <p>Tal code is confined in .tal files. Those files are called from lisp code to render a page on a component, much like a render method. You can either replace a render method or embed tal files in a render method. You can also embed render methods in tal files, tal files in render methods and you can embed tal files in other tal files. Tal files can harbor control structures, variables and lisp code. When a component is rendered, the  the tal control structures, variables and lisp code in a tal file are evaluated and the specified tal files are transformed into yaclml code, which on it's turn is transformed into xml/html.</p>
    1120. 

  1120.     <p>An example. First add the tal-generator key-value pair to the make-instance of our *ucw-intro-application* in config.lisp and add two entry-point to our dispatcher list. With the stuff added in previous chapters it should look something like this:</p>
    1121. 

  1121.     <pre>
    1122. 

  1122. (defparameter *ucw-intro-application*
    1123. 

  1123.   (make-instance 'cookie-session-application
    1124. 

  1124.                  :url-prefix "/ucw-intro/"
    1125. 

  1125.                  :www-roots (list *www-root*)
    1126. 

  1126.                  :tal-generator (make-instance 'yaclml:file-system-generator
    1127. 

  1127.                                                :cachep t
    1128. 

  1128.                                                :root-directories (list *www-root*))
    1129. 

  1129.                  :dispatchers (list (make-instance 'ucw::action-dispatcher)
    1130. 

  1130.                                     ;; hello world
    1131. 

  1131.                                     (url-dispatcher "hello-world.ucw"
    1132. 

  1132.                                       (call 'hello-world))
    1133. 

  1133.                                     ;; basics
    1134. 

  1134.                                     (regexp-dispatcher "^(basics.ucw|)$"
    1135. 

  1135.                                       (call 'basics))
    1136. 

  1136.                                     (regexp-dispatcher "^(get.ucw|)$"
    1137. 

  1137.                                       (with-request-params ((cow "moo"))
    1138. 

  1138.                                           (context.request *context*)
    1139. 

  1139.                                         (let ((cow (concatenate 'string "mighty " cow)))
    1140. 

  1140.                                           (call 'basics :cow cow))))
    1141. 

  1141.                                     ;; containers
    1142. 

  1142.                                     (regexp-dispatcher "^(containers.ucw|)$"
    1143. 

  1143.                                       (call 'office))
    1144. 

  1144.                                     ;; tal
    1145. 

  1145.                                     (regexp-dispatcher "^(tal.ucw|)$"
    1146. 

  1146.                                       (call 'tal-component))
    1147. 

  1147.                                     (regexp-dispatcher "^(more-tal.ucw|)$"
    1148. 

  1148.                                       (call 'more-tal)))
    1149. 

  1149.                  :debug-on-error t))
    1150. 

  1150.     </pre>
    1151. 

  1151.     <p>Then we create the first part of tal.lisp:</p>
    1152. 

  1152.     <pre>
    1153. 

  1153. (in-package :ucw-intro)
    1154. 

  1154.     </pre>
    1155. 

  1155.     <pre>
    1156. 

  1156. (defcomponent tal-component (template-component)
    1157. 

  1157.   ((page-name :initarg :page-name :accessor page-name)
    1158. 

  1158.    (contents :initarg :contents :accessor contents))
    1159. 

  1159.   ;;  (:entry-point "^(|tal.ucw)$" (:application *ucw-intro-application* :class regexp-dispatcher))
    1160. 

  1160.   (:default-initargs :template-name "intro.tal" :page-name "Que tal!" :contents "&lt;blink&gt;Qual blink!!!&lt;/blink&gt;"
    1161. 

  1161.                      :flag t))
    1162. 

  1162.     </pre>
    1163. 

  1163.     <p>Observe the :tal-generator bit in the application constructor, which specifies the root directories of the search paths to the tal files. Furthermore we let tal-component inherit from template-component, which adds the :template-name slot to standard component, next to some custom methods that do undercover work. In default-initargs you specify your tal file to render. Let's make that file:</p>
    1164. 

  1164.     <pre>
    1165. 

  1165. &lt;html xmlns:tal="http://common-lisp.net/project/bese/tal/core"
    1166. 

  1166.       tal:in-package=":ucw-intro"&gt;
    1167. 

  1167.   &lt;head&gt;
    1168. 

  1168.     &lt;title tal:content="$page-name"&gt;page name goes here&lt;/title&gt; 
    1169. 

  1169.   &lt;/head&gt;
    1170. 

  1170.   &lt;body&gt;
    1171. 

  1171.     &lt;h1 tal:content="(content $component" tal:escape-html="nil"&gt;content goes here&lt;/h1&gt;
    1172. 

  1172.     &lt;h1 tal:replace="$contents" tal:escape-html="t"&gt;content goes here&lt;/h1&gt;
    1173. 

  1173.   &lt;/body&gt;
    1174. 

  1174. &lt;/html&gt;
    1175. 

  1175.     </pre>
    1176. 

  1176.     <p>In the html tag you see the xmlns bits. They are xml name spaces. You can look them up in your browser but they lead to nowhere. But inside lisp they are mapped to different packages where custom defined tags, attributes and parameters reside. In this case :it.bese.yaclml.tal. tal:in-package of course maps to in-package. We for example reach the tal tag and attribute definitions by putting tal: in front of them. They are:</p>
    1177. 

  1177.     <ul>
    1178. 

  1178.       <li>tags: tal, lisp, include</li>
    1179. 

  1179.       <li>attributes: content, replace, when, dolist, in-package</li>
    1180. 

  1180.     </ul>
    1181. 

  1181.     <p>When a tag (a tal tag, or a html/xml tag) is parsed, tal checks, from left to right, if the tag and/or any of it's attributes are part of a namespace which begs them to be evaluated by tal. A tag can contain multiple tal attributes and they can be mixed with html/xml attributes. If so tal determines which handler is fit and hands it the tag to be operated upon. (For your understanding, when it concerns an attribute, tal usually eats that attribute, performs the specified operation, and processes the tag again without it.)</p>
    1182. 

  1182.     <p>To continue the treatment of our example, we examine the attributes content and replace. Content replaces the content of the tag it's a part of (in this case "content goes here") with what's contained in it's variable (the result of "(contents $component). Replace replaces the complete tag with what's in it's variable. They both check for the value of escape-html which doesn't escapes html if the value is nil and which does escape html whenever the value is non-nil. If escape-html isn't supplied it defaults to t.</p>
    1183. 

  1183.     <p>For completeness: we could also have had our  tal-component class inherit from simple-component and leave out everything except for the contents of the body, and ucw would have added the code around it.</p>
    1184. 

  1184.     <p>But where are variables defined? How can tal interact with the class it renders? And what about those other tags and attributes? Enter the next section:</p>
    1185. 

  1185.     <h5>Tal and lisp</h5>
    1186. 

  1186.     <p>Basically where a tag or an attribute accepts some sort of parameter you usually have a window into lisp. This is the case with lisp, content, replace, when and dolist. The text inside " and " is evaluated, except for tal:lisp which evaluates the text inside its beginning- and end-tag. Variables start with the character $ and are matched against values inside the so-called tal environment. This environments equates to a collection of supplied classes, alists and hash-tables in which tal tries to match the variable. When it does it returns the value. In our example some methods on template-component make sure the component that the tal file is rendered on is included and can be referenced with $component. As you can see you can either use the slot function of contents or you can refer to contents directly by pasting a $ to its front, as you can refer directly to the key of a cons in an a-list or the key in a hash table. Later on you will see ways to extend the tal environment.</p>
    1187. 

  1187.     <p>Sometimes you want to use a variable, or the output of some lisp code in an ordinary attribute. You can do that by putting "${..your lisp code...}" after the attribute (see the next example). If you for some reason want to splice the contents of a list after an attribute you can replace the $ with a @.</p>
    1188. 

  1188.     <p>Let's review the rest of the tal tags and attributes. We start of with another example. This time we create a component called more-ucw, two simple classes and a hash table for use with the tal file:</p>
    1189. 

  1189.     <pre>
    1190. 

  1190. (defcomponent more-tal (template-component)
    1191. 

  1191.   ((flag :initarg :flag :accessor flag)
    1192. 

  1192.    (da-var :initform "da-var from more-tal class" :accessor da-var)
    1193. 

  1193.    (tal-name :initform "more-wrapper.tal" :accessor tal-name)
    1194. 

  1194.    (another-var :initform "another-var from more-tal class" :accessor another-var)
    1195. 

  1195.    (a-href :initform "http://planet.lisp.org" :accessor a-href)
    1196. 

  1196.    (a-class :initform (make-instance 'in-list) :accessor a-class)
    1197. 

  1197.    (spliced-href :accessor spliced-href :initform '("http://" "planet." "lisp." "org"))
    1198. 

  1198.    (my-list :accessor my-list
    1199. 

  1199.             :initform `((,(make-instance 'in-list)
    1200. 

  1200.                          ,(make-instance 'another-in-list))
    1201. 

  1201.                         (((da-var . "da-var from a-list") (another-var . "another-var from a-list")))
    1202. 

  1202.                         (,(make-instance 'in-list :da-var "da-var from class in another bullet")
    1203. 

  1203.                          ((da-var . "da-var from another a-list") (another-var . "another-var from another alist")))
    1204. 

  1204.                         (,*tal-table*))))
    1205. 

  1205.   ;;  (:entry-point "^(|more-tal.ucw)$" (:application *ucw-intro-application* :class regexp-dispatcher))
    1206. 

  1206.   (:default-initargs :template-name "more-tal.tal" :flag nil))
    1207. 

  1207.     </pre>
    1208. 

  1208.     <pre>
    1209. 

  1209. (defclass in-list ()
    1210. 

  1210.   ((da-var :initarg :da-var :initform "da-var from in-list class" :accessor da-var)))
    1211. 

  1211.     </pre>
    1212. 

  1212.     <pre>
    1213. 

  1213. (defclass another-in-list ()
    1214. 

  1214.   ((another-var :initform "another-var from in-list class" :accessor another-var)))
    1215. 

  1215.     </pre>
    1216. 

  1216.     <pre>
    1217. 

  1217. (defparameter *tal-table* (make-hash-table))
    1218. 

  1218.     </pre>
    1219. 

  1219.     <pre>
    1220. 

  1220. (setf (gethash 'another-var *tal-table*) "another-var from hash")
    1221. 

  1221.     </pre>
    1222. 

  1222.     <p>and we make a .tal file called more-tal.tal:</p>
    1223. 

  1223.     <pre>
    1224. 

  1224. &lt;html xmlns:tal="http://common-lisp.net/project/bese/tal/core"
    1225. 

  1225.   xmlns:ucw="http://common-lisp.net/project/ucw/core"
    1226. 

  1226.   xmlns:param="http://common-lisp.net/project/bese/tal/params"
    1227. 

  1227.   tal:in-package=":ucw-intro"&gt;
    1228. 

  1228.   &lt;head&gt;
    1229. 

  1229.     &lt;title&gt;more tal&lt;/title&gt;
    1230. 

  1230.   &lt;/head&gt;
    1231. 

  1231.   &lt;tal:include tal:name="more-wrapper.tal" param:little-class="(a-class $component)"&gt;
    1232. 

  1232.     &lt;param:contents&gt;
    1233. 

  1233.       &lt;div tal:when="$flag" tal:content="$another-var"&gt;
    1234. 

  1234.         flag is set?
    1235. 

  1235.       &lt;/div&gt;
    1236. 

  1236.       &lt;ul&gt;   
    1237. 

  1237.         &lt;li tal:dolist="$my-list"&gt;
    1238. 

  1238.           &lt;b tal:content="$da-var"&gt;&lt;/b&gt;&lt;br/&gt;
    1239. 

  1239.             &lt;tal:tal tal:content="$another-var"&gt;another var&lt;/tal:tal&gt;
    1240. 

  1240.         &lt;/li&gt;
    1241. 

  1241.       &lt;/ul&gt;      
    1242. 

  1242.       &lt;p&gt;&lt;a href="${(a-href $component)}"&gt;attribute insertion&lt;/a&gt;&lt;/p&gt;      
    1243. 

  1243.       &lt;p&gt;&lt;a href="@{(spliced-href $component)}"&gt;spliced attribute insertion&lt;/a&gt;&lt;/p&gt;
    1244. 

  1244.       &lt;tal:lisp&gt;
    1245. 

  1245.         (setf (a-href $component) "http://www.cliki.net")
    1246. 

  1246.       &lt;/tal:lisp&gt;
    1247. 

  1247.       &lt;a href="${(a-href $component)}"&gt;new value of href&lt;/a&gt;      
    1248. 

  1248.     &lt;/param:contents&gt;
    1249. 

  1249.   &lt;/tal:include&gt;
    1250. 

  1250. &lt;/html&gt;
    1251. 

  1251.     </pre>
    1252. 

  1252.     <p>We leave tal:include and the param: tag and attribute alone for a moment because they need some extra code to explain. We explain the rest first:</p>
    1253. 

  1253.     <ul>
    1254. 

  1254.       <li>tal:when - an attribute - which is of course not dissimilar to lisps when. When the value produced by the expression inside the quotation marks equates to nil, attributes after the when tag are not processed. If this means that no tal attribute will supply the tag with content, the whole tag, and it's contents are removed. If a previous attribute already supplied the tag with content through tal:content the tag will not be removed and that content will be shown. If content was previously supplied with tal:replace the tag will be replaced by the content of tal:replace, as this is the behaviour of tal:replace</li>
    1255. 

  1255.       <li>tal:dolist - an attribute - This is a rather cool and nifty tag. It works not dissimilar to dolist. The code between the quotation marks of dolist should equate to a list of lists containing alists, classes hash-tables or a combination of the former. Dolist iterates over the list of lists. On each iteration the tag dolist is a part of and it's children are evaluated and added to the yaclml tree in the pending tal environment extended with the list which is at that point the list dolist is iterating over. See the initform of the my-list slot of the more-tal component to get a feel for it.</li>
    1256. 

  1256.       <li>tal:tal - a tag - In the dolist tag tree in more-tal.tal you see tal:tal which is simply a placeholder for attributes that doesn't show up in the html/xml code you want to produce.</li>
    1257. 

  1257.       <li>the $ AND @ ones after a normal attribute - as discussed earlier these are used when you want to use the result of some lisp code output or a list of some lisp code output respectively after an ordinary attribute.</li>
    1258. 

  1258.       <li>tal:lisp - a tag - The text enclosed within a tal:lisp tag is processed for side effects. No output is passed back into the tag tree.</li>
    1259. 

  1259.     </ul>
    1260. 

  1260.     <p>Now to explain tal:include, which basically does what you expect. Tal:include extends the current tal environment with the parameters that are in the param name-space and that are enclosed in the include tag (so everything with param: in front of it). This environment is passed to the calling tal file which it uses to evaluate it's own tal tags and attributes. You can pass param: tags and param: attributes, which behave differently. Param tags (you may call them whatever you wish) stuff all the evaluated content enclosed in them in a variable. (in the case of our example  this will be in $contents). All the tags enclosed in the include tag are evaluated together with their attributes and the attributes of the param: tag before they are passed to the included tal file. So the content of $contents will be a big (or a little) string. By using attributes on the other hand, you can pass variables that refer to lisp objects. The value of the variable is the value returned by the code enclosed within the quotations that stick to it via the equal sign. The template that tal:include calls can be specified by either a tal:name or tal:name-expression attribute. Tal:name simply maps to the specified tal file. Name-expression evaluates the expression typed inside it's quotation marks, which should equate to a valid tal-file path. With this information we look at the .tal file we call from more-tal, called more-wrapper:</p>
    1261. 

  1261.     <pre>
    1262. 

  1262. &lt;body
    1263. 

  1263.   xmlns:tal="http://common-lisp.net/project/bese/tal/core"
    1264. 

  1264.   xmlns:ucw="http://common-lisp.net/project/ucw/core"
    1265. 

  1265.   tal:in-package=":ucw-intro"&gt;
    1266. 

  1266.   &lt;tal:tal tal:content="$contents" tal:escape-html="nil"&gt;here goes more-tal&lt;/tal:tal&gt;
    1267. 

  1267.   &lt;tal:lisp&gt;
    1268. 

  1268.     (setf (da-var $little-class) "this is the new and quite boring contents of little class")
    1269. 

  1269.   &lt;/tal:lisp&gt;
    1270. 

  1270.   &lt;p tal:content="(da-var $little-class)"&gt;contents of little-class&lt;/p&gt;
    1271. 

  1271. &lt;/body&gt;
    1272. 

  1272.     </pre>
    1273. 

  1273.     <p>Should be pretty clear. For some more clarity, you could also have specified the file to include with:</p>
    1274. 

  1274.     <pre>
    1275. 

  1275. tal:name-expression="more${(print (string-downcase '-wrapper.tal))}"
    1276. 

  1276.     </pre>
    1277. 

  1277.     <p>Now granted, this looks rather useless and hackerish, but the point is to show how you can use arbitrary expressions enclosed in ${} to get to your filename.</p>
    1278. 

  1278.     <p>But when would you want to use name-expression? Well, imagine you want to reference a tal file based on the a component you have in a certain slot of the component you are rendering. Then you could write:</p>
    1279. 

  1279.     <p>&lt;tal:include tal:name-expression="details/${ (class-name (class-of (datum $component))) }"
    1280. 

  1280.                 param:datum="(datum $component)"/&gt;</p>
    1281. 

  1281.     <p>This will include a different file in the details directory, depending on the class of the datum slot, and pass the datum object itself to the included file. (example and explanation from Marco Baringer)</p>
    1282. 

  1282.     <p>Note that the code inside ${} will only return the name of a class. tal:name-expression automagically appends .tal to the end if it's not already present, as does tal:name.</p>
    1283. 

  1283.     <h5>Ucw-specific tal</h5>
    1284. 

  1284.     <p>Ucw also has a couple of custom defined tal attributes and tags. They are:</p>
    1285. 

  1285.     <ul>
    1286. 

  1286.       <li>ucw:select - tag</li>
    1287. 

  1287.       <li>ucw:option - tag</li>
    1288. 

  1288.       <li>ucw:action - attribute</li>
    1289. 

  1289.       <li>ucw:accessor - attribute</li>
    1290. 

  1290.       <li>ucw:render-component - tag</li>
    1291. 

  1291.     </ul>
    1292. 

  1292.     <p>Which simply map to their yaclml equivalent, except for render-component which doesn't have one. Surprisingly enough it allows you to render a component from within tal. Typical well-formed tal strings using ucw would and actually do look like the tags below because they're straight from tal files found in the source code:</p>
    1293. 

  1293.     <pre>
    1294. 

  1294. &lt;a href="" ucw:action="(respond $component $value)" tal:content="$text"&gt;text&lt;/a&gt;
    1295. 

  1295. &lt;input type="file" ucw:accessor="(file-upload-example.file $component)"/&gt;
    1296. 

  1296. &lt;ucw:render-component ucw:component="$selected-component"/&gt;
    1297. 

  1297.     </pre>
    1298. 

  1298.     <p>Well, it should all be self-explanatory. Only render-component is slightly out of context, but even my obsessive over-explaining-gene doesn't feel the need to explain it.</p>
    1299. 

  1299.     <h5>Rendering tal files from within render methods</h5>
    1300. 

  1300.     <p>Sometimes you want to render tal files from within render methods. You can do this by using the render-template method, which is also used under the cover for children of template-component. A render-template method expects a request-context class, the location of a tal file and a tal environment. A basic one looks like this:</p>
    1301. 

  1301.     <pre>
    1302. 

  1302. (render-template ucw:*context* "tal-file.tal" nil)
    1303. 

  1303.     </pre>
    1304. 

  1304.     <p>In this example the method grabs the standard ucw context, but what is a context? From the source code:</p>
    1305. 

  1305.     <p>A request-context object contains all the information associated with one particular request/response loop. The request context is usually accessed via the special variable *context* and contains the currently relevant application, session, session-frame, request and response object.</p>
    1306. 

  1306.     <p>So you should almost always use ucw:*context*, unless you let the code do things advanced enough you don't need to read this tutorial to explain this particular aspect.</p>
    1307. 

  1307.     <p>Furthermore our example above specifies a tal file and a request context of nil. So if you want to render that particular tal file, all variables you want the file to look up in the request context will equate to nil.</p>
    1308. 

  1308.     <p>For explanations sake, we change the  tal-component component so it doesn't inherit from template-component anymore, eg change:</p>
    1309. 

  1309.     <pre>
    1310. 

  1310. (defcomponent  tal-component ()
    1311. 

  1311.   ...
    1312. 

  1312.     </pre>
    1313. 

  1313.     <p>to:</p>
    1314. 

  1314.     <pre>
    1315. 

  1315. (defcomponent tal-component (template-component)
    1316. 

  1316.   ...
    1317. 

  1317.     </pre>
    1318. 

  1318.     <p>Then we define a render method on the component:</p>
    1319. 

  1319.     <pre>
    1320. 

  1320. (defmethod render ((component tal-component))
    1321. 

  1321.         (render-template ucw:*context* "intro.tal" nil))
    1322. 

  1322.     </pre>
    1323. 

  1323.     <p>Now this one will actually report an error. Since our tal environment is nil, intro.tal tries to get to the slot component of an inexistent class. Let's add a class to our environment:</p>
    1324. 

  1324.     <pre>
    1325. 

  1325. (defmethod render ((component tal-component))
    1326. 

  1326.   (render-template ucw:*context* "intro.tal"  `(((component . ,component)))))
    1327. 

  1327.     </pre>
    1328. 

  1328.     <p>Since a tal-environment consists of lists of alists, components and hash tables intro.tal now finds our component by referencing the specified alist in the tal-environment. The $contents variable in the tal file however equates to nil, because the component itself isn't listed as an object the tal-environment references to look up values. To add both the component itself and use it as a variable we might as well use the function make-standard-environment which is meant for this purpose:</p>
    1329. 

  1329.     <pre>
    1330. 

  1330. (defmethod render ((component tal-component))
    1331. 

  1331.   (render-template ucw:*context* "intro.tal" (make-standard-environment `((component . ,component)) component)))
    1332. 

  1332.     </pre>
    1333. 

  1333.     <p>And now tal-component renders like before.</p>
    1334. 

  1334.     <p>This pretty much rounds up tal, but this intro is way from complete... Will the horror never end?</p>
    1335. 

  1335.     <p><span id='debugging'></span></p>
    1336. 

  1336.     <h2>Debugging</h2>
    1337. 

  1337.     <p>Next to your standard debugging aids, ucw sports a few extra methods like debugging output deferred to the callers web-page and calling components from the repl.</p>
    1338. 

  1338.     <p>First for completeness the different debugging switches and levers described at their respective sections:
    1339. 

  1339.     The ucw-inspector and ucw-debugger web-switch described in the configuration section, the log-level lever described in the configuration section, and the debug-on-error switch of an application described in the initial environment section. </p>
    1340. 

  1340.     <p>Furthermore, your standard ucw-sources come supplied with an administration page that is divided in a few sections. Click UCW web-admin from the examples page and log in with guest:guest. Ah, just play around. It's got some info screens, configure switches, a web-repl and a web inspector.</p>
    1341. 

  1341.     <p>Last but certainly not least: Perhaps you would like to test your components at the repl. There is a problem here because calling components requires you to include some context-information that's normally only present when ucw actually tries to handle incoming requests. To circumvent this problem ucw has a with-dummy-request macro on board. It accepts a list of keys and a body. The keys are :render :action and :application. Render defaults to t, which means the component will be rendered and the output will be shown on *trace-output*. If nill no output. If :action is true (by default), the body will be treated as an action, if not it will be wrapped in a progn. With application you can pass an application object. If it's not given, the macro will try *default-application*, else a standard-application will be created. With url-prefix /DUMMY/, although that is a bit irrelevant. The output of with-dummy-request-context is the output of the render method followed by the component under scrutiny, so you wish to inspect it:</p>
    1342. 

  1342.     <pre>
    1343. 

  1343. UCW-INTRO&gt; (with-dummy-context (:action nil :application *ucw-intro-application*)
    1344. 

  1344.     (call 'tal-component))
    1345. 

  1345.     </pre>
    1346. 

  1346.     <pre>
    1347. 

  1347. --&gt;
    1348. 

  1348. 16:36 UCW-LOGGER/+INFO+: CALL'ing to /#&lt;BASICS {AE183A1}&gt; 
    1349. 

  1349. &lt;!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/transitional.dtd"&gt;
    1350. 

  1350. &lt;html
    1351. 

  1351.   &gt;&lt;head
    1352. 

  1352. ...
    1353. 

  1353.   &gt;&lt;/html
    1354. 

  1354. &gt;
    1355. 

  1355. #&lt;BASICS {AE183A1}&gt;
    1356. 

  1356.     </pre>
    1357. 

  1357.     <pre>
    1358. 

  1358. UCW-INTRO&gt; (with-dummy-context ()
    1359. 

  1359.              (get-stuff-to-say * "bla"))
    1360. 

  1360.     </pre>
    1361. 

  1361.     <pre>
    1362. 

  1362. --&gt;
    1363. 

  1363. 16:40 UCW-LOGGER/+INFO+: Serving action (/#&lt;BASICS {B00FDA9}&gt;/UCW-INTRO::GET-STUFF-TO-SAY #&lt;BASICS {B00FDA9}&gt; "bla")
    1364. 

  1364. 16:40 UCW-LOGGER/+INFO+: CALL'ing to /#&lt;THE-OTHER-ONE {B1707B1}&gt; 
    1365. 

  1365. &lt;!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/transitional.dtd"&gt;
    1366. 

  1366. &lt;html
    1367. 

  1367.   &gt;&lt;head
    1368. 

  1368. ...
    1369. 

  1369.   &gt;&lt;/html
    1370. 

  1370. &gt;
    1371. 

  1371.     </pre>
    1372. 

  1372.     <pre>
    1373. 

  1373. UCW-INTRO&gt; (with-dummy-context (:render nil :application *ucw-intro-application*)
    1374. 

  1374.                       (call 'tal-component))
    1375. 

  1375.     </pre>
    1376. 

  1376.     <pre>
    1377. 

  1377. --&gt;
    1378. 

  1378. ; in: LAMBDA NIL
    1379. 

  1379. ;     (IT.BESE.UCW:CONTEXT.WINDOW-COMPONENT IT.BESE.UCW:*CONTEXT*)
    1380. 

  1380. ; ==&gt;
    1381. 

  1381. ;   IT.BESE.UCW:*CONTEXT*
    1382. 

  1382. ; 
    1383. 

  1383. ; note: deleting unreachable code
    1384. 

  1384. ; 
    1385. 

  1385. ; compilation unit finished
    1386. 

  1386. ;   printed 1 note
    1387. 

  1387. 16:48 UCW-LOGGER/+INFO+: CALL'ing to /#&lt;TAL-COMPONENT {B6EEE21}&gt; 
    1388. 

  1388. #&lt;TAL-COMPONENT {B6EEE21}&gt;
    1389. 

  1389.     </pre>
    1390. 

  1390.     <p><span id='source'></span></p>
    1391. 

  1391.     <h2>Source</h2>
    1392. 

  1392.     <p>is <a href='ucw-intro_source.tar'>here</a>.</p>
    1393. 

  1393.     <p><span id='miscellaneous'></span></p>
    1394. 

  1394.     <h2>Miscellaneous</h2>
    1395. 

  1395.     <h5>Changes</h5>
    1396. 

  1396.     <p>last modified 4th of may 2006</p>
    1397. 

  1397.     <p>- added debugging tools chapter 
    1398. 

  1398.     <br>
    1399. 

  1399.     
    1400. 

  1400.     - added info on slightly changed startup procedure 
    1401. 

  1401.     <br>
    1402. 

  1402.     
    1403. 

  1403.     - added tabbed pane info in the templating chapter 
    1404. 

  1404.     <br>
    1405. 

  1405.     
    1406. 

  1406.     - added ucw-boxset info 
    1407. 

  1407.     <br>
    1408. 

  1408.     
    1409. 

  1409.     - fixed bugs concerning variable passing between pages in basics.lisp 
    1410. 

  1410.     <br>
    1411. 

  1411.     
    1412. 

  1412.     - fixed little bug in the spliced-href slot</p>
    1413. 

  1413.     <p>25th of april 2006: 
    1414. 

  1414.     <br>
    1415. 

  1415.     
    1416. 

  1416.     - overhauled code examples and related text to make them easier to maintain/install/use 
    1417. 

  1417.     <br>
    1418. 

  1418.     
    1419. 

  1419.     - changed text and code examples to reflect dispatch methods/changed defentry-point due to big backend code-changes 
    1420. 

  1420.     <br>
    1421. 

  1421.     
    1422. 

  1422.     - changed text and code examples to reflect new container behaviour 
    1423. 

  1423.     <br>
    1424. 

  1424.     
    1425. 

  1425.     - changed text to conform to changed configuration options
    1426. 

  1426.     - added &lt;:ah + &lt;:ai info 
    1427. 

  1427.     <br>
    1428. 

  1428.     
    1429. 

  1429.     - removed legacy ucw-install 
    1430. 

  1430.     <br>
    1431. 

  1431.     
    1432. 

  1432.     - fixed some minor bugs</p>
    1433. 

  1433.     <p>21th of april 2006 - added tal explanation section 
    1434. 

  1434.     <br>
    1435. 

  1435.     
    1436. 

  1436.     15th of april 2006 - fixed mod_lisp install errors 
    1437. 

  1437.     <br>
    1438. 

  1438.     
    1439. 

  1439.     11th of april 2006 - updated install instructions and a lot of minor fixes 
    1440. 

  1440.     <br>
    1441. 

  1441.     
    1442. 

  1442.     5th of april 2006 - first buggy version, landed on the net by accident</p>
    1443. 

  1443.     <h5>Todo</h5>
    1444. 

  1444.     <p>The rest</p>
    1445. 

  1445.     <h5>Contact</h5>
    1446. 

  1446.     <p>to mail, put these in the right order: <b>at dot fallenfrukt stuij</b>  </p>
    1447. 

  1447.   </body>
    1448. 

  1448. </html>
    1449. 

    1450.