Not a problem for Julia: https://github.com/Keno/Cxx.jl

Looks like that uses Clang/LLVM. Does it work with C++ libraries built with GCC or MSVC?

MSVC: probably not; Clang's MSVC ABI support is coming along well, but last time I checked there was no COFF support in the JIT. GCC on Itanium ABI platforms should be fine, although mixing C++ stdlib versions would be risky (primarily an issue on OS X).

What about when Julia gets those things?

I thought Julia was interpreted and/or ran against a required pre-installed runtime?

For now...

Thoughts on Julia?

Solved here: http://www.ibis-project.org/index.html

Also, any plans for the stats ecosystem? (dataframe, dashboards, imputation, data cleaning etc)

It is still a bit wanting.

I've been doing a lot of work behind the scenes there, but it's still going to take a while to offer a mature product. What we really need are more qualified engineers to speed up the process, but there's a vanishingly small group of people who are interested in doing eng work on statistics libraries.

Makes sense. Thanks for both your open source work and your reply!

A lot of interesting things are going on in the DataFrames area - especially with the recent work on NullableArrays by David Gold and John Myles White. A blog post will be out soon describing it all. In my opinion, Escher.jl makes it really easy to build amazing dashboards and is progressing well.

But, a lot more remains to be done, and contributions would be really welcome in these areas that take Julia's statistical computing to the next level.

I'd like to add a note about my experience with doing this; I ended up forking Distributions.jl and added a fitting function for the Weibull distribution. Still need to clean it up and do a pull request,.

The amazing thing about Julia I've come to enjoy is how clean the source code, how easy it is to find functionality, and it's all written IN Julia. That means I can modify libraries that are normally C or C++ for perf reasons. It's changed the prospect of needing to add functionality from one of hesitation to feeling that it's actually enjoyable.

I'm really glad to hear this! I'd like to think that the community and inspectability argument for Julia is actually one of the strongest ones out there, but it's not easy convincing people who haven't had that experience.

It really is pretty great.

"However, it gives us the ability to do some really amazing things with our array infrastructure going forward."

What kind of things? Super curious.

The github issue linked actually has a detailed list of all the things that are planned - native bounds checking and removal, reshaped arrays, a lot more consistency in indexing and concatenation, slices as views, etc.

The GIL issue has been solved without breaking backwards compat: http://pyparallel.org/

It just need further dev work and acceptance into py3

Did you actually look into it? The threads you run can't make any change to existing objects, and various other changes. It does break compatibility, and needs patched version of Numpy, ODBC (and I would guess, most other packages).

Definitely not "solved without breaking backwards compat".

On Windows

Your example is trivially parallelized with some decorators from the dask library.

Example here: http://dask.pydata.org/en/latest/imperative.html

I hadn't seen Dask before this. Thanks!

Sure!

If you like it, can you please blog about it (and post on hn)? Needs exposure outside the python data community.

Have you seen this: http://dask.pydata.org/en/latest/

They pretty much already did, but with 3.x: http://pyparallel.org/