(define cc (make-parameter #f))

  (define (input name) `(input ((type "text") (name ,(format "~a" name)))))
  (define (submit) `(input ((type "submit"))))
  (define (form . body) `(form ((action ,(cc))) ,@body))
  (define (a ref . body) `(a ((href ,ref)) ,@body))
  (define-syntax page
    (syntax-rules ()
      [(page x ...) (send/suspend (lambda (k) (cc k) `(html (body ,x ...))))]))
  (define (get name req)
    (extract-binding/single name (request-bindings req)))

  (define (start initial-request)
    (define foo (get 'foo (page (form (input 'foo) (submit)))))
    (page (a (cc) "click here"))
    (page "you said: " foo))

What I mean is most of the other posts demo how to do it with some required (exotic) framework. This example is just using the basic web server APIs of the PLT continuation based web server.

In other words in this example, Eli BOTH writes the framework (in the first 9 lines), then uses the framework in the last 4 lines.

PLT's mzscheme is in effect, a very distant cousin to Scheme. If they weren't all eggheads and had at least one attentive marketing person, they would have labeled it some new fangled SuperLispIncarnateNextGeneration (SLING) moniker and received a bit of buzz.

I haven't looked at exactly how PG implemented Arc over MzScheme, but consider this. Much of what he did _could_ be done using no more then PLT mzscheme's out of the box, macro system, custom language module capability and custom reader capability, by anyone. Yes, even you.

In some sense most of Arc is just what anyone does who develops in PLTs Scheme/laguage system, i.e., create their own custom language/DSL. PG's may have done it a bit better, more extensively, with a general purpose intent.

So what is the secret weapon here Arc, or the underlying system that allows someone to create an Arc so easily?

You could, right now, be using PLT MzScheme to do your own Arc(s), your own, just for you and your friends custom language/DSL.

While Matthew and Robby are the "drivers" (with lots of co-pilots :-) I think that setting this tone early in the project has placed PLT Scheme naturally in a lonely niche: it is a real scripting language with capabilities that rival those of everything out there and it is also a serious academic infrastructure. Typed Scheme -- the first and only sound 'gradual typing' language so far -- is just an example of what I mean. We can publish about this in the flagship research conference on programming languages and at the same time, we are using it for its intended applications. Sam Tobin-Hochstadt is porting a part of DrScheme to Typed Scheme as I type. It is this kind of experiment -- porting a piece that your "life" depends on -- that puts us squarely on the applied side, too.

It's quite short and set out in a question and answers style. The thing is, it very gently and very subtlety bends your mind around to the Lisp way of thinking. After reading this, SICP seems so much more accessible.

1 - Paste the following code into a new document test.ss and save in servlet example folder (/usr/plt/collects/web-server/default-web-root/servlets/examples/test.ss) If document name test.ss changes, change the module name on first line.

(module test mzscheme (require (lib "servlet.ss" "web-server")) (provide (all-defined)) (define interface-version 'v1) (define timeout +inf.0)

  (define cc (make-parameter #f))

  (define (input name) `(input ((type "text") (name ,(format "~a" name)))))
  (define (submit) `(input ((type "submit"))))
  (define (form . body) `(form ((action ,(cc))) ,@body))
  (define (a ref . body) `(a ((href ,ref)) ,@body))
  (define-syntax page
    (syntax-rules ()
      [(page x ...) (send/suspend (lambda (k) (cc k) `(html (body ,x ...))))]))
  (define (get name req)
    (extract-binding/single name (request-bindings req)))

  (define (start initial-request)
    (define foo (get 'foo (page (form (input 'foo) (submit)))))
    (page (a (cc) "click here"))
    (page "you said: " foo))
  

2 - Start the PLT web server sudo /usr/plt/bin/plt-web-server

3 - Open a web browser and navigate to http://localhost/servlets/examples/test.ss

That said, I must disagree with Paul's recent blog entry/essay and this challenge...

Brevity or compactness as a measure of a language's "greatness" is a red herring. There are two acceptable methods by which source code can be compact: syntactic sugar and factoring/libs. I say "acceptable", because I don't consider putting everything on 1 line or using function names like "f" acceptable. And while syntactic sugar can be good at times, it can also lead to write-only code (see: APL, Perl (imo), and many others).

There's absolutely nothing special with PG's example code and the challenge isn't much of a challenge at all. Analogy: everyone has cars and I "invent" a jet, and then challenged everyone else to a race from Boston to LA. I've picked a challenge to show off what I consider to be my best trait: speed. Why didn't I challenge everyone to get from my home to the local grocery store? Given the terrain, perhaps a mountain bike would have been the best tool for that job.

How about this challenge for Arc:

On a little-endian machine, read in the Quicktime .MOV header atom format (big-endian), parse, and dump it to the console in a human readable format.

The reason I say there's nothing special with the example code is that we all know there's a lot of code going on under the hood behind it - a lot of code that PG has already written. And it's a cop-out to state at the end of the challenge... "Code to import standard libraries doesn't count..."

The code still had to be written. It isn't magical just because it comes standard. It shouldn't make a difference if it's included with the language or downloaded from the internet. The question isn't how much code was written, but rather, how much code did I have to write?

Again compactness is a red herring.

Perhaps Arc will be my language of choice for implementing <insert task>. It would be far more informative to me to be told (by PG) what problem(s) Arc is being design to solve and then show me how my life as a programmer would be easier - using Arc - to accomplish those tasks.

Again, I wish PG all the best with Arc, and I look forward to using it. But currently, I very much agree with Ron Garret when he said, "...[Arc] seems to pretty much punt on all the hard problems of language design."

You're right. That's why libraries are so popular. Laziness pushes us to excell.

  $('body').append('<input id = "myInput" /><input type = "submit" />')
    .find('input[@type=submit]').click(function() {
       val = $('#myInput').val();
       $('body').html('<a href = '#'>click here</a>').find('a').click(function() {
          $('body').html('You said: ' + val);
       });
    });

