http://paste.lisp.org/display/50797

I dont use emacs, but I found it pretty easy to find good sites on this kind of stuff.

Seriously - Originally I had thought it was just me, but I am noticing this more now.

Even google cache proves it's been changed:

http://www.google.com/custom?domains=arclanguage.org&q=M...

used to be:

http://news.ycombinator.com/item?id=43635

  (load "news.arc")
  (nsv)

Why would you want to do that? If it's just so the terminal window isn't up, I would suggest using screen -> http://www.gnu.org/software/screen, or if using a mac you could run an apple script which would run the process silently:

     do shell script "cd /Users/thaddeus/arc;
     /Users/thaddeus/scheme422/bin/mzscheme -f loadscript.scm"

Here's what I normally do as per how-to-run-news.txt

mzscheme -f as.scm

I get the mzscheme prompt. I type:

(load "news.arc") (nsv)

It runs well, so far so good, but I have the interactive interpreter. As soon as I shut down, the service disappears.

To run it as a shell script I looked at mzcheme man page and tried to run the following in a script called run_hacker_news.sh:

[script starts] #! /bin/sh #|

exec /home/bahadir/mz/bin/mzscheme -f as.scm |# (load "news.arc") (nsv) [script ends]

  Or indent a line by at least two spaces to get text verbatim.

I use Textmate with Terminal. There's an bundle for it here -> http://github.com/aran/arc.tmbundle It's a little out of date, but you can easily hack changes to it if you need to.

> What does Arc have built in? Is it ALL covered in the tutorial?

Arc has nothing built in (for ide/gui/editor management), so it's not covered in the tutorial.

> Why isn't there a little website that lists and documents all the built-ins in Arc?

I think pg (paul graham) has chosen this forum as a means for distribution/collaboration. I suggest you check into -> http://af.searchyc.com/ since, by default, the forum has no built in search mechanism There's also google -> http://lmgtfy.com/?q=arc+forum+between (lol - I had to use lmgtfy at least once in my life :).

They just don't want to submit them yet -- work being done on the compiler and such: http://www.reddit.com/r/programming/comments/2krih/factor_90... (granted, this link is a year old)

Hello World in Arc:

   arc> (pr "Hello World")
   Hello World

   Prelude> putStrLn "Hello World"
   Hello World

   USE: io
   IN: hello-world
   hello ( -- ) "Hello world" print ;
   MAIN: hello

  $ factor -run=listener
  Loading ~/.factor-rc
  ( scratchpad ) "Hello word" print
  Hello word

http://concatenative.org/wiki/view/Factor/Examples

I presumed that without "USE: io" that "Hello World" was not being sent to the standard output where as my arc/haskell examples actually were. i.e. With arc I could load/run a file/script with (pr "Hello World") and it would output "Hello World", but with Factor?...

I just went to each language site and looked for the Hello World examples. It may be that Factor could do a better job advertising AND that I need to spend more than 5 minutes looking :)

I presumed that without "USE: io" that "Hello World" was not being sent to the standard output

Actually, that line's like an import statement in Haskell. I would say it's like load in Arc, but that's not really true; USE: and import have to do with module systems, which Arc doesn't have. If you're already familiar with modules, you can skip this stupid explanation, but...

Basically, modules let you structure your functions into different places so that they don't mess with each other. As a silly example, maybe you write a text adventure in Arc and name a function get, as in (get 'ye-flask). But Arc already defines a function called get, as in (map (get 'a) list-of-hash-tables). You want to be able to use both of them at the same time, but would rather not rename your new function. If Arc had modules, you could qualify the function name with the name of the module in which it's defined. Something like

  (use 'game)
  (game.get 'ye-flask)
  (map (get 'a) list-of-hash-tables)

This is a vast oversimplification, of course, but that's essentially what they do. So, in languages like Factor, all the I/O routines are in a module called "io". In the io library is a function called print. If you don't need to print things, you don't need to USE: io, which helps keep the "surface area" of your code small.

i.e. With arc I could load/run a file/script with (pr "Hello World") and it would output "Hello World", but with Factor?...

Because Arc doesn't separate anything into modules, you don't need to import things like pr since it's already there by default. The reason the Haskell code in my other reply could do without the import is that putStrLn is similarly defined in Haskell by default: it's in the so-called "standard prelude". That's what the Prelude> prompt tells you in GHCi. You can import other libraries in GHCi, and the prompt will tell you what you're using:

  Prelude> :m + Control.Monad
  Prelude Control.Monad> :m + System.IO
  Prelude Control.Monad System.IO> :m + Foreign.C.Types
  Prelude Control.Monad System.IO Foreign.C.Types>

yup... I should really write then post :)

> Hope that helps.

True. After all, transliterating the Factor example to Haskell looks something like

  module Main where
  import System.IO (putStrLn)

  hello :: IO ()
  hello = putStrLn "Hello world"

  main = hello

  module Main where

  main = putStrLn "Hello world"

It's really neither here nor there: picking a language and getting at least somewhat comfortable with it is going to be better than endlessly deliberating. They all have their merits (even bad languages!).