How Lisp is designing Nanotechnology (with Prof. Christian Schafmeister) 

Common Lisp is fine. But here professor is using Common LIsp as wrapper on C++ library?

@@user-zx3vp8mw7d Not exactly. He wrote a Common Lisp compiler in C++. That makes it easy to drop down from Common Lisp to C++ if he needs to optimize the performance of a certain hot spot. The vast majority of the code is written in Lisp.

Got It, will read it later.

Glad you're enjoying them! 😊 Bill and I actually spoke a few weeks back. You can expect that episode sometime in January. 🙂

Glad you enjoyed it!

There is a field called Computational Chemistry.

Lisp is the meta language. It's so easy to define a domain specific language with lisp that I could imagine someone doing so accidentally, and this is both one of it's greatest strengths, and one of the biggest things that hold it back The fact that you can create a domain specific language with lisp means that it's really easy for any random programmer to elevate themselves to a language designer, which is pretty dangerous when they don't put much thought into it (*especially* if they don't document their code) I'm not sure if it's still the case that lisp is the language of choice in quantum computing, it doesn't seem like there's a consensus. Quil does seem to be used though, and quil is written in common lisp. Also, qvm (quantum virtual machine) does also exist in lisp. You can still learn stuff from other languages - APL, Erlang, and Haskell all come to mind. Different programming languages can give you different abstractions with different properties, which sometimes lend themselves to different solutions. Admittedly, you'd probably learn more from any of those three than something like Golang. Collaboration is a pretty strong reason to use other languages though. Finding a rust programmer at your average college in the sea of java already isn't very common. Finding a lisp programmer is like finding a unicorn. Even though the lisp programmer might be massively more productive, their projects will likely be faced with far more variance in speed of patching bugs, updates, etc., simply because they are more likely to be the sole maintainers of their projects. People would be aghast to that sort of never updating because programmers have not really cared about security for very long, and security flaws in projects that do care still appear all the time

When you start to study Lisp seriously you quickly discover religious wars about what "real Lisp" is. It simply changes the realm of the argument away from languages defined by syntactical convenience towards s-expression languages that each contain subtly different semantics and assumptions around the development environment or how much Lisp is meant to be a complete system versus an application language. 17:45 of the interview: "...my own Common Lisp implementation". CL is, in some sense, frozen in 1994 - while you can do what this guy did and make a new implementation, what's out there and ready for consumption has a lot of ties to development in Emacs and to the Quicklisp package management system, and both of those are similarly frozen in time(the supply chain attack surface of Quicklisp is huge). And then when you go further into that, it's like, well, there's Common Lisp, but then Emacs is scripted in a different Lisp, and if you use GNU Guile, that's ALSO different. The Schemes are similarly fragmented in terms of code reuse. Clojure and Janet stand out as more modernized takes that slot into the roles of Java and Lua, respectively. I'm working in Janet right now, using it as a preprocessor system, and I think it's a good entry point for someone currently working in Python or JS. Whichever one you end up with, the s-expressions are good, and worth the few weeks of effort needed to get used to it. You're gaining more ways to express your program, and that's hard at first, and then gradually easier as you go along.

Julia doesn’t have a standard and there is only one implementation, AFAIK. The interviewee said he wanted a “forever language.” Julia might become one but it’s not currently one.

Julia is nice, but I think Lisp is a better choice for what he's doing. There is a lower impedance mismatch between the code and the data he is dealing with. Plus the whole "forever language" requirement he placed on the project.