<input id="in" type="text" /><input type="submit" onclick="window.result='You said: '+document.getElementById('in').value; document.body.innerHTML='<a href=\'#\' onclick=\'document.body.innerHTML=window.result;\'>click here</a>'" value="Submit"/>

    class Root:
        def form(self):
          return render("form.html")
        
        def link(self, foo):
          cherrypy.session["foo"] = foo
          return render("link.html")
        
        def message(self):
          data = {"foo": cherrypy.session["foo"]}
          return render("message.html", data)

    (defun said ()
      (make-page "a" 
       (action-form (((:input :name "foo"))
                      (form-submit "s"))
        (make-page "b"
          (action-link "click here"
             (make-page "c"
                (html (:princ "you said: " (getf form-data :foo))))))))

    (setf (gethash "said" *views*)
          (view-definition (action-form ...

    <?php
    require_once('liball.php');
    
    if ($foo = $_POST['foo']) {
      $_SESSION['foo'] = $foo;
      localredirect('b.html');
    }
    sendpage('a');
    ?>

Assuming page c needs to be protected against people just coming to it:

    <?php
    require_once('liball.php');
    if (!($foo = $_SESSION['foo'])) {
      localredirect('a.php');
    }
    sset('foo', $foo);
      
    
    sendpage('c');
    ?>

    you said: {$foo}

    <?php
    // unvarying HTML elided above
    if ($foo = $_POST['foo']) {
      $_SESSION['foo'] = $foo;
      print '<a href="">click here</a>';
    } else if ($foo = $_SESSION['foo']) {
      print 'you said: ' . $foo;
    } else {
      print "<form method='post'><input type='text' name='foo'><input type='submit'></form>";
    }
    ?>

    <?php
      $step = isset ($_POST['step']) ? $_POST['step'] : 0;
      if ($step == 0)
        $_POST = array();

      $_POST['step'] = ($step + 1) % 3;
      echo '<form method="post">';
      foreach ($_POST as $k => $v)
        echo '<input type="hidden" name="' . htmlspecialchars ($k) . '"
            value="' . htmlspecialchars (stripslashes ($v)) . '" />';
    
      echo '<p>';
      switch ($step)
        {
        case 0:
          echo '<input type="text" name="simon-sez">';
          break;
        case 1:
          echo 'Simon sez...';
          break;
        case 2:
          echo htmlspecialchars (stripslashes ($_POST['simon-sez']));
          break;
        }
      echo '</p>';
      echo '<input type="submit" value="Go on" />';
      echo '</form>';
    ?>

Writing short programs is nice, but looking at the above example, I can't make heads or tails out of it, or how it works. "Unfamiliarity with Arc's library!" you cry. Yes. Yes it is. But, I'm just as unfamiliar with other frameworks demonstrated in the comments, and I can follow those just fine (well, except the Perl and Ruby ones). The Python examples are _stellar_ in their comprehensibility, with ANSI CL coming in at a close 2nd place, and Smalltalk following in at a luke-warm 3rd place; there is sufficient redundancy in the code that, while being short and sweet, it still gave enough context to know and understand how the pieces fit together.

Not so with Arc. It's TOO terse. This is the same problem that you see with otherwise stellar languages like J/APL, Perl-golf, and older Linux and BSD source code files. Yes, your productivity sky-rockets when you write the code. Alas, your productivity sinks like a rock while trying to maintain it, unless you've been at it for at least 3 years.

Your understanding problem can probably be traced to two things: the implicit separation of the code into different pages (you haven't used the library yet, so you don't know what visual cues to look for), and the backwards order of the pages from the structure of the aform and w/link macros. Both problems can be solved by using Arc's library for an hour or two: you'll either get used to Arc's library or you'll find a way of handling common cases that's more to your taste.

  class HomeController < ApplicationController
    def first
      if request.get?
        aform 'first', [input('foo'), submit]
      else
        session[:foo] = params[:foo]
        wlink 'third', 'click here'
      end
    end

    def third
      pr "you said: #{session[:foo]}"
    end
  end

  class HomeController < ApplicationController
    def first
      if request.get?
        aform 'first', [input('foo'), submit]
      else
        if params[:foo] && params[:foo] =~ /[A-Za-z0-9]/ 
          session[:foo] = params[:foo]
          wlink 'third', 'click here'
        else
          aform 'first', ["Please enter an alphanumeric string", input('foo'), submit]
        end
      end
    end

    def third
      pr "you said: #{session[:foo]}"
    end
  end

aform, input, pr, submit, wlink

This might seem like a minor thing, but it ends up being pretty important in practice. E.g. most airline fare comparison sites don't allow you to do multiple searches in parallel; most checkout processes get very unhappy if you use the back button. The basic browsing metaphor -- of a page's state being contained within that page -- is broken by cookies, and it shows even in these toy examples.

(Sometimes breaking that metaphor is ok -- e.g. for persistent logins.)

With the closure-based approach, you don't have to worry about tabs, or the back button, or any other issues caused by badly leaking abstractions.

Second, improving back button behavior is a matter of setting all the right nocache attributes. If you use forms, you're likely to have trouble with back navigation no matter what you do ("The page contains expired POST data").

Finally, I don't see how closures have any impact on the user experience one way or another, since it's just a different way of storing server-side state. The server can be implemented with closures, in-memory state, state backed by a database, or trained pigeons and it shouldn't make any difference to the user. (Modulo performance, reliability, etc of course.)

In theory, that's absolutely true; of course there's no technical reason that one can't use cookies and still keep the desirable properties of the Arc example (outlined in the grandparent).

But that's really the point: even though both styles make either model _possible_, they still encourage radically different approaches -- and this is of course borne out by the stuff people have submitted.

Secondly, on the perceived cookies/closures dichotomy, you reduce things to a question of where one should store the session ID, and that's a totally orthogonal issue.

We basically have three models -- sessions with IDs in cookies, sessions with IDs in URLs, and closures. Cookies give you a single, linear progression of state; session-IDs-in-URLs give you multiple linear progressions; and closures give you a nonlinear tree of progressions.

What do I mean here?

Sessions with IDs in cookies are simple: they're a single global state. Session IDs in the URL are a small bit closer to the closure-based approach, but they really just mean that the flow of state proceeds linearly in several independent threads. It's still a long way from matching the browser metaphor of "a page's state being contained within that page".

With session IDs in the URL, you can't get identical semantics to the closure-based approach unless you do make your sessions immutable, and create a new clone at each juncture. And if you do adopt this "session frame" approach (should that be "stack frame" approach?) you've basically created succumbed to some form of Greenspun's Tenth Rule.

Does this really matter? When state is contained within the page -- that is to say, when the closure-based approach is used -- it makes for much more flexible browsing. To take a tangible example, say you're searching for an airfare. You first search for tickets from SFO to BOS, then on the next page pick dates, and then on the third you (holding down alt) open a new tab investigating the price when you book first-class, while you proceed with economy in your main tab. You go through a few more pages, and you're now at the checkout in both. But you realise that you really need to go a day earlier, and that first-class is too expensive, so you close that tab, and hit back 'till your at the date selection page, and then head back to the checkout.

And it all just works. We humans are inquisitive creatures, and the tree of closures facilitates our natural instinct to poke and then retreat when things don't look right. Desktop app designers have long known this (even the first Macintosh had undo), and though generally far less information-dense, almost any modern desktop app supports virtually-infinite undo. Session-based approaches on the web choke this.

If the airline example sounds a bit contrived, it's because it is -- but at the same time, it's also a lot less chaotic than many people's flows when going through this an airline booking process (I know that for a fact because I spent a while investigating it once...).

The biggest difference between my example and real life is that, in mine, things _work_, whereas in real life, opening the new tab or using the back button would almost certainly completely screw the web-app up.

As heavy internet users, we've grown to accept this crap, because 1) we're used to it and 2) we know it's hard to get right. But it's not inevitable. Browsers can still be made to work as advertised.

Strangely enough PG specifically disallow this approach in his competition!

Most web apps need _both_ global session state and URL-based state. As others have pointed out, if you browse a product catalog, you would like to be able to branch into different browser windows or use the back-button. However, when you add an item to the shopping basket, you want it to be a global state change (you want have the same shopping basket in all windows), and you don't want a buy to be undone by clicking back.

Continuations are only an options for handling URL-based state, not for handling global state. And for page state they have some limitations.

For example, if all navigation is handled by continuations, you basically have to store a continuation for every hit indefinitely, since you dont know if the user have bookmarked the URL. If you don't want to store the continuations forever, you should only use them on pages that are not bookmarkable anyway, i.e. pages that are the response to form posts. But then the stated advantages, like the ability to branch and use the back button is moot, since you cannot do that anyway with form responses.

  Second, improving back button behavior is a matter of 
  setting all the right nocache attributes. If you use forms, 
  you're likely to have trouble with back navigation no matter 
  what you do ("The page contains expired POST data").

  #!/usr/bin/env ruby
  require "ramaze"
  class MainController < Ramaze::Controller
    def index
      if f = session['foo'] then "you said #{f}"
      elsif session['foo'] = request['foo'] then A("click Here", :href => '/')
      else '<form><input name="foo" /><input type="submit"></form>'
      end
    end
  end
  Ramaze.start :port => 7001
  __END__
  

My sentiments exactly. This is a demonstration of a library, which handles a certain scenario very well. I'm sure, an equally terse library could be written in most other languages.

  case r.qs
  when '': isindex
  when /^@/: r.qs.tail
  else a'follow',:href =>'?@'+r.qs
  end

  def said
    if request.method == :post
      session[:said] = params[:said]
      render :action => "clickhere"
    else
      render :action => "result" if session[:said]
    end
  end

  default template said.rhtml:
  <% form_tag do %><%= text_field_tag "said", "" %><%= submit_tag %><% end %>

  clickhere.rhtml:
  <%= link_to "click here", "" %>
  
  result.rhtml:
  You said <%= session[:said] %>

here's a ruby version a bit closer to the original. there's a bunch of support and then process roughly corresponds to said above

  #!/usr/bin/env ruby
  require 'rubygems'
  require 'mongrel'

  class FooHandler < Mongrel::HttpHandler
  
    def initialize
      @fnids = {}
      @c = 0
    end
  
    def new_fnid(proc)
      @c += 1
      @fnids[@c] = proc
      @c
    end
  
    def query_params(request)
      request.class.query_parse(request.params['QUERY_STRING'])
    end
  
    def pr(response, html)    
      response.start do |head,out|
        head["Content-Type"] = "text/html"
        out << html
      end
    end
  
    def w_link(response, link_text, &block)
      c = new_fnid(block)
      pr(response, "<a href='?fnid=#{c}'>#{link_text}</a>")
    end
  
    def aform(response, form_html, &block)
      c = new_fnid(block)
      pr(response, "<form><input type='hidden' name='fnid' value='#{c}'>#{form_html}</form>")
    end
  
    def process(request, response)
      if (fnid = query_params(request)['fnid'])
        @fnids[fnid.to_i].call(request, response)
      else
        aform(response, "<input name='foo'><input type='submit'>") do |req1, resp1|
          w_link(resp1, "click here") do |req2, resp2|
            pr(resp2, "you said: " + query_params(req1)['foo'])
          end
        end
      end
    end
  end

  Mongrel::Configurator.new :port => 8080 do
    listener {uri "/", :handler => FooHandler.new}
    trap("INT") {stop}
    run
  end.join

  #!/usr/bin/perl
  use Continuity;
  Continuity->new->loop; # This starts the webserver
  sub main {
    my $request = shift;
    $request->print("<form><input type=text name=foo><input type=submit>");
    my $foo = $request->next->param('foo');
    $request->print("<a href='.'>Click Here</a>");
    $request->next->print("You said: $foo");
  }

  package ArcChallenge;
  use strict;
  use Catalyst;
  use Catalyst::Action::REST;
  
  my @said;
  
  sub index : Action ActionClass('REST') {}
  
  sub index_GET {
      my ($self, $c) = @_;
      $c->res->body( "<form method=post><input name=said><input type=submit>" );
  }
  
  sub index_POST {
      my ($self, $c) = @_;
      my $n = push @said, $c->req->params->{said};
      $c->res->body( "<a href='/said/$n'>Click Here</a>" );
  }
  
  sub said : Regex('^said/(\d+)$') {
      my ($self, $c) = @_;
      $c->res->body( $said[ $c->req->captures->[0] - 1 ] );
  }
  
  __PACKAGE__->setup;
  
  1;

  package CatArc;
  
  use strict;
  use warnings;
  
  use Catalyst qw/Session Session::Store::FastMmap Session::State::Cookie/;

  our $VERSION = '3.14159265359';
  
  __PACKAGE__->setup;
  
  sub index : Index { } # No need to do anything
  
  sub landing : Local {
    my ( $self, $c ) = @_;
    $c->flash->{said} = $c->req->params->{said};
  }
  
  sub display : Local { } # Do nothing
  
  sub end : ActionClass('RenderView') { } # Do a magical nothing.
  
  1;

    <!DOCTYPE HTML>
    <html>
        <head>
            <title></title>
            <style type="text/css">
            #page2{display:none}
            #page2:target{height:100%;width:100%;position:absolute;top:0;left:0;background-color:#ffffff;z-index:2;display:block}
            #page13:target input[type="submit"]{display:none}
            #page13 p{display:none}
            #page13:target p{display:inline}
            #page13:target input{display:inline-block;border:0px}
            </style>
        </head>
        <body>
            <div id="page13" class="page">
                <form action="" method="post">
                <p>You said:</p>
                <input type="text">
                <div style="position:relative">
                    <input type="submit">
                    <a href="#page2" style="position:absolute;top:0;left:0;height:100%;width:100%"></a>
                </div>
                </form>
            </div>
            <div id="page2" class="page">
                <a href="#page13">click here</a>
            </div>
        </body>
    </html>

1) No programming languages used, only markup/presentation languages (0 lines of code?).

2) Entirely client side behavior.

3) Works simultaneously across multiple page instances in tabbed browsing as several folks have pointed out that this could be a problem with some of the session managed solutions here.

