111–120 of 164 posts
> And it's small. Currently the interpreter, JIT, GC, and stdlib clock in at about 10.3MB once compiled down to an executable. Oh how the definition of "small" has changed. I actually would like to know how they managed to make something like this so big . To compare, LuaJIT is about 400 KB, and that includes the Lua standard library, a JIT almost certainly more advanced than Pixie's current one, an incremental GC, a…
Earlier quoted context omitted.
SBCL does not create binaries per se, but dumps the program image. While it practically is a binary, it's not equal to an executable that a conventional compiler/linker produces.
I wonder why tree shaking is so ineffective. Is that because any symbol could be accessed dynamically at runtime?
Earlier quoted context omitted.
I wonder why tree shaking is so ineffective. Is that because any symbol could be accessed dynamically at runtime?
eval is the root of all evil. String to symbol lets you introduce anything.
Earlier quoted context omitted.
> But there are also interpreted interpreters aren't there? I mean, not in use.... What would be the point? Every other interpreter worth using is AOT compiled, it's hardly something to boast about. One exception might be JRuby, I suppose. Kind of a strange comparison to go out of your way to disabuse.
Not strange at all. The main language inspiring pixie is clojure, whose interpreter runs on the JVM. I might even go so far as to say that the main reason to use pixie is because you want to write clojure but can't afford to use a JVM for the task at hand
IIRC with RPython/pypy the two techniques are interleaved, but most users I've seen opt for some JIT optimization.
Earlier quoted context omitted.
eval is the root of all evil. String to symbol lets you introduce anything.
In lisp eval does not take a string as its input, but a form , i.e. a linked list, containing the program to execute. Maybe you confuse it with JavaScript or Python eval (or the like) where the function both reads in a string and runs the program it parsed from that string. There are diverse functions to convert a string to a symbol in different lisps.
in this case
(funcall #'+ 1 2 3)
(apply '+ '(1 2 3))
So if that's true, you run into this problem:
(funcall (string->symbol "+") 1 2 3)
(apply (string->symbol "+") '(1 2 3))
so anyway, at the end, you run into this problem:
(funcall (string->symbol "any-random-function") 1 2 3)
(apply (string->symbol "any-random-function") '(1 2 3))
you could, of course, look for the handful of ways to bind symbols to functions, maybe do constant folding and include a minimal set if the compiler can prove what's actually needed.
but in general i think tree shaking is hard when you can load things like that dynamically.
I'm the original author of pixie, and yeah, I'm a bit surprised to see this hit HN today. It should be mentioned that I put about a year of work into this language, and then moved on about a year or so ago. One of the biggest reasons for my doing so is that I accomplished what I was looking for: a fast lisp that favored immutability and was built on the RPython toolchain (same as PyPy). But in the end the lack of sup…
As a somewhat different data point, we've been developing pycket, an implementation of Racket on top of rpython, for the past 3 years, and while it faces many of the same challenges, we've been very happy with the results. The JIT can remove almost all of the intermediate data structures caused by the functional nature of the language, and we support tail calls and first class continuations. Overall, pycket is almost…
> If you like Clojure, but are unhappy with the start-up time, or if you want something outside of the JVM ecosystem, then Pixie may be for you YES! :D
Earlier quoted context omitted.
> Clojure vectors are nice for the performance they give. What difference does it make when representing code?
Vectors eval to themselves, while lists eval to a function/macro/special-form call. Vectors also differ from lists in that they are ordered and indexed, so in macros and special forms they tend to be used to represent positional bindings.
(let [a [x y]] ...)
(let [x y] ...)
(fn [x y] ...)
(defn foo ([] (foo 0)) ([n] ...))
Earlier quoted context omitted.
A big one is persistent data structures. Where 'persistent' may not mean what you think it means. In Clojure it is impossible to surgically modify a data structure. That is, you can't do something like: (SETF (CAR (CDR x)) 'foo) which would alter a data structure. You can modify a data structure, but it returns a new data structure, yet the old one remains if it is not GC'able. All of the common data structures have…
How is the cost of copying close to zero or not apparent?