Arc Forumnew | comments | leaders | submit | akkartik's commentslogin

I don't recall the details atm, but I believe https://github.com/arclanguage/anarki does this correctly. Can you check? Read the readme for caveats first, though.

reply

1 point by akkartik 15 days ago | link

Yes it does.

    $ git clone git@github.com:arclanguage/anarki.git
    # install Racket 7.7
    # create x.arc
    $ cat x.arc
    (prn "hi")
    $ anarki/arc.sh
    arc> (load "x.arc")
    hi
But like I hinted, anarki is the community-managed fork and has 3 incompatibilities with Arc 3.2. Be especially careful if you're already managing a HN-like site using Arc 3.2.

reply

3 points by akkartik 40 days ago | link | parent | on: Arc Forum installation Step 3

Is this step 3 at http://www.arclanguage.org/install? You need to open a terminal. What OS does your computer use?

reply


I love the first sentence in the doc:

"As far as feasible, it macroexpands expressions ahead of time instead of just interpreting everything."

Still reading.

-----

1 point by akkartik 63 days ago | link

"However, there’s a certain kind of seamlessness Fexpress won’t attempt: Racket’s and can’t be passed into Racket’s map, and sometimes this surprises people who expect macros to act like functions. In languages with fexprs as the default abstraction, it tends to be easy to implement and and map in such a way that this interaction succeeds."

Do you have an fexpr-aware version of map at the moment? Or and? Or do you have to switch both?

-----

2 points by rocketnia 62 days ago | link

The point I'm making in that paragraph is that there are reasons for `map` and `and` not to work together even in an fexpr-capable language. So I'm not sure what you're asking for; I'd say Racket's `map` and `and` already are "fexpr-aware."

Are you asking for clarification on how "this interaction succeeds" in a language where fexprs are more pervasive?

Let's see... I found an online PicoLisp runner.

As an initial test, `prin` prints and returns its string argument, and anything non-NIL counts as truthy:

  : (and (prin "hello^J") NIL (prin "world^J"))
  hello
  -> "hello^J"
So here's `mapcar` mapping a function over two lists:

  : (mapcar '((a b) (+ a b)) (list 1 2 3) (list 4 5 6))
  -> (5 7 9)
Here it is mapping `and` over two lists, where "the interaction succeeds" in the sense I was referring to:

  : (mapcar and (list T NIL) (list NIL (prin "oops^J")))
  oops
  -> (NIL NIL)
Here it is mapping a custom fexpr over two lists so we can see what unevaluated arguments it observes:

  : (mapcar
      '(args
        (println args)
        (and (eval (car args)) (eval (cadr args))))
      (list T NIL)
      (list NIL (prin "oops^J")))
  oops
  ($177775247560141 $177775247560143)
  ($177775247560141 $177775247560143)
  -> (NIL NIL)
(PicoLisp doesn't evaluate rest arguments like `args` here, even though it does evaluate every other argument in the argument list, and that's by design. This is how we can write custom fexprs.)

It appears that what our fexpr observes is a list of what PicoLisp calls "anonymous symbols" (probably like gensyms), which apparently are bound to the already-evaluated argument values.

Incidentally, notice how this `mapcar` call fully evaluates the list arguments, including the part that prints "oops." That makes these two programs arguably inconsistent:

  : (mapcar and (list T NIL) (list NIL (prin "oops^J")))
  oops
  -> (NIL NIL)
  : (list (and T NIL) (and NIL (prin "oops^J")))
  -> (NIL NIL)
When the transformation passed to `mapcar` is a pure function, refactoring a `mapcar` call this way makes no difference. When the transformation is a side-effecting procedure, it does make a slight difference because one transformation call might perform its effects before the next transformation's arguments have started to be evaluated. And here, when the transformation is `and`, this refactoring makes a difference because `and` usually changes how often its arguments' effects are performed, but `mapcar` doesn't let it have that control.

That more or less makes sense operationally, but it means that in PicoLisp, I could imagine `mapcar` being more "fexpr-aware" than it is now. A more fexpr-aware design for `mapcar` would either:

- Allow `and` to affect the evaluation of `mapcar`'s own arguments. Now we get to implement a way to evaluate a list-valued expression without evaluating the list elements, so that we can pass the elements along to `and`. And once we're done with that, what should happen when we map fexprs that aren't even procedure-like, such as (mapcar let ...) or (mapcar setq ...)? Is there even a point to doing any of this?

