clojure

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.

sattvik/neko. Also noted for later, Clojure for programming Android applications with a few bindings for the Android APIs. Although the question remains whether they have tackled the startup problem, or if that still limits the use of Clojure.

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.

Heroku | Clojure on Heroku. And even more Lisp. With Clojure, you can now also work on Heroku, the cloud platform. This might be an alternative to, for example, Google App Engine (on whose Java incarnation Clojure also runs).

Home // Overtone. I'm always excited about sound makers - this is a tool for interactive sound programming and live coding and instrument building (of course digital), and all of it written in Clojure. Maybe for one or the other a reason to take a closer look at Clojure.

clojurescript demo convex hull. A demo for programming client-side code in Clojure using Clojurescript. Clojurescript compiles Clojure to JavaScript using the Google Closure Compiler and the Closure Library. Looks like a very interesting way to program clients, especially since Clojurescript is supported by Rich Hickey, the inventor and main developer of Clojure, so we can assume that the integration into the Clojure world will be good.

clj-android. And while I'm at it, a framework for Clojure and Android. Although it all seems a bit raw (for example, it requires a fork of Clojure to work around some issues with Dalvik). And just for playing around with Clojure on the go, the Clojure REPL might be interesting.

Seesaw - GitHub. Since GUI programming almost always annoys me, this is quite interesting: a Clojure library that brings Swing into a much more compact form. So that you don't have to write your fingers raw for simple GUIs. And since MCL-IDE now also supports Clojure, it might actually be time to take a closer look at the whole thing.

counterclockwise - Counterclockwise is an Eclipse plugin helping developers write Clojure code. And if you already have Eclipse installed, a Clojure plugin might not be uninteresting either, so you can get your daily dose of parentheses.

icylisper.in - jark. Hmm, yet another of many solutions for Clojure that enables simplified deployment of Clojure scripts, complete with persistent VM and #! support. Somehow, there seem to be quite a few of these lately.

nathanmarz/elephantdb. Same author as for Cascalog, here he built a distributed Key/Value-Store on Hadoop with Clojure. Also not uncool.

live-processing is something like Impromptu - so a live coding environment - in Clojure. It naturally focuses more on graphics, as it is based on Processing, and does not yet have the full scope of Processing available, but hey, it should be enough to play around with a new language.

dcolthorp/matchure - Pattern-Matching on Clojure data structures (not just strings and regular expressions, but also more complex matchings against lists, vectors, maps).

kriyative/clojurejs - GitHub I should check out, is another JS integration, here for a subset of Clojure, which is automatically translated to client-side JavaScript. And this one also supports jQuery rudimentarily.

For those who need to fiddle with bytes in Clojure: gloss. At the moment, I don't have an application for it, but I'm bookmarking it for later when I have to deal with binary data again.

Clojure Libs and Namespaces: require, use, import, and ns - 8th Light Blog. Just a brief overview of the different namespace functions in Clojure.

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.

gcv's appengine-magic at master - GitHub - is intended to enable interactive development of Google AppEngine tools.

jduey's arrows at master - GitHub - I should take a closer look, Lisp (and thus Clojure) is usually much closer to me as a programming language than Haskell and maybe I will finally understand what these Arrows are all about.

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

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

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.

Clojure - datatypes - what I like about Clojure: pragmatic and compact solutions for typical programming problems. Clojure 1.2 will introduce the possibility of having better descriptions of data structures with functionalities defined on them. And not some monstrous construction like CLOS or other Lisp-OO extensions, but rather lean constructs that also fit well with the host environments (JVM and CLR). Looks quite interesting. The downside of all the changes in Clojure: books become outdated faster than they can be printed ...

alienscience's leiningen-war - interesting plugin for Leiningen, the build tool in and for Clojure. Provides commands that quickly and easily generate .war files, which can be used for deployment to the Google App Engine, for example.

hiredman's lein-gae - Documentation is practically non-existent, but it only provides a simple command that prepares the war structure for a Google AppEngine project and adjusts the project.clj. Another way to build Clojure programs for the AppEngine.

Licenser's lein-search - and a small plugin that brings the search for modules and their versions to the (Leiningen) command line.

sethtrain's beget - alternatively to leiningen-war, you could also use this base project and simply adapt it. The Google AppEngine Tools are also fetched as a dependency here.

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 ...

hugoduncan's clj-ssh at master - GitHub - quite an interesting library that enables ssh access in Clojure scripts. For example, very interesting for server automation. Uses Jsch, a native Java ssh library (so no detour via shell-pipes or similar).

A simple web application in Clojure using ring and enlive « LShift Ltd. - and here is a small example of how to actually work with ring and Clojure. Looks quite interesting, could be particularly interesting for me for web services in Clojure.

Kotka : Projects : Clojure : VimClojure - and anyone like me who is a VIM fan might be pleased with this Clojure integration. Many of the features already come close to the performance class of IDEs like Netbeans or Eclipse. (although the Clojure plugins for Eclipse and Netbeans also make a very good impression).