So then, to sum it all up, I'd have to say that this "program" to meet pg's requirements requires no server-side code (and thus a server-side parse tree of size 0) since it's just being served up as a static page. If you want to count the DOM parse tree length of my HTML/CSS, then you must also count that generated by every other submission here, which essentially adds some constant factor to all the metrics in this forum and thus becomes essentially a non-useful piece of information in comparing the entries.

pg claimed that you don't need to include your template libraries or other magical exotic web framework code. You can just assume it's there, so most folks aren't showing their HTML, and of course, it wouldn't make sense to count it towards their program's parse trees on a tag-by-tag basis since it's likely just a bunch of strings in most of their systems. But hey, like I said, in the end they're all making webpages, and if that's the case then I still think I've got a bit of a headstart on a lot of folks.

Then again, maybe not. What do you folks think? Am I just a big fat cheater or what? prepares to dodge ballistic tomatoes

  ~Keep on hackin' in the Free world.

In most examples, HTML runs on client machines which may be roughly comparable to your example, but who cares, because the code (whether measured in lines or nodes) the author had to write to generate that HTML was presumably superior in some way compared to writing HTML manually. (Otherwise why not just code straight HTML, all the time?)

In your example, even though the server side code consisted of 0 lines/nodes, the code written by you consisted on an entire HTML page. So did you really save any time or effort in writing the HTML? Maybe, that's why we compare the code trees. But even in that case, the HTML itself will count toward the code tree.

Perhaps this means that HTML templates (not HTML generated by server-side scripts) used in other entries should also be included in their code tree count, if they had to be coded manually by the author. But even if this is the case, it doesn't just add a constant factor to all entries (I believe the arc entry did not require any HTML to be written by the author), and thus is still useful information, although perhaps the two should be considered separately.

The thing that strikes me as being kind of a funny metric here with code length is that if the author wrote the HTML and imported it into their code, you have to count it, but if some other author wrote the HTML and you import it, then you don't have to count it. Seems kind of weird to me, seeing as this opens the door to somebody else saying:

Alright, maybe gjohnson's code count includes all that silly HTML and CSS, but my program uses his HTML template file (which isn't much of a template in this case, of course, being kind of the whole shebang), and has a parse tree of length 1.

Here it is:

  <!--#include virtual="gjohnsons_magic.html" -->

Anyway, keep going everyone. Those submissions are rockin' on. I've got my mind wrapped around a pretty perversely heinous challenge response that I may get to in the next couple of days. Keep your eyes peeled!

    from pyricks import *
    class Said(PyricksApp):
        def initSession(self, root, data):
            def onsub(foo):
                def yousaid():
                    Yield("you said: " + foo)
                Yield(Link("click here", yousaid))
            Yield(Form(Input("foo"), onsubmit=onsub))

  | foo |
  foo
    ifNil: [html form: [html textInput callback: [:t | foo := t]]]
    ifNotNil: [html anchor callback: [self inform: 'You said ', foo]; with: 'click here']

    renderContentOn: html
        said 
            ifNil: 
                [html form: [html textInput callback: [:v | said := v]. 
                html submitButton]]
            ifNotNil:
                [clicked 
                    ifNil: [html anchor callback: [clicked := true]; with: 'click here']
                    ifNotNil: [html text: 'You said: ', said]].

