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 DRACOs may be a cure for all viral diseases
Son (2015) shows detection of dsRNA from (-)ssRNA viruses by immunofluorescence: http://jvi.asm.org/content/89/18/9383.full

They include this comment on the Weber (2006) paper cited above:

> their lack of success might relate to the production of smaller amounts of dsRNA in negative-strand RNA virus infections, the use of the less sensitive J2 MAb, the choice of less than optimum times for p.i. sampling, or, possibly, technical issues.

ihnorton··on Julia v0.5.0 Released
For Julia core it should be feasible, but possibly requiring patches to Emscripten, so the level of effort is still unknown. The other issue is the C and Fortran numerical libraries -- some of which use inline-assembly, others (Fortran) don't have a working LLVM frontend as far as I know.
ihnorton··on Julia v0.5.0 Released
I'm not aware of anyone working on it. There were some attempts with Emscripten which ran in to unsupported instructions; some of those may be supported by newer versions of Emscripten, but I haven't heard of any attempts to get this going recently.
ihnorton··on Julia v0.5.0 Released
There has been ongoing work toward supporting this feature. See:

http://juliacomputing.com/blog/2016/03/10/j2c-announcement.h...

http://juliacomputing.com/blog/2016/02/09/static-julia.html

ihnorton··on Pardon Snowden
> The main difference is you're not getting fired or ostracized or jailed for run of the mill political views or dissidence.

Jailed, no. Fired and ostracized? Certainly, except for narrow definitions of "views" and "dissidence" (largely calibrated by region and type of employment).

ihnorton··on Show HN: Cross-platform dependency manager using bash and cmake
CMake already has decent support for dependency building through External Projects:

http://www.kitware.com/media/html/BuildingExternalProjectsWi...

There are a number of issues/annoyances with the mechanism, especially when working with local modifications, but nothing to make me eager to add the anguish of bash+CMake onto the existing toil of CMake.

(Arguably this also bootstraps a build environment, whereas CMake requires itself and an SDK in order to bootstrap, but at the point where a build environment needs to be scripted/reproducible containerization seems preferable)

ihnorton··on NativeJIT – JIT compilation of expressions involving C data structures
> If you were to somehow make LuaJIT into a C/C++ compiler

Clang -> Sulong -> Java bytecode -> Luje [1]? May need more turtles :)

Technically, one reason -of several- this probably wouldn't work without significant effort is that Sulong relies on Graal's FFI intrinsics. But those should be convertible to LuaJIT FFI calls (in theory).

[1] https://cowlark.com/luje/

ihnorton··on Programming Language Rankings: June 2016
It is unmaintained now, but you might want to have a look at [1], which builds on the type inference system to add some static checks. I believe there may also be some related work in [2].

> Then again, maybe nobody else has these issues and I'm just bad at deducing when AbstractVector can't be used.

Nope, not just you. This is definitely an issue.

[1] https://github.com/astrieanna/TypeCheck.jl [2] https://github.com/tonyhffong/Lint.jl

ihnorton··on Why Python Is Slow: Looking Under the Hood (2014)
> This is now a problem for Python 2.7, because the Microsoft compiler version used to build it is no longer available.

There is a CMake build system for 2.7 that works great with VS2013-2015:

https://github.com/python-cmake-buildsystem/python-cmake-bui...

ihnorton··on Mozilla could walk away from Yahoo deal and get more than $1B
> The Foundation has a wholly-owned for-profit subsidiary, Mozilla Corporation (the Corporation). The Corporation serves the non-profit, public benefit goals of its parent and the vast Mozilla community.

...

> The consolidated financial statements include the accounts of the Foundation and its wholly-owned subsidiary, the Corporation (collectively “Mozilla”). All significant intercompany accounts and transactions have been eliminated.

IIUC, receiving revenue would be more complicated if the transactions were undertaken directly with the not-for-profit foundation. Certainly many "non-profits" do receive transactional revenue, i.e. hospitals, but in that case they often have a number of subsidiaries -- for example one subsidiary actually employs the physicians, another signs funding contracts with the NSF/NIH and distributes grant revenue, a holding company owns the buildings, etc. Accounting is complicated (perhaps more accurately: "the tax code is complicated").

ihnorton··on Mozilla could walk away from Yahoo deal and get more than $1B
As of 2014: $212 million on software development (presumably mostly salaries?), another ~$100 million on marketing/administration/etc. They appear to put away from $10 to $70 million per year from 2010-2014, and had about $140 million in investment assets (again, 2014).

