Dave Herman, a Mozilla researcher and W3C TAG candidate, writes about JavaScript, Rust, macros, and web platform design.
Commenters describe him as a high signal-to-noise contributor and cite his post arguing homoiconicity is not the point when discussing Lisp macros.
> 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-web/. (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.
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/
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/
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=author
[2]: http://calculist.org/
[3]: https://www.thefeedbackloop.xyz/
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/
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/)