
Julia Computing Raises $4.6M in Seed Funding - sandGorgon
https://juliacomputing.com/press/2017/06/19/funding.html
======
flavio81
I wish them all the best. Julia seems to a good idea -- a high performance
language with easy syntax (easy for Python users to jump to Julia), very good
features for threading/multiprogramming, good type system...

...here it seem like any other modern language, until you see that Julia has
something that many other languages lack: true macros (true metaprogramming.)
A _big_ feature. And multiple dispatch on all functions! (a very nice feature
that puts it above many other languages in use.)

You can even program Julia in s-expressions if you feel like it. (Some argue
that Julia should be considered a Lisp dialect.)

Compared to the other languages with Python-like, C-like or Algol-like syntax,
Julia stands out from them as a more powerful alternative. (If you need more
power and flexibility than Julia with good processing speed, i think only
Common Lisp will clearly provide it.)

A very recommendable language, especially now with this initiative for giving
more "enterprise-like" support, and worth looking in depth, if you are also
considering moving to Go and Rust.

~~~
zbobet2012
Julia is a great language, but it is still focused on the numerical computing
world and is not "1.0" (language and API's are not locked down). I wouldn't
really compare it to Go or Rust at this point. Go is focused on building
services at its core (e.g. external event driven workflows). Aka
microservices. Rust is focused on being a "traditional" systems programming
language. Things like web browsers (duh), office suites, games, etc.

Julia is focused on taking the best of R, Python/Numpy, and Matlab. It is a
_great_ language. But as far as I can see it's really focused on a different
problem space.

~~~
flavio81
If you take a look at the features (esp. macros and multiple dispatch) you can
see that is readily extensible for lots of applications. Thus the reason it is
also sold as a "general purpose" language.

Additonally, the very good support for threading and multiprocessing means it
has a good future with services, async IO, and with event-loop web servers (a
la node.js and friends).

Finally, the focus on fast speed for numerical computation is particularly
suited to games (as is the support for threading).

~~~
moomin
This sounds like a small thing, but with 1-based arrays, I'd bet more on it
taking share from MatLab/R than from Rust or Java.

~~~
dangjc
I didn't think 1 based arrays would be a big deal, but whenever I try to port
code from Julia to almost any other environment (C++, python/numpy, scala,
JS), it becomes one of the hardest things to reason about quickly and
correctly.

~~~
ScottPJones
1-based arrays, and column-major layout of arrays annoyed me at first,
however, one of the beautiful things is that much of Julia is written in
Julia. If you want 0-based (or arbitrary based!) arrays, then simply use the
[https://github.com/JuliaArrays/OffsetArrays.jl](https://github.com/JuliaArrays/OffsetArrays.jl)
package, and PermutedDimArrays have been added to Base, to handle some of the
issues of dealing with row-major (and other sorts of memory layout) matrices.

~~~
moomin
Doesn't this mean that instead you're now dealing with inconsistent data
representations?

------
skybrian
I was a bit surprised by the idea of the FAA using Julia for an "Aircraft
Collision Avoidance System", since it apparently doesn't have static type
checking and deployment seems like a weak spot.

Digging a bit deeper, it appears they use it to deliver specifications and
example code to vendors?

"[T]ransferring the specifications to industry using this legacy system
required three different types of documentation: first, the specifications
were written both in variable-based pseudocode and in English descriptive
pseudocode. But this approach left gaps in interpretation, leading to possible
confusion or disagreement. So programmers also created state charts to fill
these gaps and eliminate the potential for misinterpretation."

[https://juliacomputing.com/case-studies/lincoln-
labs.html](https://juliacomputing.com/case-studies/lincoln-labs.html)

~~~
KenoFischer
Yes, it's quite cool. The specification is a literate Julia program and the
specification document is built from it. Simultaneously, they run large scale
simulations to make sure that the specification behaves as the theory says it
should. There was some discussion with them about deployment, and they funded
us for a proof of concept Julia-to-C compiler, but the continuation of that
discussion is probably still a number of years off. It's a very long term
project.

~~~
skybrian
Having read a little about TLA+ recently, I'm curious about how specifications
are written in Julia. (For example, is there model-checking involved?)

~~~
simonbyrne
There was a talk at JuliaCon 2015:
[https://www.youtube.com/watch?v=19zm1Fn0S9M](https://www.youtube.com/watch?v=19zm1Fn0S9M)

Slides here:
[http://juliacon.org/2015/images/juliacon2015_moss_v3.pdf](http://juliacon.org/2015/images/juliacon2015_moss_v3.pdf)

------
indescions_2017
I know it's also gained a following at MIT's Broad Lab amongst genomics folks.
And that seems to be Julia's sweet spot: easy parallelism for scientists who
can't spare the time futzing with HPC internals. Congrats to the Julia
language team and to the great scientific discoveries that will be enabled
with this investment!

[http://julia.mit.edu/](http://julia.mit.edu/)

~~~
Q6T46nT668w6i3m
Interesting. I'm a member of a Broad Institute lab that recently evaluated
Julia. We reached the conclusion that Julia, while promising, lacked the
flexibility and performance of our existing tools. I suppose this is a problem
that investment could address!

~~~
mac01021
What are the existing tools that it doesn't match up to?

~~~
Q6T46nT668w6i3m
Python’s scientific ecosystem (i.e. Keras, matplotlib, NumPy, pandas, scikit-
image, scikit-learn, SciPy, and TensorFlow, et al.)

~~~
thebooktocome
* matplotlib is wrapped by PyPlot.jl.

* TensorFlow is wrapped by TensorFlow.jl, improves on Python API ([https://github.com/malmaud/TensorFlow.jl/blob/master/docs/sr...](https://github.com/malmaud/TensorFlow.jl/blob/master/docs/src/why_julia.md))

* Pandas is wrapped by Pandas.jl, interfaces with Julia's DataFrame, generally excellent.

* Images.jl is a 60%-to-70% replacement for scikit-image.

* NumPy and SciPy are mostly covered by StatsBase and Base, can't think of anything off-hand that's missing.

Julia's still immature in the machine learning domain, but a lot of new work
is being done. One interesting somewhat-new package is Madeleine Udell's
LowRankModels.jl, which has a particularly Julian approach to low rank
fitting.

------
drej
Julia frustrates me. I was in a mathematical modelling sphere, so I learned
the language basics years ago and immediately fell in love (multiple dispatch,
optional types, broadcasting, ...). But I couldn't get approvals at work to
push it, because it was immature. Then a month later, all my code broke. I
rewrote it using new APIs. It broke again. I know they reserved the right to
make breaking changes up until 1.0, but they are hindering adoption because of
all this. Sorry, guys, but I'll have to stick to Python, Go and (sigh)
Fortran.

That being said, I applaud getting good funding for a project that's actually
more than beyond MVP, it has happy users/customers and it serves a purpose.
That's not all that common these days. Good luck, guys.

~~~
smt88
My girlfriend does incredibly complex modeling (she's a computational
geneticist). From my limited understanding, it sounds like you may have some
of the same challenges that she does.

Do you think Python and Go are more suited to that domain than R or Julia?

~~~
flavio81
R is very, very slow compared to all the other programming platforms
(including Ruby, a nice language but with some of the slowest implementations
out there).

R syntax is very unlike most programming languages so jumping to other
languages can feel strange.

Python with Numpy, SciPy and Pandas, is the current widespread alternative to
R and a good starting point. Recommended!!

~~~
nnm
For all the cases I worked on, R is not slow at all. At home, I wrote a R
package to do deep learning (include most common layers, but only conv layer
was implemented in C++) from scratch, and I also wrote one in python (using
numpy + numba). My R version is same fast as python on the MNIST dataset
(without conv layers, hence all code is in plain R or python).

~~~
flavio81
What this means is that for your purposes R is fast enough. But in the
absolute sense (or in any case, relative to other programming platforms), R is
one of the slowest ever. R is usually slower than Python, and Python in some
cases can be 100x slower than C.

Performance, assuming identical hardware, depends on the program itself (that
is, on what you are trying to calculate or compute or perform), but if you
choose many different programs you can have a comparison between platforms
("platform" in this case means combination of programming language plus
compiler or interpreter.)

Here is a graphic comparing Julia to other platforms:
[https://julialang.org/benchmarks/](https://julialang.org/benchmarks/)

You can see that according to that graphic, R can be up to 400x slower than
Julia (or C).

There is another independent benchmark here. It does not include R but it
includes Python, and it's very interesting.

[http://benchmarksgame.alioth.debian.org/](http://benchmarksgame.alioth.debian.org/)

But the best comparison graphs are here, this is worth a look:
[http://blog.gmarceau.qc.ca/2009/05/speed-size-and-
dependabil...](http://blog.gmarceau.qc.ca/2009/05/speed-size-and-
dependability-of.html)

~~~
ferdterguson
> Python in some cases can be 100x slower than C

Yeah, the Python implemented version is. But people doing serious computing in
Python that requires speed are doing it with NumPy or even Cython or just
straight up calling C/Fortran libraries in Python.

~~~
fourthark
It's the same in R - you can have good performance of you use vectorized
routines, because those routines are written in C/C++/Fortran.

------
faitswulff
I wonder if this would be a feasible funding strategy for Crystal
([https://crystal-lang.org/](https://crystal-lang.org/)) as well. From the
scattered benchmarks I could find online†, Crystal seems to be just as fast,
if not a bit faster.

†
[https://github.com/kostya/benchmarks](https://github.com/kostya/benchmarks),
[http://blog.seraum.com/crystal-lang-vs-nodejs-vs-golang-
vs-j...](http://blog.seraum.com/crystal-lang-vs-nodejs-vs-golang-vs-julia-vs-
rust-vs-luajit-vs-c-fibonacci-benchmark)

~~~
throwaway7645
Well, they're both implemented in LLVM, but Julia uses a JIT and not straight
to a native binary. I bet they have very similar performance. The use cases
are different though. Julia is a replacement for MATLAB, R, Fortran, &
scientific Python with speed and good macro support. Crystal is basically
fast/native Ruby, so websites and business apps. You could technically use
either for those applications, but the communities will be mostly scientific
computing for Julia and business apps for Crystal.

~~~
cutler
Last time I looked Crystal's string handling was significantly slower than
Ruby's.

~~~
throwaway7645
In a pre 1.0 language there will always be some things that are still waiting
to be optimized. I saw some performance spec for one of their HTTP libraries
awhile back and it was a lot faster than Ruby. It might have been faster than
Go.

~~~
glwtta
It was faster than everything, and by a huge margin:
[https://github.com/costajob/app-
servers#results](https://github.com/costajob/app-servers#results)

It does seem that immature languages tend to win a lot of benchmarks, likely
because they're still cutting a lot of corners. Still, though.

I only wish they picked a more "Enterprise-friendly" name...

~~~
throwaway7645
Well, it is the only LLVM language on the list. Even so, Nim transpiles to C
and should be fairly comparable unless it is because of the async part or like
you said they're cutting corners. I guess it's possible they're just that
good, but it seems unlikely.

~~~
dom96
Please stop using the word transpiles in this context. Nim compiles to C.

------
edshiro
That's an impressive amount of money to raise in Seed funding. Here in the UK
this is more like Series A money: a Seed round would probably be around $700K
(no authoritative source - purely from knowledge of a few companies raising
this kind of money).

I do wonder though: have Julia been able to raise this much money thanks to
awesome traction or the reputation of the team?

~~~
CalChris
That's A money. They were founded in 2013. They have 11-50 employees. They
already have products (read: MVP) and services. That's not _proving a
hypothesis_ seed money. That's _scaling an enterprise_ A money. That said,
Crunchbase [1] says seed round. But that's A money both by size and apparent
intent.

 _We are self-­funded and have been profitable from day one._ [2]

[1] [https://www.crunchbase.com/organization/julia-
computing#/ent...](https://www.crunchbase.com/organization/julia-
computing#/entity)

[2] [https://venturebeat.com/2015/05/18/why-the-creators-of-
the-j...](https://venturebeat.com/2015/05/18/why-the-creators-of-the-julia-
programming-language-just-launched-a-startup/)

------
krupan
What is the business model? How are they making money?

~~~
olympus
They sell an enterprise version of Julia for $1500 per year. The main things
you get are support, MS Excel integration, and a non-GPL license. They also
offer consulting, training, and a few other flavors of Julia (large scale
server based gets its own edition).

I'm sure the main draw will be companies that don't want to be stuck with a
GPL license in their product.

~~~
wodenokoto
So if I send a patch to Julia, do I have to give them the rights to GPL and a
non-GPL version?

~~~
Buttons840
They advertise that Julia is MIT licensed on their website, so I think the
parent comment is wrong.

~~~
detaro
The Julia core is MIT and thus not an issue. The issue with making a bigger
GPL-free package is in libraries and dependencies (which I assume are either
turned off, swapped out for non-GPL versions or have dual-license deals of
their own for the gpl-free package)

------
smaili
For those thinking "What's Julia?", article has a nice tldr --

 _Julia is the fastest modern high performance open source computing language
for data, analytics, algorithmic trading, machine learning and artificial
intelligence._

------
cyber1
Julia seems very attractive with clear syntax and really fast! I wish you
best!

I think Julia should be very nice in server-side development.

------
pixelmonkey
Anyway else think it's interesting that $4.6m could be labeled "seed funding"?

Seed round 2016 average is around $1m per Crunchbase:

[https://techcrunch.com/2016/09/07/crunchbase-sees-rise-in-
av...](https://techcrunch.com/2016/09/07/crunchbase-sees-rise-in-average-seed-
round-in-2016/)

Cooley has seed round pre-moneys at $4-6m. (Thus, a $5m check is pretty much
out of question at that stage.)

[https://www.cooleygo.com/trends/](https://www.cooleygo.com/trends/)

So, this is much more like a Series A? I wonder if they were advised to call
it seed funding to leave open the possibility of a "big" Series A, due to the
level of interest. It does seem like SV VCs are making somewhat large bets on
F/OSS-based companies, so maybe that is wise.

I also realize a lot of this is semantics.

~~~
ghc
General Catalyst and Founder Collective are both Boston funds, so SV rules
don't apply here. For better or worse raising in Boston is _very_ different. I
did a bit of diligence on this deal as it was going around (for a different
fund), and the dynamics of the company stage probably dictated the raise size.

It's not uncommon for an institutional seed round to be $2-3MM on a valuation
of $6-15MM in Boston right now. The size of rounds is partially a function of
how frothy the OSS tools market has gotten. I'm looking at another hybrid
enterprise/OSS deal that has a valuation north of $15MM.

A rounds nowadays look for $!MM ARR so you can say the letters shifted as well
:)

------
zitterbewegung
Sounds like a good idea for the language and a good startup idea. I know of
two businesses that support python and since Data Science is a growing field
we can always need competition in environments and languages.

------
gruglife
As someone that uses Python and R for data analysis, is it worth learning this
language?

~~~
gaius
No. Not a knock on the language (I've never used it) but look at the R and
Python ecosystems - it will be incredibly hard to replicate them. Then you
have all the proprietary tools - MATLAB, Mathematica, Q etc - they aren't
going anywhere. Then there's all the legacy FORTRAN code...

If it's still around in 10 years then it _might_ be worth looking at (but
still probably not).

~~~
ihnorton
> it will be incredibly hard to replicate them

This is true, sort of. It was also true when people said the same about Perl
(some people still say this about Perl!). Then Rails happened to Ruby, just as
the web was going through another phase of explosive growth. Likewise, Node or
Rust + GitHub effect.

The point is not to compare the growth trajectories or projected peaks, but to
emphasize the levering effect of an enjoyable language combined with modern
collaborative development and infrastructure. A language doesn't need
"everyone" to build a viable ecosystem, just a critical mass.

> If it's still around in 10 years then it might be worth looking at (but
> still probably not).

Knock on wood and all, but from past observation, I think Julia is at or very
close to this critical mass already. I would compare Julia now to the SciPy
ecosystem around 2009-2010. That's just when IPython was getting popular,
early versions of Pandas were released, and people were starting to trust
Cython. (I was a heavy Python user then, and frequently suggested it to Matlab
users who had exactly your question even in to 2012-2013). There's already a
surprising breadth of packages, they just need time to mature. Sometimes too
many, actually -- I recently found _three_ for a relatively obscure geophysics
format I used to work with. That lever is big enough that people often don't
mind rolling their own.

------
sriram_sun
I've heard good reviews of the language here. So I've no doubt about its
technical capabilities. However, funding might suppress the ability to make
breaking changes.. which I believe are pretty good until 1.0 or so. On the
business side, will we end up with (hopefully) a better, cheaper Matlab?

~~~
hatmatrix
$1500 for JuliaPro - maybe not?

~~~
sriram_sun
My guess is that we'll probably start seeing pricing split into various
modules a la Matlab - Julia Financial, FEM, Semiconductor etc. Also Julia
Enterprise etc.

Maybe Mathworks will acquire them and call it MATLAB 2020!

------
nickpeterson
I'm not sure I buy the notion of, "Solves the two language problem." There is
always going to be some library or environment consideration that makes a
unified language for everything impractical (unless your entire business runs
on an AS400).

~~~
ffriend
The two language problem is more specific to scientific computing where
literally every popular library is written in more then one language - fast
C/C++/Fortran and convenient high-level R/Matlab/Python. NumPy, SciPy, Caffe,
Theano, Tensorflow to name a few. I once had to rewrite Matlab + C code (for
face tracking) to pure Julia - not only the resulting code was almost twice
smaller, it also ran ~20% faster.

~~~
dnautics
I wrote a library in c to replace a Julia one I wrote (and make it more
portable) and found that the c version was slower! (Couldn't inline functions
as easily in c and was also being more parsimonious about memory usage in c)

------
dkarapetyan
"Speed of C++ and Java"? What does that even mean?

~~~
mr_overalls
Its performance rivals that of traditionally "fast" languages for a wide
variety of benchmarks.

[https://julialang.org/benchmarks/](https://julialang.org/benchmarks/)

[https://www.ibm.com/developerworks/community/blogs/jfp/entry...](https://www.ibm.com/developerworks/community/blogs/jfp/entry/A_Comparison_Of_C_Julia_Python_Numba_Cython_Scipy_and_BLAS_on_LU_Factorization?lang=en)

[https://modelingguru.nasa.gov/docs/DOC-2625](https://modelingguru.nasa.gov/docs/DOC-2625)

------
mr_overalls
This seems a little premature when considering that Julia is only up to v0.6,
and the language is still making breaking changes.

[https://github.com/JuliaLang/julia/blob/release-0.6/NEWS.md](https://github.com/JuliaLang/julia/blob/release-0.6/NEWS.md)

------
rllin
Any suggestions for learning Julia (detailed projects to follow) for fluent
pythonistas?

~~~
simonbyrne
The basic syntax itself will look very familiar to someone coming from python.
The immediate obvious differences:

\- 1-based indexing instead of 0-based

\- end keyword vs significant whitespace blocks (and no colon to start a
block)

\- function instead of def (or defined inline f(x) = ...)

\- x -> ... instead of lambda x : ...

\- start:stop/start:step:stop instead range(start,stop)/range(start,stop,step)

\- strings are joined with * instead of +

The actual internals, and features such as types and multiple dispatch can
make it a very different to use, but hopefully that should be enough to get
you started.

~~~
kem
FWIW, I think now technically indexing can either be 1- or 0-based.

------
tempodox
So, will Julia finally emit stand-alone binary executables, AOT-compiled?

------
howfun
Wasn't that a language with 1 based indexes? Is yes, then forget about wide
adoption.

------
drenvuk
So this is why every once in a while we see some article about Julia being as
easy to use as Python while having nearly the performance of C. That's some
very slick but sketchy marketing tactics.

I'd rather deal with Cython apache license than deal with this GPL stuff for
commercial use.

~~~
matt4077
This seems to be a terrible misinformed comment. Not only isn't there really a
problem with using GPL tools in a commercial context, as long as they don't
become part of your work product. GCC is probably used to compile a large
percentage of commercial software. And I'm sure you're writing comments in
Chrome, yet expect to retain the copyright on those words.

But what makes this really asinine is that Julia isn't even GPL:
[https://github.com/JuliaLang/julia/blob/master/LICENSE.md](https://github.com/JuliaLang/julia/blob/master/LICENSE.md)

Moreover, since I've been seeing this kind of hostility towards the GPL more
and more often: it should be somewhat obvious to everyone that the current
ecosystem of widely available, highest-quality OSS stacks is a rather
surprising development. There are certainly parallel universes where parallel
computing requires you to buy the compiler from IBM, and URIs end not in
.html, but in .doc.

The GPL and its advocates aren't the only ones who created this, but I'm
pretty sure they were at least necessary. That includes not just the software
they created, but also the force of the moral argument for software freedom
they made.

~~~
bachmeier
What I really dislike about a lot of the GPL arguments is that they are
complaints that the GPL doesn't let you freeload masked as arguments that the
GPL is anti-business. The GPL is one of the most business-friendly licenses
there is. The freedoms guaranteed by the GPL mean dual licensing works. Good
luck with a dual licensing strategy if you release your software under the MIT
license.

