Excluding the university course listings, I think most of the resources there should be up-to-date (post Julia 1.0).
Once you have a basic feel for the language, the forum (discourse.julialang.org) and Slack are both very welcoming.
1,471 karma · joined October 23, 2011
isaiah plus hnhiring -at- tiledb -dot- com
Excluding the university course listings, I think most of the resources there should be up-to-date (post Julia 1.0).
Once you have a basic feel for the language, the forum (discourse.julialang.org) and Slack are both very welcoming.
Julia allows inline LLVM IR, so this is technically possible, if a little awkward:
https://julialang.org/blog/2017/03/piday#π-via-inline-assemb...
One small improvement I would really appreciate is a reduction in the number of clicks required to reach the real build status page. Clicking "Details" on a status row for a travis build takes me directly to the summary on travis, whereas for azure it leads to a redundant summary page hosted on github first, and requires another click to actually reach azure.
- https://github.com/maartenbreddels/ipyvolume
- https://github.com/Kitware/vtk-js
- https://github.com/FNNDSC/ami (~successor to the excellent XTK: https://github.com/xtk/X)
There's a bunch of other commits linked from that very same user profile, related to -- and this will blow your mind -- image reconstruction:
https://github.com/achael/eht-imaging/commits?author=klbouma...
Even if that were not true, scientific code often does not end up public, let alone on github. Not to mention that Dr. Bouman is the first author of a closely-related paper at CVPR, which is one of the most prestigious meetings in a field of study called "computer vision": https://arxiv.org/abs/1512.01413
Obviously this was a massive team effort, but PR frenzies happen to good people all the time and I don't see anyone scrutinizing public commit counts when it's a man in a similar context.
- A native GUI: https://github.com/revery-ui/revery
Provided the compilers generate compatible versions of LLVM IR, then cross-language calls can be done at the IR level. See github.com/Keno/Cxx.jl
IIUC Swift already uses clang to load module maps in order to expose and call Objective-C, and they plan to do something similar with C++ (no link handy but I think there is an issue or enhancement proposal about it).
In this field, this kind of technology will be augmentative for the near-term at least, so generalization matters less than elsewhere provided the false negative rate is kept low enough. Outliers can be flagged for direct inspection.
In surgical pathology, the patient is still under surgery while a pathologist makes a rapid, preliminary diagnosis on fresh tissue. This can be done in under 10 minutes, but typically takes 20-30 in practice -- the bulk of which time is spent flash-freezing and sectioning. Pathologists have only a few minutes to review after prep, so any digital augmentation technology must run on the order of a few minutes to be of use in guiding the surgery. This guidance may be crucial because many tumors cannot be characterized ahead of time due to the lack of non-invasive diagnostic tools (the most promising is gene profiling of bloodborne cells, but that is very challenging due to low circulating concentrations). Tumor type and grade are a large factor in a surgeon’s aggressiveness-vs-risk calculation, and this is especially true in brain tumors where cognitive damage poses a quality-of-life risk which must be weighed against potential survival gains.
(not a pathologist, but I've done research, classifier, and software dev in the field -- very small, hands-on lab, so spent a huge amount of time in frozen section, OR, and with paths reviewing sections)
It looks like the equivalent option is still under discussion for rust:
The question is about (public?) continuous integration testing for changes to FDB against macOS specifically, eg for pull-requests (for example, to allow contributors to make changes targeting other platforms without needing to own a mac for local tests).
Is this mostly JRE? Would Jigsaw help, or is SubstrateVM already doing something like that? (To be clear, this tech is really impressive! Just trying to get a sense of embeddability constraints)
How feasible would it then be to use Graal NFI for FFI from vanilla Java? That seems useful given the performance limits of JNA and the complexity of JNI.
How large is the resulting executable? There was some mention of shares libraries — is it possible to build a runtime that is callable from C?
Relatedly, does the GraalVM java executable support JNI?
I’m also curious about the runtime footprint in general; any idea what is the smallest possible VM for a real but relatively-small language like Lua?
If your compiler toolchain both runs on and generates WASM then you’ve removed about 90% of the pain of compiler toolchains. The experience should be on par with something like typescript or one of the ecma compatibility compilers. There’s still potential for classes of issues that would not exist in straight Javascript, but I’d rather debug most of those with browser tooling than gdb.
Numba does not support dictionaries and has limited support for pandas dataframes (only underlying arrays, when convertible to NumPy buffers, if I understand correctly). This limits usefulness for many non-array situations, as well as some existing code-bases (the dictionary is fundamental in Python and typically used everywhere -- often for performance).
> And bonus community problem:
I can't comment on private discussions to which I was not a party, but people can search the archived google groups discussions (julia-users) for the blog author's name to read the public threads.
That said, the core of the concern, as I understand it, was that these perceived issues would put a damper on growth. Young languages, especially, need growth to outpace attrition to maintain viability (ecosystem, broad testing and platform support, etc.). Three years on, with sustained user-base growth, increased funding, and Julia having been used for a number of articles in high-impact journals (e.g. Nature) -- I think this concern is somewhat less pressing. See https://pkg.julialang.org/pulse.html for a snapshot of the sustained ecosystem growth, and https://discourse.julialang.org to get a sense of the breadth, depth, and responsiveness of the community (in my obviously-biased view, of course!).
A related concern, was (quoting the blog post):
> A small team of highly talented developers who can basically hold all of the code in their collective heads can make great progress while eschewing anything that isn’t just straight coding at the cost of making it more difficult for other people to contribute. Is that worth it? It’s hard to say. If you have to slow down Jeff, Keno, and the other super productive core contributors and all you get out of it is a couple of bums like me, that’s probably not worth it.
Julia as a whole has had 697 contributors right now. At the very core of the language, the parser and lowering code have well over 40 contributors, and code-generation (LLVM lowering) has over 60.
I would also wonder about performance scaling. Are there good examples of "large" applications where CPython drives the main loop, as opposed to a scripting layer over a C++ core? CPython has a shallower optimization floor than Javascript+V8, and most larger Python GUI applications I've tried had noticeable lags (thinking of several visualization apps, and several Python-centric IDEs). I was similarly skeptical of Javascript-based desktop applications until recently, but Visual Studio Code has been very impressive.
(by the way: thank you for libffi!)