5 ms·

Arc has a very nice implementation that is bootstrapped from an impressively small number of primitives, is easy to understand, and very hackable. It was the fi

Arc has a very nice implementation that is bootstrapped from an impressively small number of primitives, is easy to understand, and very hackable. It was the first language implemention that I was really able to wrap my head around and modify in useful ways, as someone who (at the time) had no formal training in programming languages. The language itself has a focus on short names. Besides that and a few minor innovations, there really isn't much to it. I think pg considered this a feature (if Lisp is a good idea, you can't expect one to be that different from another). However, having gotten a PhD in programming languages since I messed with Arc, I can't say this is something I agree with...

dataangel 5y ago
What did you learn in your PhD that changed your mind?
- mettamage 5y ago
  Seconding this question.
- eslaught 5y ago
  Coming back to this a bit late, so I'm not sure who will read this, but here goes. Arc tries very hard to be a minimal language. This is good for the implementation (which is short, and therefore easy to read and hack). It was also an expression of pg's thinking about language power, which if I recall he defined as how concise programs in the language can be. The intuition being that a minimal language would naturally be powerful because finding the smallest set of primitives to define the language itself forces them to be orthogonal and expressive enough that you can build anything else on top of that. But I'm not sure this is true; instead I think what actually seems to have happened with Arc is that pg retreaded much of the same ground that Lisp had already covered, just with shorter names and some minor syntax sugar. In short, for a PL PhD, not very interesting. In general I'd say during my PhD I learned that there's a non-trivial tradeoff between minimality, expressiveness, and static analysis (which is related to both safety (via type systems) and performance (via compiler optimizations)). The static analysis problem for nearly any non-trivial property is very hard in most general purpose languages. In fact it's so hard that we've basically given up trying to do aggressive static analyses (for things like whole-program parallel and distributed code generation). And yet, if you're willing to introduce non-minimal features, it turns out that some of these problems are actually tractable. Here are some examples of the sort of thing I'm talking about from my own work: [0][1][2][3]. I'd also add that some of the things I thought were great about Lisps have actually been replicated in more syntax-ful languages (e.g., Terra [4] has metaprogramming with very similar power to Lisp, and also many advantages I haven't seen in any Lisp implementation). And meanwhile, some things that Lisps have traditionally included, like a self-contained, owns-the-world, garbage collected implementation, aren't necessarily all they're cracked up to be, as we've seen with e.g., Rust's approach to safety and performance without a GC. So in general, I think we've seen a lot of interesting developments in the PL world in the last 10-ish years, and most of them have not come from the Lisp community. [0]: https://legion.stanford.edu/pdfs/dpl2016.pdf https://legion.stanford.edu/pdfs/dpl2016.pdf [1]: https://legion.stanford.edu/pdfs/cr2017.pdf https://legion.stanford.edu/pdfs/cr2017.pdf [2]: https://legion.stanford.edu/pdfs/parallelizer2019.pdf https://legion.stanford.edu/pdfs/parallelizer2019.pdf [3]: https://legion.stanford.edu/pdfs/idx2021.pdf https://legion.stanford.edu/pdfs/idx2021.pdf [4]: https://terralang.org/ https://terralang.org/
  - math-dev 5y ago
    Thanks!

dataangel 5y ago

What did you learn in your PhD that changed your mind?

mettamage 5y ago
Seconding this question.
eslaught 5y ago
Coming back to this a bit late, so I'm not sure who will read this, but here goes. Arc tries very hard to be a minimal language. This is good for the implementation (which is short, and therefore easy to read and hack). It was also an expression of pg's thinking about language power, which if I recall he defined as how concise programs in the language can be. The intuition being that a minimal language would naturally be powerful because finding the smallest set of primitives to define the language itself forces them to be orthogonal and expressive enough that you can build anything else on top of that. But I'm not sure this is true; instead I think what actually seems to have happened with Arc is that pg retreaded much of the same ground that Lisp had already covered, just with shorter names and some minor syntax sugar. In short, for a PL PhD, not very interesting. In general I'd say during my PhD I learned that there's a non-trivial tradeoff between minimality, expressiveness, and static analysis (which is related to both safety (via type systems) and performance (via compiler optimizations)). The static analysis problem for nearly any non-trivial property is very hard in most general purpose languages. In fact it's so hard that we've basically given up trying to do aggressive static analyses (for things like whole-program parallel and distributed code generation). And yet, if you're willing to introduce non-minimal features, it turns out that some of these problems are actually tractable. Here are some examples of the sort of thing I'm talking about from my own work: [0][1][2][3]. I'd also add that some of the things I thought were great about Lisps have actually been replicated in more syntax-ful languages (e.g., Terra [4] has metaprogramming with very similar power to Lisp, and also many advantages I haven't seen in any Lisp implementation). And meanwhile, some things that Lisps have traditionally included, like a self-contained, owns-the-world, garbage collected implementation, aren't necessarily all they're cracked up to be, as we've seen with e.g., Rust's approach to safety and performance without a GC. So in general, I think we've seen a lot of interesting developments in the PL world in the last 10-ish years, and most of them have not come from the Lisp community. [0]: https://legion.stanford.edu/pdfs/dpl2016.pdf https://legion.stanford.edu/pdfs/dpl2016.pdf [1]: https://legion.stanford.edu/pdfs/cr2017.pdf https://legion.stanford.edu/pdfs/cr2017.pdf [2]: https://legion.stanford.edu/pdfs/parallelizer2019.pdf https://legion.stanford.edu/pdfs/parallelizer2019.pdf [3]: https://legion.stanford.edu/pdfs/idx2021.pdf https://legion.stanford.edu/pdfs/idx2021.pdf [4]: https://terralang.org/ https://terralang.org/
- math-dev 5y ago
  Thanks!