I agree that mine isn't precisely by the spec -- you have to press 'enter' to submit the form, and there's an ok button on the last page -- but these are fairly trivial differences in presentation due to the behaviour of the built-in libraries.

  function said_action() {
    Html.form({
        callback: function() {
            var foo = req.data.foo;
            Html.link({
              callback: function() { res.write("you said: " + foo); }
            }, "click here")
        }, method: "post"},
      Html.Input({name: "foo"}), 
      Html.Submit()
    );
  }

  function said_action() {
    var foo;
    var step1 = function() {
        foo = req.data.foo;
        Html.link({ callback: step2 }, "click here");
    };
    var step2 = function() {
       res.write("you said: " + foo);
    };
    Html.form({callback: step1, method: "post"},
      Html.Input({name: "foo"}), 
      Html.Submit()
    );
  }

    class HelloController(BaseController):
        def hello_pylons(self):
            if session.get('foo'):
                c.content = 'you said ' + session['foo']                    
            elif request.POST.get('foo'):
                session['foo'] = request.POST['foo']
                session.save()
                c.content = h.link_to('click here')            
            else:
                c.content = h.form('') + h.text_field('foo') + h.submit() + h.end_form()
            return render('template.mako')

  <html><body><script type="text/javascript">
  (function (){
    d = document; b = d.body
    function nu(n,t){
      var e = d.createElement(n)
      if(t.h) e.innerHTML = t.h
      for(var k in t) e[k] = t[k]
      return e
    }
    function ad(o){ b.innerHTML = ''; for(var i=0, o; o=arguments[i]; i++) b.appendChild(o) }
    ad(
      nu('input', {id: 'foo'}),
      nu('button', {h: 'go', onclick: function(){
        f = d.getElementById('foo').value
        ad(
          nu('a', {h: 'click here', onclick: function(){
            ad( nu('p', {h: 'you said ' + f}) )
        }}))
    }}))
  })()
  </script></body></html>

  def said
    aform(input("foo"), submit) {
      w_link("click here") {
        "you said: #{arg :foo}"}}
  end

Display the form to collect answer1 (still named foo), on submit display the form again to collect answer2 (also named foo), then the "click here" page, then a page with "you said: [answer2]" and a "click here" link, then a page with "you said: [answer1]".

How do you do that in Arc? In this Ruby example, it would be:

  def said
    aform(input("foo"), submit) {
      aform(input("foo"), submit) {
        msg = "you said: #{arg :foo}"
        w_link("click here") {
          "you said: #{arg :foo}<br />" + w_link("click here") {
          msg}}}}
  end

I'm more of a designer than a developer, and when looking at the Arc example I have to ask how this matters in a real world example. How much extra code would it be to add classes on the links or form elements so they could be appropriately styled with CSS? The Arc code is short because it drops in HTML and nothing else, but that's not useful at all when actually creating and producing web applications.

  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head><meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
  <title>Contrived example</title></head><body><div>
  <% if (null == session.getAttribute("page")) {
        session.setAttribute("page", "1"); %>
        <form action="said.jsp" method="post">
        <div><label>Enter something <input type="text" name="foo"/>
        <input type="submit"/></label></div></form>
  <% } else if ("1".equals(session.getAttribute("page"))) {
        session.setAttribute("page", "2");
        session.setAttribute("value", request.getParameter("foo")); %>
        <a href="said.jsp">click here</a>
  <% } else if ("2".equals(session.getAttribute("page"))) {
        session.setAttribute("page", null); %>
        you said: <%= org.apache.commons.lang.StringEscapeUtils.escapeHtml((String)session.getAttribute("value")) %>
  <% } %>
  </div></body></html>

  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head><meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
  <title>Contrived example</title></head><body><div>
  <?rb if not @w.session['page']
        @w.session['page'] = '1' ?>
        <form action="jsp_said" method="post">
        <div><label>Enter something <input type="text" name="foo"/>
        <input type="submit"/></label></div></form>
  <?rb elsif @w.session['page'] == '1'
        @w.session['page'] = '2'
        @w.session['value'] = @w.f('foo') ?>
        <a href="jsp_said">click here</a>
  <?rb elsif @w.session['page'] == '2'
        @w.session["page"] = nil ?>
        you said: ${@w.session['value']}
  <?rb end ?>
  </div></body></html>

    serveAs "said" $ hasIndex $ \x -> "click me" `linksTo` (text ("You said " ++ x))

------

said = standardQuery "What's your name?" (p_T (do { text_S "Hi there! What's your name?" ; activate greeting textInputField empty }))

greeting :: String -> CGI ()

greeting name = standardQuery "Hello" (do { text_S "Hello " ; text name ; text_S ". This is my first interactive CGI program!" })

------

where said <==> helo5, code at http://www.informatik.uni-freiburg.de/~thiemann/WASH/Tutoria...

Try it, live (chose Hellow World Personalized):

The last part looks pretty lispy.

The idea is that `hasIndex f` creates a page that prompts for a string, then (after the page is submitted) calls the function f with the input string as parameter and shows the resulting page.

But I like Haskell. :-) Interesting, how long will be explicit declaration of form.

1) Some simple validation on the input field. Ensure something was entered, and ensure it conforms to some pattern. Notify the user of invalid input and request it to be reentered instead of going to the second page.

2) Some facility for placement/presentation. If you're depending totally on CSS for presentation, that's fine, but at least give the poor designer some ids/names to work with.

3) Produce valid html that passes:

http://validator.w3.org/check

    (defcomponent page (info-message)
      ()
      (:render ((self page))
        (if (message self)
           (<:as-html "you said: " (message self))
           (<lol:form :action (call 'info-message :message "Click Ok")
             (<lol:input :accessor (message self))
             (<:submit)))))

    (defcomponent page (info-message)
      ()
      (:render ((self page))
       (<lol:form 
           :action 
             (progn (call 'message :message "click here")
                (call 'message :message (format nil "you said:~A"  
                                                         (message self))))
              (<lol:input :accessor (message self))
              (<:submit)))))

