He started the Cyc project, using Lisp Machines as a development environment. The project is roughly since 40 years ongoing. Cyc was the dream of a large-scale knowledge base of common sense knowledge. One that has many ways of reasoning and making inferences. It used SubL a variant of Common Lisp.
Mark Watson (@mark_watson) wrote this #eBook to introduce #CommonLisp to developers who already know how to program in another language. If you are a complete beginner, you can still master the material in this book with some effort.
A few years ago I have created a visual overview of (mostly) Common Lisp related books... Good thing: even the older ones can be useful, given that the core language hasn't changed that much over the last years.
I just built and installed ECL #CommonLisp (hompage) onto my computer, and after playing around with it for only a few minutes, I am quite impressed with it!
First off, the entire installation is only 40 MB, so this is definitely one of the more compact Common Lisp implementations I have ever seen.
It emits C code, native shared libraries, native static libraries, and native executables.
It uses libffi for C interoperability.
It provides ASDF, and the ability to install packages from QuickLisp
It implements Lisp standard processes on top of Pthreads
It provides some bindings to Qt4 for GUI programming
It implements all of CLOS
All of that in just 40 MB (not including Qt, which you need to install separately). The only drawback so far is that the documentation has some gaps in it.
But I definitely want to play around with #ECL some more. The trouble is most Common Lisp packages written nowadays only support SBCL. I would like to see how much of the Common Lisp ecosystem I can actually use through ECL. I wonder if I could maybe port something like the Lem text editor over to ECL instead of building it with SBCL, but that might prove impossible.
Anyway, my overall impression right now is that I have a very lightweight but powerful Common Lisp compiler at my disposal now that can easily be embedded into any C program I want, which is very exciting!
The ultimate yak shave: to implement its last generation of #LispMachines, Symbolics developed a complete #EDA toolset in #CommonLisp called NS that enabled them to design and verify their ASICs, gate arrays, and boards from architecture to photomasks for manufacturing.
It's not yet on MELPA, but hopefully will be soon.
This is the third library in the series, after the #commonlisp and #fennel implementations. Next are some extensions for #clojure , and then a return to Guile #scheme .
The software industry, especially in the realm of free software, has mostly settled on a pattern of using C++ for creating performance critical libraries, and creating Python binding to the C++ libraries for scripting. I was hoping Rust might come along and change all this, but it will take decades.
In the mean time, if you want to use C++ but not actually write C++, you can make use of the ECL Common Lisp compiler, which can compile Lisp to C++ code. This gives you all the best features of Common Lisp for programming with the universe of C++ code libraries available to you. You can use a C++ library and still have Common Lisp macros, garbage collection, high-level scripting, S-expressions as serialization, domain specific languages, a proper meta-object protocol that wraps C++ classes nicely, and wealth of choices for functional programming systems from the untyped lambda calculus all the way up the lambda cube to System-F and the Calculus of Constructs. This not only makes ECL a viable alternative to Python for scripting and app development, but objectively better than Python since you can actually turn your Common Lisp scripts into code that gets compiled into a larger C++ application.
With ECL I would have all sorts of C++ libraries available to me:
game engines like Unreal and Godot
3D modeling: FreeCAD, OpenSCAD, Blender
Machine learning, big data, and HPC with PyTorch, TensorFlow, OpenCV, OpenCL
I will continue to contribute to the Scheme and Haskell communities as much as I can. I will continue to pursue my dream of an Xfce-like desktop environment written in Scheme. But no matter how I look at it, I am going to more productive in the long run using ECL and C++.
I was hoping that the software industry would gradually shift over to better, more functional languages like Rust and Haskell. And I would love it if Scheme languages could ever begin to seriously replace Python as a scripting language. But realistically, I think I am going to change tack and meet the industry half way. I think I should probably start using ECL as my language of choice, as much as I would prefer Scheme or an ML-family language like Haskell.
Listen folks, common lisp is not an open source ecosystem, an ecosystem has corporate sponsorships, startups, consulting fees, foundations and grants. We are a free software enthusiast art scene. Different rules and different outcomes. It's absolutely ok that there are 80+ utility libraries.
🥳 Celebrating 1001 learners on my Common Lisp course, thank you very much for your support!
Starting with CL was honestly not easy. The first thing I did was writing the "data structures" page on the Cookbook, bewildered that it didn't exist yet. A few years and a few projects later, this course allows me to share more, learn more, have fun, and have some rewards to keep the motivation up.
Puh... after two weeks almost exclusively working with Common Lisp & Emacs, I had a hard time today with the Write-Compile-Wait-Fail-Debug cycle of a Go project. It felt almost as if 80% of my time I was just waiting and restarting all the time.
Well, I guess CL is growing on me for real. If that's a good thing has to be determined at a later post ;-)
Petalisp is an attempt to generate high performance code for parallel computers by JIT-compiling array definitions. It is not a full blown programming language, but rather a carefully crafted extension of Common Lisp that allows for extreme optimization and parallelization.
In this 1994 paper Richard Waters acknowledged the momentum of C and its implications for the Lisp ecosystem. He laid out a stretegy for the survival and growth of Lisp focused on the development of a critical mass of reusable software.
Three decades later the Lisp community has come a long way but, as Waters concluded back then:
"As long as we are a vibrant community [...] Lisp will hold its own."
the biggest missing piece of #SmallWeb is PEOPLE SHARING LINKS. It's cool that we can use RSS to get new articles, but we need the meat-suitted algorithm of recommendations for new sites.