As I see it, the dot (car.ls) is syntactic sugar for applying a one arg function? Pretty clever! It replaces really well the y, no doubt.

The differences are subtle, but it definitely feels better, my personal alarm gets a bit of rest.

Use of iso. Don't know why I used is.. Question I had, can '=' be use as a comparison operator?

Also I get your use of 'else, but not exactly sure how it passes. Does it count as an expression evaluated to true, so then (unique_list...) gets to be it's true clause/case? Or is is simply not counted at all (making (unique_list...) the false clause of (iso car.ls x). Not sure if I'm making my self clear here, so I'll try and rephrase a bit. A -> 'else gets to be an other if expression (if 'else) wich always evaluated to true -> following expression is the true clause of it. (what I think is happening) B -> 'else isn't counted as a full s-expr (not sure it's the right way of saying this) and so it just goes along with following (unique_list...) -> Makes it the false clause of (iso car.ls x) and not interpreted as an other if. (Then, I don't understand why!)

Finally, and that's really a bonus I'm asking, but since I'm looking into making my next side-project (wich could be a long-term project) in Arc-based lisp, it could get me closer, I'll ask it anyway. As of what I know, since PG's fully involved in YC, and so arc's development is in a semi-dead state, I'd better be at least looking at forks of it. Now, if I understood well, there are two major forks, one you are working on, that would be wart, and anarki (mistaken already?).

Would there be any difference in wart's implementation of the same alorigthm (since it shows a bit more use-case than pg's algorithm), or then, what would be wart's more natural form?

I actually wanted to re-write it using a hash but couldn't get right away the semantics and syntax they had. This is perfect, It'll get me to discover how they actually work.

Thanks for the tip! It'll render better :)