UCW is component based by default, so quite verbose for a small program like this indeed. It's not hello-world optimized. Having said that, there are a number of things we could do to optimize things for this particular example. It's all lisp right?

     ;;;;    Still using components.
     ;;;;    This, while it meets the spec, is semantically quite 
     ;;;;    differrent than the arc version, IIUC.
       (defvar *is-link* nil)
       (defun/cc pr (message args &optional (linkp *is-link*))
         (apply 'call-component *component* 'message 
                    :message (apply 'format nil message args)
                    :linkp *is-link*))
       (defmacro w/lnk (&body body)
         `(let ((*is-link* t)) ,@body))
       (defmacro aform (action &body body)
         `(<lol:form :action ,action ,@body))
       (define-symbol-macro _ (message *component*))
       (defcomponent message (info-message) ()
         ((is-link? :accessor link-p :initarg :linkp))
         (:render :around ((m message))
            (if (linkp m)
                 (<lol:a :action (answer m) (call-next-method))
                 (call-next-method))))
 
       ;;;; finally:
       (defcomponent said (message) ()
        (:render ((said said))
          (aform (progn (w/lnk (pr "click here")) (pr "you said ~A" _))
            (<lol:input :accessor _)
            (<:submit))))

As luck would have it, UCW is really quite flexible. In arc, we're just using call/cc directly, without the component architecture present in other continuation based frameworks (seaside, ucw. weblocks). It is trivial to remove the component stack and just render the continuations directly.

    ;;;; * LoL arc 
    ;;;;    This is a minimal 'arc-like' framework build on UCW.
    (defclass arc-action (basic-action) 
       ((renderer :initarg :body)) 
        (:metaclass action-class))
    (defmethod render ((action arc-action)) 
       (funcall (slot-value action renderer))
    (defmethod call-render ((action basic-action)) a s f)
       (handle-raw-request  (:with-network-output *standard-output*)
         (render action)))
    (defmacro defop (name &body renderer)
       `(progn 
            (defclass ,name (arc-action) () 
              (:metaclass action-class)
              (:default-initargs :body (lambda () ,renderer)))))
    (defun arg (name)
      (get-parameter (context.request *context*) name))
    (defmacro w/lnk (action &rest txt)
      `(<lol:a :action ,action :action-class arc-action (<:as-html txt))
    (defmacro aform (action &body body)
    `(<lol:form :action ,action :action-class arc-action ,@body))
    (defun input (name &optional value)
     (<:input :name name :value value))
    (defun submit () (<:submit))
    (defun pr (&rest strings)
     (print (apply 'concatenate 'string 'strings))

    ;;;; * Finally, we can re-create the arc example in CL
    ;;;;   using UCW/LoL. I'm not sure what 'req and '_ are 
    ;;;;   are for in the original, so i've omitted them.

    (defop said 
      (aform (w/lnk (pr "you said: " (arg "foo"))
                    (pr "click here"))
        (input "foo")
        (submit))

EDIT: oops .. figured out what the '_ is doing and it's absolutely needed. In Arc we are using a closure to capture the state of the world. In CL, special variables and the lack of [] make that a little more difficult/verbose. Rather than re-write my AFORM and either make a [] reader macro or code-walk AFORM, i'll just cheat a little and use an object to store params.

Objects and Closures .. same thing right?

    ;;;;We need to add a slot to the 'op' in order to hold the 
    ;;;; parameters, and make sure '_ is bound to the op.

    (defvar _)
    (defclass arc-op (arc-action)
      ((args :accessor args :initform (make-hash-table :test #'equal))
    (defmethod render :around ((op arc-op))
      (let ((_ op)) (call-next-method)))

    ;;;; Make sure the 'arg' machinery works with this new slot 
    ;;;; rather than the get/post params, which was the whole point.

    (defun arg (op name)
      (gethash name (args op) (error "No arg ~A found in ~A" name op)))
    (defun input (name &optional (val ""))
     (<:input :type "text" 
                   :name (register-callback
                               (lambda (new-val)
                                 (setf (gethash name (args _)) new-val)))
                   :val val))

    ;;;; And this time our example will really work!
    ;;;; Having though about it for a while, 'req is
    ;;;; Most likely the current request. 
    ;;;; In CL we just bind a special, *context*.
    ;;;; Arc lacks special variables AFAIK, so you need 
    ;;;; 'req.  Sombody please correct me if i'm wrong.

    (defop said 
      (aform (w/lnk (pr "you said: " (arg _ "foo"))
                    (pr "click here"))
        (input "foo")
        (submit))

i'm using UCW for more-or-less usual applications, and find it's not optimal for them either -- it's too hard to figure out how to do stuff, it's bloated, buggy and fragile.

maybe it's "optimal" for some other sort of applications, but i'm yet to see them.

But, if you think CLOS is evil and there is something arcane about the precendence rules, you're a lost cause anyway. "object slots acting like global variables instead of function parameters" ... what does that even mean? :P

My last example uses absolutely no CLOS explicitly once the core language is defined, and is identical in almost every way to the arc version. It is through the miracle of CLOS and the MOP that i can so easily change the functionality of something like UCW, in about 5 minutes, to create a PLT-style webserver.

You may find CLOS confusing, but when writing massive lisp applications with constantly changing requirements on teams of 50+ programmers, i've found having an object system that is malliable enough to take the application anywhere, yet that is based on a few simple principles that anybody who has read the MOP understands, is something i would not trade for anything.

Our experiences obviously differ significantly. I never had any major difficulties figuring out UCW and CLOS... have you read Keene, AMOP or any other books that cover OO design in lisp? Maybe they'll help you 'figure out how to do stuff'. AMOP changed the way i view software design... i really recommend it.

said(_Req) -> form(fun(Data) -> link(["you said: ", arg(Data, "foo")], "click here") end, input("foo"), submit()).

The main different is that Erlang doesn't have syntactic sugar for a single-variable lambda function. However, the total number of tokens is almost the same.

Also, the last two parameters should be in a list, i.e.

   handle(_, [{said, Value}|_]) ->
        {Value, {ehtml, {a, [{href, self}], "click me"}}};
   handle(S, [_|R]) ->
        handle(S, R);
   handle([], []) ->
        {[], {ehtml, {form, [{action, self}],
                            [{input, [{type, "text"},
                                      {name, "said"}, {size, 50}], []},
                             {input, [{type, "submit"}]}]}}};
   handle(S, []) ->
        {S, {ehtml, {p, [], io_lib:format("you said: ~s", [S])}}}.

  <%@ Page Language="C#" ClassName="WebApplication1._Default" %>

  <script runat="server">

    // C# and ASP.NET
    protected void SubmitButton_Click(object sender, EventArgs e)
    {
        MultiView1.ActiveViewIndex = 1;
    }

    protected void ClickHereButton_Click(object sender, EventArgs e)
    {
        SaidLabel.Text = string.Concat("You said: ", SayTextBox.Text);
        MultiView1.ActiveViewIndex = 2;
    }

  </script>

  <html>
  <head runat="server">
    <title></title>
  </head>
  <body>
    <form id="form1" runat="server">
      <asp:MultiView ID="MultiView1" runat="server" ActiveViewIndex="0">
        <asp:View runat="server">
          <asp:TextBox ID="SayTextBox" runat="server" />
          <asp:Button ID="SubmitButton" runat="server" Text="Submit" OnClick="SubmitButton_Click" />
        </asp:View>
        <asp:View runat="server">
          <asp:LinkButton ID="ClickHereButton" runat="server" Text="Click Here" OnClick="ClickHereButton_Click" />
        </asp:View>
        <asp:View runat="server">
          <asp:Label ID="SaidLabel" runat="server" />
        </asp:View>
      </asp:MultiView>
    </form>
  </body>
  </html>

    <%@ Page Language="C#" %>
    <html>
    <head>
    <title>Said</title>
    </head>
    <body>
        <form id="form" runat="server">
            <% if (!IsPostBack) { %>
                <input name="foo" />
                <input type="submit" />
            <% } else if (Request.Form["foo"] != null) {
                Session["foo"] = Request.Form["foo"]; %>
                <a href="javascript:form.submit()">click here</a>
            <% } else { %>
                you said: <%=Session["foo"]%>
            <% } %>
        </form>
     </body>
    </html>

Step 2: figure out how to get the right version. Not hard, but a step.

Step 3: get the right architecture. Also not hard.

Step 4: run $RIGHT_PATH/bin/mzscheme -m -f as.scm

Step 5: figure out how to run "webapp.arc".

Step 5a: First attempt: "mzscheme -m -f as.scm webapp.arc" doesn't work.

Step 5b: Read documentation (what, I'm supposed to read it first?) and see pointer to "blog.arc"

Step 5c: Read header at top of blog.arc which says to run '(load "blog.arc")' followed by '(bsv)'. Okay, I can do '(load "webapp.arc")'

Step 5d: Figure out that '(bsv)' is the function name to start the server, and is specific to that blog code. I need to '(asv)' instead. w00t!

Step 5e: Go to localhost:8080 and find "it's alive". Figured out that I need to go to "localhost:8080/said" to get the web interface.

Step 6: Go to newly started server. Input my home town (contains a diacritic). Oops! The diacritic disappeared. The english spelling of the city's name is not the same as the real name minus the diacritic! Try it out yourself with "Espana" - including the tilde over the n (which you won't see here because this server stripped it away). The english name for spain is not "espana".

(Step 7: Mutter when repeated ^C don't kill the program; did a ^Z; kill %% rather than the (tl) (quit) needed to exit more gracefully.)

I tried various other special characters: the symbol for British pounds (GBP) gets turned into "GBP", the Japanese yen symbol (JPY) gets turned into "JPY". A grep finds this conversion done in "latin1-hack", which is indeed a hack.

Yet upper case sigma (&#8721;) comes back without a problem, as does the traditional Chinese for China (&#20013;&#22283;). These are encoded through '&' escapes. So why do the Latin-1 hack at all?

Hmm, and the server doesn't specify a charset ... and it doesn't escape embedded text, so if I write "<b>this is not bold</b>" the HTML tags get interpreted.

In summary, the specification says that the final page displays "whatever [was] put in the input field". Yet the given solution does not display "A <GBP>" (that's "A-with-a-circle less-than-sign British-pound-sign greater-than-sign") correctly. The output is "A<GBP>" and the unknown HTML tag is not displayed, so I only see "A".

So far I've only seen a couple of people mention the lack of proper Unicode support and the huge XSS hole, and these were people who implemented the complete problem using some other language.

For further information see:

http://arclanguage.org/item?id=391

http://paulgraham.com/arc0.html

Try writing "The first conquistador in what is now the US was Juan Ponce de Leon and the last was Don Juan de Onate Salazar." There's an o-with-acute-accent in Leon, and there's an n-with-tilde in Onate).

Try writing "Noroveirusyking a HliX", which is a headline from today's MorgunblaXiX (a newspaper in Iceland).

Try writing "Don't use the <blink> element!"

Or try writing some of the other problems I pointed out earlier. (A parent to this comment.)

  * They do not work. *

At the very least, raise an exception for out-of-range characters. The current code hacks some Latin-1 characters to ASCII, others to "X", and encodes characters >= 256 to &# escape codes. This is wrong.

The other is that it doesn't escape '<' and '>' correctly so embedded HTML-like text gets improperly interpreted as HTML. One of the advantages of some of the templating systems is the default mode is to escape everything, making it harder to do XSS and other attacks. Fixing that might make the code longer, or not, depending on the solution.

  tt = [
      '<form method="POST"><input name="t" /><input type="submit" name="OK"></form>',
      '<a href="said?show=1">click here.</a>', 
      "you said: #{@w.session['t']}"
      ]
  ti = 0    
  if @w.f(:OK)
    @w.session['t'] = @w.f(:t) 
    ti = 1
  elsif @w.q(:show)
    @w.session['do_show'] = true
    @w.redirect 'said'
  elsif @w.session['do_show']
    @w.session['do_show'] = nil
    ti = 2
  end
  @w.content = tt[ti]

I wanted to keep it all in one URL and without template for this though. I'm not sure I'd normally program it like that, as I enjoy multiple pages and URLs. Anyway, many ways to skin a cat, and Arc did good.

    @expose('/arctest')
    def said(request):
        if "msg" in request.cookies:
            resp = BaseResponse('<html><body><h1>You said:</h1><p>%s</p></body></html>' % request.cookies['msg'], mimetype='text/html')
        elif request.method == 'POST':
            resp = BaseResponse('<html><body>Click <a href="/arctest">here</a>.</body></html>', mimetype='text/html')
            resp.set_cookie("msg", value=request.form.get("msg"))
        else:
            resp = BaseResponse('<html><body><form action="/arctest" method="post"><input type="text" name="msg" /></form></body></html>', mimetype='text/html')
        return resp

  class ArcChallenge < Pan::Task                                                               
    def go                                                                                     
      msg = call Input.new                                                                     
      call ClickHere.new                                                                       
      call YouSaid.new(msg)                                                                    
    end                                                                                        
  end

  class Input < Pan::Component                                                                 
    def render_on(html)                                                                        
      html.form {                                                                              
        html.input                                                                             
        html.submit {|val| answer(val)}                                                        
      }                                                                                        
    end                                                                                        
  end

  class ClickHere < Pan::Component                                                             
    def render_on(html)                                                                        
      html.link("Click here") { answer }                                                       
    end                                                                                        
  end

  class YouSaid < Pan::Component                                                               
    def initialize(msg)                                                                        
      @msg = msg                                                                               
    end                                                                                        
    def render_on(html)                                                                        
      html.lit("you said: #{@msg}")                                                            
    end                                                                                        
  end

    var what_the_user_types = new PageVariable();
    PageSequence
        .define_page_sequence("said")
        .with_an.input_field(what_the_user_types).and_a.submit_button
        .Then_a_page.with_a.link.saying("click here").to("")
        .Then_a_page.with_a.paragraph("you said: ", what_the_user_types);
        

    var what_the_user_types = new PageVariable();
    PageSequence
        .define_page_sequence("said")
        .input_field(what_the_user_types).submit_button
        .Then_a_page.link.saying("click here").to("")
        .Then_a_page.paragraph("you said: ", what_the_user_types);

  arc = do name <- getInput
           link "click here"
           display $ "You said: " ++ name

  add = do x <- getInput
           y <- getInput
           display $ "The product is " ++ show (x * y)

The ABCL implementation isn't bad either...who'd've thought make-page would make a page? I would've thought

get p/rfd_<asdf>::x[] set - insert 10 more lines of random characters -

Here's a solution using the lovely simple web api Sinatra (http://sinatra.rubyforge.org/). How many tokens is this? I didn't use any form helpers, but I'm assuming string literals count as one token.

  require 'rubygems'
  require 'sinatra'

  get '/' do
    '<form action="success" method="POST"><input name="message"><input type="submit"></form>'
  end 

  post '/success' do
    session[:message] = params[:message]
    '<a href="show"> click here </a>'
  end

  get '/show' do
    "You Said: #{session[:message]}"
  end

  var body = req.isPost() ?
    ((session.message = req.postParams.say), <a href={req.path}>click here</a>) :
    (res.message ?
      <p>{"you said: "+res.message}</p> :
      <form method="post"><input name="say"/><input type="submit" /></form>);
  res.write(<html><body>{body}</body></html>);

    ;; Should be available at <http://poseur.com:8080/said>.
    ;;
    ;; Full source at <http://poseur.com/magic3/magic3.scm>.
    
    (define-handler (said)
      (send-xml!
       (form (message)
             '(((input type text name message))
               ((input type submit value "Go")))
             (send-xml!
              (link "click here" (send-xml! `(p you said: ,message)))))))
    
    ;; Start thusly: (spawn serve)

    (define-handler (said)
      (send-xml
       (form (message)
             `(,(field message) ,(submit "Go"))
             (send-xml (link "click here" (send-xml `(p you said: ,message)))))))

    (define-handler (said)
      (page
       "Arc Challenge"
       (form (message)
             `(,(field message) ,(submit "Go"))
             (page "Almost"
                   (ajax-link "Click here" 'message
                              `(p "You said: " ,message))
                   `((div id message))))))

    (define-handler (said)
      (page
       "Arc Challenge"
       (ajax-form 'output (message)
                  `(,(field message) ,(submit "Go"))
                  `(p
                    ,(ajax-link "Click here" 'output
                                `(p "You said: " ,message))))
       '((div id output))))