https://www.mozilla.org/en-US/foundation/documents/

ihnorton··on fMRI software bugs could upend years of research
> This is the same misconception I have been trying to dispel. The null hypothesis is not the inverse of that "layman's" statement, it is a specific set of predicted results calculated in a very specific way.

The entire point of this discussion is that the software is not calculating the null hypothesis that users expect. That the current model it does in fact calculate is internally-consistent is tautological and irrelevant (though actual bugs were found in at least one package).

As you yourself said: "I didn't read the code, or even the paper very closely." (https://news.ycombinator.com/item?id=12037207) Perhaps you should do?

ihnorton··on fMRI software bugs could upend years of research
> Describing the problem as excess false positives is confused, because these are true positives.

This is deeply wrong. A "true positive" in this context would mean that the resting brain activity of multiple subjects is actually correlated with arbitrary length, randomized, moving test windows. Again, the data is untreated; they are imposing arbitrary test windows and looking for increases in brain activity (increased image intensity) correlated with the stimulus-ON sections of the pseudo-treatment.

From reading some of your prior comments on the subject, it seems prudent to point out that the causal link between stimulus and BOLD effect is quite literally observable: http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3130346/

ihnorton··on fMRI software bugs could upend years of research
FWIW, typical raw fMRI data is mostly useless unless you know the design parameters of the study (stimulus timing, imaging onsets, etc.). Though there are some interesting data-driven analyses techniques, especially for resting-state data.

Many research studies in the U.S. are required to do "structural" scans (high-resolution T1 or T2) and send them to a safety read by a radiologist, for liability reasons. At very least, this scan should be available directly from the hospital imaging department. If you are lucky all the data will have been sent through the hospital PACS and the imaging department will indiscriminately dump everything. At a research-only center it might be more complicated because such images are likely sent off-site for the safety read.

ihnorton··on Human Connectome Project Updates
Interesting, thanks. I didn't realize multiband was so fast on the Skyra - good to know.

The big advantage in principle for neurosurgery is better resolution of crossing fibers and complex branching, for example the lower/lateral projections of the CST to hand area. I'm not sure if any clinical software can take advantage of these scans, yet, though -- so processing would probably need to be done under IRB in researchy software. There's also ongoing work in several groups to better resolve and possibly even characterize tissue microstructure in and around tumors using multi-shell DWI (especially relating to edema).

Here's one small study that compared several high-angle methods to standard DTI: http://www.ncbi.nlm.nih.gov/pubmed/23254805

Walt Schneider's group at Pitt has also done studies in neurosurgery planning and TBI using HARDI-type methods (no cite handy at the moment).

ihnorton··on Human Connectome Project Updates
> Diffusion is a routine tool but at <2 minutes it's hardly a problem to acquire.

The kinds of high-angular coverage scans they are talking about here (60-120+ gradient directions) take 45+ minutes on current clinical scanners. These scans give improved white matter resolution -- both spatially and for complex sub-voxel microstructure. With acceleration and faster gradient ramps the connectome scanner can get that down to under 15 minutes. It's still a long time for routine clinical use (typical U.S. scan sessions are billed in ~40 minute increments), but more feasible than 45+.

ihnorton··on Why Rust for Low-Level Linux Programming?
> I know that it did, but it was removed a few years back, and I haven't heard anything about it coming back into tree yet.

(out-of-tree) fork(s) have been kept alive by several groups. The most current one I'm aware of is: https://github.com/JuliaComputing/llvm-cbe

ihnorton··on Stanza: A New Optionally-Typed General Purpose Language from UC Berkeley
> The QT gui library.

How?

ihnorton··on Giving up on Julia
For better or worse, most development discussion happens on GitHub rather than julia-dev. I've been catching up on GitHub threads recently, and the progress towards 0.5 is really impressive -- both in the language itself, and in the tooling (especially the debugger). I think the nature of priorities has changed somewhat as the language matures, but I disagree that development has slowed. (disclosure: I'm a Julia committer, but have been a bit out of the loop for some months now)

There is certainly a need for better interim communication on progress between releases, to let people know what is happening without reading every GitHub thread.

ihnorton··on Giving up on Julia
> For packages that needs arrays of indices, it would be quite easy to define an `IndexArray` type that does the translation automatically.

(just to add: there is currently an open pull request from a core array-focused developer adding such support to base)

