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 OpenBSD 5.9 released early
> crashes all the time with segmentation faults

We would very much appreciate any bug reports, even if you don't have the time to reduce (if you have filed under another username, thank you!).

ihnorton··on Cook: 'This Is Not What Should Be Happening in This Country'
There is no way for us to know if this is only speculation, or an allusion to some encumbered order.
ihnorton··on Ask HN: Is Python dying?
I won't comment on organizations using Julia, but some conclusions can be drawn from the presenters and sponsors at JuliaCon 2015: http://juliacon.org/2015/

Here is a brief list of some major packages that I am aware of:

- https://github.com/JuliaOpt/JuMP.jl - https://github.com/JuliaOpt/Convex.jl (Stephen Boyd's current and former students) - https://github.com/ApproxFun/ApproxFun.jl (Nick Trefethen's former students) - https://github.com/dmlc/MXNet.jl - http://nemocas.org

Julia has been used (and cited) in at least one Nature publication: http://www.nature.com/nature/journal/v526/n7575/full/nature1...

A larger list (with associated publications): http://julialang.org/publications/

Julia is also being used for courses at a number of universities: http://julialang.org/teaching/

ihnorton··on Static, Ahead of Time Compiled Julia
See https://github.com/eschnett/FlexibleArrays.jl

(somewhat in jest, there's also https://github.com/simonster/TwoBasedIndexing.jl)

ihnorton··on GoQt
MSVC: probably not; Clang's MSVC ABI support is coming along well, but last time I checked there was no COFF support in the JIT. GCC on Itanium ABI platforms should be fine, although mixing C++ stdlib versions would be risky (primarily an issue on OS X).
ihnorton··on Hacking inclusion by customizing a Slack bot
I know this might hurt y'all's pride, but yous can't claim to be the only ones to have done so.
ihnorton··on How Theranos Misled Me
Autonomy.
ihnorton··on A neuroscientist had his brain scanned for a year and a half
There can be one effect during diffusion-weighted scanning, which is muscle twitching due to induced depolarization when the gradients are ramped hard. I've had that happen a few times and it was a fairly weird sensation, but not discomforting enough for me to stop the scan. No long-term issues that I'm aware of though.
ihnorton··on How R Took the World of Statistics by Storm
Still early days, but see http://www.nemocas.org/
ihnorton··on The Macro
Hacker Newsletter and HN Daily have filled this role for a while now for me. I read the highlights over lunch or on the train, and otherwise try to avoid HN during the day (heh, mostly).

http://www.hackernewsletter.com/ http://www.daemonology.net/hn-daily/

ihnorton··on NNSA, Nvidia to create an open-source Fortran compiler front-end for LLVM
I see. Indeed, Julia's ecosystem is still quite young. (possibly of interest: a project building a Julia-integrated CAS called Nemo, at http://nemocas.org/)
ihnorton··on NNSA, Nvidia to create an open-source Fortran compiler front-end for LLVM
> My other problem is code generation. I can't generate Julia code yet.

Perhaps I am misunderstanding your meaning here, but Julia has a range of metaprogramming functionality including both Lisp-like macros, as well as "generated functions" that allow custom code specialization based on input type signatures (https://medium.com/@acidflask/smoothing-data-with-julia-s-ge...). These capabilities have been used for DSLs (e.g. https://github.com/JuliaOpt/JuMP.jl) and parser generation (e.g. https://github.com/abeschneider/PEGParser.jl).

ihnorton··on CINT – A C/C++ interpreter
People interested in CINT and Cling might also be interested in Cxx.jl: https://github.com/Keno/Cxx.jl. It provides a C++ REPL mode for Julia and integrates Clang with Julia and the LLVM JIT to provide a powerful C++ FFI (the author has started using to wrap ROOT).
ihnorton··on Julia Computing Granted $600k by Moore Foundation
It is worth noting that Fortran, MATLAB, Mathematica / Wolfram Language are all 1-indexed. These are, by far, the most influential and widely-used languages in numerical and mathematical programming for the past ~60 years.
ihnorton··on Didn’t Homejoy Shut Down?
The consideration provided by HomeJoy's customers was, naturally, payment.
ihnorton··on Rreverrse Debugging
Qt Creator's gdb integration handles the basics well (I haven't used it with lldb, but lldb supports the gdb MI protocol so it should at very least "work").
ihnorton··on Light Table 0.8.0-alpha
The next version will be based on Atom.
ihnorton··on Julia 0.4 Release Announcement
People are working on this -- come join the fun! There is a LightTable-based environment at http://junolab.org/, but that group has shifted focus to building on Atom for long-term sustainability: https://github.com/JuliaLang/atom-language-julia

(I don't really use emacs, but I thought julia-mode was available from MELPA)

ihnorton··on Julia 0.4 released
This is a detailed log of major changes for 0.4. There is also a summary release announcement here: http://julialang.org/blog/2015/10/julia-0.4-release/

Binary downloads are available here: http://julialang.org/downloads/

ihnorton··on Matrices in Julia
Another one: https://github.com/zenna/Sigma.jl

There was a talk about Sigma at JuliaCon this year, but I don't think the video is posted yet.

ihnorton··on It Just Works
1000x this. I've turned to dtrace twice in the past several weeks to find fixes for serious issues on other people's computers. One was a segfault at startup in iTunes caused by a corrupted cookie cache. The other one was a corrupted plist that prevented adding new exchange accounts or calendars to mail (with no indicators at all -- the new account would just hang indefinitely).
ihnorton··on C/C++ facts we learned before going ahead with CLion
Listing GCC usage essentially at parity with Visual C++ on Windows (34% vs 36%) is also ridiculous.
ihnorton··on John Carmack working on Scheme as a VR scripting language
I tend to end up writing `Expr` objects directly when I'm building larger macros as I find them much easier to reason about. It's clearly not as convenient/clean as Lisp though. (David Moon actually sent a PR last year to make hygiene much easier.. unfortunately it got stuck for a while, but the PR was recently rebased and hopefully will be merged eventually).

Regarding the learning curve: we rewrote the first half of the Metaprogramming section of the manual a few months ago to try to provide a more gradual introduction, especially for people without a Lisp background. Objectively I don't know if the change has helped, but I tell myself that the number of macro-related questions has gone down :)

We would really like to make these tools accessible to people both with and without a formal CS background (probably the majority of Julia users will fall in the latter category). So, if you have any suggestions for doc/pedagogy improvements in this area, I would be very happy to hear them!

ihnorton··on Introduction to Concurrency
This article by Tomas Petricek goes into some interesting historical background and philosophical questions regarding types:

http://tomasp.net/blog/2015/against-types/

ihnorton··on Lush Programming Language
His lab now uses (and contributes to) Torch7:

http://www.reddit.com/r/MachineLearning/comments/25lnbt/ama_...

ihnorton··on Twitter Needs New Leadership
It boggles my mind that Twitter still does not provide a built-in way to follow a hashtag.
ihnorton··on MSBuild is now open source on GitHub
The CMake language is just an atrocious mess, but that gets easier with time. The main problem with CMake on Windows is that it is really really slow for large projects (because it has to call back out to CMake to do all sorts of basic stuff) and that debugging CMake errors is horrifically hard (this has improved in recent MSVS generator integration, but I'm stuck w/ VS2008 still).
ihnorton··on MSBuild is now open source on GitHub
CMake supports VS2012-2015 natively in the latest releases.
ihnorton··on The new MacBook
The prevalence of "chat with us!" and "take a quick survey?" website popups encapsulates everything that is wrong with non-Apple computer hardware manufacturers.
ihnorton··on Side projects
On the other hand, consider the following: Emscripten, Numba, Julia, Rust, Pyston, Pure, Polly, Mono-LLVM, ghc -fllvm, Terra, ... and those are just the ones I can think of in a few seconds. Several of these have the potential for huge impact over the next decade, and nearly all of them would have been significantly less viable either using GCC tooling (due to license-driven architectural decisions) or building a backend from scratch.

LLVM is known for being rather ruthless with their API refactorings. This has the twin advantages of keeping the code quality very high, and giving people an extra incentive to contribute upstream (e.g. the PS4 compiler backend). I won't go so far as to say this is intentional, but it does represent a rather amusing way to discourage users from keeping everything in-house.

← PreviousPage 6 of 15Next →