brehaut

hace 11 añosdiscuss

"but what have you shipped recently?"

Looks like he has shipped 14 books and at least 36 papers on software engineering methodologies.

brehaut

hace 13 añosdiscuss

optional clojure type checking: https://github.com/clojure/core.typed/ (not finished, but showing promise)

brehaut

hace 13 añosdiscuss

http://en.wikipedia.org/wiki/Pareidolia

brehaut

hace 13 añosdiscuss

Depends on the audience, and the implementation of fizzbuzz.

This haskell fizzbuzz is great: http://dave.fayr.am/posts/2012-10-4-finding-fizzbuzz.html

brehaut

hace 14 añosdiscuss

The author of this article, Jim Duey, has written some newer introductions to monads in clojure on his new site: http://www.clojure.net/archive.html

brehaut

hace 14 añosdiscuss

Pedantic point: Light years are a unit of distance, not time.

http://en.wikipedia.org/wiki/Lightyear

brehaut

hace 14 añosdiscuss

Pedantic note: #^ for metadata has been deprecated for at least 2 if not 3 versions. ^{ and ^:x aren't special. It's just ^ (reader metadata symbol) followed by a map and keyword respectively. Other things can also be metadata (for instance you can tag something with a classname to indicate a type hint).

You also missed out a few of the syntax quote stuff.

So, other tokens are #{} ^ #() #_ #'x ` ~ ~@

Full details: http://clojure.org/reader

brehaut

hace 14 añosdiscuss

kickstarters are not the sole way people contribute to projects and communities. ibdknox has created some very popular (in the clojure community anyway) software (noir, korma etc) that a lot of people build on top of. Surely this should count for something.

brehaut

hace 14 añosdiscuss

While not addressed to me, i'd like to chime in with some comments of my own here.

One of my personal gripes with javascript as an environment is that out of the box there is exactly two composite data structures, and both are associative: Objects, and Arrays.

As you are probably aware, Objects are the bread and butter of Javascript and double as full OO objects and also as map/dictionary types with the limitation of only allowing String keys. Arrays have their own quirks but lets leave that aside for now.

Javascript lacks a well understood model of value identity[1]. Without a common model for value identity (i.e. more than reference identity) it becomes very difficult to implement custom data structures (e.g. a BTree for implement a true dictionary type) in a way that can easily (and naturally) be consumed by third parties. Lacking the ability to hook into the [] operator increases the awkwardness for anyone attempting to provide their own custom collections. I would suggest that the lack of good quality collections deployed widely in the javascript world underscores this problem. Contrast this with just about any other language you can think of and it is even more stark.

As an example, any good language probably has a Set datastructure these days. There are two ways to fake it: Degenerate map with the key being the real value and either some sentinal (such as true) or the key itself as the value, or (as is very common in javascript) an array and then doing indexOf.

Let that sink in: a common approach to sets in javascript (when you cant easily provide a string key for your object) is to do a linear search. Yuck.

For a wonderful counter point, have a look at how ClojureScript implements its own collection types, complete with value identity, indentity partitions and proper maps with object keys.

[1] Leaving aside all the unknowns most javascript programmers have about the `valueOf` method.

brehaut

hace 15 añosdiscuss

Simple: a fanboy is someone you disagree with and would rather attack ad hominem than engage with in rational discourse.

brehaut

hace 15 añosdiscuss

It would be remiss to not point out that noir probably has the strongest set of documentation (both api and tutorial styles) of the main three libs.

brehaut

hace 15 añosdiscuss

> Noir isn't very large

None of the main clojure web libs are very large, so this applies to all of them :)

brehaut

hace 15 añosdiscuss