ihnorton··on Introducing MIR
Yes, Julia uses a similar "lowered" form: http://docs.julialang.org/en/latest/devdocs/ast/#lowered-for...

If you are interested in more details, there was a talk two years about the compiler design: https://www.youtube.com/watch?v=osdeT-tWjzk (many type names and implementation details have changed since then, but conceptually it is still very applicable).

ihnorton··on A polyglot's guide to multiple dispatch
I'm not aware of any pull-requests implementing an incremental GC with pinning support, or any alternative module/namespacing scheme. Those would certainly be welcome.

As I said, the people actively working on the compiler have to prioritize because time and resources are finite. This is not the same as anyone being "dead set against changing", or a "ban people for making too much noise about it".

> when did any of them last move.

Here's a sampling of some improvements over the past 4 months.

- Debugging, everyone's priority by astronomic margins, has seen massive work and a recent preview-release (I've been using it since the announcement: rough edges, but very solid core): https://github.com/Keno/Gallium.jl/commits/master https://github.com/Keno/ASTInterpreter.jl/commits/master https://github.com/JuliaLang/julia/pull/15859 https://github.com/JuliaLang/julia/pull/15444

- Revamp of closures to make anonymous functions as fast as any other: https://github.com/JuliaLang/julia/pull/13412

- Significant compiler performance improvements: https://github.com/JuliaLang/julia/pull/15300 https://github.com/JuliaLang/julia/pull/14543 https://github.com/JuliaLang/julia/pull/15609

- Work towards static compilation (a number of PRs): http://juliacomputing.com/blog/2016/02/09/static-julia.html

- Multithreading improvements: https://github.com/JuliaLang/julia/pull/15917 https://github.com/JuliaLang/julia/pull/15106

- Someone else pointed you to recent commits toward fixing the recompilation issue.

ihnorton··on A polyglot's guide to multiple dispatch
> Their namespacing and modularity is terrible, writing a complex gui, non-trivial web server, 3d renderer, or any sort of real time system is right out. And they seem dead set against changing that

There are many dozens of open issues discussing namespacing, interfaces, levels of type abstraction and extensibility, garbage collector improvements, i/o latency problems, task-switching performance, and more.

Prioritization of core effort in certain directions does not mean other issues are suppressed or even forgotten. Considerate proposals in other areas are welcome, and pull-requests implementing such proposals will be gratefully reviewed. They may not always be accepted -- immediately or sometimes ever. There is certainly some conservatism about adding features (such as interfaces), because features have costs and are near-impossible to remove once added. But other things just take time to get merged; for example, the generational GC took over a year, and there are other very large proposals that have been pending for longer than that because the implementation is lacking in some way or the implications are not fully worked-out to the point of consensus acceptance. That's ok, and IMHO healthy.

ihnorton··on A polyglot's guide to multiple dispatch
The main mailing list is here, people can judge for themselves:

https://groups.google.com/forum/#!forum/julia-users

Here's a recent (and typical) example of a lengthy series of technical and sometimes pointedly-critical questions:

https://groups.google.com/forum/#!searchin/julia-users/%22ve...

ihnorton··on Why I am betting on Julia (2014)
Slots are still mutable, so they don't help with most of those concerns.

(also: http://lucumr.pocoo.org/2014/8/16/the-python-i-would-like-to...)

ihnorton··on Why I am betting on Julia (2014)
> I would love to know what fundamental design flaws are there for Python

Everything described here, for starters: https://news.ycombinator.com/item?id=11522767

ihnorton··on How fast can we make interpreted Python? (2013)
> SciPy or numpy might be better examples.

Python comprises less than 50% of the code in both of those repositories, but they are certainly great for learning the CPython API.

ihnorton··on The murky history of moderation and how it’s shaping the future of free speech
Or plausible deniability.
ihnorton··on Why I am betting on Julia (2014)
> I think what's far more common is prototyping something in Python or R, and then realizing that 99% of its CPU time is already spent in wrapped C code. And then you call it a day and move on to other things.

Someone has to write those libraries.

> This is why Julia hasn't taken off nearly as quickly as I initially expected

Not sure what you were expecting, but consider:

- the most conservative userbase estimate I would believe is 20k users (based on mailing list subscriptions, website stats, and download numbers).

- sustained package ecosystem growth: http://pkg.julialang.org/pulse.html

ihnorton··on LLVM based Just-in-Time-Compiler for C++
Try https://github.com/Keno/Cxx.jl (or Cling, as someone else mentioned).
← PreviousPage 5 of 15Next →