mmcgrana's ring at master - GitHub - nice small lib at the level of Python WSGI. So absolutely minimal HTTP bindings for Clojure with the possibility to then operate the whole thing via a whole range of different techniques. Particularly interesting for the cases where you don't want to be put into the corset of a finished framework like Compojure.

Clojure 1.1 and Beyond - where Clojure will develop in the near and medium-term future. Much of this indicates that Clojure will have an experimental character for a longer period of time - which should be considered when using it in production, as new versions can indeed have significant changes both in the language, the base library and above all the runtime behavior.

duelinmarkers's clj-record - a persistence framework inspired by Active Records (the ORM of Ruby on Rails), but in Clojure and with a more Lisp-like API. (that was a lot of Denglisch in one sentence!)

mattrepl's clojure-neo4j - and here is an interface to Neo4J, a graph database for Java, with which complex data structures can be stored on disk quite easily. Looks quite interesting for simple persistence in programs.

pjstadig's tim-clojure-1.0.0 - quite a cool project that implements a distributed environment for Clojure using Terracotta (basically a distributed map for Java). Objects with appropriate metadata are automatically distributed to all Clojures connected to this distributed environment - and it does this for almost all objects that can be defined in Clojure.

Building a Clojure Web application with Incanter, Compojure, and Leiningen « Data Analysis and Visualization with Clojure - very nice, especially because this example not only beautifully shows how simple it is to build a web application with Clojure using Leiningen and Compojure, but also because it's not the usual boring suspects as examples, but something completely different. (doesn't work on OS X at the moment due to a change by Apple to Java for 10.6, but the Leiningen people are probably already on it)

InfoQ: Clojure 1.1 Adds Transients, Chunked Sequences for Efficiency - at the moment, Clojure is seeing the more interesting optimizations and considerations for functional programming. Because they focus on the essential part: data structures. An often neglected area in other languages - what good is a functional language if the included data structures are simply too low-level? Clojure provides access to low-level elements from Java if necessary for performance reasons, but also high-level data structures that behave much more naturally in functional code. And with chunked sequences and transients, now two quite elegant optimizations for these, which help avoid descending into the Java depths.

briancarper.net :: Clojure Reader Macros - very dirty. Wild patching of the Clojure runtime at runtime. But a nice example of how you can easily reach into active Java objects from Clojure. However, you should not use this in production code (so this specific application of building your own reader macros for it).

trotter's bert-clj - and now another BERT implementation in Clojure

Widefinder 2 with Clojure - Tim Bray's Widefinder2 project is slowly delivering very interesting results, here an article about how to optimize Clojure so that the performance beats the best Scala and Java solutions so far (where the Java version can of course catch up trivially, as most performance-relevant things in this version rely on Java libraries). A nice example of how you can bring low-level optimization into Clojure for the things that are really important for performance, but still keep the good high-level mechanisms of Clojure for the rest of the code.

Clojars Tutorial - GitHub - Clojars will be something like CPAN for Clojure (and it will become more and more) and is very simple and elegant to use with Clojure and the support of Leiningen.

Short Chat Server in Clojure - interesting small example of Clojure code. Shows well the use of asynchronous processes and network access. And with 75 lines nicely clear.

Building Clojure Projects with Leiningen - simply explains Leiningen. I like it very much, especially because it uses the entire Java world, but feels significantly simpler. No XML orgies and clean standalone-JAR generation.

Clojars - the beginning of a repository for Clojure libraries à la Ruby gems or PyPi or CPAN.

Incanter: Statistical Computing and Graphics Environment for Clojure - something like R (statistics package) for Clojure. Could help me to make some practical doodles with Clojure.

technomancy's leiningen - interesting small build system for Clojure that simply writes its metadata in Clojure and thus comes across much more compact than monsters like Ant or Maven. If you use something like Netbeans, of course the build is already regulated in the IDE, but with this system you can also build small standalone projects without a large Java IDE. And it integrates well with Clojars.

in which things are mapped, but also reduced - a really nice example of Agents in Clojure using a log analyzer. Calculations are distributed across parallel processes, a central process reads and distributes, and at the end everything is merged. So classic map/reduce technique. It would have been nice if the reading had also been parallelized, because on flat systems with many spindles, parallel reading can indeed be faster than sequential reading (especially with gigantic file sizes as postulated by Tim Bray in the original problem). But still, it's nice to see a compact, meaningful example of map/reduce in Clojure. I like the language more and more.

The Enclojure REPLs (Not just for Netbeans!) - how to use the REPL from the Netbeans plugin also standalone. And this is a quite usable REPL, with nice features.

:: Clojure and Markdown (and Javascript and Java and...) - interesting post, because here the advantage of mixed languages on the JVM is fully utilized. Instead of writing a Markdown parser for Clojure, one in JavaScript is simply used via Rhino (JS in Java). Which also ensures that both the web client and the blog server can use the same implementation of Markdown.