
Lisp Koans by Google - juanfatas
https://github.com/google/lisp-koans
======
IvyMike
This is mildly interesting coming out of google because I thought lisp wasn't
a google-approved language.

(Yes, there are other projects on github in non-approved languages, but they
appear mostly to allow 3rd party interop with google services. The educational
nature of this project puts it in a slightly different category.)

~~~
muuh-gnu
Lisp became a "language internally used by Google" when Google purchased ITA
with a Lisp code-base so large and Lisp-only staff so large, that it is
unlikely that it will ever be rewritten or that the staff will be retrained to
use Java.

~~~
gohrt
ITA had a small staff, and was not Lisp-only. They were hiring people to do
Java work >5 years ago.

------
nuttendorfer
As someone eyeing SICP with previous programming experience should I do SICP
first and then do these koans? How big is the difference between Scheme and
Common Lisp?

~~~
muuh-gnu
You dont do SICP to "learn Lisp", you do SICP to learn fundamental programming
principles. SICP just happens to use Scheme because one of the authors of SICP
was also one of the authors of Scheme. The difference between Scheme and Lisp
is big enough to justify them having different names and Scheme not being
"just another dialect of Lisp".

The problem with Scheme is not the language, the problem is that the ecosystem
is so hopelessly balkanized, that it is useless for practical purposes and
nobody uses it for anything interesting except for teaching of SICP. You have
tiny standards covering only base language constructs, and everything else is
left to implementations of which 1001 different one exists and each implements
the same stuff in a different, incompatible way, so there is no code
portability. So an large number of Scheme users, instead of developing
interesting and useful _new_ libraries, instead rewrite 1001 different
implementations and 1001 different manuals covering the same area. If you
write something and tell me you wrote it in Scheme, the first thing I'd have
to ask is "Which one?" because your code will not run on the 1000 remaining
ones. The scheme ecosystem is the prime example of code non-reuse, of the NIH
syndrome and waste of man-decades of effort, so while the language itself is
nice for teaching, the existing worst-practices are examples of what _not_ to
do.

~~~
abecedarius
SICP doesn't 'just happen' to use Scheme; the simple language from a well-
chosen combination of powerful mechanisms is the kind of thing they're
teaching you to design. The medium is part of the message. (Yes, you can solve
the problems using another language; I used XLisp.)

On 'dialects of Lisp': it used to be standard for very different Lisp-family
languages to be called that, while nowadays someone will always contradict you
if you do. It seems more of a social change than a technical one to me. (I
first noticed it among Common Lispers after the AI winter.)

I know someone impressive doing real work with Scheme (though I recommended
they try Lua). I don't know whether you're right about the Scheme ecosystem,
as I've been elsewhere the last 15 years.

------
lesterbuck
>In test-driven development the mantra has always been, red, green, refactor.
Write a failing test and run it (red), make the test pass (green), then
refactor it (that is look at the code and see if you can make it any better.
In this case you will need to run the koan and see it fail (red), make the
test pass (green), then take a moment and reflect upon the test to see what it
is teaching you and improve the code to better communicate its intent
(refactor).

While the above was quoted from the Ruby koans, I would have thought a Lisp
author would have corrected the unbalanced parentheses. Am I unusual in
finding unbalanced parentheses in English text very distracting? It must be
something like my borderline OCD.

~~~
clkoans
Heh. Fixed.

------
alecdbrooks
Other functional language koans:

* <https://github.com/functional-koans/clojure-koans>

* <https://github.com/HaskVan/HaskellKoans>

* <https://github.com/rubbish/scala-koans>

Other interpreted language koans:

* <https://github.com/bittersweetryan/ColdFusion-Koans>

* <https://github.com/matyb/java-koans>

* <https://github.com/liammclennan/JavaScript-Koans>

* <https://github.com/midpeter444/mybatis-koans> (In Java, but for the library MyBatis 3)

* <https://github.com/kikito/lua_missions>

* <https://github.com/forcedotcom/PerlKoans>

* [https://github.com/TorontoPHPSoftwareCraftsmanship/PHPUnit-K...](https://github.com/TorontoPHPSoftwareCraftsmanship/PHPUnit-Koans)

* <https://github.com/gregmalcolm/python_koans>

* <https://github.com/DASpringate/Rkoans>

* <https://github.com/neo/ruby_koans>

* <https://github.com/brysztofor/koans> (Ruby on Rails koans)

Other language koans:

* <https://github.com/marcinbunsch/bash_koans>

* <https://github.com/paytonrules/PointerKoan> (C pointers)

* <https://github.com/CoryFoy/DotNetKoans>

* <https://github.com/torbjoernk/CppKoans>

* <https://github.com/liammclennan/coffeescript-koans>

* <https://github.com/patrickgombert/erlang-koans>

* <https://github.com/VictorDenisov/go_koans>

* <https://github.com/cdarwin/go-koans>

* <https://github.com/cjudd/groovy_koans>

* <https://github.com/joecannatti/Objective-C-Koans>

Other programming or technical koans:

* <http://stevelosh.com/blog/2013/04/git-koans/>

* <https://github.com/chicagoruby/MongoDB_Koans>

* <http://blog.sanctum.geek.nz/vim-koans/>

(For any aspiring koan writers, Arc, Rust, and Scheme lack koans. And PHP's
and R's are pretty sparse.)

~~~
felixgallo
Every time I resolve never to read HN again, something like this happens. Damn
you. Excellent post.

------
aidenn0
Anyone know why the author chose .lsp for the extension? I've not seen that on
any system that allows longer extensions.

------
paines
What is a Koan ?!?!

~~~
coolsunglasses
<http://en.wikipedia.org/wiki/Koan>

<http://en.wikipedia.org/wiki/Hacker_koan>

<http://www.catb.org/~esr/writings/unix-koans/>

<http://catb.org/jargon/html/koans.html>

<http://c2.com/cgi/wiki?TestDrivenDevelopment>

<http://rubykoans.com/>

<https://github.com/google/lisp-koans/blob/master/README>

------
Rickasaurus
F# Koans <https://github.com/ChrisMarinos/FSharpKoans>

------
meemo
how would you get started with clisp instead of sbcl?

~~~
clkoans
The lisp koans should execute on any common lisp implementation _modulo the
threads koan group._ If you modify the file ".koans"

<https://github.com/google/lisp-koans/blob/master/.koans>

to remove the last entry ":threads" it should work.