- With full awareness of fexprs, make the decision to explicitly disallow non-procedure fexprs from being used with `mapcar`. That way, we don't even open up that can of worms.

Racket's `map` essentially accomplishes the latter.

-----

2 points by rocketnia 62 days ago | link

By the way, if you'd be interested in a version of `and` that can be used as both a Racket macro with short-circuiting behavior and a first-class procedure without it, you can do that in Racket (using essentially a symbol macro):

  (define (my-and-procedure . args)
    (andmap identity args))
  
  (define-syntax (my-and stx)
    (syntax-parse stx
      [_:id #'my-and-procedure]
      [(_ args:expr ...) #'(and args ...)]))
This basically reproduces the same halfheartedly fexpr-aware behavior as PicoLisp, but without any fexprs:

  > (map my-and (list #t #f) (list #f (displayln "oops")))
  oops
  '(#f #f)
  > (list (my-and #t #f) (my-and #f (displayln "oops")))
  '(#f #f)
In the context of Fexpress, this punning can be taken to another level, letting the first-class version of `my-and` be both a procedure and an Fexpress fexpr at the same time, while the second-class calls to it have Racket macro behavior. I've put together a test to demonstrate it:

- Code link: https://github.com/rocketnia/fexpress/blob/main/fexpress-tes...

- Code link pinned to the current commit as of this writing: https://github.com/rocketnia/fexpress/blob/e33c07a4e8252793a...

In the Fexpress proof of concept, there's no way to convert between Fexpress fexprs and Racket macros in either direction. That makes this punning pretty pointless, except perhaps as a technique for publishing libraries that can be used roughly the same way by both Racket and Fexpress programmers.

-----

1 point by akkartik 61 days ago | link

Sorry, I do know that fexpr lisps can combine `map` and `and`. It sounds like you're proposing a different approach in Fexpress, so I was wondering what sort of vocabulary you are imagining. Were you thinking you'd have something called `map/f` that can take non-functions as its first argument? And so there'd be fexpr-aware variants for all higher-order functions? (Thinking harder, an `and/f` doesn't really make sense here.)

-----

2 points by rocketnia 61 days ago | link

"Were you thinking you'd have something called `map/f` that can take non-functions as its first argument?"

No, I was thinking `map` should only take a procedure.

I don't think there's a particular way to "map" an fexpr that stands out as a compelling abstraction. I propped up a certain ambitious "evaluate a list-valued expression without evaluating the list elements" vision for `map` above, but this is really more of a lazy function map than an fexpr map.

The `map` operation is basically about the list data structure. Since it's a data structure that holds its elements eagerly, we can transform it with an eager function. If it held its elements lazily, we could use a lazy function. If it held its arguments unevaluated-ly, and if the elements didn't even have to be expressions, then the abstractions we could map over these lists might be fexpr-like, but I don't know of a way to make that make sense.

If you're thinking "but then what do you do with an fexpr once you have one?" I don't know. I've only found so many compelling uses for fexprs, which have to do with places where the code of the call site is needed at run time, possibly because run time and compile time are tangled up:

- Defining custom syntaxes in mutually recursive ways that involve invoking some of the syntaxes before some of the others have finished being defined.

- Making macro systems where redefinitions of the macros automatically propagate to change the behavior of previously defined things that call them.

- Writing abstractions that take care of their own JIT behavior. In order to strategically recompile their use sites according to usage statistics collected at run time, they need access to both the source code and the ability to observe run-time conditions.

In each case, fexprs would be serving as a language front-end layer, not as internal building blocks for general-purpose computation. I think source code is second-class in an essential way; although we can write macro abstraction layers that fabricate source code as they go along, this makes it harder to report informative errors in terms of the user's original code. Macros and fexprs take source code as input, so they're tied to the language front-end in a way that procedures aren't.

And when the source code isn't something we're abstracting over much, then neither is the environment of macros or fexprs that are in scope there. (Like, the environment is more or less an annotation on the source code, and if we focus on having only one original source codebase to annotate this way, then we only have one set of annotations to produce.) So a lot of the best techniques for macros or fexprs are likely to be self-contained abstractions that keep their first-class manipulations of macros and fexprs behind the scenes, rather than whole programming styles which make pervasive use of macros or fexprs as first-class values.

-----

2 points by akkartik 61 days ago | link

Thank you, that is very helpful! And this also matches some of my growing ambivalence with macros.

When I was building Wart[1], I repeatedly ran into situations that seemed very difficult to debug. Looking back, I tend to debug by simulating computation in my head, and macros made it easy to create code that was more complicated than I could visualize[2]. When I built Mu[3] I hoped that backing away from first-class macros and pervasive support for traces[4] would help. That's still in early days, but the evidence is quite ambivalent so far.

[1] https://github.com/akkartik/wart

[2] https://www.goodreads.com/quotes/273375-everyone-knows-that-...

[3] https://github.com/akkartik/mu

[4] https://archive.org/details/akkartik-mu-2021-06-23

-----

2 points by rocketnia 55 days ago | link

I think macros can get pretty complicated fast. I think in some ways it's at least as hard to write well polished macros (with good error messages, editor support, debugging steppers, pretty printers, and so on) as it is to build a well polished language without macros. I think the reason it feels easy to write macros in many languages is because many languages don't set a high bar for a polished experience.

I don't think taking macros out is an answer I'm very interested in, though. I want people to be able to use my stuff without having to write code the same way I do, and vice versa. Some kind of syntactic extensibility is important to me.

And I don't think taking macros out even really eliminates the "tied to the front end" non-compositionality issues. Every abstraction that can be used has a user experience, and macros just take more control of that experience than functions do. Every time a programmer tries to report a friendly error message from a function, they're trying to take some control over that experience, but the capabilities of a function only give them so much information to work with.

A language without macros can supply a one-size-fits-all kind of polished experience, which may indeed be a much better experience than what most macros provide in practice. But a language like that also imposes a practical limit on how much more polished it can get, especially for domain-specific applications that don't have the attention of the language developers.

reply

1 point by akkartik 54 days ago | link

To be clear I still use macros. I'm skeptical of the benefit of fexprs, but it totally makes sense to support them as a sharp-edged, high-power capability intended to be used rarely.

reply

2 points by rocketnia 54 days ago | link

There's not much use I have for fexprs. I just had certain ideas about how they fit in with other concepts and how they could be made compatible with a compilation-favoring workflow.

I consider it basically a mistake to use the same syntax for macro calls and function calls... but not because they're different things. When we want to invoke a function like a macro, we can just conceptualize it as a macro that expands into a function call.

I think it's the same for fexprs. Macro calls can more or less expand into fexpr calls by simply preserving all the code they received under a `quote` in their expansion result. This doesn't quite get us a lexical-scope-respecting version of fexprs unless we also capture the local lexical environment, and that's not necessarily possible depending on the macro system, but it's not much of a stretch:

- Racket's macroexpander keeps track of the set of local variables in scope, but it doesn't quite expose it to user-defined macros.

- Arc's macroexpander `ac` keeps track of the set `env` of Arc local variables in scope, but it doesn't expose it to user-defined macros.

- In Guile, the local environment can be captured using (procedure-environment (lambda () '())).

- Fexpress currently lets compilation-friendly fexprs do this using the `depends-on-env?` field of a `compilation-result?` data structure. If a subexpression depends on the lexical environment this way, (fexpress-clambda ...) forms surrounding that subexpression expand differently so that they create a run-time representation of the lexical scope. This way, no one step in the code has to traverse or build up the whole environment, so the cost is spread out. Since Fexpress's variables are immutable, variable accesses don't even have to go through this run-time environment; they can be Racket variable accesses.

Anyhow, I basically consider fexprs to be one of the things a macro-capable language is theoretically capable of, even if people don't commonly prefer to use that functionality and macro systems don't always quite offer it.

I've been interested in exploring the concept of typed macros in general for the purposes of designing module systems which have both macros and typed API signatures. And I've had typed fexprs on my mind as an optimization approach since the Eight thread way back when, and I expect these two trains of thought to be on their way to the same destination.

With Fexpress, I explored the typed fexpr side, and I kept a really narrow focus on types for optimization rather than API boundary delineation so that I wouldn't make it any more complicated than it had to be. I don't want to be like "oh, by the way, in this complex type system for macros, you can find fexprs if you look for them," because some people might recoil at that. :-p And if I said something like that, but I didn't actually have an fexprs-by-default language ready to show, that would be quite a tease.

The actual languages I build with these ideas will probably not have fexpr calls as the default behavior for calling a local variable. Personally, I prefer not to have any default; it's not too much work to write out `funcall` unless I have a whole DSL's worth of local variables I'm invoking. But if it's a typed language, a lot of the local variables will probably have Lisp-1-style behavior anyway, because a variable of function type could be known to have function-call-like macro behavior and so on. And if some of the types people use turn out to declare that their variables have fexpr-like call behavior, I'll consider that to be an interesting outcome. The types, if they do any kind of soundness enforcement (unlike Fexpress's unsound hints), can keep those fexprs from sneaking into other people's code unless they're ready to receive them.

I know API enforcement wouldn't necessarily be your favorite feature in those designs. :-p But I think that's basically the picture of where Fexpress-style fexprs slot into my long-term goals, basically as one part of the possibility space that macros have more room to explore with the help of a type system.

reply

1 point by akkartik 80 days ago | link | parent | on: Is the sort function broken in 3.2?

I can reproduce it. And it doesn't seem to depend on the comparison function:

    arc> (sort < '("orange" "pea" "apricot" "apple"))
    Error: "set-car!: expected argument of type <pair>; given: 577273856"
What version of Racket are you using? I'm running 8.2, and I see some weirdness:

    arc> (let x '("orange" "pea" "apricot" "apple") (= (car x) 1))
    1
    arc> (let x '("orange" "pea" "apricot" "apple") (= (car x) 1) x)
    Error: "invalid memory reference.  Some debugging context lost"
The "bleeding edge" community repo at https://github.com/arclanguage/anarki doesn't seem impacted.

Edit 14 minutes later: looks like 7.7 shows identical errors.

Edit 45 minutes later: all this works fine with Racket 6.0. That version was already dealing with immutable lists by default (https://download.racket-lang.org/releases/6.0/doc/compatibil...), so I'm inclined to consider this a regression in Racket.

-----


Y'all might recognize some of the definitions on the screen :)

Main project page: https://github.com/akkartik/mu

-----


I also see some failures in unit-test.arc:

    (require 'lib/unit-test.arc/unit-test.arc)
    (load "lib/unit-test.arc/tests.arc")
    (test-and-error-on-failure)

    unit-test-tests.suite-creation.add-tests-to-suite.tests-are-wrapped-to-create-test-result-template failed: (isa result (quote table)) should be nil but instead was nil
    unit-test-tests.remove-thing.remove-nothing-from-single failed: (remove-thing (quote (not-found)) single-suite) should be (obj (single #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash()) (suite-name . suite-with-no-name) (tests . #hash((nested . #s(ar-tagged tem (test #hash((suite-name . test-with-no-suite-name) (test-fn . #<procedure: g5264>) (test-name . test-with-no-name)) #hash())))))) #hash())))) but instead was (obj (single #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash()) (suite-name . suite-with-no-name) (tests . #hash((nested . #s(ar-tagged tem (test #hash((suite-name . test-with-no-suite-name) (test-fn . #<procedure: g5264>) (test-name . test-with-no-name)) #hash())))))) #hash()))))
    unit-test-tests.remove-thing.remove-nested-test failed: (remove-thing (quote (single double one)) two-nested-tests) should be (obj (single #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash((double . #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash()) (suite-name . suite-with-no-name) (tests . #hash((two . #s(ar-tagged tem (test #hash((suite-name . test-with-no-suite-name) (test-fn . #<procedure: g5264>) (test-name . test-with-no-name)) #hash())))))) #hash()))))) (suite-name . suite-with-no-name) (tests . #hash())) #hash())))) but instead was (obj (single #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash((double . #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash()) (suite-name . suite-with-no-name) (tests . #hash((two . #s(ar-tagged tem (test #hash((suite-name . test-with-no-suite-name) (test-fn . #<procedure: g5264>) (test-name . test-with-no-name)) #hash())))))) #hash()))))) (suite-name . suite-with-no-name) (tests . #hash())) #hash()))))
    unit-test-tests.remove-thing.remove-one-of-two-suites failed: (remove-thing (quote (first)) two-suites) should be (obj (second #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash()) (suite-name . suite-with-no-name) (tests . #hash((nested . #s(ar-tagged tem (test #hash((suite-name . test-with-no-suite-name) (test-fn . #<procedure: g5264>) (test-name . test-with-no-name)) #hash())))))) #hash())))) but instead was (obj (second #s(ar-tagged tem (suite #hash((full-suite-name . suite-with-no-full-name) (nested-suites . #hash()) (suite-name . suite-with-no-name) (tests . #hash((nested . #s(ar-tagged tem (test #hash((suite-name . test-with-no-suite-name) (test-fn . #<procedure: g5264>) (test-name . test-with-no-name)) #hash())))))) #hash()))))

-----

3 points by zck 141 days ago | link

Updated unit-test.arc to the latest. PR at https://github.com/arclanguage/anarki/pull/205

-----

2 points by zck 141 days ago | link

Hrm, this should have been failing for a while. It comes down to functions never being able to be `iso` to each other.

  arc> (iso (fn ()) (fn ()))
  'nil
I suspect this might've changed in the new Racket? I hope this hasn't snuck through for so long.

Anyway, working on a fix now.

-----

3 points by rocketnia 141 days ago | link

At one point, years ago, I relied on every lambda returning a newly allocated object. I think I brought it up as a bug in Rainbow that the [] expressions in my Arc code were generating the same lambda-lifted result instead of creating unique objects each time.

But I think this was never something I could rely on in the original, Racket-based Arc either. The Racket docs don't specify whether a lambda expression returns a new object or reuses an existing one, and in fact they explicitly allow for the possibility of reusing one:

"Similarly, evaluation of a lambda form typically generates a new procedure object, but it may re-use a procedure object previously generated by the same source lambda form."

That sentence has been in the reference since the earliest versions I can find online:

The latest docs, currently for 8.1 (2021): https://docs.racket-lang.org/reference/Equality.html#%28part...

5.0 (2010): https://download.racket-lang.org/docs/5.0/html/reference/eva...

4.0.0.1 (2008): https://web.archive.org/web/20080620030058/http://docs.plt-s...

3.99.0.13 (2008): https://web.archive.org/web/20080229164003/http://docs.plt-s...

I'm not sure if the bug you're referring to had to do with making the same mistake I was making back then, or if you're talking about making the opposite assumption (expecting two procedures to be equal), but it's probably best not to expect stability either way.

-----

2 points by zck 140 days ago | link

I was doing a deep-`iso` comparison I called `same`, because in Arc, hash tables are not the same. In Arc3.1:

  arc> (iso (obj) (obj))
  nil
  arc> (iso (obj 1 2) (obj 1 2))
  nil
So I made a function that iterated over the key/value pairs and compared them. In some unit tests, I used that on a hash table that contained functions. Yesterday, I refactored the unit tests to instead make sure the keys were right.

Interestingly, it seems that Anarki can compare hash tables:

  arc> (iso (obj) (obj))
  't
  
  arc> (iso (obj 1 2) (obj 1 2))
  't
Anyway, this should fix the unit test tests in the Anarki repo.

-----

2 points by zck 141 days ago | link

Oh jeez, let me take a look.

-----

2 points by akkartik 141 days ago | link

Not on you. I know we forked it as well a while ago.

-----

1 point by krapp 141 days ago | link

>should be nil but instead was nil

I'm sorry, what?

-----

1 point by zck 141 days ago | link

It's printing out the two values it's comparing. Not sure yet why they're not the same.

It makes more sense when you see an error message like "should be 3 but instead was 2".

-----


It does work on my Mac with Racket v8.0. I'm at commit 009a8d9388 in the Anarki repo (May 9)

I'm not sure what's going on! Did it used to work for you on Windows 10? How long is the possible window of breakage?

-----

2 points by jsgrahamus 160 days ago | link

Thanks for checking in. The dates of the files in the directories is 2018. I downloaded recent version and gave it a spin: It took about a minute to start up and then I ran (app-start "news") and it started the news app.

Thanks again.

Steve

-----

2 points by jsgrahamus 160 days ago | link

Odd that downloading it again caused it to work.

-----


Do you have much experience programming? That'll help tailor advice for your situation.

The first step is to get Arc running like you asked before. After that the next step would be to go through the steps in how-to-run-news in the Arc directory.

There's a lot involved in maintaining a site for a community at this point in time. A good language can only help so much.

-----

2 points by Jonesk79 172 days ago | link

Yes, I have experience programming from years ago and recently started learning Python until I happened across Arc. I think it's neat and would be great for my project. Where is the how-to-run news in case I don't find it myself? Thanks

-----

1 point by akkartik 172 days ago | link

It's right inside the arc3.2.tar file. Just cd into the arc3.2 directory after you expand it, and you should see it. It looks like this: https://github.com/arclanguage/anarki/blob/official/how-to-r...

-----

2 points by Jonesk79 172 days ago | link

I run this code and check http://localhost:8080/ but nothing loads.

  arc> load "news.arc"
 
  #<procedure: load>

  arc> "news.arc"
  
  arc> nsv

  #<procedure:zz>

-----

3 points by Jonesk79 172 days ago | link

I ran (load "news.arc") this time and it prints out a list of items prefixed with * redefining and 'nil' returns after the last item.

However, nothing happens at localhost8080 and when I run (nsv) it gives this message:

  The syntax of the command is incorrect.

  The syntax of the command is incorrect.
  
  The syntax of the command is incorrect.
  
  The syntax of the command is incorrect.

  'rm' is not recognized as an internal or external command,
  operable program or batch file.

  load items: Error: "directory-list: could not open 
  directory\n  path: C:\\Users\\Hopet Ma'at 
  Amun\\Desktop\\arc3.2\\arc\\news\\story\\\n  system error: 
  The system cannot find the path specified.; win_err=3"

-----

2 points by rocketnia 172 days ago | link

There are a number of system calls like (system "rm ...") in news.arc and other places. These run shell commands, and most of them only work on a POSIX shell. I'm sorry to say, I'm not sure anyone has ever gone through all these calls and made them portable so that news.arc can run on Windows.

If you use the Anarki master branch, I think a few of those calls have been replaced with more portable code, but not all of them. I've at least been able to get a server started up and showing content before.

I used to use Arc on Windows quite a bit, and I tried the web server a couple of times, but I never really used the web server. Nowadays I still use Windows, but I do a lot of my programming projects inside a Linux Mint VM using VirtualBox. I think running news.arc inside a VM like that would be one of the easier ways to get it working. Of course, learning to set up a VM like that could be a lot to figure out, but at least that's something a lot of people out there have already written up tutorials for.

Another possibility is to look for one of the many Hacker News clones that people have whipped up in other languages. You probably won't get to use Arc that way, but some of those clones may be better architected and better maintained than news.arc.

-----

2 points by Jonesk79 171 days ago | link

I have found this and it looks promising. https://coderrocketfuel.com/courses/hacker-news-clone

My only concern is that it won't use the news.arc algorithm. In that case, I think I'd take the time to learn how to set up a virtual environment.

-----

2 points by akkartik 172 days ago | link

Ah, news.arc doesn't work on Windows, unfortunately.

-----

3 points by krapp 171 days ago | link

The Anarki fork should work, I run it in Windows.

https://github.com/arclanguage/anarki

-----

2 points by Jonesk79 171 days ago | link

Ok, thanks

-----

2 points by akkartik 173 days ago | link | parent | on: Arc Installation

It looks like you're trying to run racket -f as.scm inside Racket. It's just a terminal command. Open a new terminal (unrelated to Racket) and type it in there.

-----

2 points by Jonesk79 172 days ago | link

I got it set up in the regular terminal by adding the path to environment variables, however, it gave me the same message as before. Is there something more I should be doing with the untarred folder, maybe?

-----

1 point by akkartik 172 days ago | link

I'm not sure where the disconnect lies. I think we might need to discuss details more explicitly. What OS are you on?

-----

2 points by Jonesk79 172 days ago | link

You're a great help, thanks! I was typing in Racket before racket -f as.scm, when I don't need to

-----


I don't think so, since OP mentioned Arc 3.2 without any Nginx. I just tried it and I'm able to reproduce this issue with just the official branch in anarki (which is identical to Arc 3.2) without any Nginx.

Arc 3.2 doesn't get very frequent updates, but we should probably fix this in the stable branch. It shows the same error, and also has some errors in the log. Unfortunately I'm not sure when I can get to this. I've been having some RSI issues and time at the computer is limited at the moment.

-----

More