1) As a general principle, IMO, it should be the programmer's responsibility to avoid problems arising from concurrent use of objects by explicitly using concurrency primitives (mzscheme provides a host of these, and it's not too hard to write a wrapper which lifts them into arc, if someone hasn't already put one into Anarki). If they find this too much of a burden, then they can write some convenience macros.

2) Adding the overhead of 'atomic, which is implemented (and pretty much has to be implemented) using a global mutex, to every single assignment is just not okay.

1) As a general principle, IMO, it should be the programmer's responsibility

I myself am quite happy to have responsibility taken off my hands, if the resulting code actually works. However...

2) Adding the overhead of 'atomic

If it worked, I wouldn't mind the overhead. (I haven't measured it, so I don't know if things being made atomic by Arc adds 10% to my program's execution time or 0.01% or 0.00001%) But the way to make a program fast is to profile it and fix the parts that are slow, not to leave out useful features in order to do global, unmeasured optimizations.

However...

I don't think it does work, which is probably part of what you're saying as well. Consider

  (readfile "foo.txt")

Should I have the misfortune to say

  (obj a (readfile "foo.txt"))

For the second, well, I wouldn't be surprised if someone who worked at optimizing Arc could make it run twice or maybe even ten times as fast, while still implementing the full specification. So if a particular language feature is actually useful, and happens to cause a 10% slowdown, I mostly don't worry about it myself... I suspect greater gains would be found from a systematic optimization approach.

    (mac withs (parms . body)
      (if (no parms) 
          `(do ,@body)
          `(let ,(car parms) ,(cadr parms) 
             (withs ,(cddr parms) ,@body))))

They're not recursive in the same way functions are:

  (mac foo (x)
    (if x '( ...)
        (foo ...)))

    (set board-size 8)

    (set moves
      '((-2 . -1) (-2 . 1)
        (-1 . -2) (-1 . 2)
        ( 1 . -2) ( 1 . 2)
        ( 2 . -1) ( 2 . 1)))

    (def move (pos diff)
      (cons (+ car.pos car.diff) (+ cdr.pos cdr.diff)))

    (def valid (pos visited)
      (and
        (< -1 car.pos board-size)
        (< -1 cdr.pos board-size)
        (~mem pos visited)))

    (def moves-from (pos) (map [move pos _] moves))

    (def succs (pos visited)
      (let valid [valid _ visited]
        (sort (compare < [count valid moves-from._])
          (keep valid moves-from.pos))))

    (def knights-tour (start (o visited))
      (let visited (cons start visited)
        (if (is len.visited (* board-size board-size)) rev.visited
          (ormap [knights-tour _ visited] (succs start visited)))))

    (~mem pos visited)

    (~mem [iso _ pos] visited)

    (def valid (pos visited)
      (and
        (< -1 car.pos board-size)
        (< -1 cdr.pos board-size)
        (no visited.pos)))
    
    (def trace (k e)
      (cons k (let v e.k (if (isnt t v) (trace v e)))))

    (def knights-tour (start (o prev t) (o visited (table)))
      (= visited.start prev)
      (do1 (if (is len.visited (* board-size board-size)) (rev:trace start visited)
             (ormap [knights-tour _ start visited] (succs start visited)))
        (= visited.start nil)))

    (mac iflet (var expr then . rest)
      #`(let temp #,expr
          (if temp (let #,var temp #,then) #,@rest)))

    (mac aif (expr . body)
      #`(let #,'it #,expr
          ,(if (cddr body)
             `(if #,'it #,(car body) (aif #,@(cdr body)))
             `(if #,'it #,@body))))

    (def flip (f) (fn (a b) (f b a)))
    (def curry (f x) (fn a (apply f x a)))