lisp

sharplispers/cormanlisp. Haven't lisped in a long time. Corman Lisp - one of the coolest implementations of Common Lisp on Windows at the time - is now open source and on GitHub. However, it probably still needs a lot of work before it runs smoothly on modern Windows versions. But the first step has been taken with the source release.

FriCAS - an advanced CAS. I've lost track of it a bit - FriCAS is formerly Axiom, a quite extensive mathematics package like Mathematica, written in Common Lisp. Available for various systems, somewhat rough in the interface (just a command line), but very powerful. And somewhat more modern than perhaps Maxima (whereas for Maxima there are GUI options, I have no idea what FriCAS has to offer). Like every decent open source project, it is of course only a fork of a fork - under Open Axiom there is another project and under Axiom the original code is continued. Although for me, since Sage (and actually even much more since Anaconda and IPython Notebooks), all of this has become less relevant - in general, my requirements are at a much lower level and are already covered by the libraries available via IPython and Python. Of course, Mathematica and similar are still interesting - but the motivation to start the packages and to enter the rather different syntax world is rather low. Python has long since achieved the good-enough status.

part-cw/lambdanative. Interesting - a cross-platform programming environment targeting Android, iOS, OSX, Linux, Windows, and BSD. Based on Gambit-C, a pretty good (and already quite long available, so also "mature") Scheme compiler.

"3 windows builds have been performed on win95. There is an as yet unidentified runtime error running the 2.6.9 images on win7. More information here will be forthcoming shortly." - [[[Gcl-devel]] GCL 2.6.8 and 2.6.9 are released](http://lists.gnu.org/archive/html/gcl-devel/2013-08/msg00011.html). Apart from the fact that I thought it was already long dead (a "few" years have passed since the release), it's funny that someone still makes builds for Windows under Windows 95 today ...

Updated Cocoa Contrib. Wow - CCL now has completely new (and significantly expanded) capabilities for OSX GUI programming. This is growing slowly.

davazp/jscl · GitHub. Wow, impressive. A Common Lisp that runs as a REPL in the browser. What's exciting about it is how complete it is - after a (defun anton (a b) (+ a b)) I directly did a (disassemble #'anton) without any problems and it gave me the generated JavaScript code. Other constructs from the CL world also work smoothly. Definitely worth keeping an eye on, could become exciting (e.g. a JSCL on Node.js?).

What I considered worth reading during the week and did not want to link separately, collected here and uncommented.

lein-droid Wiki. I'm playing around with alternatives to raw Android Java programming again, and this could be an interesting candidate as you can play with Clojure.

Write Yourself a Haskell... in Lisp 17 February 2013. I always find this kind of thing exciting, even if I have to admit that I probably won't do anything with it. Still, it's interesting to read.

Moby is a package for Racket with which you can create Android programs. Integrated in DrRacket, you also have a suitable IDE in which most things can be tested. So much to try out, so little time.

Clojure/core — Reducers - A Library and Model for Collection Processing. Why a new library? Because the standard functions are interesting and meaningful, but sometimes you need a stricter implementation that avoids intermediate temporary collections and provides direct out-of-the-box support for parallelization. Without much fuss and bother, just a different namespace.

mtravers/heroku-buildpack-cl. And yet another Lisp link - here someone has relied on Heroku's buildpack-capable stack and built a buildpack for Clozure CL, so that you can also put Common Lisp in the cloud through it. Although this then has less similarity with Google App Engine, but rather with something similar to Amazon EC2.

Deep down inside, I'm still a Lisp fan. That's why the ecl-iphone-builder by Terje Norderhaug is very interesting to me - with it, you can compile a version of Embeddable Common Lisp for the iPhone or iPad and then deploy it to an iOS device via Xcode, start a Swank server there, and then connect remotely - and then play around or program with Lisp on the iPhone. Ok, the binding to the OSX APIs is still a bit brittle.

Practical Common Lisp - Crawling InterfaceLift with Common Lisp - second try. Interesting run through a simple project in Common Lisp using Quicklisp. It really makes a lot of things easier than if you program raw in CL and manage all the packages and systems by hand. However, you should not necessarily run the example script, as it violates the terms of use of InterfaceLift (and is not really nice to their servers).

Mac App Store - Clozure CL. One of the nicer free Common Lisp implementations is now in Apple's App Store. CCL is essentially the free and portable version of the old Macintosh Common Lisp, with integration into Objective C frameworks. So it's quite interesting to play around with if you like both Lisp and Cocoa.

Elnode - an Emacs version of node.js. Another project from the "because it can be done" category - I don't believe anyone would spontaneously answer "Emacs" to the question "how do I want to run my web services". But well, the operating system with built-in basic text processing functions can also represent an asynchronous web server.