There is no one framework (in fact, most of clj's web ecosystem is not frameworks) that is far and away more popular than the others.

At the heart of everything is Ring[1]. Ring is roughly equivalent to WSGI or Rack. However, if you use Django in python you basicly dont ever have to know about WSGI. In Clojure you do want to know about Ring. Thankfully Ring is very simple; its a spec describing request maps and response maps. In addition provides common adapters for various JVM web servers (In the general ring ecosystem there is support for Jetty, Netty (via Aleph/Lamina), Google App Engine (via appengine magic), Servlets, Mongrel2) and middlewares.

There are three sets of libraries on top of ring that are commonly used to build sites:

## Moustache

Probably the closest to raw ring of the three, moustache provides a sophisticated url routing API. Of the three I'm mentioning here it is probably the least suitable for clojure beginners, however it is my personal favorite.

## Compojure

This was the most popular [noir is apparently on par] and oldest (it predates ring but was rewritten ontop of it in the 0.4.0 release). The best analogy here is apparently sinatra for ruby.

## Noir

Noir is the most recent addition and is higher level than Moustache or Compojure. In fact, Noir is built on Compojure. I havent had any real experience with Noir myself but it is probably the easiest entry point into web programming in clj.

Compojure and Noir both use Hiccup for HTML generation, and Moustache uses Enlive. Enlive is extremely powerful; even if you choose hiccup I would encourage you to take a good look at enlive anyway, the two solutions dont need to be mutually exclusive.

  [1] Ring: http://github.com/mmcgrana/ring/

brehaut

hace 15 añosdiscuss

And to clarify, grandparent probably wants the terms 'first class function', 'anonymous function' or 'lambda' (depending on the specific usage.)

brehaut

hace 15 añosdiscuss

"If you come from a javascript background, you will have a leg up on most people in terms of learning clojure. You get used to inlining functions pretty regularly."

You'd be better off listing the languages that don't have some sort of 'inline functions' than claims about javascript superiority here; Heres a handful of common imperative/OO languages that have an analogous construction: Python, Ruby, C#, Visual Freaking Basic Dot Net, Smalltalk, Objective C and other C languages with Apple's blocks extension, probably PHP and Lua…

brehaut

hace 15 añosdiscuss

The other libraries are clojure libs that implement javascript analogies[1] as clojure macros and functions and generate javascript.

ClojureScript is a Clojure The Language compiler that implements Clojure (its datastructures, standard lib, protocols, deftypes etc etc) and is hosted[2] on javascript rather than the JVM.

In ClojureScript you are not writing reskinned javascript, you are writing Clojure.

[1] simplified for the argument

[2] By outputting javascript

brehaut

hace 15 añosdiscuss

xmlrpc[1] is similar.

    <?xml version="1.0"?>
    <methodCall>
       <methodName>examples.getStateName</methodName>
       <params>
          <param>
             <value><i4>41</i4></value>
          </param>
       </params>
    </methodCall>

my favorite part[2] is how <params> only contain <param> elements within. each <param> has exactly one child. Why is it not just <params><i4>41</i4></params>?. Its no surprise that the creator of xmlrpc was involved with soap.

[1] http://www.xmlrpc.com/spec [2] not really.

brehaut

hace 15 añosdiscuss

The obvious reason for no Object/Relational Mappers in Clojure is that while Clojure has objects available, it doesn't orient around them. It makes much more sense to treat a set of records from the DB as a sequence of maps.

For DBs and Clojure in general I can only speak about CouchDB via Clutch and SQL via ClojureQL and clojure.contrib.SQL. I don't want to claim to be an expert in either of these technologies, but if you have some more specific questions i'm happy to do my best to answer them. you might find some answers about couch in an older post of mine http://brehaut.net/blog/2010/couch_impedance

brehaut

hace 15 añosdiscuss

I'll look into fixing then. Do you have any suggestions for good syntax highlighting to use from either clojure or javascript?

brehaut

hace 15 añosdiscuss

Regarding Clojure, while compojure is popular, a compojure centric view of web programming is misguided. Compojure is part of a growing ecosystem of libraries built on top of ring[1][2].

Firstly this ecosystem is not analogous to rails or django. The closest is that Compojure is similar to Sinatra i believe.

If you are looking at getting started with web programming in Clojure you need to get familiar with ring (the http abstraction) and look at Compojure and Moustache (routing and handler composition), and Enlive[4] and Hiccup[5] (templating/html generation). Compojure and Moustache are fairly similar, but Enlive and Hiccup are extremely different. A web application will consist of ring plus one of each layer.

As has been mentioned by others in this thread, the depth, breadth and currentness of documentation for these libraries varies. David Nolen has a great tutorial for enlive[6] that i would encourage anyone looking at these libs to work through. Enlive is one of the most compelling aspects of the clojure web ecosystem at present.

These libraries provide the core pieces you would expect to see in any web framework, but a lot of the smaller details are missing. Of note there is no ORM for clojure (for obvious reasons) - If you are looking for a good SQL abstraction you should look at ClojureQL[7] - and aspects such as form generation, validation and processing is still in early days.

My day job has me building web apps with Django. I wouldnt suggest that my coworkers and I jump to clojure / ring et al yet. The breadth of libraries and out of the box stuff in django is still a huge advantage for the day to day rapid web site / web app development, however clojure's story is improving rapidly and i think that the functional model is a particularly good fit for web applications.

I cannot compare clojure's story with the other languages and frameworks mentioned.

  [1] https://github.com/mmcgrana/ring/ 
  [2] This is true of compojure 0.4 and newer. compojure existed prior to ring (with hiccup as part of it).
  [3] https://github.com/cgrand/moustache
  [4] https://github.com/cgrand/enlive
  [5] https://github.com/weavejester/hiccup
  [6] There is a link in the enlive readme
  [7] https://github.com/LauJensen/clojureql/

Submissions

Start Parsing in Clojure: fnparse

Macro-writing macros in Clojure

Unifycle - a syntactic unification API for Clojure

Software will be unpatentable in New Zealand

Designing with color-blind users in mind

Caponia - an in memory, full text search system in clojure

comments