
OCaml for the Masses - fogus
http://queue.acm.org/detail.cfm?id=2038036&ref=fullrss
======
scott_s
The code examples were formatted wrong in my browser. If that happened to you,
try the pdf:
[http://delivery.acm.org/10.1145/2040000/2038036/p40-minsky.p...](http://delivery.acm.org/10.1145/2040000/2038036/p40-minsky.pdf?ip=129.34.20.19&CFID=48219331&CFTOKEN=92125742&__acm__=1317218739_8d77a1cfe3577a2347dbe1d0dd567eb7)

~~~
kkwok
Thank you for this. When I was reading his article I was not seeing how OCaml
was readable. Good to know it was just formatted oddly on the webpage.

------
chollida1
Seeing as how the discussion seems to be here, I'll post my comment from the
other post here...

Yaron really does know his stuff when it comes to OCaml.
<http://ocaml.janestreet.com/?q=node/61>

people interested in some great OCaml libraries should check out what Jane
street has released to the public:

<http://ocaml.janestreet.com/?q=node/13>

~~~
Stasyan
It's an awesome video. Thank you for posting it. I wish I could upvote you
more than once

------
wickedchicken
Weirdly enough, last night I posted a project skeleton up on GH:
<https://github.com/wickedchicken/ocaml_skeleton>

While the core OCaml language is fun to play around in, a lot of the build
tools are scattered across the web and hard to decipher (4 year old blog posts
with only half-working code don't help). This aims to remedy that, and I'd
appreciate any feedback :).

~~~
iskander
Cool, this would have helped me a lot when I was getting started. An idea: You
might want to start the README with 'Skeleton is X'. I had to scan around for
a while to figure out what your project actually does.

~~~
wickedchicken
Hey, I looked up your profile and you mention doing some compiler research. HN
has no way to 'ping' a user, but I'd be curious what that research entailed...

~~~
iskander
If that email on qrunk.com works, then I just emailed you.

------
colanderman
This is missing one key feature of OCaml: module functors.

Briefly stated, module functors allow you to wrap up a set of functions _and_
types as a module, and state not only which functions and types this module
_provides_ but also which functions and types the modules _requires_. You can
plug together module functors with complementary provides and requires, like
building with toy bricks.

Many languages support the _provides_ half of this feature (e.g. Java's
interfaces) but few support the _requires_ half (Scheme's units are one of the
few that come to mind). The advantage of supporting both provides and requires
include ability to swap out equivalent implementations of some module, perform
massive code abstraction, and to better isolate unit tests without resorting
to conditional compilation. (You can quite literally plug a high-level module
into a fake lower-level module in order to test the high-level one using one
line of code.)

The "language of 2020" _will_ have this, or an equivalent, means of massive
abstraction. Or better still, such a mechanism will exist as a separate
language unto itself which can work with multiple languages. (Think C-style
symbolic linking combined with a .NET ABI.)

~~~
cwzwarich
OCaml does have functors.

~~~
colanderman
Yes, I said "This is missing one key feature of OCaml", not "OCaml is missing
one key feature" :)

------
Stasyan
He talks about C# 4.0, but F# is not mentioned at all. Once you switch from
OCaml to F# you never go back.

~~~
j2labs
What makes F# so much more compelling?

~~~
Stasyan
I programmed OCaml for couple of years, and now I've been programming F# for
past 3 years.

OCaml is more verbose than F#. F# is on par with Python.

F# besides having all features of OCaml. (You could (and maybe still can)
compile OCaml using F# compiler.) also has some nice extras. Workflows (think
monads in Haskel). Workflows in turn used to implement Asynchronous Workflows,
and mailbox thread processing. So you get Erlang style multithreading.

Another point for F#: since it's on .Net and .Net actually runs on multicore
machines the way one would think it should run. OCaml on the other hand has
garbage collection that does not play with multicore very well.

Last but not least: F# can call any .Net function or create any .Net object ->
you have access to a lots of things out of the box. F# - batteries included;
OCaml - batteries are not included.