Why not just the following?

        #!/usr/bin/perl
        use strict;
        use warnings;

        use CGI;
        use CGI::Session;

        my $cgi     = new CGI;
        my $session = new CGI::Session();

        print $session->header();

        $session->param('name', $cgi->param('name')) if ($cgi->param("name"));
        $session->clear('name')                     if ($cgi->param("c"));

        if ($cgi->param("m") eq 'show') {
          print "You said:", $session->param("name"), " ", $cgi->a({href=>'?c=1'},'Start Over');
        } elsif ($session->param("name")) {
          print $cgi->a({href=>'?m=show'},'See what you said');

        } else {
          print $cgi->startform, $cgi->textfield('name'), $cgi->submit('Submit'), $cgi->endform;
        } 

print "enter your message";

input a$

print "hit enter here";

input

print "you said: ";a$

http://forum.java.sun.com/thread.jspa?threadID=594475&me...

You have some page with an edit box and a submit button. When you submit, the data in the box transfers to the server, which displays a new page, which relies on session data to print something to your screen.

Your challenge is to create an application where the behavior of the second page can't be manipulated by by altering the URL.

The reason I don't quite understand the question is that I don't know how the contents of the text box gets to the server in the first place. Certainly once the text is on the server, if the server relies on closures for the second page, then it cannot be manipulated. Say it's http://arclanguage.com/second/cid=3. You can't change that pages because by the time you hit that URL, the text is already in the server and it operates with closures.

