HNHacker News
TopNewBestAskShowJobs

ihnorton

1,471 karma · joined October 23, 2011

Software engineer at TileDB

isaiah plus hnhiring -at- tiledb -dot- com

submissionscomments
ihnorton··on Julia v1.2
The best place to start is this list of resources: https://julialang.org/learning/

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.

ihnorton··on Getting Started with Lisp in 2019
> And while you can't write in assembly in Julia

Julia allows inline LLVM IR, so this is technically possible, if a little awkward:

https://julialang.org/blog/2017/03/piday#π-via-inline-assemb...

ihnorton··on GitHub Actions now supports CI/CD, free for public repositories
> Better integration for GitHub for the Azure DevOps suite

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.

ihnorton··on It’s Time for a Modern Synthesis Kernel
Are you compiling to LLVM IR with a modified Clang that is intended to be drop-in, and then interpreting+JITing? Or instrumenting?
ihnorton··on A WebGL canvas-based volume viewer
If that's an issue, there are several other browser-based volume renderers with unrestricted BSD/MIT-style licenses:

- 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)

ihnorton··on Katie Bouman, the computer scientist behind the first black hole image
I'm reluctant to even dignify this kind of low-effort drivel with a response.

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.

ihnorton··on OCaml on Baremetal Shakti RISC-V Processor
I think you forgot one ;)

- A native GUI: https://github.com/revery-ui/revery

ihnorton··on Julia Language Co-Creators Win James H. Wilkinson Prize for Numerical Software
That might be possible with nteract (Javascript, not sure if pure) and the IJulia kernel.
ihnorton··on Perl 11
Julia does not have a tracing JIT right now, but does use runtime information in order to JIT specializations based on (often inferred) method argument types.
ihnorton··on On Apple's Love Affair with Swift
> I don't believe LLVM provides a stable cross language ABI, and AFAIK languages just use regular FFI (via the C ABI) to communicate with one another

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).

ihnorton··on Using Deep Learning to Help Pathologists Find Tumors
The data from Camelyon '16 and '17 apparat to be available without registration on GigaScience:

http://gigadb.org/dataset/100439

ihnorton··on Using Deep Learning to Help Pathologists Find Tumors
> the resulting models all generalize quite poorly

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.

ihnorton··on Using Deep Learning to Help Pathologists Find Tumors
> Moreover, it seems that the ability to provide fast (in seconds to minutes) analysis implies powerful computational ability and data network. Finally, the data acquisition right now takes more or less 20 to 45 minutes depending on the patient and the targeted area, which means the promised analysis quickness is not such a real pro.

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)

ihnorton··on Fortran is still a thing (2017)
Note that ifort defaults to a substantial equivalent of gfortran’s `-ffast-math`, which is not the default in gfortran.

It looks like the equivalent option is still under discussion for rust:

https://github.com/rust-lang/rust/issues/21690

ihnorton··on FoundationDB community highlights, two weeks in
The question is not about where FoundationDB can run in general. Sorry if that was unclear.

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).

ihnorton··on FoundationDB community highlights, two weeks in
I’m curious how they plan to do continuous integration. The Apple hardware-only clause of the macOS SDK license agreement really crimps the options for CI, especially for open source projects with limited budget. Travis is a godsend, but there are startup latency and capacity issues there even in the paid tier. Apple has made major contributions to open source, as evidenced by FoundationDB here, LLVM, WebKit, and other projects. But they no longer make servers, and the fallback — Mac mini — is on life support, which puts projects and service providers who need to treat macOS as a first-class target in a real bind. Even something limited like the IE Edge and Visual Studio images Microsoft provides would be a huge boost.
ihnorton··on Unprivileged Docker Builds – A Proof of Concept
IIUC building Singularity containers still requires root.
ihnorton··on GraalVM: Run Programs Faster Anywhere
> If you had a language VM for the real world language that is Lua built using SVM it would probably be a hundred MB or so.

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)

ihnorton··on GraalVM: Run Programs Faster Anywhere
> you can just embed the JVM the usual way and ship the Graal compiler with it

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.

ihnorton··on GraalVM: Run Programs Faster Anywhere
> With the SubstrateVM it is possible to produce a single, statically linked native binary executable version of Graal.js, which doesn't need any JVM to run.

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?

ihnorton··on Let’s Replace JavaScript with Something Better
> means requiring a compiler toolchain

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.

ihnorton··on Newer C++ features can create a lot of system yak shaving
Only assuming you have root or a sufficiently cooperative IT department. In situations where this is a problem, both assumptions are often untrue (managed HPC).
ihnorton··on Please – A Cross-Language Build System
Microsoft (both vscode and studio) seems to be moving toward ide adaptation — parsing output from other compilers, supporting compilation databases and folder-only (non solution) projects. Perhaps this, combined with Clang viability for MSVC ABI, will reduce the impetus for cross-platform projects to use cmake just to support Windows. Of course, there’s added inertia in favor of cmake due to LLVM, Boost, and others moving over. Not to mention that Microsoft now also supports the “cmake server” concept (there will be some deep irony if after 20 years of “we need cmake to support Microsoft” the argument for the next N years becomes “we should use cmake because Microsoft supports it”).
ihnorton··on JupyterLab is ready for users
Julia does (Pandas, matplotlib, many others). Swift is getting some language features to make this kind of binding possible/simpler. IIRC xtensor does (or can) wrap Python libraries from c++.
ihnorton··on Merrell Trail Glove Failures and Minimal Running in a Communist Shoe
I’m sad to hear my recent bad Merrills we’re not a one-off. I know people who swear by Keen, but I can’t stand the toe box. Might have to try to get used to it for the next pair.
ihnorton··on Python’s Weak Performance Matters
> Also, have you tried Numba?

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).

ihnorton··on Python’s Weak Performance Matters
(1) Test coverage has dramatically improved. (2) Improved, and to some degree a matter of taste (Julia is not statically checked, so some errors can only be discovered at runtime) (3) There has been significant refactoring since 2014 to improve consistency, especially in the recent push toward 1.0. (4) Developers are much more disciplined now, and just about everything goes through CI. (5) Docs are much, much better for both users and developers. For the latter, see https://docs.julialang.org/en/latest/devdocs/ast/ and others in that section (none of which existed in 2014, IIRC).

> 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.

ihnorton··on Show HN: Cross-platform desktop applications with PyQT
Yeah, I finally got windows version to download (cut out a few times, HN overload?). The win download is an online installer, so the size makes much more sense. I didn’t check the install directory, but it took 2 minutes to retrieve on slowish WiFi, so I would expect the install size is in-line with the others. (Good point about Arch).
ihnorton··on Show HN: Cross-platform desktop applications with PyQT
I am curious about final package size on various platforms when using this project. The download bundles for the related "fman" project vary considerably -- Win: 1MB; macOS: 23MB; Ubuntu: 39MB. The last number matches my experience with scripted Qt applications, at which point the size is comparable to a typical ~50-70 MB Electron app, at least for compressed downloads. Visual Studio Code is 44 MB on Windows and 65MB on Mac. Scriptable wrappers usually imply that the core Qt shared objects can't be pruned, and the wrappers themselves also add up, so that Windows number is impressive and intriguing!

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.

ihnorton··on DragonFFI: C Foreign Function Interface and JIT Using Clang/LLVM
LuaJIT’s DynASM would go a long way there; might even have reusable stubs. Or slightly crazier, if 520K isn’t too big a burden: wrap the LuaJIT cffi ...from C... and embed all of LuaJIT.

(by the way: thank you for libffi!)

← PreviousPage 3 of 15Next →