
SBCL 1.2.0 Released with ARM support - enduser
http://www.sbcl.org/news.html?1.2.0#1.2.0
======
enduser
FYI, SBCL is a high-performance open source compiling implementation of Common
Lisp. All SBCL code is either released into the public domain or available
with the FreeBSD license. Rumor has it that the next release of SBCL will
support calling SBCL from Java on Android.

~~~
piokuc
SBCL on Android will be really great. There is mocl there already, but SBCL is
a bit more mature... And it's a full Common Lisp, no limitations.

~~~
emiljbs
But you won't be allowed to post those apps on the Play Market, because
apparently compiling code at runtime isn't okay.

~~~
piokuc
Really? I thought eval was not allowed on iOS only.

------
photex
I noticed that ARM binaries aren't yet provided. Does this just mean they
haven't gotten around to it yet or that ARM isn't suitable for production at
this time?

I'd really like to experiment with SBCL on the beaglebone. :)

~~~
jlarocco
I can't answer authoritatively, but I do know they're not really good at
updating the downloads page for anything other than AMD64 Linux and the source
tarball (and of course the Git repo). Usually I just build from source.

The catch, of course, is that building from source requires a pre-existing
SBCL to bootstrap.

My guess is the only way to get it running on ARM right now is to get it for a
non-ARM platform they have for download, bootstrap to 1.2.0, and then cross
compile to ARM.

~~~
zachbeane
One of SBCL's claims to fame is that it doesn't necessarily require a previous
copy of itself to bootstrap; it can in theory use CLISP or Clozure CL. (In
practice it isn't always tested and working, and I don't know if it would work
on ARM if you tried it today.)

------
tempodox
Yay, good news. By the time Apple uses ARM instead of Wintel CPUs for OS X, I
hope that SBCL will be ready for ARM in at least the same quality it now has
for x86_64.

BTW, are there any comparisons between SBCL's “Python” compiler and an LLVM
backend (mocl seems to have one)?

~~~
enduser
I haven't seen any published mocl performance data. One significant difference
between the two is that SBCL's compiler is online (available at all times)
whereas mocl's is only available on the development machine. So mocl is an
implementation of Common Lisp the language, but not a complete Common Lisp
environment.

------
tete
I browsed through Common Lisp GitHub repos, but it didn't really answer my
question. Are there any known, much used applications, frameworks, libraries,
whatsoever? Something to see the structure of big projects? Something that
possibly shows there are also bigger companies interested into LISP?

~~~
rayiner
Lisp was popular back when the "interesting" apps were things like compilers,
AI systems, mathematics systems, GUI's, etc. See:
[http://en.m.wikipedia.org/wiki/Category:Common_Lisp_software](http://en.m.wikipedia.org/wiki/Category:Common_Lisp_software)

~~~
throwawayaway
what do you consider interesting nowadays?

~~~
rayiner
I mean "interesting" in the sense that those were areas of active research and
development. I think the equivalent today would be things like control
software for self-driving cars and drones, the software that does StreetView,
etc.

------
guiomie
I'm not too knowledgable about lisp, but what should I focus learning, Clojure
or Steel Bank ? If I understand properly, SB Common lisp doesn't run on a VM
... ?

~~~
brudgers
The best choice depends on your reasons for learning Lisp. If it's to work
through _Structure and Interpretation of Computer Programs_ or just learning
in general, then Racket is the way to go. Teaching Lisp is embedded in its
culture.

On the other hand, if you are hard core all day with the JVM, then Clojure.
But I would not recommend Clojure as a first Lisp. Its community is very much
organized around being a better JVM language, somewhat around teaching people
Clojure in that context, and not really around introducing people to Lisp.
It's more about providing Lisp to the JVM programmer and JVM to the Common
Lisp programmer.

As for learning Common Lisp, if you're plan is to work your way through
Graham's _On Lisp_ or Hoyte's _Let Over Lambda_ then it makes sense.

Of course any of them make sense if it's for work.

~~~
zurn
What about ClojureScript?

~~~
brudgers
I'd never suggest it as a good starting point for learning Lisp. Clojure's
design inherits some implementation details from Java and the JVM.
ClojureScript has amother layer of limitations based on ECMAscript's
specification. They make sense If one understands Clojure as a response to the
JVM and has a similar understanding of JavaScript's specification. Without
that it's going to be hard to have an intuitive feel for the ways in which
it's been ported. And given its lack of standalone documentation the a
programmer is even more on their own.

