
Rewriting the Technical Interview - hprotagonist
https://aphyr.com/posts/353-rewriting-the-technical-interview
======
pmiller2
Clever, as usual. But, this could have been done in far less code in a
language that already supports term rewriting, such as _Mathematica_.

~~~
aphyr
Funny story--I am also a (recovering) Mathematica programmer! I'm not sure
it's quite as good of a fit, for a few reasons.

One is that Mathematica's syntax is, in a lot of ways, already pretty C-like.
It uses mutable assignment `x = y`, function-arglist syntax `Fun[arg1, arg2]`
instead of a Lisp-style `(f arg1 arg2)`, commas for list separators (in
Clojure, they're whitespace), braces `{a, b, c}` are a sequential construct,
rather than a map, and semicolons `first ; second ; third` denote sequential
expressions (in Clojure, ; is an end-of-line comment).

The second reason is that Mathematica, in my understanding, doesn't treat
parentheses as first-class syntactic elements: they're used to control
interpretation of the parse tree, but they transparently collapse, instead of
being accessible as a reified _type_. (Are they? I know Mathematica is sort of
an endless coal-mine of a language, and it's entirely possible I'm just not
experienced enough to know about this!) If this constraint is true, I'm not
sure how you would parse `func(arg1, arg2)` vs `func((arg1, arg2))`. Maybe
it's inferrable from any symbol followed by a list, since `(arg1, arg2)` gives
you a bounded context for the arglist, even if the parens disappear--and we
can give up on having `(a,b)` for tuples or `()` as a unit syntax. It might
also be inferrable from context, depending on what types of infix operators
you allow, and how ; works as a separator. My license is long-since expired,
so I can't test right now--perhaps you can give it a shot and show it off
here!

I wound up cutting this from the post, but... the full version of this
rewriter provides a Java-style OO syntax with property accessors and chainable
method calls. A tricky thing in Mathematica might be disambiguating
`obj.property` from `obj.method()`, if the `()` isn't reified. For that
matter, what do you do about `fun` vs `fun()`...

One possible workaround might be to exploit (as I've done to hack around
Clojure's insistence that "map keys be unique" and "maps have even numbers of
elements") lesser-used Unicode codepoints, only this time, using alternatives
for `(` and `)`, and to roll your own stack parser for arglist parsing...
ideas, ideas. :)

------
hprotagonist
previous entries in the series:

typing: [https://aphyr.com/posts/342-typing-the-technical-
interview](https://aphyr.com/posts/342-typing-the-technical-interview)

hexing: [https://aphyr.com/posts/341-hexing-the-technical-
interview](https://aphyr.com/posts/341-hexing-the-technical-interview)

reversing: [https://aphyr.com/posts/340-reversing-the-technical-
intervie...](https://aphyr.com/posts/340-reversing-the-technical-interview)

------
Fellshard
A new entry in one of my favorite series of blogs? I must be dreaming!

This is some black macro magic, indeed.

------
mdo123
Or... how to be a total jackass during your tech interview.

~~~
KirinDave
What's inappropriate about the behavior here, I wonder? The interviewer got
exactly what they asked for, and an awful lot more signal than they probably
were expecting.

