;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; LL2 Talk
;;  ---  Ken Anderson and Tim Hickey
;;  Saturday 11/9/2002
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;(define starttime (Date.))
(let (
  (ses (.getSession request))
  (page (.getParameter request "page"))
     )

;  (define starttime (Date.))
;    (tryCatch starttime (lambda(e) (Date.))))

(define (trs C rows) 
  (map (lambda (row) {<tr>[(tds C row)]</tr>}) rows))
(define (tds C row)  
  (map (lambda (col) {<td class="[C]">[col]</td>}) row))

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; first we define some helper procedures, used in making the slides
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  (define (small x)
    {<p style="font: 10pt 'Times Roman',serif"> [x] </p>})

  (define default-style
       "
        <style type=\"text/css\" media=\"screen, projection\">
         <!--
         .blue {padding:1px;background:rgb(230,230,255)}
          h1 {color:black; background-color:rgb(200,180,160);
              text-align: center;
              border: thick double black}
          xmp {color:yellow; background-color:black; font: bold 12pt Courier,monospace;
               border: thick double blue; padding: 5px}
          .xmp {color:yellow; background-color:black; font: bold 12pt Courier,monospace;
               border: thick double blue; padding: 5px}
          pre {color:yellow; background-color:black; font: bold 12pt Courier,monospace;
               border: thick double blue; padding: 5px}
          body {
            font: 18pt \"Times Roman\",serif;
            color: black;
            background-color: rgb(255,255,255)}
          td {
            font: bold 12pt \"Courier\",monospace;
            color:yellow;
            background-color: black}
         .title {
            text-align: center;
            width: 50%;
            color:red;
            background-color: white;
            border: thick double blue;
            font: bold 36pt \"Helvetica\", sans-serif;
            }
         .green {
            color: black;
            background-color: lightgreen}
          -->
        </style>
       ")

  (define print-style
       "
        <style type=\"text/css\" media=\"screen, projection\">
         <!--
         .blue {padding:1px;background:rgb(230,230,255)}
          h1 {color:black; background-color:rgb(200,180,160);
              text-align: center;
              border: thick double black}
          xmp {color:black; background-color:white; font: bold 12pt Courier,monospace;
               border: thick double blue; padding: 5px}
          .xmp {color:black; background-color:white; font: bold 12pt Courier,monospace;
               border: thick double blue; padding: 5px}
          pre {color:black; background-color:white; font: bold 12pt Courier,monospace;
               border: thick double blue; padding: 5px}
          body {
            font: 18pt \"Times Roman\",serif;
            color: black;
            background-color: rgb(255,255,255)}
          td {
            font: bold 12pt \"Courier\",monospace;
            color:black;
            background-color: white}
         .title {
            text-align: center;
            width: 50%;
            color:red;
            background-color: white;
            border: thick double blue;
            font: bold 36pt \"Helvetica\", sans-serif;
            }
         .green {
            color: black;
            background-color: lightgreen}
          -->
        </style>
       ")

  (define the-style
    (let ((t (.getAttribute ses "the-style")))
      (if (equal? t #null)
          default-style
           t)))


  (define (td class) (lambda(x) {<td class="[class]">[x]</td>}))
  (define (tr class) (lambda(r) {<tr class="[class]">[(map (td class) r)]</tr>}))
  (define (table class rows) {<table class="[class]">[(map (tr class) rows)]</table>})

  (define (link page title)
    {<a href="talk.servlet?page=[page]">
           [title]  </a>})

  (define (linklist L)
    {<ul>[ (apply string-append
     (map (lambda (x) {<li> [(apply link x)]</li>})
           L)) ]</ul>})



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Here we begin creating the individual pages of the talk
;; They all have a common start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(if (equal? page #null) (set! page "title"))


{
 <html>
  <head>
     <title>[page]</title>
     [the-style]
  </head>
  <body bgcolor=white>
<div align=right>[
;(- 15 (* 0.01 (Math.round (* 100 (/ (- (.getTime (Date.)) (.getTime starttime)) 60000.0))))) " minutes left "
] </div>
  [ (case page 
       ;; here are the individual pages, starting with the title page
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       (("title") 
        {
         <div align=right>[(link "hypothesis" "continue")]</div>
         <div align=center>
         <h1>Leveraging Libraries in Lightweight Languages:<br> 
             the Jscheme Experience; or, <br>
             How Bambi snuggles with Godzilla!</h1>
            <br> Ken Anderson(BBN)<br> Tim Hickey (Brandeis University)
         <br> Saturday, 11 November 2002<br>
          LL2
         </div>
      <div class="xmp" style="text-align:left">
         <b>Goals for talk</b>
         <ul><li>
           </li><li> Describe our unsuccessful attempt 
to build the ultimate scripting language in 20K LOC</li>
           </li><li> Explain the failure and later partial successes</li>
           </li><li> Relate to other scripting languages
        </li></ul>
         </div>
        })






               
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       (("hypothesis")
        {
         <div align=right>[(link "jscheme" "continue")]</div>

         <h1>Our Initial Hypothesis</h1>
<pre style="font:bold 20pt Helvetica,sans-serif">
  Small Powerful Lightweight Language (JScheme)
   +
  Huge Industrial-strength Libraries (jdk1.4 libraries)
  =
  The Ultimate Lightweight Scripting Language
</pre>
<br>         [(link "jscheme" "continue")]

        })


      (("jscheme"){
         <div align=right>[(link "javadot" "continue")]</div>

         <h1>JScheme:  (http://jscheme.sourceforge.net)</h1>
    <center>  A Scheme-like language implemented in Java</center>
        <ul>

          <li class="xmp"> Powerful: 
          <ul>
            <li>almost all R4RS Scheme (partial call/cc, immutable strings)</li>
            <li>plus Objects, Threads and Exception Handling</li>
          </ul></li>

         <li class="xmp"> Lightweight:
          <ul>
            <li> <b>SYNTAX</b>
                 S-expressions + Java literal syntax
            <li> <b>SEMANTICS</b> about 20 special forms:<br>
               <code> quote, begin, if, or, and, set!, define, lambda,
                 cond, let, let*, letrec, case, quasiquote, 
                <font color=red>tryCatch, define-macro, define-method, ...
                </font></code></li>
            <li> <b>JAVA ACCESS</b> 
               Javadot notation (next slide)</li>
          </ul></li>
          <li class="xmp"> Small:
          <ul> 
            <li> 7200 lines of Java and 800 lines of Scheme</li>
            <li> 150KB jar file</li>
            <li> 23MB of java libraries (8128 classes) </li>
          </ul></li>

       </ul>
         [(link "javadot" "continue")]

})

      (("javadot") {
         <div align=right>[(link "javadot1" "continue")]</div>

        <h1>JavaDot Notation: calling Java from Scheme using Reflection</h1>
<b>symbols containing "." or "$" = Java methods, constructors, or fields<br>

<table border=2 cellpadding=10 class="xmp">
<tr>
<td>(.println X Y)</td><td> "." at beginning </td><td> ==> instance method<br></td></tr>
<td>(Math.sin 0.0)</td><td> "." in middle only </td><td>==> static method</td></tr><br>
<td>(JButton. S)</td><td>"." at end </td><td>==> constructor</td></tr><br>
<td>System.out$</td><td>  "$" at end </td><td>==> static field</td></tr>
<tr><td>(.first$ x 5)</td><td>initial ".", terminal "$"</td><td>instance field</td></tr>
</table>

<pre>
// Java
System.out.println(new JButton("Hello").toString());   
</pre>
<pre>
;; JScheme
(.println System.out$ (.toString (JButton. "Hello")))    
</pre>
<br>         [(link "javadot1" "continue")]
       }
)

      (("javadot1") {
         <div align=right>[(link "javadot1a" "continue")]</div>

<h1>JScheme can be more concise that Java</h1>
<pre>
  //Java
  public static ResultSet readData (String url) \{
    try \{
      return (ResultSet)(new SaxHandler().read(
         new BufferedReader
           (new InputStreamReader 
              ((new URL(url)).openStream()))));
    \} catch (IOException e2) \{
      e2.printStackTrace();
      return null;    \}  \}
</pre>

<br>         [(link "javadot1a" "continue")]
       }
)



      (("javadot1a") {
         <div align=right>[(link "javadot1b" "continue")]</div>
<h1>JScheme can be more concise that Java</h1>
<pre>
  //Java
  public static ResultSet readData (String url) \{
    try \{
      return (ResultSet)(new SaxHandler().read(
         new BufferedReader
           (new InputStreamReader 
              ((new URL(url)).openStream()))));
    \} catch (IOException e2) \{
      e2.printStackTrace();
      return null;    \}  \}
</pre>
<pre>
;; JScheme
(define (readData url)
 (.read (SaxHandler.) 
   (BufferedReader.(InputStreamReader.(.openStream(URL. url))))))
</pre>

<br>         [(link "javadot1b" "continue")]
       }
)

      (("javadot1b") {
         <div align=right>[(link "javadot2" "continue")]</div>
<h1>JScheme can be more concise that Java</h1>
<pre>
  //Java
  public static ResultSet readData (String url) \{
    try \{
      return (ResultSet)(new SaxHandler().read(
         new BufferedReader
           (new InputStreamReader 
              ((new URL(url)).openStream()))));
    \} catch (IOException e2) \{
      e2.printStackTrace();
      return null;    \}  \}
</pre>
<pre>
;; JScheme
(define (readData url)
 (.read (SaxHandler.) 
   (BufferedReader.(InputStreamReader.(.openStream(URL. url))))))
</pre>

<em>no static typing<br> uniform syntax for methods/constructors/instance fields<br>
optional exception handling</em>

<br>         [(link "javadot2" "continue")]
       }
)




      (("javadot2") {
         <div align=right>[(link "javadot2a" "continue")]</div>

        <h1>but Javadot often is as obtuse as Java</h1>

<pre>
;; Java
final JFrame w = new JFrame("Test");
JButton eb = new JButton("Exit");
eb.setBackground(Color.red);
eb.addActionListener(new ActionListener()\{
      public void actionPerformed(ActionEvent e) \{
        System.exit(0);\}\});
w.getContentPane().add(eb); 
w.pack(); w.show();
</pre>

<pre>
;; JScheme
(import "javax.swing.*")
(define w (JFrame. "Test"))
(define eb (JButton. "Exit"))
(.setBackground eb Color.red$)
(.addActionListener eb 
   (Listener. (lambda(e) (System.exit 0))))
(.add (.getContentPane w) eb) 
(.pack w) (.show w)
</pre>

<br>         [(link "javadot2a" "continue")]
       })
   



      (("javadot2a") {
         <div align=right>[(link "javadot2b" "continue")]</div>

         <h1 style="background:red">
             This is not the Ultimate Scripting Language</h1>

We had to write libraries to hide the direct Javadot access.
<pre>
(load "jlib/Swing.scm") ;a little functional language for GUI creation

(define w 
  (window "Test"
    (button "exit" red 
            (action(lambda(e)(exit))))))
(.pack w) 
(.show w)
</pre>

Resulting code is much simpler than straight JScheme + javadot
<pre>
(import "javax.swing.*")
(define w (JFrame. "Test"))
(define eb (JButton. "Exit"))
(.setBackground eb Color.red$)
(.addActionListener eb 
   (Listener. (lambda(e) (System.exit 0))))
(.add (.getContentPane w) eb) 
(.pack w) (.show w)
</pre>


<br>         [(link "javadot2b" "continue")]
       })
   


   (("jlib-b"){
         <div align=right>[(link "JLIB" "continue")]</div>

     <h1>Flexible Calling Patterns in Other Languages</h1>

<pre>
# in Jython
import javax
from javax import swing

def exit(e)
    java.lang.System.exit(0)
w=javax.swing.JFrame(title="Test")
p=top_frame.getContentPane()<font color=red>
eb = swing.JButton(label="Exit", background=Color.red, actionperformed=exit)</font>
p.add(eb)
w.pack()
w.visible=1
</pre>

<pre>
#! /usr/bin/perl5 -w
# from http://pmwww.cs.vu.nl/documentation/Tk/UserGuide.html
use strict;
use Tk;

my $main = MainWindow->new;<font color=red>
$main->Button(-text => 'Exit',
              -command => \[$main => 'destroy'\]
              )->pack;</font>
MainLoop;
</pre>

<br>         [(link "JLIB" "continue")]

})



      (("javadot2b") {
         <div align=right>[(link "jlib" "continue")]</div>

<h1>Our Hypothesis was wrong....</h1>
<pre style="font:bold 20pt Helvetica,sans-serif">
  Small Powerful Lightweight Language (Scheme)
   +
  Huge Industrial-strength Libraries (javadot+jdk1.4 libraries)
  !==
  the Ultimate Scripting Language
</pre>

<br>         [(link "jlib" "continue")]
})


(("jlib") {
         <div align=right>[(link "jlib-0" "continue")]</div>
<h1>New Hypothesis</h1>
<pre style="font:bold 20pt Helvetica,sans-serif">
  Small Powerful Lightweight Language (Scheme)
   +
  Huge Industrial-strength Libraries (javadot+ jdk1.4 libraries)
  +
<font color=red>  Little Lightweight Languages interfacing to libraries</font>
  =
  The Ultimate Lightweight Scripting Language (???)
</pre>

<xmp>Oh no, not another language to learn?!</xmp>
Make the little languages either really powerful or really easy to learn!

<br>         [(link "jlib-0" "continue")]
       })
   
(("jlib-0"){
         <div align=right>[(link "JLIB" "continue")]</div>
<h1>Questions</h1>
<pre>
What makes a good lightweight scripting library?
What do various scripting libraries have in common?
Where does lightness come from?</em>
</pre>
<hr>
We will start the discussion with three examples from Jscheme:
<pre>
JLIB for building GUIs
SERVLET for writing simple servlets
RUN for simple shell scripts
</pre>
<br>         [(link "JLIB" "continue")]
       })
   
   (("jlib-a") {
         <div align=right>[(link "JLIB" "continue")]</div>
<h1>JLIB windowing library (about 500 lines of JScheme)</h1>
Continuing with previous example of Java/JScheme GUIs:
<pre>
;; JLIB
(define w 
  (window "Test"
     (button "exit" red
             (action(lambda(e)(exit))))))
(.pack w) (.show w)
</pre>

 instead of

<pre>
;; JScheme
(define w (JFrame. "Test"))
(define eb (JButton. "Exit"))
(.setBackground eb Color.red$)
(.addActionListener eb 
   (Listener. (lambda(e) (System.exit 0))))
(.add (.getContentPane w) eb) 
(.pack w) (.show w)
</pre>

<br>         [(link "JLIB" "continue")]

   })


(("JLIB"){
         <div align=right>[(link "JLIB-1" "continue")]</div>
   <h1>Case Study 1: GUI building with JLIB<br>
Flexible widget constructors lighten the code
</h1>
<ul>
<li> JLIB functions may have any number of args</li>
<li> their args are dispatched on types</li>
<li> JLIB provides support for commonly used abstractions</li>
<li> JLIB also provides escapes to most general tools</li>
</ul>
<pre>
(define b
   (button "abc"                               ;; string is button label
           (color 255 80 10)                   ;; background color
           (action (lambda(e) (.hide w)))      ;; action function
           (HelveticaBold 24)                  ;; font
           (lambda(t) (.setForeground t blue)) ;; general property setting
      )
</pre>
<br>[(link "jlib-b" "The earlier GUI example in other scripting languages")]<br>
Jython uses <code>variable=value</code> pairs in arg list<br>
Perl/TK uses <code>-property ==> value</code> pairs in arg list
<br>         [(link "JLIB-1" "continue")]

})

(("JLIB-1"){
         <div align=right>[(link "Strings" "continue")]</div>
<h1>Using a Functional Language lightens code</h1>
<b>component functions</b>: button, label, textfield, textarea, choice, menus, ...<br>
<b>layout functions</b>: border, row, col, grid, table, splitpane, scrollpane<br>
<b>fonts and colors</b> ...<br>
<pre>
(load "jlib/Swing.scm")

(define w 
 (window "sorry" 
  (menubar 
    (menu "File"
      (menuitem "quit" red 
          (action (lambda(e) (.hide w))))))
  (border 
    (north 
      (label "Join Request Refused" (HelveticaBold 24)))
    (center 
     (scrollpane
      (textarea 5 30 (TimesRoman 18) yellow
        "Your request to join the group\\nhas been denied")))
   (south 
      (button "OK" 
         (action (lambda(e) (.hide w))))))))

(.pack w) (.show w)
</pre>
 <applet
     code="jsint.SchemeApplet"
     codebase="."
     archive="/u/lib/applet.jar"
     height=1
     width=1>
   <param name=expr value="(define (init thisApplet) 
(define lib (jlib.Swing.load))

(define w 
 (window &quot;sorry&quot; 
  (lambda(t) (.setTitle t &quot;sorry&quot; ))
  (menubar 
    (menu &quot;File&quot;
      (menuitem &quot;quit&quot; red 
          (action (lambda(e) (.hide w))))))
  (border 
    (north 
      (label &quot;Join Request Refused&quot; (HelveticaBold 24)))
    (center 
     (scrollpane
      (textarea 5 30 (TimesRoman 18) yellow
        &quot;Your request to join the group\\nhas been denied&quot;)))
   (south 
      (button &quot;OK&quot; 
         (action (lambda(e) (.hide w))))))))

(.pack w) (.show w)
 )">
   <param name=init value="init">
  </applet>

<br>         [(link "Strings" "continue")]

})

(("Strings"){
         <div align=right>[(link "Run" "continue")]</div>
  <h1>Case Study 2: Complex String Handling<br>
Quasi-string/Quasi-list syntax lighten code</h1>
<b>Key Idea</b>: Quasi-strings:
<b><code>
  \{7 * 8 = \[<font color=red>(* 7 8)</font>\]\}
</code></b>
<br>
\{\} indicates string, \[\] escapes out to Scheme.
<br>
Easy to learn/use, clearly lightens code.
<pre>
; generate HTML histogram table from results of DB query
(define (histogram field table)
   (define results
      (dbquery<font color=red>
          \{select \[</font>field<font color=red>\],count(*) from \[</font>table<font color=red>\] 
            group by \[</font>field<font color=red>\], order by \[</font>field<font color=red>\] asc\}</font>))<br><br>

<font color=red>
   \{&lt;html&gt;&lt;body&gt;
      &lt;h1&gt;Query results&lt;/h1&gt;
      The result of query &lt;pre&gt;\[s\]&lt;/pre&gt; is 
      &lt;table&gt; \[</font>(trs results<font color=red>)\]&lt;/table&gt;
      &lt;/body&gt;&lt;/html&gt;\}</font>)

(define (trs rows) (map (lambda (row) <font color=red>\{&lt;tr&gt; \[</font>(tds row)<font color=red>\]&lt;/tr&gt;\\n\}</font>) rows))
(define (tds row)  (map (lambda (col) <font color=red>\{&lt;td&gt; \[</font>   col   <font color=red>\]&lt;/td&gt;\}</font>) row))
</pre>
Similar Scheme approaches: SCRIBE (Serrano), BRL (Lewis), ...
<br>         [(link "Run" "continue")]
})


(("Run"){
         <div align=right>[(link "Run2" "continue")]</div>
 <h1>Case Study 3: Simple Shell Scripting<br>
pattern matching, file handling, system calls
</h1>
Recompile all C files below "." which have been modified
after their corresponding ".o" file.
<pre>
....Ruby example, from pixel@mandrakesoft.com
Dir\['**/*.c'\].each\{|c|
  o = c.sub('\.c$', '.o')
  if !FileTest.exist?(o) || File.stat(o) <= File.stat(c) then
    puts "compiling #\{c\} to #\{o\}"
    system("gcc", "-c", "-o", o, c)
  end
\}
</pre>
Ruby provides support for iteration (<font color=red>.each\{|c|...\}</font>),
pattern matching/replacement (<font color=red>c.sub(P1,P2)</font>), 
system calls (<font color=red>system(Command,A1,A2,...)</font>),
recursive file filtering (<font color=red>Dir\['**/*.c'\]</font>), 
file property access (<font color=red>File.stat, FileTest</font>).
<br>         [(link "Run2" "continue")]
})


(("Run2"){
         <div align=right>[(link "Run3" "continue")]</div>
 <h1>
Naming Issues for Libraries: brevity versus clarity
</h1>

Goal: Implement same procedure in Jscheme with same abstractions
by building lightweight libraries on top of three java classes:
<br>
<table border=1 cellpadding=5>
<tr><th>Library</th> <th>Source</th> <th>Lightweight access</th></tr>
[(trs "" '(
("pattern matching/replacing" "<code>java.util.RegEx</code>" "<code>(// PAT) (/// PAT REP)</code>")
("recursive file filtering" "<code>java.io.File</code>" "<code>(file** DIR FILTER)</code>")
("system access" "<code>java.lang.Runtime</code>" "<code>(run CMD . ARGS)</code>")
))]
</table>
<br>
[(link "Run2a" "Reusable version")], give descriptive names to more
subexpressions
<br>
[(link "develversion" "Developer's brief version")]
-- short/symbolic names for oft-used patterns
<br>
[(link "brevity" "Perl wanna-be version")]
--give procedures and macros 1-character names,
<br>
<br>
The use of functional iteration (e.g. for-each and map) also
lightens the code considerably.
<div align=left>[(link "Run3" "continue")]</div>

})

(("develversion"){
         <div align=right>[(link "Run2" "continue")]</div>
<h1>Developer's version</h1>
<br>
<pre>
(load "ll2.scm")  ;; JScheme version with lightweight library

(for-each 
  (lambda(f)
      (define o ((/// "\\\\.c$" "\\\\.o") f))
      (if (or (not (.exists o)) (<= (.lastModified o) (.lastModified f))))
          (begin  (display \{compiling \[f\] to \[o\]\\n\})
                (run gcc -c -o  ,o ,f)))
  (files** dir (// "\\\\.c$")))

</pre>

This version uses RegEx pattern matching(//) and replacement(///), 
recursive file filtering(file**), and System access(run).
<br>
<br>
[(link "Run2" "back")]

})


(("brevity"){
         <div align=right>[(link "Run2" "continue")]</div>
 <h1>Simple Shell Scripting: overly concise JScheme version</h1>
Here we replaced almost all symbols with one or two character aliases
(which could be defined in the library)

<pre>
;; Perl wanna-be version
(@ f (**/* Dir(// "\\\\.c$"))
   (<- o((/// "\\\\.c$" "\\\\.o")f))
   (? ((||(!(Fis? o))(<=(Fmod o)(Fmod f)))
        (d \{compiling \[f\] to \[o\]\\n\})
        (run gcc -c -o  ,o ,f))))
</pre>
Using
<pre>
(define-macro (@ f fs . body) `(for-each (lambda(,f) ,@body) ,fs))
(define-macro (? . R) `(cond ,@R))
(define-macro (<- . R) `(define ,@R))
(define-macro (|| . R) `(or ,@R))
(define **/* files**)
(define d display)
(define ! not)
(define Fmod .lastModified)
(define Fis? .exists)
</pre>

[(link "Run2" "back")]
})

(("Run2a") {
         <div align=right>[(link "Run2" "continue")]</div>
<h1>Reusable Version of Jscheme Shell Script</h1>
<pre>
;; JScheme version
(load "ll2.scm") ;; provide same <font color=red>support</font> as Ruby example in 70 lines
(define (compile dir)
   (for-each  (lambda(c) 
                   (display \{compiling \[c\] to \[(c->o c)\].\\n\})
                   (<font color=red>run</font> gcc -c -o  ,(c->o c) ,c))
               (<font color=red>files**</font> dir needsUpdate?)))


(define isCFile? (<font color=red>//</font> "\\\\.c$"))   
(define c->o (<font color=red>///</font> "\\\\.c$" "\\\\.o")) 
(define (needsUpdate? f) (and (isCFile? f) (needsRecompile f (c->o f))))
(define (needsRecompile f o)
  (or (not (.exists o)) (<= (.lastModified o) (.lastModified f))))
</pre>



<br>         [(link "Run2" "back")]
})

(("Run3"){
         <div align=right>[(link "tradeoffs" "continue")]</div>
<h1>Implementation</h1>
JLIB library  = 600 lines of Jscheme code
<br>
Database library = 30 lines (to implement  <code>(dbquery STRING)</code>)
</br>
Shell Scripting lib = 70 lines
<br>
<br>
Jscheme + javadot + jdk1.4... makes it very easy to write such libraries.
<br>
e.g., Pattern matching is implemented in 4 lines using java.util.RegEx
<pre>
(define (// pattern)
  (let ((p (Pattern.compile pattern)))
    (lambda (object)
      (.find (.matcher p (.toString object))))))
</pre>
Similarly, file filtering is implemented in 6 lines using java.io.File methods
and takes a function argument for filtering.
<br>
<br>
 [(link "tradeoffs" "continue")]

})

(("LL2") {
         <div align=right>[(link "title" "restart")]</div>
<h1>Conclusion:<br>
Lessons from building 
<br> lightweight libraries in Jscheme</h1>
Things that lighten code:
<ul><li> 
<b> functional iteration</b> <em>e.g. for-each, map, filter<br> 
(don't need loop-bounds/tests,car,cdr,for...)</em>
</li><li>
<b> functional mini languages</b> <em> e.g. JLIB GUI construction<br>
(don't need temp variables, assignments, structure mirrors syntax, ...)
</em>
</li><li>
<b>good support <font color=red>only</font> for most common operations </b> 
<br> <em>e.g. pattern matching, system access, table layouts, simple db queries<br>
(keeps language small)</em>
</li><li>
<b>API access to all other features,</b> <em> e.g. grid bag layout...
<br>
(makes common things elegant, uncommon possible but possibly ugly)</em>
</li><li>
<b>functions with args dipatched on types or keywords</b>
<em> e.g. JLIB widget args<br>
(simplifies language, don't need to remember arg number/order)
</em>
</li><li>
<b>easy to read/learn string syntax</b> <em> e.g. quasi-strings for HTML and DB<br>
(allows complex strings to be created easily)
</em>
</li></ul>
<font color=red>Summary:
reduce cognitive load whenever possible</font>
<br>
<br>         [(link "title" "restart talk")]

})

(("tradeoffs"){
         <div align=right>[(link "LL2" "continue")]</div>
<h1>Tradeoffs</h1>
<ul>
<li> More complex library <--> harder to learn/use<br>
compare SchemeQL with  dbquery+quasi-strings 
</li>
<li> More concise names <--> harder to read code</li>
<li> Use of prefix functional language <--> lots of close parens</li>
</ul>


<br>         [(link "LL2" "continue")]

})


       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       (("help")
         (linklist '(
           ("set-style" "Change CSS style of the talk")
           ("set-default-style" "Reset CSS style to the default")
           ("set-print-style" "Set CSS style to a printable style")
           ("title" "Return to talk"))))



       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       (("set-style")
        (string-append
         {
          <form method=post action="talk.servlet">
            <input type=hidden name="page" value="store-style">
            <textarea rows=20 cols=80 name="the-style">[the-style]
            </text[]area>
            <input type=submit value="change style">
          </form>}))



       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       (("store-style")
        (.setAttribute ses "the-style" (.getParameter request "the-style"))
        {
          "New Style has been stored"
         <p><a href="talk.servlet?page=title">return to talk</a>
         <p><xmp>old style
               [the-style]</xmp>
         <p><xmp>new style
               [(.getParameter request "the-style")]</xmp>
         <p><hr><p>})




       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       (("set-default-style")
        (.setAttribute ses "the-style" default-style)
        {
          "Default Style has been stored"
         <p><a href="talk.servlet?page=title">return to talk</a>
         <p><xmp>new style
               [default-style]</xmp>
         <p><xmp>old style
               [the-style]</xmp>
         <p><hr><p>})
       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       (("set-print-style")
        (.setAttribute ses "the-style" print-style)
        {
          "Print Style has been set"
         <p><a href="talk.servlet?page=title">return to talk</a>
         <p><xmp>new style
               [print-style]</xmp>
         <p><xmp>old style
               [the-style]</xmp>
         <p><hr><p>})


       (else
        {
          <h1>Unknown page: "[page]"</h1>
       })
    )]
    <p><hr><p>
  <div align=right>
    [(small (link "title" "back to top"))]<br>
    [ (small (link "help" "set preferences"))]
  </div>
    <div align=left>[(small {
    LL2, Saturday 9 November 2002, Tim Hickey/Ken Anderson
    })]
    </div>
 </body>
 </html>
}

))