Sounds spiffy. Also, I must find time to learn Julia.
One problem with these 'out of a box' cookbook systems is that you only know approximately what you are doing. If it works, that may be fine, but for statistical systems the outcome depends heavily on the formulation, is strongly influence by random or irrational correlations and is more art than science. If you remove the element of experience that animates the "art", you get nonsense. Big box programming tools can make it hard to know what correlations are being established, and this is true with even simple neural networks. By the time they have many layers and filters in them, all hope is fled. You buy the result or you don't: simple as that.
Although I have never used Julia, this is something that is possible in Ruby, and I think this feature is seriously underrated – i.e. to be able to jump quickly to the definition of external code, modify it and run it. When you work with multiple libraries/repo this is very valuable when debugging, saves a lot of time.
It should also be possible with Node.js I think (node_modules).
Makes sense to write it in Julia. Pretty much the only non commercial language that deals natively with mathematical objects in a way that makes sense to non CS people doing statistics. Plus, it is fast out of the box.
Like, when I first saw how you work with matrices in Python, I had a stroke.
I dont really get why we use Python for everything. The matlab style syntaxt is infinitly better for ML, stats and math.
> The matlab style syntaxt is infinitly better for ML, stats and math.
Syntax is a secondary concern for all but short-term, small-scale programming.
When it comes to making scalable software systems (scalable in every sense of the term, not just performance but also feature growth etc.), syntax is really not the biggest concern; as such, optimizing for syntax can be detrimental to other more important aspects (e.g composability, reusability, programmability), and focusing on syntax means you're not paying attention to the really critical stuff.
I mostly work in Clojure where _all_ operations use prefix syntax (e.g you write (+ A B C) instead of (A + B + C) for addition, and + is just a function). Trust me, it's unfamiliar at first, but it makes reasoning about the program MUCH saner than all the special cases and irregularities that language designer bake into the language just to make some operations infix.
In Haskell, you can turn any function into an infix operator with backquotes. As a qualitative, nonfunctional stylistic, ergonomic opinion, I find Haskell much more flexible and beautiful than the ugliness of most brace-, paren- and prolixity-heavy languages. It can present too many features for pragmatic use, orthogonal to something in another domain like Rust or Go for effective software production where features are intentionally constrained or disallowed.
Different things to care about.
I have worked on stats in research, start ups and at large banks. A lot of production/infrastructure related things certainly profit from the points you mention.
But 99% of statistical applications I have seen differ.
For someone using math, "programmability" and the other aspects you mention are certainly higher in a language that emulates how we think about the problems. While indeed Clojure may work well for some areas in math, Julia is certainly appropriate for statistics and probability - in my opinion the best -, and finally, Python isn't very good for either.
Everything else is almost always secondary. I would also argue that Julia is absolutely fine for developing large, scalable programs, not worse than Python.
Since Clojure has no statistics / ML ecosystem afaik, I am not sure why you mention it. This is absolutely crucial to even being considered in my point. That is why R dominates statistics still, by a large margin.
R, SAS, Octave, Mathematica, MATLAB, Excel (lol), FORTRAN and many more come to mind. Julia seems more like flavor of the month.
As an example, I know of a Monte Carlo nuclear reactor simulator that was written in tens of millions of lines of Fortran over a period of 3+ decades by non-software engineer nuclear engineers.
Also, have you used an HP 48 calculator? You can snag an emulator app and a ROM to use it on most smartphones, and it does integration and derivation.
The problem with frameworks like this is when you try to do something which isn't strictly standard, or lack understanding on whatever the framework is actually doing. Things will no doubt break, and then you have a 15 layered framework stack trace to try to debug.
You can't dodge knowledge with frameworks, only use frameworks to effectivize your knowledge.
I haven't had that problem with Julia-based probabilistic programming frameworks. I stick functions from pre-existing packages into Turing.jl and it seems to work fine as long as the library is compatible with AD.
I'm excited for the probabilistic programming symposium at JuliaCon :). We had so many submissions around PP languages and approaches that we decided to bunch them all together to get people talking about the pros/cons of various approaches and find out what kinds of problems to collectively tackle. PP seems like a very promising field.
Ranked programming is like probabilistic programming but you don't use probabilities. Instead, you state how your program normally behaves and how it may exceptionally behave. Conceptually it's very similar to probabilistic programming, but the underlying uncertainty formalism is replaced with ranking theory.
You can find an implementation of this idea (based on Scheme/Racket) here:
I think this is an exciting time for programming language designers. As we can see in blockchain space, on which there are new programming languages like Solidity and Vyper, I believe there will be new programming languages to make it easier for the programmers to express themselves (something different compared to Julia, R, Swift, or Python) in AI.
Right now people solve the problem with frameworks like Keras so the programmers have easier time to express themselves (for example designing neural networks). Imagine you have a new programming language on which it is much clearer and easier to create a neural network (in Deep Learning).
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].
Readit News
The source code of the packages sit on my computer, I can (and sometimes do) modify it, and I can still compile the same function to SIMD or GPU.
It should also be possible with Node.js I think (node_modules).
Like, when I first saw how you work with matrices in Python, I had a stroke.
I dont really get why we use Python for everything. The matlab style syntaxt is infinitly better for ML, stats and math.
Syntax is a secondary concern for all but short-term, small-scale programming.
When it comes to making scalable software systems (scalable in every sense of the term, not just performance but also feature growth etc.), syntax is really not the biggest concern; as such, optimizing for syntax can be detrimental to other more important aspects (e.g composability, reusability, programmability), and focusing on syntax means you're not paying attention to the really critical stuff.
I mostly work in Clojure where _all_ operations use prefix syntax (e.g you write (+ A B C) instead of (A + B + C) for addition, and + is just a function). Trust me, it's unfamiliar at first, but it makes reasoning about the program MUCH saner than all the special cases and irregularities that language designer bake into the language just to make some operations infix.
In Haskell, you can turn any function into an infix operator with backquotes. As a qualitative, nonfunctional stylistic, ergonomic opinion, I find Haskell much more flexible and beautiful than the ugliness of most brace-, paren- and prolixity-heavy languages. It can present too many features for pragmatic use, orthogonal to something in another domain like Rust or Go for effective software production where features are intentionally constrained or disallowed.
But 99% of statistical applications I have seen differ. For someone using math, "programmability" and the other aspects you mention are certainly higher in a language that emulates how we think about the problems. While indeed Clojure may work well for some areas in math, Julia is certainly appropriate for statistics and probability - in my opinion the best -, and finally, Python isn't very good for either.
Everything else is almost always secondary. I would also argue that Julia is absolutely fine for developing large, scalable programs, not worse than Python.
Since Clojure has no statistics / ML ecosystem afaik, I am not sure why you mention it. This is absolutely crucial to even being considered in my point. That is why R dominates statistics still, by a large margin.
As an example, I know of a Monte Carlo nuclear reactor simulator that was written in tens of millions of lines of Fortran over a period of 3+ decades by non-software engineer nuclear engineers.
Also, have you used an HP 48 calculator? You can snag an emulator app and a ROM to use it on most smartphones, and it does integration and derivation.
You can't dodge knowledge with frameworks, only use frameworks to effectivize your knowledge.
(e.g.: text books, practical applications, introductory articles)
The Design and Implementation of Probabilistic Programming Languages (https://dippl.org) by Noah D. Goodman https://cocolab.stanford.edu/ndg.html
Stanford CS 228: Probabilistic Graphical Models https://cs228.stanford.edu and book by Daphne Koller http://openclassroom.stanford.edu/MainFolder/CoursePage.php?...
ProbTorch: Library for deep generative models that extends PyTorch https://github.com/probtorch/probtorch
Anglican: Probabilistic programming language integrated with Clojure and ClojureScript https://probprog.github.io/anglican/index.html
Discussion: https://news.ycombinator.com/item?id=18585465
Ranked programming is like probabilistic programming but you don't use probabilities. Instead, you state how your program normally behaves and how it may exceptionally behave. Conceptually it's very similar to probabilistic programming, but the underlying uncertainty formalism is replaced with ranking theory.
You can find an implementation of this idea (based on Scheme/Racket) here:
https://github.com/tjitze/ranked-programming
For more detailed information check the paper linked to on that page.
- Probabilistic Models of Cognition https://probmods.org/ by Noah D. Goodman, Joshua B. Tenenbaum & contributors
- An Introduction to Probabilistic Programming https://arxiv.org/abs/1809.10756 By Jan-Willem van de Meent, Brooks Paige, Hongseok Yang, Frank Wood
Right now people solve the problem with frameworks like Keras so the programmers have easier time to express themselves (for example designing neural networks). Imagine you have a new programming language on which it is much clearer and easier to create a neural network (in Deep Learning).
[1] https://github.com/FluxML/Flux.jl/issues/625
[2] https://fluxml.ai/