[Edit - spelling and formatting]

~~~
Dn_Ab
My memory of OCaml is faded. Can you explain how Ocaml can be more verbose?
Especially since the inference story in F# is not as full due to having to
deal with objects with ad-hoc polymorphism. I don't see how Ocaml can be more
verbose. The core language of both is virtually identical.

Also F# is not all of Ocaml. To mind, it lacks functors, ocaml strength
modules and polymorphic variants. Ocaml also has the potential to be faster.
At least in the single core case.

~~~
Stasyan
I meant that the syntax of OCaml is more verbose. In F# (now that the #light
directive is a default) you need less comparing to OCaml. Do not need to add
;; to terminate an expression (except for in REPL). Do not need to have "done"
to close every loop declaration. Do not need to have "in" for "let"
declarations.

~~~
pdhborges
You don't need ;; to terminate an expression (except when using the REPL).

------
chrisaycock
Yaron Minsky has a few videos about Jane Street's use of OCaml in the finance
industry:

<http://www.janestreet.com/technology/ocaml.php>

------
chrisaycock
Hmm, this link was posted just a few minutes earlier:

<http://news.ycombinator.com/item?id=3047682>

------
agentgt
I love Ocaml. My only gripe is that the language has a ton of ways to do
something.. ie there is a syntactical shortcut for almost everything. So I can
see how Python guys might scoff at the language.

It would be pretty cool if someone made a node.js (event lib) like web server
for Ocaml.

~~~
silentbicycle
Ocsigen (<http://ocsigen.org/>) is based on cooperative threads, AKA
coroutines.

There's also an OCaml-to-Javascript compiler.

------
silentbicycle
Duplicate. <http://news.ycombinator.com/item?id=3047682>

~~~
fogus
Sorry about that, I suppose I should'nt lay true faith on the HN dup detector.
I typically delete a dup, but for some reason the conversation on this thread
has been hot.

------
michaelochurch
This is one of the most important articles of the past year.

It's not just about functional programming being powerful and concise and
awesome, even though it is those things. (Mostly, that is. Functional
programming, taken too far, can be incomprehensible.)

Ocaml's a very simple language: a bare-bones skeleton for what a 2020 language
will look like, a functional C. I don't intend to claim that everyone should
drop their favorite languages and switch to ML, but it's important to grok the
idea of ML to get a taste for: (1) higher-order functions (instead of objects)
as the default abstraction when mutability's not needed, and (2) the power of
strong, static typing. The actual "language of 2020" won't be this Ocaml (no
multicore support) implementation and probably not Ocaml at all, but it will
look a lot like Ocaml, Haskell, and Scala.

Let me bring out one snippet:

 _Reading code was part of the firm's approach to risk from before we had
written our first line of OCaml. Early on, a couple of the most senior traders
(including one of the founders) committed to reading every line of code that
went into the core trading systems, before those systems went into
production._

That's not bullshit. A smart person with a general sense of algorithms, but
who's not necessarily a full-time programmer, can read and understand most
OCaml code. In C++ this would be impossible; you'd need a C++ expert just to
make sure you're not going to get impaled by undefined behavior.

What makes OCaml awesome is that it's the only language I've encountered
(Haskell and Scala may have this property; insufficient exposure) where
_reading_ average-case code is _fun_. Haskell is a great language as well, but
it seems to be optimized for _writers_ of code; Ocaml's optimized for
_readers_. Yes, there's horrid Ocaml code out there and there's beautiful code
in lesser languages, but Ocaml is the only language I've _ever_ encountered
where 50th-percentile code looks attractive. The consequence is that people
_do_ read code. Sometimes, just for fun. (Yes, imagine that.) I learned a hell
of a lot about programming when I was working in Ocaml simply because I
_enjoyed_ reading the code. Average-case C++ code is never fun to read, and
what matters in a professional environment is not what the language makes
possible, but what average code actually ends up looking like.

If you're not familiar in detail with the benefits of functional programming
and strong static typing, read this article. Read it 3 times, even.

