I found this most salient:
"This is totally subjective, but I think we're at a point where the language ecosystem is much more important than the actual language. This was probably not the case when pg was writing software for Viaweb and there wasn't nearly as much FOSS that you could just use. At that point in time the LANGUAGE was probably much more important because there was not a lot of differentiation beyond that. Now, we're at a point where the language isn't as important and the ECOSYSTEM around it is much more powerful that then language itself."
Arc's own codebase doesn't implement comments of any sort, but it relies on Racket's line comments, so those at least are reliable across Arc implementations.
; A multi-line comment (nestable):
#|foo bar
baz|#
; A commented-out s-expression:
#;(foo bar
baz)
; A commented-out s-expression which happens to be a string:
#;"foo bar
baz"
; A commented-out s-expression which happens to be a symbol:
#;|foo bar
baz|
; A shebang comment
#! foo bar \
baz
That version of `atom?` always returns nil, so I'll offer a correction.
Here's a very direct transliteration:
(= atom?
(fn (x)
(and (no (acons x)) (no (no x)))))
The equivalents for `not` and `null?` in Arc are both `no`, because the empty list is the only falsy value. Scheme uses dedicated values for true and false, `t` and `#f`, but Arc uses the symbols `t` and `nil`, and `nil` doubles as the empty list.
Here's a version that uses the utilities Arc provides out of the box:
Also, from an outside perspective, I think your idea for a "Arc for Scheme" primer would be a great idea. The Little Schemer is widely recommended, so it could potentially result in more people finding their way into Arc.
I'm not sure how many people here follow the github account, so if you have questions just post them here. Don't worry about creating too many posts or comments, it's not like there's a lot of contention here :) Just do what works best for your learning, and we'll let you know if we want you to scale back.
If you see something broken or have suggestions to improve the documentation, post them on Github.
Right. I created one in Ruby not too long ago. Then I decided I wanted to see it in the browser, so I used something called Opal to convert my Ruby code to JS. Then I built up the necessary html/css.
I think you can go pretty far treating Arc as a dialect of Scheme. Arc is basically like Scheme + Lisp-style macros. So until you start dealing with macros things should correspond pretty closely. The names change, as you already noticed, so () is nil and not is no[1]. A second point of difference is that Arc tends to have fewer parens, so for example this Scheme code:
(let ((x 3) (y 4))
...)
turns into this in Arc:
(with (x 3 y 4)
...)
Kinnard is right that the atom primitive is pretty much what you want. The exact transliteration of your definition would be:
(def atom? (x)
(and (no x) (no (alist x))))
Or, with more syntactic sugar:
(def atom? (x)
(and no.x (~alist x)))
[1] Hmm, somebody should write a "Arc for Scheme programmers" primer, just with a quick cheatsheet of common names and their equivalents. Any takers?
Ah, well, I skimmed it yesterday. Which I guess skimming is the last thing to do when it comes to a document of that sort ^.^
Essentially, I want to learn Lisp because the colloquial "they" recommend it to gain a better understanding of programming in general.
I want to learn Arc because it seems to take the lisp philosophy to heart the most out of the lisps.
And generally, I'm the type of person that can withstand some amount of "jumping into the deep end." Although, I may be in a bit too deep this time. Heh.
I'll probably continue to lurk around here until I've got a bit more experience under my belt, and thoughts to contribute.
Yeah I figured that would be the deal getting into it, but I'm still willing to learn it. I think the whole philosophy is really neat.
I think what I'm going to try to do is continue to play around with Arc, while also learning on something a bit more established. Maybe Scheme or Clojure.
Though I think a real stack exchange community is in order.
As to your question, I'm not qualified to answer, but it depends on your goals. What are your goals?
EDIT: Probably not though. Arc is intended to be "powerful"[1] not "educational" and Arc doesn't behave the way scheme does in(I believe) a lot of cases, e.g.: https://github.com/arclanguage/anarki/issues/48
These kinds of articles fascinate me for showing what is possible.
APL/K/J seem to epitomize this kind of code golf. Tried the J example on my phone and it worked. Don't have a clue as to how it works or what it is saying. From the comments on HN:
each column is a row number, and the integer is which column the queen is in, or vice versa on rows and columns.
,or print how many solutions
$queens
92 8
$ gives the 'shape' of the array, that is 92 rows (solutions) x 8 columns (8-queens problem).
Hmmm, that's interesting but I don't think it's what I'm running into. I get it on a first visit. I don't think my housemates are visiting the arc-forum at all . . .
I don't know if this is the same as what you're seeing, but there's a feature of Arc application servers that does this. It's meant for rate-limiting people who might be attempting denial-of-service attacks against the site:
The default settings throttle anyone who's doing 30 requests in 10 seconds. Each page load does 5 or 6 requests to get images and such, so we can get throttled if we reload or follow links 7 times in 10 seconds. When I try it on Arc Forum, it seems to be doing exactly that.
At Hacker News... if I go a few pages into the recent comments and hit F5 approximately 30 times in 10 seconds, I get an Nginx error page. Hacker News probably lets Nginx serve its static files rather than having every request go through the Arc server's throttle, but otherwise its configuration seems to be pretty similar.
Maybe you're navigating 7 times in 10 seconds by hand, but there are other possibilities too. If you're on the same external IP address as others who are accessing the Arc Forum, you might all be under a single rate limit.
This is great! The description of quoting using signifier and signified, the description of trees be evoking the nested nature of natural language, .. (still reading)