manuel/edgelisp. Because I can never keep my fingers off the parentheses - a Common Lisp dialect and its implementation that compiles to JavaScript and makes the Lisp code executable in the browser. It seems quite complete - many other projects only show the rudimentary elements, but here there are already generic functions and macros.

A What Is Inside A Cat. A very interesting document that describes the implementation of Wraith Scheme in great detail, specifically also the implementation of parallel processes.

Clack - Web Application Environment for Common Lisp. This finally looks really nice and lean - most Common Lisp web frameworks are just too big, too complicated. This looks much more pragmatic, a simple routing, a lean request and a function that reacts to it. One could play around with that, installation is trivial thanks to Quicklisp (I'm so glad that Quicklisp exists now, the asdf-install hassle was really annoying). In its approach, it reminds me a bit of Turbogear for Python - various existing libraries are bundled with Clack, so to speak a lean web best practices. There is already an application framework that also runs in the minimal environment, Caveman.

AI art | painting robot | art | expert systems. Something else - a real robot controlled by Lisp (at least for prototyping). So not a virtual robot like Turtle graphics, but real hardware that moves.

xmlisp - eXtreme Media Lisp: Rich media cross-platform programming for 3D (OpenGL) and 2D applications. I think I've mentioned this before, but I'm not sure. Doesn't matter, repetitions aren't unusual, and this is really interesting - a Lisp environment with particularly good support for 2D and 3D data. Has a lot more on the TODO list - the goal is a Lisp environment specifically for game programming and other graphical, interactive programs. A bit like Processing.

MilkPack - Edgar Gonçalves. Interesting project that implements a task list that communicates with Remember the Milk on the Internet. The interesting thing about it: it is written in Common Lisp and intensively uses the Objective-C Bridge for OpenMCL.

dyoo/moby-scheme. Another interesting thing for Android: a PLT Scheme (i.e., Racket) dialect and a suitable toolchain to run applications created from Racket Advanced Student Language + World Primitives (ASL is already quite an extensive Scheme dialect in Racket and the World Primitives are for reactive programming in Scheme) in JavaScript and then bundle them into Android applications. So programming Android phones in a reactive Scheme dialect. Or even shorter: parentheses for Android.

spock - The Chicken Scheme wiki. If Dylan doesn't fit on JavaScript, how about Scheme? What's interesting here is the connection to Chicken Scheme - Chicken Scheme is one of the more interesting Scheme implementations in recent times that specifically focuses on integration into normal system environments (FFI and easy linking with C libraries), so this also lets us expect a bit from Spock in terms of JavaScript. And the documented functions already look quite good - not just a toy implementation, but apparently already a lot of functionality.

ralph. And if JavaScript under Flusspferd becomes too stupid for someone, they can simply install Ralph and then have a Dylan-like Lisp that compiles its function definitions to JavaScript. For whatever reason one would want that, maybe just because it's possible.

IronScheme. Interesting - a Scheme for .NET. And unlike some dead projects I found, something seems to be happening here. Ok, I probably tend more towards IronPython, F# or if it's supposed to be Lisp, Clojure for .NET (there are now quite up-to-date binary packages to try out, unfortunately probably only Windows, at least it spits out errors under Mono).

ABCL - Release notes v0.25. New version out and ABCL is increasingly developing into a really usable Common Lisp implementation. Since it runs on the JVM, you also have easy access to many libraries (if you want to) and since 0.24, Quicklisp also runs smoothly with ABCL, giving you easy access to many Common Lisp libraries. However, there are some issues with the CL libraries, as many programmers do not consider ABCL (and there are still deficiencies in the CLOS area).

Feeding the Bit Bucket» Blog Archive » Common Lisp, Clojure and Evolution. No, Clojure is not described as an evolution of Common Lisp - it's simply the example program "Evolution" from the book "Land of Lisp" translated into Clojure by someone who is learning Clojure by implementing all the examples in Clojure using the Common Lisp code as a basis. And therefore a good comparison opportunity between Clojure and Common Lisp. Maybe interesting for 2 or 3 readers of my blog. Otherwise, for me as a bookmark to look back at later.

Introduction to Pharen. A Lisp that compiles to PHP. Weird. Okay, could be practical if the host only offers PHP as a server language. But still. Weird.

Exactly. If you want to explain something boring like "why generic functions and not single-object-dispatch," then use examples like these:

A short example: Imagine you have a class human which is inherited by a class male and female. Now as we all have an urge to reproduce where to put a method for having sex? Create a method haveSex in the human class, duplicate it in male or female? What would the argument to such a class be? What about having sex with people of the same sex, toys, animals, buildings...

via /dev/random - Random Thoughts On Programming In Parentheses - Coops - An introduction to chicken scheme's object system.

App Development Tools Contrib - Yes! This is something many have been waiting for - better tools for OSX programming with CCL directly in the IDE. I hope the next release of CCL is soon stable and includes these tools.

CLPython - an implementation of Python in Common Lisp. Simply because it combines two of my favorite languages and makes pure-Python libraries available for Common Lisp. Perhaps now some of you can see where my search is heading - to have my cake and eat it too. By the way, CLPython is compatible with Python 2.5, so it's even a fairly up-to-date language level (even though I'm sure I'll miss some things from 2.6, but it's no different with PyPy).

