Personally I'd volunteer to take the lead, really fork Arc, and go on with Arc-F. Unfortunately, I'm not at all experienced in actually launching and maintaining a website. Worse, Arc-F can't host news.arc (or a ported version) yet; I'm somewhat redesigning the Arc server because of the lousy and inconsistent design, but I'm kinda stuck on how to handle the continuation server functions bit, which strike me as the dirtiest bits of the Arc Server.

The last alternative - let Arc die - is something we should seriously consider though. Clojure is gaining the popularity that Arc could have had. Like Arc it's a redesigned Lisp (fn and new ssyntax, anyone?); unlike Arc, it wasn't hyped very much for >6 years, its maintainer is still visibly leading the language, and it runs on the JVM. The only advantage of Arc that I see is that it supports both imperative and functional paradigms - and some might argue that this isn't actually an advantage.

Further, I don't think Arc, PG version, is as well-designed as you think.

For example: "code is spec". Apparently the code itself is to be the specification for the language. However, this brings up some questions: for example, does the fact that (ssplit '(1 2 3) 0) return ((1) (2 3)) part of the specification, or is that a bug? http://www.arclanguage.org/item?id=8450 .

Or how about the cute little fact that the PG 'map function can be safely recontinued when you capture the continuation in the mapping function if the given structure is a list, but is not safely recontinuable if the given structure is a string? Is this a deliberate design decision, an oversight, or something you don't specify and so any other implementation can do what they want?

And while tagging allows the programmer to arbitrarily create new types, those new types don't get along well with the builtin functions. I can't build a vector type in PG Arc that will work with the builtin functions. I can't build a quaternion type which I can multiply with a scalar number using '* .

I admire the ideas behind Clojure because it makes a different set of design decisions from Common Lisp. This seems to have even gotten the attention of Common Lisp developers, and those guys are pretty hard to impress.

The focus on immutability, literals for data structures other than lists that share a common "seq" interface, first class functions and closures, multi-methods without OO, lazy sequences, and full fledged macros hit an interesting sweet spot that is not touched by any other language I know. Mr. Hickey has managed to put all of those things together in a way that strengthen, reinforce, and complement one another. That is an impressive feat of language design.

My point is that Clojure is not "just" popular. By making unique decisions about the semantics of the language, and not just improving the syntax over the semantics of an existing language, Clojure may very well be one of those languages whose ideas remain influential long after it stops being popular.

(I'm curious, does Arc innovate in terms of its semantics being significantly different than its predecessors? It seems to have the goal of taking existing Lisp paradigms and making it possible to express them more succinctly. But I might be missing something important.)

It seems to me that I've been much more explicit about this than people working on new languages usually are at this stage:

Here are some of the differences, but I can't tell if one of them is crucial. I listed three below for which I've no clue what the impact is.

  http://clojure.org/lisps
  * The read table is currently not accessible to user programs
  * Keywords are not Symbols
  * Symbols are not storage locations (see Var)
  * immutable data and first-class functions
  * *first* is clojure's *car* ;)

Mutation. It's one thing to allow functional programming. It's another thing to force it.

The only thing constant is change.

> * The read table is currently not accessible to user programs

Neither does Arc, although Anarki does allow redefining of 'ssyntax and 'ssexpand, which almost gives you the same thing.

IMO not giving access to the read table is a good thing. There are very subtle problems with this, starting with: the read table affects all code loaded after the readtable modification.

It affects them whether or not the code was written by you, and whether or not it was written with that readtable definition in mind.

This can cause unfortunate library breakage when two libraries try to modify the same readtable entry; the poor user is thus left at the mercy of which library loaded last.

In fact Arc-F has revoked Anarki's feature which allows 'ssyntax and 'ssexpand to be modified; redefine them all you want, Arc-F will use the built-in traditional 4 ssyntaxes : ~ ! .

HOWEVER, there are currently two reserved context metacommands which will eventually allow ssyntax redefinition at the level of the individual file: 'import-ssyntax and 'interface-ssyntax.

The important thing is that they are context-based, and because they are context-based, they are not global and they will (in general) affect only one loaded file.

> * Keywords are not Symbols

Unimportant - salt to taste.

> * Symbols are not storage locations (see Var) > * immutable data

Side effect (LOL) of the enforced FP.

> * first is clojure's car ;)

  (let (i o) (connect-socket url* 80)
    (disp (readline i)))

  (mac w/url (var url . body)
    `(let ,var (cadr (get-request (str->url ,url)))
       ,@body)))

I'm not familiar with how to use xml.arc but this is what I came up with for finding the links on a page:

  (def find-links (str)
    (with (start 0 acc nil)
      (whilet p (posmatch " href=" str start)
        (= start
           (+ p (if (in (str (+ p 6)) #\' #\") 7 6)))
      (push (cut str start (pos [in _ #\' #\" #\> #\space] str start))
            acc))
      (rev acc)))

  (w/url u "http://www.google.com/"
    (find-links u))

2. Arc3F is the latest (and so far, only) version of Arc-F. Arc-F is a fork of Arc I created, featuring some neat stuff, particularly packages. The page you linked to is the Anarki repository, which contains a very modified version of Arc2.

3. When we say "Arc2" or "ArcN", we refer to the official PG release. Anarki is the community's repository of Arc, and the community version of Arc that is based on the latest ArcN. Arc-F is a more recent fork of Arc; it includes a full-fledged symbol-based package system and a partially rewritten standard library.

4. None at all. Anarki accepts all patches. Arc-F accepts all patches too, but Arc-F has very much larger differences to ArcN than Anarki.

5. None from me, I'm afraid; I'm a VIM guy ^^

6. Download rlwrap. You should be able to get it by:

  sudo apt-get rlwrap

Why does the link near the top of the forum (subj: "Arc3F Released..." (http://arclanguage.org/item?id=8270)) link to the Anarki online repo, instead of some Arc3F repo?

Here's a succinct explanation: http://arclanguage.com/item?id=8390

Here's a longer one:

The Anarki repository was first set up early this year by nex3 on his own server. It was set up such that everyone can write to it - no credentials needed, just clone the repository and you can start pushing on the Anarki repository.

Some time after that he decided to move the repository onto github.com. Even on github.com, the Anarki repository is still fully open.

However, none of the rest of us can figure out how to make our own github-based repositories fully open (i.e. publicly writeable).

I'll probably move Arc-F into its own repository if and when I figure out how to make it fully open.

> how do I use the arc.sh launcher?

Odd about the github setup issue. Guess I don't quite understand. Seems like someone could just email nex3 or someone at github to get the correct config incantations...

Also, it's confusing that the Description of the project at github doesn't say "The community's extended version of Paul Graham's Brand New Lisp". Currently, it looks like that's where pg keeps the source.

Err, Anarki and Arc-F have 'readb and 'writeb functions for this - don't they work with binary data?

>

  1. provide a means to load modules
  2. make sure they only get loaded once
  4. avoid changing the global namespace
  5. keep each module in a safe and clean execution environment (isolation from other modules)
  6. be recursive (modules can load sub-modules without disturbing other modules)
  7. allow modules to export an interface
  11. specify dependencies between modules.

  8. allow modules to declare variables with module-only scope

  9. give the user of the module a way to 'include' features from the module (that is, map them into its own namespace)

  10. not get in the way of other module systems, or even multiple instances of the same module system

So while anarki might need to support arrays internally for efficiency, they need not neccesarily be part of the language as far as the users can tell.

If the above is true, then right now the implementation of things that are efficient for the language when it wants to communicate with the cpu are of a lower priority than the things that are efficient for the communication between the user and the language.

In Arc-F for example I might use:

  (using <vector>v2) ; vector and vector-of

  (def make-world (xwidth yheight)
    (apply vector
           (w/collect:for i 0 (- xwidth)
             (collect:vector-of yheight nil))))

  ; create a location type
  (def location (world x y)
    (annotate 'location
      (list world x y)))

  (defcall location (r)
    (let (world x y) r
      (world.x y)))

  (defm sref ((t loc location) val)
    (let (world x y) (rep loc)
      (sref world.x val y)))

  ; 0---> INF
  ; |
  ; |
  ; v
  ; INF
  (def south (loc (o step 1))
    (err "'north and 'south expect a location"))
  (defm south ((t loc location) (o step 1))
    (let (world x y) (rep loc)
      (location world x (+ y step))))

  (def north (loc (o step 1))
    (south loc (- step)))

  (def east (loc (o step 1))
    (err "'east and 'west expect a location"))
  (defm east ((t loc location) (o step 1))
    (let (world x y) (rep loc)
      (location world (+ x step) y)))

  (def west (loc (o step 1))
    (east loc (- step)))

I should put some more work into it. The good news is that I just found a nice and simple editor that plays well with arc-f on windows (LispIDE - http://www.daansystems.com/lispide/)

btw. arc-f arc.bat doesn't play nice yet with "Program Files" type of directories. Works fine in C:\arc-f.

Got this error:

Of course, of course ^^

> btw. arc-f arc.bat doesn't play nice yet with "Program Files" type of directories.

However recently I thought of a method by which all that is necessary would be a (probably tagged) pointer to the actual entry within the array. This would require tagged pointers (i.e. no Boehm-Weiser!).

Basically we would define a tagged pointer type which, when found in a list-as-array, would not be a valid 'car of that entry, but rather would be a pointer to an object containing the real 'car and 'cdr for that object. It might be possible to also use a tagged pointer (potentially the same tag, but say with a null pointer) to denote the end of a list.

Let's call this invalid tag a "NON_CAR_TAG", and let's call the tag for a pointer to an array-as-list-cons-cell a "CONS_ARRAY"

Basically a (list 1 2 3 4) would be represented with the array:

  [0] INTEGER(1) // tagged with an INTEGER
  [1] INTEGER(2)
  [2] INTEGER(3)
  [3] INTEGER(4)
  [4] NON_CAR_TAG( NULL ) // null pointer

Now suppose we have the operation (= foo (list 1 2 3 4)). 'foo would then contain a CONS_ARRAY() tagged pointer to the above. Suppose the pointer to the above array is 0xDEADBEE0. 'foo would then be CONS_ARRAY(0xDEADBEE0).

Now suppose that a cell is exactly 16 bytes (just an example for easier reasoning). So (cdr foo) would be CONS_ARRAY(0xDEADBEF0), (cdr:cdr foo) would be CONS_ARRAY(0xDEADBF00), etc. Basically, 'cdr would first check if the input is a CONS_ARRAY() tagged pointer, and just add 0x10 (or the cell size). If the resulting address points to an entry that happens to be NON_CAR_TAG(NULL), it should return a NILOBJ, otherwise it returns the result of the addition.

Now, suppose we then do (scdr (cdr foo) 42). 'scdr should first detect if the the pointer it is given is a CONS_ARRAY() tagged pointer. If so, it determines if the value being pointed to is a NON_CAR_TAG() or not. If it's a NON_CAR_TAG(), it gets the underlying cons cell pointed to by the NON_CAR_TAG and modifies that. Otherwise, it allocates a new cons cell, populates it with the existing 'car and the new 'cdr, tags the cons cell pointer with NON_CAR_TAG(), and replaces the entry:

                   +---------> CONS: A INTEGER(2)
  [0] INTEGER(1)   |                 D INTEGER(42)
  [1] NON_CAR_TAG( * )
  [2] INTEGER(3)
  [3] INTEGER(4)
  [4] NON_CAR_TAG(NULL)

2) Use Arc-F

LOL.

It'll also become slightly messy if pg's statement from a month ago becomes true, and there will be new versions of arc coming out in october / november. If we pick up features from different versions of arc, would the changes compared to arc2, as well as the changes compared to arc3 need to be documented.