Dave Herman

Dave Herman has been a high signal-to-noise contributor to Lambda the Ultimate over the years; if you want to get an idea as to where he is coming from, looking at his contributions there [1], his slightly active blog [2], and on his now pretty much inactive joint blog [3] are good places to start. [1]: http://lambda-the-ultimate.org/user/825/track?sort=desc&order=auth… [2]: http://calculist.org/ [3]: https://www.thefeedbackloop.xyz/

While this is true in some sense, there are also advantages. A ruby gem written in Rust via C FFI was one of the earliest production uses of Rust; the Skylight people still thought (and think) that it was very, very worth it. https://www.youtube.com/watch?v=2BdJeSC4FFI is a further exploration of this idea and how it works. Yes, you do need that small layer, but future libraries will make it even easier. There's the Neon work, for example: http://calculist.org/blog/2015/12/23/neon-node-rust/

Homoiconicity is either a trivial property (we can define an AST!) or a not-relevant-to-macros one (probably best expressed as "we have quote", which is basically true of JS). This post by Dave Herman nicely expresses the problems with homoiconicity as a concept: http://calculist.org/blog/2012/04/17/homoiconicity-isnt-the-point/

> I used to like Lisp's homoiconicity. These days, I'm not even sure the concept makes any sense? What is it even supposed to mean? You are not alone: http://calculist.org/blog/2012/04/17/homoiconicity-isnt-the-point/

S-expressions aren't actually necessary for macros to work. You just have to be able to separate "READ" from "EXPAND" (to use Lisp-ish terminology). I believe, but am not sure, that this is possible for Go. (Of course, whether this is a good idea is another thing entirely. I probably wouldn't have included macros if I had been put in charge of Go 1.0, given Go's goals of simplicity.) More on this from my former colleague Dave Herman, who did his dissertation on macros: http://calculist.org/blog/2012/04/17/homoiconicity-isnt-the-point/

Yes: http://calculist.org/blog/2012/04/17/homoiconicity-isnt-the-point/

But most compilers have a parser. Scheme doesn't need one ;) http://calculist.org/blog/2012/04/17/homoiconicity-isnt-the-point/

previous -> http://calculist.org/blog/2015/12/23/neon-node-rust/

With specific C++ features there is still a lot of work to do, however the C FFI is solid and simple to use if that is enough for you (see e.g. https://doc.rust-lang.org/book/ffi.html). Interfacing Rust and python, ruby, node can be quite simple in fact (micro demo for node: http://calculist.org/blog/2015/12/23/neon-node-rust/)

Macro systems are becoming increasingly popular (e.g. Rust and Sweet.js), but arguably neither of those languages is homoiconic in the Lisp sense (though see also Dave Herman's "Homoiconicity isn't the point" http://calculist.org/blog/2012/04/17/homoiconicity-isnt-the-point/ ).

Homoiconicity is a neat thing when you just get started, although there's some interesting discussion around that subject here - http://calculist.org/blog/2012/04/17/homoiconicity-isnt-the-point/

This feels almost like a parody to http://calculist.org/blog/2013/11/27/on-on-asm-js/

Delimited continuations are not gonna happen. See http://wiki.ecmascript.org/doku.php?id=strawman:shallow_continuations, http://calculist.blogspot.com/2010/04/single-frame-continuations-for-h… and http://calculist.org/blog/2011/12/14/why-coroutines-wont-work-on-the-w…

> Why even bother with such half-baked solutions? In almost every case it's utterly transparent that these solutions exist for the benefit of the compiler and runtime author, usually because of intentional or unintentional technical debt--a direct or indirect dependency on the C or kernel stack. There is a significant faction of language designers that disagree, and think that keeping coroutines shallow is important for developers writing and reading the code. This post from Dave Herman<(involved in JavaScript and Rust) sums it up: http://calculist.org/blog/2011/12/14/why-coroutines-wont-work-on-the-w… (The comment from Tom van Cutsem is also a good rephrasing: http://disq.us/p/9jcee9.) Note that the argument is not as applicable in languages with racy multithreading (like C/C++ or Java). I don't think it's necessarily a knockout argument, but it at least helps me sleep with what we've chosen for JavaScript.