111–120 of 137 posts
Earlier quoted context omitted.
For numeric code sure but its because Julia are using BLAS (or any other instruction for CPU/GPU u give to LLVM). Julia (no BLAS) -> In matmul its on pair with Golang and Swift and a bit slower then RUST and Nim. If u need BLAS then just use lib with that :)
Please double check your grammar before posting
Earlier quoted context omitted.
We're using it in a soft-realtime setting to monitor industrial chlorine production, and for us it has been a very pleasant experience overall. Yes, we've had some issues, but similar to other ecosystem IMO, and our support contract with Julia computing helped us in the one case we really couldn't solve ourselves. Julia works really well for power users. There are no huge libraries full of C code like pandas or scipy…
How much LOC did u guys have at the moment, and how much data are u monitoring? For smaller problems Julia was working perfect for us.
Earlier quoted context omitted.
You are describing every Julia package. These are the rules of the package manager. 1. Every package must declare it's dependencies (and to register must declare compat bounds on them, and good devs do that always anyway) 2. Every package must have Project.toml in the base directory, source code goesin `src`, test code goes in `test`, documentation goes in. `docs` (and more structure there if using Documenter.jl) Wha…
> every sensibly done julia application. Can you point me to some documentation on those best practices. My girlfriend - architectural acoustics consultant - is working on a project in Julia and is having a hell of a time managing dependency shift underneath her program (also she barely knows how to use git).
The Pkg manual doesn't have a tutorial on standard practice. But it's worth reading the compat section and making sure to always set your compats https://julialang.github.io/Pkg.jl/v1/compatibility/
And the section on creating one's own project. So as not to need to use the global environment. And alternative to using `activate` after starting Julia (and my preferred way) is to start Julia with the `--project=.`
https://julialang.github.io/Pkg.jl/v1/environments/#Creating...
And can go further and create projects via PkgTemplates which is was "everyone" does. Because a good project looks just like a package (one might as well consider them synonyms when looking for thus kind of advice) https://github.com/invenia/PkgTemplates.jl/tree/v0.6.3
Earlier quoted context omitted.
Apparently not relevant enough to be worthy of even a small blog status update. So it has an installer now. Pity that it lacks the eco-system of libraries available to .NET, Java, Julia, and respective IDE support, on Windows. So now besides import glibc on Linux, with platform ifdef, should we do import mvsc as well? ST4F team having future plans for Android is meaningless, regarding what Android team actually puts…
The difference is that S4TF is an internal google team. I can't imagine they wouldn't coordinate with the android team, especially given the benefits that easy ML will bring to apps.
Earlier quoted context omitted.
I have to admit that over the past 20 years, java is like the most stable robust, huge project, multiple teams, IDE friendly, type safe, infinite tooling and libraries language of choice!
Type safe? NPE en masse. IDE friendly? IDE support is only good because you absolutely need an IDE for this language. It's an unwieldy, verbose mess of a language.
Earlier quoted context omitted.
The difference is that S4TF is an internal google team. I can't imagine they wouldn't coordinate with the android team, especially given the benefits that easy ML will bring to apps.
Awaiting to see anything S4TF related here, https://www.tensorflow.org/lite/guide/android
Earlier quoted context omitted.
Numeric code doesn't just mean matrix multiplication. If I have a random nested for loop, it will probably run at least as fast as those languages(apart from maybe Nim, never used it) if annotated with @simd and @inbounds. If I'm operating on a small array/matrix, then Julia will blow Go/Rust out of the water via stack-allocated static arrays ( https://github.com/JuliaArrays/StaticArrays.jl ). These can't be implemen…
Actaully, julia for loops can be made to perform at BLAS levels with this package: https://github.com/chriselrod/LoopVectorization.jl . Here are my early experiments at making a pure-julia multi-threaded BLAS using LoopVectorization.jl https://github.com/MasonProtter/Gaius.jl . It absolutely blows a naive triple for loop out of the water and is quite competitive against OpenBLAS until you get to very big sizes.
MArrays will be stack allocated if they don't escape.
One of my in development packages also uses it's own "stack" (MMap a chunk of memory), so that it can have pointers to fast "stack-alocated" arrays.
I played around with LLVM's alloca a bit, but it seems like I could only ever use a single alloca at a time; if I ever used more than one, LLVM would just return the same pointer each time instead of incrementing it. If I have to manage incrementing the pointers myself anyway, I may as well use my own stack, too.
For (the problems I have tested and tuned it on), LoopVectorization produces faster code than C/Fortran, e.g.: https://chriselrod.github.io/LoopVectorization.jl/latest/exa... But it may be more fair to compare it with plutocc. In my early tests (which involved much larger problem sizes), plutocc does a lot better, because (unlike LoopVectorization) it seems to consider memory/caches rather than just registers allocation and instruction costs.
Earlier quoted context omitted.
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. C…
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 cou…
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