
Lisp Hackers: Vladimir Sedach - vseloved
http://lisp-univ-etc.blogspot.com/2013/03/lisp-hackers-vladimir-sedach.html
======
norswap
I had to read twice to make sure I understood correctly: this guy wrote a
C-to-Lisp compiler. That's something you don't see every day.

~~~
betterunix
Actually, I started working on one this past weekend as an exercise. The only
real work is the front-end; your Lisp compiler itself can serve as the back-
end.

It's not all that shocking; Prolog-in-Lisp is a common exercise, and in Let
over Lambda there is a chapter about Forth-in-Lisp.

~~~
ScottBurson
The problem with C-in-Lisp, though, is modelling the low-level behavior of C
using the high-level concepts of CL.

Case in point: pointer punning. Somebody takes a 'char _', writes some stuff
through it, then casts it to an 'int_ ' and starts reading that stuff back.
ZetaLisp, having been built to implement the Lisp Machine OS in, had some low-
level features that made this kind of thing doable, but those features did not
make it into Common Lisp (I'm thinking of displaced arrays with mixed element
sizes, though as I write this it occurs to me that it might be possible to
coax an open source CL implementation into dealing with this, if you can give
up on the generated code being portable CL).

If you want to look at Zeta-C, the sources and some commentary can be found
here: <http://wiki.alu.org/Zeta-C>

~~~
cwzwarich
The C standard doesn't actually require as much from the implementation as you
might think. Pointer arithmetic and comparison is only defined for pointers
into the same array object (including one past the end), so it's completely
possible to implement C with bounds-checked fat pointers. The most painful
requirement is probably that there is a sufficiently large integral type to
represent pointers across round-trip casts. In portable CL that would require
you to track all allocated objects with a unique identifier or implement your
own heap.

------
mathnode
Wow inspired by Mirai! It was indeed a very cool application. In my oppinion
stomped on PowerAnimator and Softimage.

Mirai was written all in common-lisp. Wings3D, inspired by Mirai, is written
in Erlang.

~~~
Keyframe
Wow, Mirai. Haven't heard that name in a long time. So many good stuff came
out of it. It just wasn't received widely for some reason. I got a demo CD
from nichimen with it, I bet I still have it somewhere.

This is Mirai: <http://www.youtube.com/watch?v=ubgvomRTW80> Here is Bay Raitt
working with it. Note the year. Also note that is the guy that worked on Golum
(and later at Valve). Modeling in that video seems like a normal workflow by
today's standards, however at the time NURBS/Patch modeling was all the rage
and box modeling was a novelty most users were skeptical of. Mirai provided
workflow which pushed it onto a new level. Prior to that Lightwave had
something similar with its MetaNURBS.

IIRC, it was a time when Maya finally caught on (ver 2 I believe) and new
Softimage (codename Sumatra, later XSI) was getting adopted too. Interesting
fact is that Softimage bought nichimen's modeling toolset and integrated it
into XSI.

So many firsts were spawned from Mirai. Some due to technical
achievements/features, some by its users. Bridge poly tool comes to mind, and
of course, box modeling pioneered by Bay Raitt and Mirai peers for production.
Truly defining time for 3D. A year later we all learned about skybox/GI/FG,
and a couple of years later Zbrush came out. Nothing was the same anymore.

~~~
sedachv
ZBrush was an amazing piece of software when it came out. I stopped following
developments in 3d graphics around the time that happened, but I remember that
most of the remaining Mirai users active on the web back then moved over to
it.

Dave Cooper of Genworks (<http://www.genworks.com>) told me that he met some
of the Mirai developers (they're still around: <http://www.izware.com/>) at a
conference not too long ago, and that they're working on the next iteration of
Mirai.

~~~
Arcanum-XIII
A next generation Mirai ? Wow... wasn't even aware that this company trully
still exist, since they seem dead for almost 10 years now (no update or
anything).

Funny thing is that, since it's in Common Lisp, when there's a problem, you
were dumped into the debugger, which was scary... only now do I know that it's
an amazing opportunity to access the underlying system in fact !

------
sedachv
Feel free to ask me any more questions in this thread. I haven't read HN very
often in the past 6 months.

~~~
dave809
What's your opinion on clojure? I'm trying to pick the lisp I'd like to learn
and clojure with it's java interop is really attractive

~~~
sedachv
I don't see myself ever using Clojure. It's missing too many of the good
things from Common Lisp: readtables, imperative constructs (PROG, LOOP, etc.),
separate function/variable namespaces. Lispworks and Gambit have better
concurrency primitives than Clojure. I've never needed Java interop,
interfacing with C libraries is much more important. If I ever go back to
doing functional programming it's going to be in Haskell again because it's
not worth giving up imperative programming unless you get the combination of
static typing and monads in return.

------
ybaumes
I don't understand: " I really like Azul Systems' hack of using the EPT/RVI
virtualized page tables as a hardware read barrier for real-time garbage
collection, and with a single-address space operating system I think you can
do the same thing on hardware with a regular MMU."

I understand real-time garbage collection, but what is EPT/RVI virtualized
page?

------
gruseom
Vladimir has read more deeply in computing history than anyone else I know. It
shows in his work.

------
crististm
Don't break the chain!!!

