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 :).
I highly recommend you check out oasis (http://oasis.forge.ocamlcore.org/). It's a meta build system which is quickly gaining traction in the OCaml community. It's still in early development but works extremely well for most projects.
Over the past half year I've been exploring Haskell and so naturally my interest has recently piqued at OCaml. Thank you for this, it couldn't have come at a better time. I wonder if you think it would be worth including camlp4/p5 in the skeleton?
Unfortunately as I'm still coming up in the language myself I don't have knowledge of what would be useful there. If someone who does can point to somewhere, I can try and fit it in.
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.
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...
* It gives you a convenient place to stash extra config options in your project. For example, instead of having to type (and remember!) -tag pkg_oUnit, it's just in the Makefile. You can't forget something that's been saved in a text file!
* It gives you a single point of entry for "other" tools which may be added later -- documentation generation, packaging, installing as a library or Debian package. I personally like all of that recorded in one file so I have to search around less.
* As an expository project, it's helpful to show off clear examples of ocamlbuild itself -- the syntax is different enough that someone just starting out in the language may not be able to grok the documentation enough to just get something running.
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.)
Functors simply provide dependency injection for modules. It's no different from any other kind of dependency injection, except that modules themselves are a very flexible unit of organisation.
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.
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.
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.
As far as I know you never could compile OCaml with F#, it lacks nearly all advanced features of OCaml. You can do the same as workflows in OCaml with delimited continuations [1], except it is even more fluid. That said, for most software the availability of the .NET library is more important than all of this. F# also has some very cool and compelling features like type providers and extensible pattern matching.
Some important features, such as modules, are missing in F#. I suppose the intention is to replace them by interfaces and classes, but modules in particular are an important omission that makes me prefer OCaml (though I like both ;)).
A few other missing features: polymorphic variants, structural types for objects, functors, camlp4 (though it's not really O'Caml core, it's pretty nice).
I don't think F# is necessarily more compelling. It is subjective to what you weight higher.
If you go to the article at the bottom it lists some limitations. Libraries, tooling and proper parallelism including in GC. Also IMO F# ties OOP with functional better, on par with Scala.
If you weight these against F#'s weaknesses: lack of full modules and functors, tied to .net and mono / non native code generation and they come up being more of an issue then you would prefer F#. Which is the choice I ended up making.
Take a look at the limitations section of the article at the end. F# doesn't have any of those. It has great tools, massive library support, and really good parallelism support. Unfortunately it comes with its own drawbacks. It is a more complicated language. The type system is weaker. Performance isn't as good.
I may be an outlier, but the ability to compile to native code is the main reason I'm interested in OCaml. I already know enough VM-based languages, so having something that works close to the metal fills an important gap in my skill set.
(One not inconsequential issue: I spend 20 minutes the other day googling the F# "as" keyword. In the end, all you can do is read the language spec and source)
Look at this video[1], 1:09:40. Apparently their code is too functional (heh…) for F# (or, well, the CLR). Not sure whether that has changed with recent versions of both F# and the .NET platform, although I think some problems are really, really hard to solve if you want to stay compatible with .NET libraries.
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.
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.
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.
