Julia is an amazing, elegant and beautiful language. It's almost perfectly suited for scientific computing and ML. However, I'm not very bullish on its future given s4tf

Swift can get you 90% of the way there, and that extra 10% can be more than made up the by the efforts of apple, google and other companies (including money, network/clout, kaggle which is owned by google etc). Despite predictions to the contrary, Chris Lattner's departure doesn't seem to have slowed down the project, and more team members from google have been added since.

Swift is rapidly approaching usability on windows with investment from google.

Further, at some point google will facilitate Swift's use for android apps, and then Swift's popularity will skyrocket, and all those developers will be naturally inclined to check out the ML stuff. Even facebook is getting in on the party: https://twitter.com/nadavrot/status/1241150682104606720

In addition, Swift has its own benefits over julia for production and large codebases, such as compilation to small binaries and static typing. Julia doesn't have a good story for either of these (yet?), and chasing down type instabilities in larger code isn't fun.

You mean the future of Julia or the future of Flux? While an amazing accomplishment (that is still on the way of becoming truly mature, just like s4tf), Flux is just one of Julia's current ML libraries, and it definitely doesn't feel like a Rails (or maybe Flutter) situation in which the library is larger than the language. ML isn't even Julia's core target (it just happens to fits extremely well with numerical and scientific processing).

Julia will be just fine even if s4tf somehow steals all the mindshare (especially since a mature differentiable programming library will inevitably serve as inspiration for Flux itself) as the language and target audience is not very similar to Swift's and as such Flux and s4tf will also find different niches (for example one can be more used on high performance scientific research thanks to Julia's ecosystem and focus while the other can focus on mobile deployment of ML models).

If my scenario holds, at some point Swift's scientific computing ecosystem will rival and overtake Julia's.

I don't see the ML ecosystem developing in isolation because there's going to be overlap, especially as more and more code can be differentiated.

Who is going to make the scientific ecosystem? Julia and Python's scientific ecosystems are so strong precicesly because they get domain experts in those ecosystems to write the software they need for their niche.

Machine learning programmers aren't about remake DifferentialEquations.jl or scipy in Swift. I've yet to meet a single scientist from a field outside of machine learning who was seriously excited for swift. This sort of machinery is hard to make and takes deep expertise, I really doubt it'll be made in Swift any time soon. Does swift even have plotting libraries yet?

Swift has a good automatic differentiation story, mostly because it is very focused on machine learning use-cases, has corprate backing and all efforts are on one implementation. However, having only one automatic differentiation implementation has drawbacks. It won't be suitable for everyone.

Julia on the other hand has a gigantic basket of different automatic differentiation tools all of which have strengths and weaknesses. This allows people to choose the right tool for the job and explore a very wide design space, allowing us to find which approaches work best for different circumstances. Our AD machinery is still evolving and definitely has problems, but progress has been fast and really encouraging.

Even if Swift becomes the next Python and eats scientific computing, I strongly doubt this will seriously hamper Julia's community. We've been doing great living in Python's shadow. Julia doesn't need to be the most popular language in the world to be useful or successful.

> Who is going to make the scientific ecosystem?

Google and apple. Apple already is working on a swift-numerics package.

Look at TF python and jax. They've re-implemented chunks of scipy and numpy twice, hired people to work on plotting (altair) etc

And that's with python. Their engineering time will go much further with swift, obviously.

Google and Apple are not going to make a full on scientific ecosystem because they don't have the domain experts or the motive.

Numpy is not the same thing as scipy.

DifferentialEquations.jl in julia is a great example of what it actually takes to make a real, competitive differentiation equation library. The sort of stuff that was built there requires a deep connection to the scientific and mathematics literature. Cash won't cut it.

Another great example that'll resonate with physicists at least is things like ITensors.jl https://github.com/ITensor/ITensors.jl. Apple and Google are not going to make something like that.

It's not JUST google and apple, I'm sure they have enough cash and expertise and will to create enough momentum to attract more domain experts in other areas. Especially once google brain and deepmind start working on things more complex than stacking layers, which is happening now.

In particular, do you have another example aside from DifferentialEquations.jl ?

Neural ODEs are hot enough that something like that could easily pop up in swift.

ITensors is interesting, but that's only one.

Maybe, but I'm doubtful. Scientific domain experts flock to languages like Python, Julia, Matlab, R, etc. because they're interactive and allow them to quickly iterate on ideas, query data, produce plots, etc. Swift is not much of an interactive language and is not built around that kind of repl driven experience.

> In particular, do you have another example aside from DifferentialEquations.jl ?

Sure, here's a smattering of high quality packages made by and for research scientists:

    https://github.com/JuliaApproximation/ApproxFun.jl
    https://github.com/BioJulia
    https://github.com/JuliaDiffEq/ModelingToolkit.jl
    https://github.com/crstnbr/MonteCarlo.jl
    https://github.com/chriselrod/LoopVectorization.jl
    https://github.com/JuliaNLSolvers/Optim.jl
    https://github.com/PainterQubits/Unitful.jl
    https://github.com/mcabbott/TensorCast.jl
    https://github.com/JuliaPhysics/Measurements.jl
    https://github.com/Jutho/TensorOperations.jl