
Racket v5.3.2 - racketlang
http://blog.racket-lang.org/2013/01/racket-v532.html
======
DASD
Am I the only one who forgets Racket? Everytime I visit the site and browse
through the documentation, I find myself wondering why I'm not using the
language. Years ago I used Chicken Scheme but this seems more robust and the
standard library is adequate. Who's using this in production? What's your
experience?

~~~
tikhonj
Well, I haven't used it _in production_ , but I used it for a research project
last semester. It was actually pretty good, and there are definitely some very
nice features. The standard library was pretty good except it missed some
functional features I wanted like immutable vectors (or even just functional
operations on mutable vectors).

The language is extremely flexible, and you can take advantage of this to
write some really elegant and maintainable code. It's one of the more
productive languages I've used--of the languages I've used extensively, it's
better than JavaScript, Java or Python.

So I liked it quite a bit over all. However, it doesn't quite clear the
threshold where I would use the language voluntarily. I thought it had
lackluster support for functional programming, especially from what is
supposed to be a functional language. This was evident in the library (e.g.
the lack of immutable vectors and the like) and also in the way certain pretty
fundamental structures (like ports) worked.

Also, for a dynamically typed language, I thought it had too many different
types. It was too easy to get mixed up between bytestrings and strings, for
example. It was also not obvious when you should use or expect nil vs #f. That
said, the features for creating your own types (mostly structs) were very good
--I found they were very lightweight but still flexible enough to be useful.

I am actually a big fan of the syntax. Not just the s-expressions (although,
with paredit, they are pretty awesome) but also the reader macros. That said,
I'm also rather partial to infix operators, which are obviously not present.

So over all, it's a great language. However, I would still choose Haskell or
OCaml over it for virtually any project. The main exception would be projects
very heavy on metaprogramming, where Racket really shines.

~~~
javert
_However, I would still choose Haskell or OCaml over it for virtually any
project_

This might be off-topic, but I've been thinking about learning one of these
two. Can you give me any advice on which to learn first (or which to use for
what)?

~~~
tikhonj
Well, I'm a little biased, but I would learn Haskell. It's the one I learned
first--in fact, I learned it during my very first college CS course. (The
course, coincidentally, was in Scheme.) If I managed it as a freshman, it
can't be all that difficult :P.

Haskell has a couple of very good freely available books: _Learn You a
Haskell_ [1] and _Real World Haskell_ [2]. I also found _Write Yourself a
Scheme in 48 Hours_ [3] very helpful. When I was learning OCaml, I could not
find any terribly good resources. That said, it wasn't much of an issue, so I
didn't look too hard--learning OCaml after knowing Haskell is very easy. There
_is_ going to be a _Real World OCaml_ book at some point, but I think it's
still a work in progress.

[1]: <http://learnyouahaskell.com/>

[2]: <http://book.realworldhaskell.org/>

[3]:
[http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_H...](http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours)

I also think Haskell is good because it's more of a departure from languages
you're probably used to. You can't sink back into your old habits, because
everything is done completely differently. Of course, some people find it
helpful to have less of a departure from what they're used to, so perhaps you
might prefer OCaml because it's less different from normal languages.

I use Haskell for my own projects (and, this semester, for research), and I
used OCaml for an internship this summer. I think that for most tasks, they're
roughly equally suited. If you want to do multicore concurrent or parallel
code, I think Haskell has the edge, but I have not really done much of that in
either language.

OCaml has a very good JavaScript compiler called js_of_ocaml[4]. While Haskell
does have some options for JavaScript as well like Fay[5] or UHC[6], I don't
think it's quite as nice. I used js_of_ocaml during my internship and was very
happy with it. So for web stuff, I'd probably go for OCaml. Both OCaml and
Haskell have good backend web frameworks, but I haven't really used any of
them.

[4]: <http://ocsigen.org/js_of_ocaml/>

[5]: <http://fay-lang.org/>

[6]: <http://www.cs.uu.nl/wiki/UHC>

If you happen to be on windows, installing OCaml is a pain. Haskell, with the
Haskell Platform[7] should be much easier, but I haven't tried it myself.

[7]: <http://www.haskell.org/platform/>

OCaml has a really good Emacs mode called typerex[8]. Haskell has some
alternatives like ghc-mod[9] and scion[10], but I've never been able to get
them to work. Admittedly, typerex was not easy to install either.

[8]: <http://typerex.org/>

[9]: <http://www.mew.org/~kazu/proj/ghc-mod/en/>

[10]: <https://github.com/nominolo/scion>

Ultimately, you wouldn't go wrong with either one. Moreover, the core ideas
are fairly transferable between the two: you'll find that learning OCaml after
Haskell or Haskell after OCaml is relatively easy. I would lean towards
Haskell, but it's not a big deal.

I just realized that I've written a whole bunch of paragraphs to say very
little: either language is a great choice and I just happen to like Haskell
more. Hopefully this is not too much of a deluge of information :P.

~~~
pjmlp
For Windows developers I would advice to use F# instead.

Being a Microsoft language helps smuggle it into the work environment of the
enterprise.

It has become my scripting language for Windows tasks.

~~~
graue
OK, I'm curious now. Wikipedia says[1] the reference implementation is open-
source and cross-platform, which is great, but I never hear of anyone talking
about F# outside the Microsoft world.

The compiler has to be compiled from source[2] on Ubuntu, which seems to
suggest hardly anyone is using it.

Would there be any compelling reason to use F# if you're _not_ working in a
primarily Microsoft environment? What does the language itself offer over
Ocaml or Haskell?

[1]:
[https://en.wikipedia.org/wiki/F_Sharp_%28programming_languag...](https://en.wikipedia.org/wiki/F_Sharp_%28programming_language%29)

[2]: <https://fsxplat.codeplex.com/wikipage?title=FSharpLinux>

~~~
stonemetal
From what I understand F# works on mono and the F# MS team actually puts in
effort to make sure it does. Though for whatever reason mono just isn't that
good at running F# code. Maybe it is a weak GC or lack of ability to optimize
the code patterns F# produces, I don't know. It is slower than F# on CLR.

Given that, library access and ability to thread are the two big things it is
going to have over Ocaml. Cleaner syntax when compared to Ocaml too. Haskell,
not much.

~~~
pjmlp
The GC was not that great, but the new S-Gen is quite comparable to the CLR
one.

------
mlinksva
[https://class.coursera.org/proglang-2012-001/wiki/view?page=...](https://class.coursera.org/proglang-2012-001/wiki/view?page=syllabus)
is going to cover Racket (the first part, now in progress, uses ML).

Never having done anything non-trivial in a Lisp or Scheme, I'm looking
forward to filling in a tiny bit of this huge gap in my knowledge. But like
some other posters, I'll be surprised if I end up liking it better than
Haskell.

------
S4M
I am curious, is there someone with experience with Racket and Clojure? What
are the advantages of Racket over Clojure?