OK, I get that part. The part I don't understand is... the data has to get to the server sometime. If you're making a post to http://arclanguage.com/first then you can _effectively_ change the second page by altering the data then. So perhaps it's not in URL; that is, not like http://arclanguage.com/first?text=the%20entry. It's POSTDATA or whatnot. But you can still manipulate post data.

If it satisfies your challenge to say, the data gets to the server by a POST on http://arclanguage.com/first, and then the web server stores the state in a closure and forwards to http://arclanguage.com/second, which displays some things, why would it not be sufficient simply to POST to http://arclanguage.com/second ?

Is the important point the fact that the data _entered_ /first and was used in /second?

I question the value of simply making a program shorter. A shorter program will have fewer bugs than a longer one but even that is not the point. The point is that any program worth keeping will have to be maintained.

The critical question is "will the person who has to maintain the code understand the code as written and thus be able to maintain it correctly?" I suggest that both very terse and very verbose languages fail to communicate the what, why, and how by their code alone. They require massive external documentation to support understanding. THAT alone defeats the goal of simply making the code shorter.

I suggest the correct goal is to create a language that MINIMIZES the total of code, documentation, training, and learning curve to maintain it correctly. Unfortunately, that goal is orders of magnitude more difficult to achieve than merely short code.

In my 40+ years of system development, there is one language that achieves the goal of shortness without comprise: APL. Its close to possible to simulate today's weather starting from the big bang using no more than two or three lines of code using APL. However, once you get it working, neither you nor anyone else can comprehend the how, what, and why of the code. APL is the ultimate language for the disposable program: use it once and delete it. Is that really your goal for ARC? If it is, then ignore my comment.

One last question. If your goal is to optimize the production of disposable programs, have you considered the well known effect that such programs become part of "the product" as promised by the marketing department and/or some out of control salesman? Then, in a few months, they will demand that hundreds of new and incompatible features be added to make the product "better"? Will the terseness of your language save you then or will you endlessly be starting over from scratch? Your goal contains not only the seed of your defeat but also its leaf, branch, trunk, and roots.

I think I agree, except that your example is bad - complex weather would emerge from /simple/ cell interactions, and the program itself would be short and simple. But that's a similar idea to what I'd fear from a maximally compressed language - what if someone could write terse code where the meaning emerges from interactions in a way that only a genius could follow? It could be impenetrable and unmaintainable to non-geniuses. But I guess an ordinary language could have such programs, as well.

Yes. In fact a very high percentage of all software written falls into that category. The challenge is to write clear maintainable code in any language. The language can help or hinder the process but it cannot solve the problem (aka there is no silver bullet). Language terseness compounds the problem mostly by extending the learning curve beyond economic practicality.

  use base qw(CGI::Ex::App);
  __PACKAGE__->navigate;

  sub main_file_print  { \"<form method=post><input name=foo><input type=submit></form>" }
  sub main_finalize    { my $self = shift; $self->session($self->form); 1 }
  sub main_next_step   { 'click' }
  sub click_file_print { \"<a href=[%script_name%]/show>click here</a>" }
  sub show_file_print  { \"you said: [% session.foo.html %]" }

Rails shines in making common crud actions coded easily when handling models that can be expressed in a model stored in one row of a database. This arc challenge thus far only shows me that arc shines in a wizard like behavior that is carrying an input across 3 pages (with the layout of those three pages being very concise or not with a standard beyond web 0.1 layout)

The power of a language is not expressed in one application (web based interfaces without an obvious use in this example case). It is expressed, I feel, in the easy a devoloper can solve the problem which allows another developer to evolve the current code to solve evolving requirements. This places a burden on the base language and the libraries expressed with this language.

Arc is the best language to express this example in. How does Arc rise to the challenge of expressing "99 bottles of beer on the wall" within one, concise character? (http://www.cliff.biffle.org/esoterica/hq9plus.html or 9)

The real challenge for a new (if that) programming language is to provide case studies that evolved over time with consistent maintainability and quality. (Software quality is another debate involving the power of users or clients to recognize quality of software or why firefox is not yet the most standard browser).

This challenge isn't it.

  session_start();
  
  if ($_SERVER['REQUEST_METHOD'] == 'POST') {
    $_SESSION['said'] = $_POST['said'];
    echo '<a href="">click here</a>';
  } else {
    if (isset($_SESSION['said'])) {
      echo 'You said: ' . $_SESSION['said'];
      unset($_SESSION['said']);
    } else {
      echo '<form method="post">';
      echo '<input type="text" name="said">';
      echo '<input type="submit">';
      echo '</form>';
    }
  }
  

<?rb

  if @w.req.post?
    @w.session['said'] = @w.f('said')
    @w << '<a href="">click here</a>'
  else
    if @w.session['said']
      @w << "You said: #{@w.session['said']}"
      @w.session.unset 'said'
    else
      @w << '<form method="post">'
      @w << '<input type="text" name="said">'
      @w << '<input type="submit">'
      @w << '</form>'
    end
  end

page1.mp: <form action=page2.mp method=post> <input name=input1 type=text> <input type=submit> </form>

page2.mp: <form name=myform action=page3.mp method=post> <input type=hidden name=input1 value='[=req.getParameter("input1")]'> </form> <a href="javascript:document.forms["myform"].submit();">click here</a>

Maybe the challenge should also require that you be able to:

  * submit the form in one window, then open a new window and go through the complete sequence.
  * perform the steps  twice, if you go back to the original URL.

Having said that I must say that the arc solution is quite readable, while some other solutions are harder to understand. This is a very subjective statement (and probably displays more of my incompetence in some languages than in my competence in others), but if sufficiently many people are of the same opinion then it may be a useful observation.

I do have some comment on the actual task, though: Doesn't the challenge play to a particular strength of arc? Also isn't there some dependence on the available libraries? If some language doesn't have a powerful library in which the benchmark takes place it will naturally look bad.

I could come up with a task that will be ugly in arc, but plays to a particular strength of another library in a different language. Now, I could replicate that library first in arc (ignoring how long and complicated that may be) and only then count the length of the arc solution which utilizes the library.

But then I am not sure if this would still be a fair comparison.

dewd@rubynho:~/code/libraries/web_rules/examples/arcchallenge$ ls

jsp_said.rtj php_said.rtj said.rb

The program listens to 'http://localhost:8080/said'. First it shows a page with an input field and a submit button. Clicking the submit button shows another page with a link saying "click here". Clicking the link shows the last page with the text "You said: " along with the text typed in on the first page.

One might say that this is the definition, but in fact this is the solution. The verbs 'listen', 'show', 'click' and the nouns 'input field', 'submit button', 'link' or the reference 'the text typed in on the first page' are all context sensitive. A human can interpret this program by using some paper and a pen while another human could be a user. Unfortunately a computer cannot yet do this.

So how do you write it in lisp? Well, the best advice here is if you still have a couple then use your father's parenthesis. Otherwise you will have to make up some new ones such as.

(entry "http://localhost:8080/said" (show (input-field a) (submit-button (show (link "Click here" (show (text "You said: " a)))))))

Defining the terms entry, show, input-field, submit-button, link and text in a 'framework' of your choice is left to the reader as an exercise. Each one of those are generic concepts.

I think the length is better measured in time units, that is, by a) how long it takes to write it the first time and b) how long it takes to come back and make a meaningful modification to it.

