Flux.jl

For me, it would be the lack of GNN support in Flux[1]. I really root for Julia and Flux, and I hope it will take off soon. [1] https://github.com/FluxML/Flux.jl/issues/625

Note that Julia 1.2[1] is on the verge[2] of being released. Also, it is interesting to see the list[3] of GSoC and JSoC (Julia's own Summer of Code). A lot of projects target the ML/AI applications. Personally, I am waiting for proper GNN support[4] in FluxML, but seems not much interest in it. [1] https://github.com/JuliaLang/julia/milestone/30 [2] https://discourse.julialang.org/t/julia-v1-2-0-rc2-is-now-av... [3] https://julialang.org/blog/2019/05/jsoc19 [4] https://github.com/FluxML/Flux.jl/issues/625

There is a missing piece in the Julia subsystem - first class support for GNN (Graph Neural Networks). So if someone wants to help - he can take an issue[1] at the GitHub repository of FluxML[2]. [1] https://github.com/FluxML/Flux.jl/issues/625 [2] https://fluxml.ai/

Yes, there are already a couple. The most well known is a 100% Julia neural network library called Flux.jl [1], which aims to become what Swift for Tensorflow wants as well (to make the entire Julia language a fully differentiable language) through Zygote.jl [2], and even without it has already great integration with the ecosystem, for example with the differentiable equations library through DiffEqFlux.jl [3]. Plus the source code is very high level (while being high performance, including easy GPU support), so you can easily see what each component does and implement any extension directly on your code without worrying about performance. There is also another feature complete native library that allows some very concise code, Knet.jl [4], and the Tensorflow bindings [5]. [1] https://github.com/FluxML/Flux.jl [2] https://github.com/FluxM

If you want to take a look at a framework that isn't a terrible mess and that one person can understand both Darknet [1] and Flux [2] are really nice. Learned a lot from reading their source. [1]: https://github.com/pjreddie/darknet/ [2]: https://github.com/FluxML/Flux.jl

So many patently false claims here. First, julia has it's own IR (comparable to swift IR as mentioned by Chris), which is used to great effect in the autodiff packages to allow for compile time zero overhead gradients. The flexibility is actually the other way around, Julia's compiler allows these sort of compile time initiatives to be built in Julia rather than hacked into C++ like swift. Regarding the duck typing vs type checking bit, that's a matter of tooling. It's much harder to replicate Julia's combination of speed and dynamism (for example to do flexible multistage programming) than to capitalize on Julia's the compile time information to build type checking (which are planned) The compiler lag is going to be gone soon from two ends: more dynamic (interpreting code that doesn't need to be compiled, this is pretty much there alrea

Thanks! Looks quite interesting. Hopefully better seamless GNN support in Julia's FluxML[1]. [1] https://github.com/FluxML/Flux.jl/issues/625

If somebody wants to help Julia community to support any types of GNN, there is an issue[1] for FluxML to support those. [1] https://github.com/FluxML/Flux.jl/issues/625

High performance numerical computing is one area that garbage collection doesn't really matter though, unlike real-time applications that needs consistency more than raw speed. Some occasional milliseconds (or even seconds) long stop-the-world GC won't really affect anything in an hour long or days long simulation, training or calculation. Not to mention you don't really allocate that much in many of those applications, in ML for example is not unusual to allocate all tensors once and just update the values during the training loop (usually on GPUs or TPUs), so there won't be anything to even trigger GC. And for Julia in particular, there isn't really a need for bindings over C/C++ (the whole purpose of the language is not requiring another language for performance). Many of the most popular libraries for numeric computing are 100% writte

It's possible to have both the dynamism and static type checking in Julia. Check out this issue: https://github.com/FluxML/Flux.jl/issues/614