Jane Street OCaml

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

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

Good read. I rather like Yaron Minsky's videos on the Jane Street site, too: http://ocaml.janestreet.com/

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

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…

Probably the most known group using it in the US is Jane Street. https://ocaml.janestreet.com/

Documentation for the Jane Street's Core Library looks incomplete or damaged (E.g. Core.Core_list module https://ocaml.janestreet.com/ocaml-core/latest/doc/core/Core_list.html… I think, this is very unfortunate, because the labrary is probably great. I have not tried it yet (I'm pretty happy using just the standard one most of the time), but I whould like to have Async, Sexplib and other new things from Jane Street. Is there a better documentation for this lib?

I think this talk is relevant: https://ocaml.janestreet.com/?q=node/61

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-package… ) Pretty nice.

OCaml has a powerful module system which can be used in a way quite similar to typeclasses (https://ocaml.janestreet.com/?q=node/37). The main difference is the lack of purity, which means that the side effects of a function aren't part of a function's type. It also doesn't have the wide variety of extensions which you can use to do really crazy stuff (like verifiably correct red-black trees, https://github.com/yairchu/red-black-tree/blob/master/RedBlackTree.hs)…

Not really what you're thinking of but in similar spirit: https://ocaml.janestreet.com/

You might find this interesting: https://ocaml.janestreet.com/?q=node/61 TL;DR: Jane Street is a quantitative trading firm whose language of choice is OCaml and has several people programming in it full-time. Besides experiencing the commonly-cited advantages of FP (productivity, expressiveness, local reasoning), they also found it highly performant, useful for rapid prototyping and resilient to changing requirements.

A while ago I truly enjoyed his talk at CMU: https://ocaml.janestreet.com/?q=node/61 both as an introduction to high frequency trading, arbritage and stuff, and to FP in industry too. EDIT: it was already posted below.

Monads suit the problem nicely and it's been done in quite a few languages already: http://lambda-the-ultimate.org/node/4117 http://ocaml.janestreet.com/?q=node/100 http://en.wikibooks.org/wiki/F_Sharp_Programming/Async_Workflows This is something that JavaScript desperately needs. Macros aren't so nice for this stuff in non-homoiconic languages.

Haskell doesn't have any subtyping, so the problem doesn't come up. For languages that implement generics in a way that takes variance into account, you can look at e.g. Java (ignore the array class, but look at Vector<E>) or Scala. OCaml also has subtyping (for records and variants) and variance-annotated type variables (http://ocaml.janestreet.com/?q=node/99).

There is a link at the very first line of they message, while at the bottom there is a link to they complete archive. http://www.janestreet.com/ocaml/async-107.01.tar.gz http://ocaml.janestreet.com/?q=node/13

It would appear that they do. http://ocaml.janestreet.com/?q=node/80

What about Jane Street's Core (http://ocaml.janestreet.com/?q=node/13), or Batteries Included (http://batteries.forge.ocamlcore.org/) ?

Ocaml prepares you for Fsharp - a first class language of the .NET framework. Full IDE support, cross-platform, very liberal licensing, and more or less on the cutting-edge from a MS languages point of view. Ocaml is also used in the finance domain a bit. http://ocaml.janestreet.com/ Particularly the option types, pipelining, pattern matching, etc look very different to me, coming from mainstream languages.

This video explains a bit more about what they do: http://ocaml.janestreet.com/?q=node/61

On OCaml, http://ocaml.janestreet.com/ might interest the OP.

Here's a blog post by Yaron describing the talk: http://ocaml.janestreet.com/?q=node/75

Not quite what you asked for, but check out http://www.collective2.com for this. Also check out Janestreet, algorithmic trading is their business and they open source some stuff. Maybe something useful there: http://ocaml.janestreet.com/

It's very interesting. This Jane St. video had a big influence on my decision to spend some time learning ocaml: http://ocaml.janestreet.com/?q=node/61

They also rewrote the standard library. http://ocaml.janestreet.com/?q=node/27 And did so only recently. Imagine how bad a standard library has to be before a shop takes it upon themselves to rewrite it. I think that might partly explain why many people have dabbled in Ocaml but few have really embraced it.

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…

Here's a link to the latest documentation: https://ocaml.janestreet.com/ocaml-core/latest/doc/re2/Re2__/Regex_int…

https://ocaml.janestreet.com/ocaml-core/109.55.00/tmp/re2/Regex.html should do the trick! ocaml core is well maintained AFAIK

We also just released improved docs for Base. Still more to do, but much better than before: https://ocaml.janestreet.com/ocaml-core/latest/doc/base/