Prior discussion: http://news.ycombinator.com/item?id=79694

Yes.

Everyone has exactly the same amount of time: 24 hours in a day.

Every task that a person does means that there is something else that they are not doing.

To incorporate bug fixes sounds easy, but consider for example all the fixes floating around for "mkdir". Each one fixes mkdir for their operating system and their version of mzscheme, yet it's time consuming to ensure that a bugfix doesn't break someone else's installation.

  ; If we're running Unix, MzScheme <371 has a bug
  ; where make-directory* sets the sticky bit.
  ; Thus, we want to use system instead.

  arc> (mkdir "foo")
  nil
  arc> ^D
  $ ls -l
  total 0
  drwxr-xr-t 2 cat cat 48 Feb 29 09:49 foo

  arc> (mkdir "foo")
  Error: "Function call on inappropriate object nil (\"foo\")"

  (def bidir-table-sided ()
    (with (a-to-b (table)
           b-to-a (table)
           erase-link
           (fn (k-to-v v-to-k k)
             (let v (k-to-v k)
               (= (v-to-k v) nil
                  (k-to-v k) nil)))
           report-error (fn (side) (err:string "bidir-table-sided: not side a or b - " side)))
      (add-attachment
        '= (fn (v side k)
             (let (k-to-v v-to-k)
               (case side
                 a (list a-to-b b-to-a)
                 b (list b-to-a a-to-b)
                   (report-error side))
               (if
                 (no k)
                   (err "bidir-table-sided: can't assign nil key")
                 v
                   (do
                      ;first erase
                      (erase-link k-to-v v-to-k k)
                      (erase-link v-to-k k-to-v v)
                      ;now link them
                      (= (v-to-k v) k)
                      (= (k-to-v k) v))
                 ; else delete
                   (erase-link k-to-v v-to-k k))))
        ; no keys attachment: not a real table, since
        ; we specify a side
        (fn (side k)
          (case side
            a (a-to-b k)
            b (b-to-a k)
              (report-error side))))))

  (= (foo 'a 42) 1)
  (foo 'b 1)

(I personally would be perfectly delighted if Paul continues spending his time thinking about making code shorter).

For me, the BDFL model has worked quite well for Ruby, Python, etc. I expect I'm very biased since I'm a Ruby programmer currently, but I think it's fair to say the model works well to avoid dividing and conquering itself.

There are many things to like about Arc, but I think the fact that it could potentially unify a large community around a single implementation is very powerful.

Macros are not used to create unrecognizable languages. They are used when an API has grown to the point where writing the code to use it can be automated. That is probably hard to parse if you fear macros, because you can only fear macros if you do not know how they are used. But the idea is simple.

This little call tends to require this little call before it and this little call after it, or something like that. And this pattern appears often enough, or the Lisp developer recognizes it as the sort of thing that will appear again and again, and they just say, macro time!

They then give the macro a totally comprehensible name derived from the bits of the API being hit and, golly, no confusion.

The other time you see macros is in things like aif. There will only be so many of these, and they will confuse people not at all.

The funny thing is that perhaps unbeknownst to you all the Lisp establishment is ragging on pg for Arc being too much like Lisp, you (and I a little) are hosed that he diverged from Lisp, so him being smart I would guess he is now ignoring everyone. :)

  (define (ac-call fn args env)
   (let ((macfn (ac-macro? fn)))
    (cond (macfn
           (ac-mac-call macfn args env))
          ((and (pair? fn) (eqv? (car fn) 'fn))
           `(,(ac fn env) ,@(map (lambda (x) (ac x env)) args)))
          ((= (length args) 0)
           `(ar-funcall0 ,(ac fn env) ,@(map (lambda (x) (ac x env)) args)))
          ((= (length args) 1)
           `(ar-funcall1 ,(ac fn env) ,@(map (lambda (x) (ac x env)) args)))
          ((= (length args) 2)
           `(ar-funcall2 ,(ac fn env) ,@(map (lambda (x) (ac x env)) args)))
          ((= (length args) 3)
           `(ar-funcall3 ,(ac fn env) ,@(map (lambda (x) (ac x env)) args)))
          ((= (length args) 4)
           `(ar-funcall4 ,(ac fn env) ,@(map (lambda (x) (ac x env)) args)))
          (#t
           `(ar-apply ,(ac fn env)
                      (list ,@(map (lambda (x) (ac x env)) args)))))))

  (define (ac-call fn args env)
  (let ((macfn (ac-macro? fn)))
    (if macfn
      (ac-mac-call macfn args env)
      (let ((afn (ac fn env))
            (aargs (map (lambda (x) (ac x env)) args))
            (nargs (length args)))
        (cond
          ((eqv? (xcar fn) 'fn)
           `(,afn ,@aargs))
          ((and (>= nargs 0) (<= nargs 4))
           `(,(string->symbol (string-append "ar-funcall" (number->string nargs)))
              ,afn ,@aargs))
          (#t
           `(ar-apply ,afn (list ,@aargs))))))))

  (define (ac-fn args body env)
   (if (ac-complex-args? args)
      (ac-complex-fn args body env)
      `(lambda ,(let ((a (ac-denil args))) (if (eqv? a 'nil) '() a))
         'nil
         ,@(ac-body body (append (ac-arglist args) env)))))

  (define (ac-fn args body env)
   (if (ac-complex-args? args)
      (ac-complex-fn args body env)
      `(lambda ,(let ((a (ac-denil args))) (if (eqv? a 'nil) '() a))
         ,@(ac-body* body (append (ac-arglist args) env)))))

  (define (ac-fn args body env)
   (if (ac-complex-args? args)
      (ac-complex-fn args body env)
      `(lambda ,(let ((a (ac-denil args))) (if (eqv? a 'nil) '() a))
         'nil
         ,@(ac-body body (append (ac-arglist args) env)))))

  (define (ac-fn args body env)
   (if (ac-complex-args? args)
      (ac-complex-fn args body env)
      `(lambda ,(let ((a (ac-denil args))) (if (eqv? a 'nil) '() a))
         ,@(ac-body* body (append (ac-arglist args) env)))))

I think it's perfectly fine that Anarki prefers to have its documentation in docstrings. I welcome anyone who wants to to add the OpenID code to Anarki to do so (it's in the public domain, after all). If you had said, "can I add this to Anarki", I'd say "sure, I'd be delighted". If there are any patches that would help make my code easier to incorporate into your distribution, I'd be happy to consider them.

But your question was "could you add it to Anarki". The answer is no, I'm not going to take the time to be a downstream maintainer for code in a distribution that has conventions that I don't like. In fact, I'm not sure I'd become a downstream maintainer of code in a distribution that I did like.

Everyone, every single person, has exactly the same amount of time. We all have 24 hours in the day. We all have different goals, different desires. If someone out there likes the direction Anarki is going in and thinks this OpenID code I wrote is useful and wants to spend some of the limited time they have to add it to Anarki, I'm delighted. More power to you, whoever you are.

If you need hosting, I have more GitHub invites than I know what to do with.