gophernotes VS clasp

https://github.com/gopherdata/gophernotes

I've had this bookmarked for some time and just havent gotten around to it.

Gopher Notes Kernel for jupyter notebooks? Could be useful :)

I started this because gophernotes was not working for another project I'm slowing working on -- it is interpreted, and not up-to-date (generics, etc).

A go kernel is available at https://github.com/gopherdata/gophernotes

> You do know that statically typed languages have REPLs too? Like the ML family, including Haskell.

I do, but that I don't see how that relates to the bit of my post which you've quoted. I certainly didn't claim or imply that REPL and static type systems were mutually exclusive, only that REPLs are a poor substitute for many static analysis tasks.

> And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes you can do similar interactive programming.

Yeah, I'm aware. I operate a large JupyterHub cluster (among many other things) at work. :)

> Lisp REPLs take that a step further, as you interact with and in your whole actually running program.

That sounds nice, but it's too abstract to persuade IMHO.

If you are coming from python,jupyter notebook, gophernotes is a great library to setup your own playground.

Why can't you just build libraries to make Go a better language for data science? There's already Go support for a Jupyter Notebooks kernel: https://github.com/gopherdata/gophernotes

I accidentally a Common Lisp that interoperates with C++ (https://github.com/clasp-developers/clasp.git). We would also like to move beyond BDWGC and Whiffle looks interesting. I will reach out to you and maybe we can chat about it.

Clasp might be such a language, it seems.

https://github.com/clasp-developers/clasp

/u/jeaye are you aware of CLASP? https://github.com/clasp-developers/clasp https://www.youtube.com/watch?v=mbdXeRBbgDM

Sounds to me like CLASP; it automatically exports C++ objects to be used from Common Lisp also via llvm.

Now, the difference of compiling speed of SBCL and CCL is not so big. Look at cl-benchmark, LispWorks is really fast, CCL is on par with Allegro, SBCL is close to CCL. Or https://github.com/clasp-developers/clasp/wiki/Relative-Compile-Performance-of-clasp, it depends on specific project (SBCL sometimes faster, slower, alike), overall difference is not big.

So..

"Why do you want to make Lisp more popular? If you were sucessful, what would be different in the world, and why is that desirable to you?"

Normally at this point I'd listen to the response, and ask more questions based on that. That would wind up with a very, very deep thread, so I'll break a cardinal rule and pre-guess at some answers.

This kind of question comes up pretty frequently. In many cases, I suspect the motivation behind the question is "Wow! Here's this cool tool I've discovered. I want to make something really useful with it. I want to do it as part of a community effort; share my excitement with others, share in their excitement, and know that what I'm making is useful because others find it desirable and are excited by it." The field could be cooking, sports, old machine tools, tiny homes, or demo scene. Its the fundemental driver for most content on HN, YouTube, Instructables, and such. It is a Good Thing.

If that is your motivator, then my suggestion is to find something that bugs you and fix it. You've already decided you're only interested in code, not other aspects. You said you preferred vim, but the emacs ecosystem has a very rich set of sharp edges that need filing off, and a rich set of tools with which to attack them.

One example: even after 50 years there's no open IDE which allows you to easily globally rename a Lisp identifier. I don't know about LispWorks or other proprietary environments, but you can't in emacs or vim do a right-click on "foo" in "(defun foo ()...)" and select a command which automatically renames it in all invocations. [Queue lots of "but you can..." replies here.] I don't think vim is up to the task of doing this internally. It would be possible in emacs; but would require a huge effort with lots of help from other people. If you emerged alive from that rabbit warren you'd join the company of Certified "How Hard Could it Be?" Mad Scientists such as Dr. "I just want to draw molecules" Meister [1] and "Wouldn't an OS in Lisp be Cool" Froggey [2].

[1] https://github.com/clasp-developers/clasp

[2] Mezzano https://github.com/froggey/Mezzano

But also, there's a reason why most implementations readily make an effort to provide interoperability tools with a variety of runtimes. Clasp much like ABCL gives access to a whole library of other libraries trivially wrapped to interoperate with at little to no performance to cost (depending on how thin you make the wrappers, mainly).