FSet on Common-Lisp.net provides functional data structures as well. This library is also available in Quicklisp, so it's easier to install. And it looks very interesting.

CL-STM is simple Software Transactional Memory for Common Lisp (yes, I'm currently looking at CL alternatives for various Clojure features).

CLAZY: Lazy Calling in Common Lisp provides extended lazy evaluation for Common Lisp that goes beyond the usual delay/force pair.

Funds provides fully functional data structures for Common Lisp. This can be very helpful, especially for multi-threaded code. Unfortunately, it is not yet in Quicklisp.

Welcome to WuWei. Interesting Common Lisp library that makes it possible to program Ajax user interfaces purely in Common Lisp, without having to deal with the implementation in JavaScript. Unfortunately, it is not for my preferred JS library jQuery, but for Prototype and Scriptaculous.

slimv.vim - SLIME-like Lisp and Clojure REPL inside Vim with Profiling, Hyperspec, Paredit. Quite interesting, as it is much lighter and simpler to install than Slime or VimClojure or one of the other heavy solutions. And you can simply program Common Lisp or Clojure from within Vim. It is currently only in the "playing around and looking" mode, but it sounds quite interesting.

As a reminder: Zach's Journal - Making a small Lisp project with quickproject and Quicklisp. Just because I otherwise quickproject and similar things will forget again. With Clozure CL 1.6 Quicklisp also works quite completely (specifically cl-fad is functional and therefore you can get a larger stack of packages to fly finally). Zach is slowly putting together a stack of tools for Common Lisp with which it is fun to play around again. Even if I will probably never become a big Emacs fan, no matter how much others swear by the part for Lisp.

Pixie Scheme III. For the iPad. Perhaps not entirely uninteresting for doodling (provided it also has usable integration with the iOS API).

ninjudd's cake at master - GitHub - should I take a look at this? Especially the persistent JVM when using scripts could be interesting.

JazzScheme - huh? Seems to have completely passed me by - there is an IDE for Gambit Scheme that runs on multiple platforms and can create binaries for OS X, Windows, and Linux.

Quicklisp - get started with Common Lisp libraries, quickly - Zach Beane is finally going to address the problem of the rather chaotic library situation for Common Lisp and is building a central repository for libraries with easy installation on various Lisp systems. In principle, something like PyPi or CPAN. Which is generally very interesting - but would be even more interesting if there were somewhere on the site or the group or the GitHub a hint as to how to actually get it running and with which Common Lisp ... (ok, it's still very early development status, but still - the only documentation a screencast? Hello?)

nakkaya's static at master - GitHub - static site generator for websites in Clojure.

JEmacs - the Java/Scheme-based Emacs - just for future curiosity blogged.

liebke's clj - ah, someone has put together package installation and a decent REPL for Clojure, so you can play around with Clojure interactively without having to set up a project every time. Very practical for quickly trying out some Java libraries. Internally, it doesn't do anything else than setting up and managing a hidden Leiningen project, so it's rather cosmetic, but the right kind of cosmetic.

Racket Released - PLT Scheme has a new name and a new release. And is still the coolest Scheme environment.

Henry's EuLisp - someone has revived EuLisp and gathered the sources, as well as the specification. At least historically interesting, because EuLisp was one of the standard efforts for a more modern Lisp with quite good object-oriented support. But the implementation itself also has some interesting features.

clojure-python - an interesting project that aims to simplify interoperability between Jython and Clojure and raise it to a similar level as it already is between Clojure and Java. Particularly interesting for me, as it would allow me to rely more on Clojure as an alternative - Jython is already a planned component of the toolkit, but has some performance issues that Clojure does not have through more direct Java integration. Moreover, I prefer to write compact Lisp code rather than verbose Java ...

Bill Clementson's Blog: Elephant and Rucksack - Comparison of two CL Open Source Prevalence packages - because I'm also interested in Common Lisp again at the moment. Elephant and Rucksack are probably the more interesting persistence solutions for Common Lisp right now. Unfortunately, Rucksack is not asdf-install-compatible, so a lot of manual work is required.