Jane Street's OCaml site hosts material from its engineers, including Yaron Minsky's talks and the Core, Async, and Base libraries.
HN commenters cite it as evidence of OCaml's use at Jane Street and praise Minsky's expertise, with Jane Street staff posting hiring notices.
Jane Street's Async library is a great example of backpressure (or as they call it, pushback) done right. Specifically, their Pipe module[0] is what implements this concept very nicely. In essence, a Pipe is a stage in a pipeline. You shove values into one end, and it'll pop out the other end. Then, you can build on a pipe by map-ing over it, filter-ing over it, doing whatever you want over it. Each time you add another operations like this, you're extending a pipeline with another stage, all of which can proceed concurrently.
A Pipe is an unbounded FIFO. But, you can give it a size budget. What that size budget does is determine when writes to a Pipe will block. So if a Pipe has a size budget of 0, then any write will return a Deferred.t (i.e., a promise) that will become determined only when the value has been sent downstream to the next stage of the pipe. If the size budget is 1 on the other hand, then the Deferred.t of the first write will become determined immediately, allowing computation to proceed. If on the second write the first value hasn't been sent downstream, then it'll block. Once there's only one value waiting in the first stage of the Pipe, the second Deferred will become determined.
Another nice module in the library that addresses the connection pooling issue at the end of the blog post (and really that's all it amounts to) is the Throttle module[1]. Here's you can create a Throttle object with however many connections you like, say 5, to however many…
ML's and C# have their strengths and weaknesses, but from a type theory perspective, ML's type system is simply much more powerful when it comes to ensuring correct code than C#'s. Take, for example, your implementation of Head, what if you messed up and wrote:
> return (list.Count == 0) ? null : list[0];
Would the C# compiler catch it or would you not find out until runtime? An ML compiler would tell you that function is wrong.
What about using Head? If you have a list of integers, will the compiler let you do:
> Head(integer_list) + 2
An ML compiler won't, because it's not safe.
> This isn't strictly the same as what you described if "None" is different from "null".
It is, but the important thing to note is I had to specify that the function, 'hd', can return 'null', by wrapping it in the option type. 'null' is only a valid value for option types. If I write:
> val hd : 'a list -> 'a
I could not return 'null'/None, it simply isn't valid. And the compiler wouldn't let me.
> the 'option' function you have in your example
'option' is a type, not a function (I suppose you can make some high level argument that all types are functions over values or something, but not relevant here). And 'option' itself isn't really even a type, it requires a type variable, so "'a option" is a type where "'a" is replaced by a concrete type at some point. It's not doing the work you described above, it's actually defining a contract between me and users of hd and the…
Jane Street - New York City, London, Hong Kong - Software Developer (Functinoal Programming) INTERN / VISA
Jane Street is a technology-focused proprietary trading firm. We are looking to hire great software developers with an interest in functional programming. OCaml, a statically typed functional programming with similarities to Haskell, Erlang, F# and SML, is our language of choice. We’ve got the largest team of OCaml developers in any industrial setting, and probably the world’s largest OCaml codebase. We use OCaml for running our entire business, supporting everything from research to systems administration to trading systems. If you’re interested in seeing how functional programming plays out in the real world, there’s no better place.
The atmosphere is informal and intellectual. There is a focus on education, and people learn about software and trading, both through formal classes and on the job. The work is challenging, and you get to see the practical impact of your efforts in quick and dramatic terms. Jane Street is also small enough that people have the freedom to get involved in many different areas of the business. Compensation is highly competitive, and there’s a lot of room for growth.
You can learn more about Jane Street and our technology from our main site, janestreet.com. You can also look at a a talk given at CMU about why Jane Street uses functional programming (http://ocaml.janestreet.com/?q=node/61) and our programming blog…
While this is mostly true, it's worth noting that this is part of a push to make Core easier to build and use, which we hope will encourage more people to use it. (And enable others to contribute.) There's still a ton of work to be done in that regard, but this release, at least, includes a Linux build script, and the libraries which are necessary for building Core.
Also, this release includes Async (our concurrency library), which is a much more recent release (October 2011). If you'd like more information about Async, there's Ron's blog post announcing the release [1], and also a previous comment of mine with some very basic sample Async code [2].
[1] https://ocaml.janestreet.com/?q=node/100
[2] http://news.ycombinator.com/item?id=3278532
Can Rust retarget GTK or QT ? Actually, the important question is whether it is meant to.
Will it ever be intended to replace application languages like Vala, Mono (used to write Tomboy, Banshee, etc.) or will it be restricted to system level stuff.
If yes, will there ever be scripting support (like Ocaml https://ocaml.janestreet.com/?q=node/80)
edit: Rust has a nice decentralized package manager as well called Cargo https://github.com/mozilla/rust/wiki/Doc-using-cargo-to-manage-packages ) Pretty nice.
I can't speak for best, but:
Ocaml is used and praised by Jane Street [1]
Python has a nice suite of financial tools available [2]
It may be that the best tool for analysis and for trading are different. For the former you want visualization tools and interactive exploration, but for the latter, you may need raw speed or relative safety of the code.
[1] https://ocaml.janestreet.com/?q=node/61
[2] http://wiki.quantsoftware.org/index.php?title=QuantSoftware_ToolKit