Though, for the sake of learning (I am, for sure, studying PG's version and learning from it), could anyone quickly comment my code cause and what bad practices I'm doing (I may be a newbie in Lisp, but I still feel when things aren't elegant!).

Here is the simple code to do that on etc/nginx/nginx.conf server { listen 80; server_name bloggervietnam.com www.bloggervietnam.com;

    location / {
    proxy_pass http://127.0.0.1:8080;

    }

1. I just install screen and fortunately it works well. I just hit F6 button to detach my terminal session. That is why I removed fluxbox GUI for saving RAM and resource.

2. I follow the help above and now I can chance the color of the forum.

3. I have not solved the matter yet since apache did not work despite that I already installed necessary modules as you mentioned.

1/ I often use WinSCP instead of PuTTY on Windows to control VPS. Of course, we can only interact/manage the virtual private server via commands line, but in the case WinSCP helps me to upload the files easily. I tried to use fluxbox (a lightweight GUI for Ubuntu) and VNC to remote connect the server and use the "original" terminal to run racket and ARC forum. As far as I tested, whenever I turn off terminator/SSH window on Windows, the ARC forum will turn off as well. So there is no other choice for me to run source code.

2. Thanks for your investigation, however, the color on the front page does not change from grey to yellow/orange like Hacker News or ARCforum. I found out that the <tag> is "bgcolor", not "border-color", so it will not run even you tweak the code on the top of news.arc file. I believe that we need to change the color of the forum by "dealing" with html.arc file. I got the tag bgcolor (line 86) in that file but not sure how to change.

3. One of the most problem with me right now is how to "forward" the default port on racket server from 8080 to 80 which is default port of Apache. When I tried to configure my httpd file inside apache2 according to this instruction http://nicholasblee.com/blog/hacker-news-clone-on-a-free-aws...

but it does not work. So that is the reason why I have to access the ARC forum by typing the port 8080, otherwise the apache will run the 80 port with a blank page.

Here is what I add to /etc/apache2/httpd.conf <VirtualHost :80>

ServerAdmin myaccount@gmail.com

DocumentRoot /var/www

ServerName bloggervietnam.bloggervietnam.com

<Directory /var/www >

Options FollowSymLinks

AllowOverride None

Order allow,deny

Allow from all

</Directory>

#configure cluster

<Proxy balancer://arc_cluster>

BalancerMember http://127.0.0.1:8080

</Proxy>

RewriteEngine On

#Redirect all non-static requests to the cluster (arc)

RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f

RewriteRule ^/(.)$ balancer://arc_cluster%{REQUEST_URI} [P,QSA,L]

ErrorLog logs/blogervietnam.bloggervietnam.com-error_log

CustomLog logs/bloggervietnam.bloggervietnam.com-access_log common

</VirtualHost>

When I tried to restart apache2 with sudo permission, it responded that:

Syntax error on line 27 of /etc/apache2/httpd.conf: BalancerMember Can't find "byrequests" 1b method. Action "configtest" failed.

Method-chaining doesn't come into play, because, technically, there is no such thing as methods. Just regular functions.

I haven't used ruby, but I think terseness and readability tend to go hand in hand, and ruby looks terse.

Ok. I did the mistake (missed to take the apply) not to apply it.

No it is clear. I learned from this mistakes.

foo; bar; qux ;corge (foo(bar(qux))corge

foo; something is foo(something)

On to the specifics:

For quasiquote... yeah it had occured to me that almost every time I am not 'unquoting' a symbol then this is a mistake... but only when writing a macro. Outside a macro it's less clear that this is what someone would want.

And to clarify, you mean that :

    `(one two (three))

    (list one two (list three))

    (list one two (three))

I had also realised that the "hygiene" is currently broken by the fact that, in FirstClass Lisp, "quasiquote", "quote", "unquote", "unquote-splicing", "dot" and "slash" are all "special" in terms of what the reader reads in, so something like the following:

    (lambda (quote phrase)
        ('quote-tag quote phrase))

It seems to me that the correct resolution is to have the reader itself also have a lexical environment which it refers to when generating these special symbols - although you would then have the problem of how to supply this environment to the reader. Something like:

    (define quasiquote ...)
    (set-reader-environment! (env))
    `(a list)

By far the most interesting statement you've made is that making the macros first class isn't actually necessary for this hygiene trick anyway! That's a very interesting statement... I need to think about this. What I most wanted was a "simple" concept of hygienic macros - that is, simple in understanding how they work: that they are just functions which happen to operate on the unevaluated source tree and return a source tree to be evaluated. Once we have that, I think the next most important thing is that there is no performance cost to using them. If what you're saying is true then it might be possible to expand all of the "non" first class macros in a pre-compilation step anyway.

I'd really like to get the Sudoku solver at least at the same level of performance as the Python one.

One area in which the first class nature of the macros was particularly elegant was in the implementation of an "amb" macro. All of the classic examples of amb require some sort of global state to keep all of the continuation instances. But this is inelegant if you wanted to have multiple usages of (amb) which don't interfere with each other: suppose for example you want to create two threads - one for solving each Sudoku puzzle.

The conventional examples always add some sort of "amb-reset!" function to say "forget about everything you tried to solve before" - but this is inelegant and wouldn't work for multiple threads.

At the same time, you want (amb) to be a macro which lazily evaluates the possibilities, so that you can write code such as:

    (define (anything-starting-from n)
            (amb n (anything-starting-from (+ n 1))))

    (define (solve puzzle failure-continuation)
        (with* (amb (make-amb-macro failure-continuation)
                assert (make-assert amb))
        ... stuff requiring amb and assert
    )

Here's the way I defined "make-amb-macro" and "make-assert":

    ; A hygienic 'amb' macro.
    ;
    ; Using a factory function allows us to maintain
    ; the hygiene of 'amb-fail'.
    ; Use 'make-amb' to make an
    ; amb macro that you know won't interfere
    ; with anyone else's amb macro.

    ; The ability to do this - return a hygienically
    ; scoped 'amb' macro from a
    ; function, is something that is only possible
    ; in a Lisp with First Class macros and continuations
    ; (i.e. First Class Lisp!)
    (define (make-amb-macro exhausted)
        (define amb-fail exhausted)
        (define (set-fail thunk)
            (set! amb-fail thunk))
        (define (get-fail)
            amb-fail)

        ; Based on
        ; http://c2.com/cgi/wiki/?AmbSpecialForm
        (define amb
            (define expand-amb (lambda
                ()  (list force (get-fail))
                (x) x
                (x y)
                    (with* (old-fail (gensym)
                            c (gensym))
                    `(,let ,old-fail (,get-fail)
                        (,force
                            (,let-cc ,c
                                (,set-fail
                                    (,make-thunk
                                        (,set-fail ,old-fail)
                                        (,c (,make-thunk ,y))))
                                (make-thunk ,x)))))
                (x . rest)
                    `(,amb ,x (,amb ,@rest))))
         (macro expand-amb))
        amb)

    ; Given an amb macro, make an appropriate
    ; assert function. Once again, this sort of
    ; thing is only possible with first-class macros.
    (define (make-assert amb)
        (lambda
            (#f) (amb)
            (condition) #t))

* How many concepts must be taught to the child before writing useful programs?

* How many of those concepts are right there, and how many are hidden?

I intuitively feel that Kalimat's example is just more simple and direct than the Logo equivalent, but "intuitively feel" and "just more simple..." are not very scientific; perhaps when Kalimat is more experimented with, we could have more empirical results.

But at least I can try to justify my feelings a little:

* The Logo example seems more nested while the Kalimat one is flatter. "Do this task, then that one" seems easier to keep inside one's head than do this task, which is made out of so and so.

* The Kalimat example completely avoids the need to teach function definition and invocation.

* The Logo code needs a discussion about variable scope and function activations; how :numberoftimes has a value in this greet different from that greet.

Yes, in Kalimat we'd have a related discussion about mutable variables, but a variable is an isolated concept that doesn't need to be explained alongside invocation and scope (at this level).

When I was talking about "less mysterious and complex" I wasn't thinking about how a real CPU works, but how a programmable machine works.

My idea is that a language too high-level would make the child think of a computer as something having human-like behavior, that the computer just "knows" what to do when you talk to it. On the other hand a programming language with a well-known execution model and few assumptions would mean the child can know early how to map a language's syntax to its semantics.

Let's compare two programming languages for children, Logo and Kalimat. To print "hello" ten times in Logo:

repeat 10 [print "hello]

Here the child has to either assume the computer 'just knows'/be told "you'll understand later", or otherwise has to take some conceptual leaps in order to understand what's really happening:

* The stuff between [] is code not to be executed yet, a description of a future action to be applied

* This code is given to 'repeat'

* 'repeat' would apply this code as many times as needed

Now in Kalimat:

label top

x = 0

print "hello"

x = x + 1

if x<10 : goto top

Assuming the child already knows assignment 'if', and 'goto', the code here can be analyzed, traced, and adapted, without having to know little more than what is already known.

When the student becomes more confident, they can learn about 'for' and 'while', while being told that under the hood, those high-level constructs are pretty much the same as the previous version.

This way, the student can go directly into writing interesting programs using only if/goto/expressions. Later they can learn more disciplined forms like procedures or OOP, also included.

I don't have empirical evidence, but I think that the advantage of 80s basic for learning is that there are no hidden semantics that need to be known -- what you see is exactly what you get. No parameter passing, no local variables, no call/return (except in gosub, which is presented later), no blocks...Basic is - in a sense - like assembly language with math expressions and graphics.