Also the other file-operation changes that you will need to make are:

-- In ac.scm

    1. add at the top:
    (require (lib "file.ss"))

    2. add at the bottom near the other xdef's:

    (xdef 'make-directory make-directory)
    (xdef 'make-directory* make-directory*)

 -- In arc.arc change these functions to: 

    (def mkdir (path (o parents))
         (if (is parents nil)
             (make-directory path)
             (make-directory* path)))

    (def ensure-dir (path)
        (unless (dir-exists path)
             (mkdir path t)))

The only other one fix I think you might need to make would be to the the shash function in app.arc, which I believe is unixy.

[edit]

I was reminded of http://ycombinator.com/rfs5.html.

At least part of the excitement was in the fact that I didn't have to go through an 'app marketplace'. When everything about modern devices seems to involve jumping through endless hoops, it was a relief to have a nice experience.

As an FYI aw (aka CatDancer) once provided code for arc/OpenID support. -> http://arclanguage.org/item?id=3333. Link is no longer valid and aws currently published pages[1] don't appear to contain the code. I'm sure if someone needed it they could contact him and he would be willing to help[2].

[1] http://sites.google.com/site/arclanguagewiki/ http://awwx.posterous.com/ http://awwx.ws/

See: http://www.w3schools.com/tags/att_input_checked.asp

Mulitple radio buttons having the same name will act as a group.

See: http://www.w3schools.com/jsref/dom_obj_radio.asp

In arc, the requested attribute will reflect the currently selected radio button for the group.

Also, note that arc's gentag doesn't handle the 'checked' attribute. So you you'll need to add:

  (attribute input      checked        opstring)

Then change your code:

  (def radio (n v (o c nil))
    (gentag input type 'radio name n value v checked c))

  arc> (radio "rdgp" 1)
  <input type=radio name="rdgp" value="1">

  arc> (radio "rdgp" 2 "checked")
  <input type=radio name="rdgp" value="2" checked="checked">

Arc, however, does not filter system files - it just looks in the directory, finds the list of all files and tries to load them... and of course the news.arc tries to convert all the file names into integer keys (when loading into a table), but ".DS_Store" can not be coerced to an int, so instead you get that error.

  $ rm arc/news/*/.DS_Store; mzscheme -f as.scm

  > Where is the database, how are entries being stored?
  > How does HN (Hacker News) handle the huge load and   
  promptly behave as expected, even though Arc wasn't   
  designed for speed?

Note that HN doesn't allow you modify records after a certain time frame and this gives HN the luxury to not support writes to older content and gives the users less incentive to go back to older items, lessening the need to access older data.

Note, though, that you're changing the behavior of the function in two ways:

1. nil is not returned when passed an empty list. I notice arc code does this often with the expectation that when composing your functions you may iterate though many lists to assemble them. So assembling with empty lists will break with your new function:

  old > (best > '())
  nil

  new> (best > '())
  Error: "procedure  best2: expects 2 arguments, given 0"

  old > (best (fn (x y)(> (+ x y) 10)) '(3 2 2 1 1 1))
  3

  new > (best (fn (x y)(> (+ x y) 10)) '(3 2 2 1 1 1))
  1

Then again, you could argue that the original behavior is more 'stable': it's like sorting the list and taking the first element.

If anyone called 'best on an infinite list, I'd expect it to diverge regardless of how it was implemented. You never know if something's the maximal/minimal element unless you've checked all the others.

(If 'best operated on heaps or something, then you might be able to say "this potentially infinite substructure has no better candidates" because the heap structure makes guarantees like that.)

Anyway, #2 is still irrelevant because it's trivial to fix:

   (def best (f seq)
     (reduce (fn (a x)
  -            (if (f a x) a x))
  +            (if (f x a) x a))
             seq))

Here's a fix for #1 as well, along with a return to the original variable names:

   (def best (f seq)
     (when seq
       (reduce (fn (wins elt)
                 (if (f elt wins) elt wins))
               seq)))

Because of the variants? The only mention of fold I found was this one:

Rich Hickey (at 30:33): "Imperative loops--fold, even, which seems kinda higher-level? Still has some implications that tie two things together... whereas set functions are simple."

I thought he was referring to the way the calls to the folded function are all lined up in a dependency chain, just like they'd be lined up if you were using an iterative loop.

  (state before the iteration, input to this iteration)
    -> state after the iteration

  (def foldl (first rest func)
    (ret result first
      (each elem rest
        (zap func result elem))))

With "set functions," you can determine certain properties about the result if you know some subsets' results:

- The result of (some odd (join '(17) foo)) is t, because (some odd '(17)) is t.

- The result of (keep odd (join '(17) foo)) has at least the element 17 in it, because (keep odd '(17)) has that element in it.

Rich Hickey's main point is that these "simple to reason about" properties help humans. But they also mean that if we know enough about these function calls statically (which we never do, in Arc), we might be able to turn them into constants without knowing the value of 'foo, or at least we might be able to parallelize them. These set functions may be implemented as special cases of fold, but fold doesn't have the same reasoning potential in the general case.

Look around minute 40. He says they complect what to compute and how to compute it, which I took to mean the need to specify foldl/foldr.

"Loops and fold! Loops are pretty obviously complecting what you're doing and how to do it. Fold is a little bit more subtle, 'cause it seems like this nice 'somebody else is taking care of it,' but it does have this implication about the order of things. This left-to-right bit."

I can see how you'd get that. I think our interpretations are related. As far as how they're related goes...

The underlying issue may be that introducing non-commutativity makes an operation more cumbersome when used with sets, and introducing non-associativity makes it even worse.

- Commutative and associative: If you apply '* or 'max pairwise to a set, you can only get one result. (It's possible to implement 'some this way, and a 'keep that returns an unordered bag.)

- Associative: If you apply 'compose or 'join pairwise to a set, you can get many results, but you can choose between them by putting the items in a list. (It's possible to implement 'keep this way.)

- Commutative: If you apply XOR pairwise to a set, you can get many results, but you can choose between them by placing the items on the leaves of a rooted binary tree.

- Neither: If you apply 'cons pairwise to a set, you can get many results, but you can choose between them by placing them on the leaves of a rooted binary tree with a distinction between left children and right children.

  arc> (isnt 'zip (isnt 'nada 'nil))
  t
  arc> (isnt (isnt 'zip 'nada) 'nil)
  nil

Here's another:

  arc> (is 'zip (is 'nada 'nil))
  nil
  arc> (is (is 'zip 'nada) 'nil)
  t

If two parts of the program observe the system at the same time but see different states, that's called inconsistency. Consistency is difficult to achieve in a distributed program, thanks to the fact that "observation" isn't necessarily instantaneous or reliable. Per the CAP theorem (http://en.wikipedia.org/wiki/CAP_theorem), to achieve full consistency in a distributed program you have to sacrifice availability or partition tolerance. These three properties are inherently complected.

Things that are consistent are simpler than things that are not.

I was more specifically referring to the part at 31:17 where he had Inconsistency vs. Consistency on the slide and he explained the complexity as "taking a set of things that stand apart and trying to think of them all at the same time." He finished that line of thought with "And anybody who's tried to use a system that's eventually consistent knows that."

    (def reduce (f xs)
      ((rfn rdc (a s)
        (if (no s)
          a
          (rdc (f a (car s)) (cdr s)))) (car xs) (cdr xs)))

As a guess, 'best' is probably used for http://arclanguage.org/best in the news.arc code. In which case it's probably not an issue... ?

I don't see the purpose of 'best. I don't see a bigger purpose in most of Arc. If what Arc gives me isn't what I need, I reinvent it.

(In fact, I think if we try to keep working on the same language, rather than tearing it down and reinventing it, we're worrying about at least some kind of "support" and stifling our development. But too much tearing down can be destructive too, of course. :-p I appreciate that you're applying a scientific-ish mindset to this.)

There are a few ways to cut through this Arc ennui:

- If Arc gives me tools I can use to reinvent things, those tools are extra-relevant, since even if I don't like them I'll use them on my way to replacing them. This is not something 'best does for me.

- Sometimes we may want everyone in the language community to use the same variant of something, so that the tools we build around that thing can work together. Are we trying to optimize 'best in the compiler/runtime? Nope. Do people often extend 'best with extra capabilities? Nope. Even if these things were true, are we even having an issue with people reinventing 'best all the time? Nope, I don't think so.

For example, in Clojure, I can just build my project by excluding the function in question and replace it with my version. Anyone else that wants to use Clojure doesn't need to worry about another persons great idea.

; example

  (ns a-project.core
    (:refer-clojure :exclude (best))
    (:gen-class))
  
  (defn best []
    ...)

  (ns your-project.core
    (:refer-clojure :exclude (best))
    (:use [a-project :only (best)])
    (:gen-class))
   
   (defn do-my-stuff []
    (best ....))

  (def reduce (func xs)
    (whenlet (x . xs) xs
      (foldl func x xs)))

Alternatively we could have this...

  (def reduce (func xs)
    (iflet (x . xs) xs
      (foldl func x xs)
      (func)))