I mean something like asp.net would generate a whole bunch of code to solve this problem, but it wouldn't really take that long to produce it.

Somewhere in the effort to produce the simplest language might there be a place for code generation tools, IDEs and, well, any other tool that speeds up the problem at hand? Funny that computer programmers are often the last people to ever want to actually use a computer program (think vi and notepad enthusiasts).

Will the beauty of Arc be confined to software written as ascii characters?

Anyway, that's just a comment; I really do love this stuff and think the work on Arc is wonderful.

Chris Tantillo

  Coco init said {r {
    set r [yield [Http Ok+ [yield] [<form> said "[<text> stuff][<submit> ok]"]]]
    Query qvars [Query parse $r] stuff
    return [Http Ok+ [yield [Http Ok+ $r [<a> href . "click here"]]] ["You said: $stuff"]]
  }}

#!/usr/bin/perl use HTTP::Server::Singlethreaded function => { '/' => sub { $counter++; # we need a session, right? <<LIGHTNING Content-type: text/html

<html><body><form action="YouSaid/$counter" method="GET"> <input type=text name=foo> <input type=submit></form></body></html> LIGHTNING }, '/YouSaid' => sub {

    my ($foo) = $_{QUERY_STRING} =~ m/foo=(.+)/;

    <<THUNDER

<html><body>you said: $foo </body></html>

  | something |
  something := self request: 'Say something'.
  self inform: 'Click here'.
  self inform: 'You said: ' , something

  (serve said
    (form1 [link-to-code "click here" (text "you said: " _)]))

<html>

<body>

[

session_start( -name='helloworld');

if(session_result == 'new');

		'

		<form method="post">

			<input name="msg" type="text" />

			<input name="go" type="submit" value="go" />

		</form>

		';

	else(action_param('msg'));

		var('msg') = action_param('msg');

		session_addvar('msg', -name='helloworld');

		'<a href="' + response_filepath + '">Click Here</a>';

	else;

		'you said: ' + $msg;

		session_end( -name='helloworld');

	/if;

</body>

  if {[ns_conn method] eq "POST"} {
    ns_set put [ns_conn outputheaders] Set-Cookie "foo=[ns_urlencode [ns_set get [ns_getform] foo]]; Path=/"
    set page "<html><body>said.tcl</body></html>"
  } elseif {[regexp {foo=([^;]*)} [ns_set iget [ns_conn headers] cookie] match foo]} {
    set page "<html><body>you said: [ns_quotehtml [ns_urldecode $foo]]</body></html>"
  } else {
    set page "<html><body><form method='POST' action='said.tcl'><input name='foo'><input type='submit'></body></html>"
  }
  ns_return 200 text/html $page

  page <#>{(formlet <#>{input -> y}{submitButton("submit") -> z}</#> yields y) => fun (x) {page <a l:href="{page <#>{stringToXml("you said: " ++ x)}</#>}">Click Here</a>}}</#>

  page
  <#>
  	{(formlet <#>{input -> y}{submitButton("submit") -> z}</#> yields y)
  		=> fun (x) {
			page <a l:href="{page <#>{stringToXml("you said: " ++ x)}</#>}">Click Here</a>
	}}
  </#>

1. What makes this a good (bad) idea?

2. How to distinguish between language and framework (its been mentioned before).

3. Should they/can they be included/morphed into Arc, or is Arc kind of now too "set" (eg what sort of ideas can be included).

4. Or can cool ideas be added as libraries or something?

5. Some idea of the thought process that Paul goes through when reading submissions - that would be interesting to hear.For example I imagine overcoming the natural NIH bias must be challenging.

   #!bin/picolisp lib.l

   (load "ext.l" "lib/http.l" "lib/xhtml.l" "lib/form.l")

   (de p1 ()
      (app)
      (html 0 "First Page" "lib.css" NIL
         (<post> NIL "@p2"
            (<field> 20 '*Said)
            (<submit> "OK") ) ) )

   (de p2 ()
      (html 0 "Second Page" "lib.css" NIL
         (<href> "Click here" "@p3") ) )

   (de p3 ()
      (html 0 "Third Page" "lib.css" NIL
         "you said: " *Said ) )

   (server 8080 "@p1")

Project: "First: generate a page with input field and submit button. If the user clicks on submit, he gets a second page with a link saying "click here." If he clicks on that, he gets a third page saying "you said: ..." where ... was whatever he put in the input field. This has to happen without the value being passed in the url; it should not be possible to change the behavior of the third page by editing the url in the second"

  page <#>{input => fun (x) {page <a l:href="{page <#>{stringToXml(x)}</#>}">Click Here</a>}}</#>

   (define (page . args)
     (html/ (apply body/ args)))

   (define-entry (said)
     (define (end say)
       (page (p/ "you said:" say)))
     (define (here say)
       (page (a/cont/ (@@/ (cont (lambda _ (end say)))) "click here")))
     (page
      (form/cont/ (@@/ (cont (entry-lambda (:keyword say) (here say))))
        (input/ (@/ (type "text") (name "say")))
        (input/ (@/ (type "submit") (value "SAY"))))))

   (initialize-main-proc said)

   (use dsl-simple)

   ;; said
   (define-main-page (said)
     (selfish "say"
      (form/cont/ (entry-lambda (:keyword say)
   		 (a/cont/ (cut p/ "You say:" say) "click here"))
           (readln/ say)
           (submit/))))

   (define-macro (s id)
     `(selfish ,(x->string id)
        (form/cont/ (entry-lambda (:keyword ,id)
   		   (div/ (a/cont/ (cut p/ "you say:" ,id) "click here")))
          (readln/ ,id)
          (submit/))))

   (define-main-page (said5)
     (node-set/ (s say1) (s say2) (s say3) (s say4) (s say5)))

<html>

<?php

if ($_GET['data'])

{

        $id = uniqid().'.html';
        file_put_contents($id,"You said : ".$_GET['data']);
        echo ''.$id.'';

else

{ ?>

        <form method="get">
        <input type="text" name="data">
        <input type="submit">
        </form>

</html>

To try it out, paste the code here http://runbasic.com/seaside/go/runbasic?_page=WriteYourOwn

input "Say something"; something$

cls

link #continue, "Click here", [continue]

wait

[continue]

cls

    class Said(Task):
        def go(self, b):
            said = b.call(View(lambda h: h.form(h.input.action(lambda v: b.answer(v)), h.input(type='submit'))))
            b.call(View(lambda h: h.a('Click here').action(b.answer)))
            b.call(View(lambda h: h.div('You said: ', said)))

  (defpage said ()
    (form/cont/ (a/cont/ (p/ "You said: " (last-post "foo")) "click here")
      (input-text/ "foo")))

    html anchor
        callback: [
            (self request: 'enter something') in: [ :answer |
                self inform: 'you said: ', answer] ];
        with: 'click here'

   like this line here

  read text
  read -p clickhere
  echo you said $text