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 DragonFFI: C Foreign Function Interface and JIT Using Clang/LLVM
I believe other languages could use this without Python, in principle. It is currently distributed as a Python package to provide functionality similar to the existing cffi package. The Python wheels are 18MB and statically linked -- so no external Clang or LLVM dependencies as far as I can tell. That is indeed quite large relative to libffi (or compared to LuaJIT, which is well under 1MB IIRC). But relative to 100s of MB for a full SciPy stack with Anaconda, it's not that much.

This could also be a foundation for more than "just" C FFI: it includes a full C++ compiler and JIT! Adding C++ FFI support would take a lot of work I’m sure, but I doubt it would noticeably increase the footprint because the bulk is already in LLVM+Clang. Another possibility would be to JIT Cython-generated code on-demand.

ihnorton··on WxPython 4.0.0 Released
The LGPL requirement is relinkability, which implies either distributing object files for your application (rare, inconvenient), or, more commonly, linking the LGPL library as a shared object. But that shared object could be stripped down to contain only the symbols your app uses (and their transitive dependants) — just as long as someone can do the same and use their API-matched .so as a drop-in replacement.
ihnorton··on Netflix is now worth more than $100B
> Recall a few days ago some people were trying to reconstruct the genome of the first black man in Iceland.

Recall who funded that work.

ihnorton··on Falsehoods Programmers Believe About Build Systems (2012)
Meson might be of interest.

http://mesonbuild.com/

ihnorton··on The State of Atom's Performance
The other thing to keep in mind is that a similarly script-extensible Qt application carries the weight of Qt shared libraries, plus scripted wrapper shims. This can easily run 25-40 MB in Python-Qt systems, at which point 70 MB for Electron looks much less crazy.

(also a C++/Qt dev, jealously eyeing love preview, hot-reloading, and other niceties).

ihnorton··on Ask HN: Career change at 22
> They dress badly, they swear alot, simply they look like people from lower social classes.

Doctors swear plenty, but they generally avoid doing so in mixed company. As for dress, well, they effectively live in scrubs for up to a decade.

But they do indeed end up with much higher social capital than a typical software developer (even devs making equivalent to board-certified MD compensation) or skilled tradespeople, which is what I think you are getting at.

ihnorton··on Some Insights from a Julia Developer
Inclusion is by selection of the admin [1,2]. There are Julia implementations available for most of the benchmarks [3] so perhaps eventually they will be included.

[1] https://alioth.debian.org/forum/message.php?msg_id=182495&gr...

[2] http://benchmarksgame.alioth.debian.org/play.html#languagex

[3] https://github.com/JuliaLang/julia/tree/master/test/perf/sho...

ihnorton··on A Comparison of Differential Equation Solver Suites
Julia's meta-programming functionality is ideal for implementing such domain-specific languages (the popular JuMP suite is a flagship example in a different domain: https://jump.readthedocs.io/en/latest/).

Several groups are working on systems inspired by Modelica, including:

http://tshort.github.io/Sims.jl/latest/

and

https://www.modelica.org/events/modelica2017/proceedings/htm... (https://github.com/ModiaSim/Modia.jl)

ihnorton··on Back to the Future: Lisp as a Base for a Statistical Computing System [pdf]
> Can you call R from Julia yet?

Yes. There's even an R REPL mode.

https://github.com/JuliaInterop/RCall.jl

ihnorton··on Create your own Game Engine but don't use it
Parse error on my part, excuse the pedantry :) Tcl is such a weird and wonderful language, and I occasionally miss it (though I don't miss working with a GUI written in C++ wrapped around tk).
ihnorton··on Create your own Game Engine but don't use it
Julia JIT compiles C calls via LLVM, so there's no libffi performance overhead (similar to LuaJIT's CFFI, though that does not use LLVM).
ihnorton··on I found a bug in Intel Skylake processors
> I worked from the executable provided by SIOU, first interactively under GDB (but it nearly drove me crazy, as I had to wait sometimes one hour to trigger the crash again), then using a little OCaml script that ran the program 1000 times and saved the core dumps produced at every crash.

rr can often be a time-saver in situations by providing deterministic replays up to the point of a crash, whereas coredump analysis is a single retrospective snapshot.

http://rr-project.org/

ihnorton··on What Challenges and Trade-Offs Do Optimising Compilers Face?
> Has any C compiler closed the loop on that by shipping the full compiler with the program to do runtime optimization?

- The truffleruby "cext" project demonstrated something like this. They interpret and then JIT C on the JVM, and do cross-language inlining and other optimizations.

http://chrisseaton.com/rubytruffle/cext/

The same group is working on compiling LLVM IR on the JVM. Presumably the JVM's tiered runtime optimizations would apply to both of these.

https://github.com/graalvm/sulong

- There are also interactive C(++) "JITs" from CERN and the Julia project. However, as far as I know, they are both method JITs and don't do any trace-based re-JIT/OSR.

https://root.cern.ch/cling and https://github.com/Keno/Cxx.jl

ihnorton··on Julia Computing Raises $4.6M in Seed Funding
This is totally fair. Even the Julia creators regularly mention "stay with existing tools for now, if you are happy." Julia is an increasingly attractive option for greenfield, high-performance development, but for folks who aren't doing a lot of that, a more stable language and mature ecosystem is obviously important. Julia and many libraries can still require some elbow-grease, and the maturity and coverage varies between fields. However, this is rapidly changing as folks do new research in Julia and build up everything else they need along the way. The current situation is very similar to SciPy in the mid-2000s, though with perhaps a somewhat different mix of backgrounds. Here are a few examples:

https://github.com/JuliaOpt https://github.com/jeff-regier/Celeste.jl https://github.com/dlfivefifty https://github.com/JuliaInv http://docs.juliadiffeq.org/latest/ https://github.com/denizyuret/Knet.jl http://nemocas.org/ https://juliaplots.github.io/

So, hopefully you'll have reason to take another look in a few years. The most important thing, to me, is that all of these communities want more open, reproducible, and accessible science. There is plenty of room for growth, because users of closed-source software still probably outnumber py/r/jl by 5:1 or more.

ihnorton··on Julia Computing Raises $4.6M in Seed Funding
> it will be incredibly hard to replicate them

This is true, sort of. It was also true when people said the same about Perl (some people still say this about Perl!). Then Rails happened to Ruby, just as the web was going through another phase of explosive growth. Likewise, Node or Rust + GitHub effect.

The point is not to compare the growth trajectories or projected peaks, but to emphasize the levering effect of an enjoyable language combined with modern collaborative development and infrastructure. A language doesn't need "everyone" to build a viable ecosystem, just a critical mass.

> If it's still around in 10 years then it might be worth looking at (but still probably not).

Knock on wood and all, but from past observation, I think Julia is at or very close to this critical mass already. I would compare Julia now to the SciPy ecosystem around 2009-2010. That's just when IPython was getting popular, early versions of Pandas were released, and people were starting to trust Cython. (I was a heavy Python user then, and frequently suggested it to Matlab users who had exactly your question even in to 2012-2013). There's already a surprising breadth of packages, they just need time to mature. Sometimes too many, actually -- I recently found three for a relatively obscure geophysics format I used to work with. That lever is big enough that people often don't mind rolling their own.

ihnorton··on Julia Computing Raises $4.6M in Seed Funding
They expose an FFTW-compatible API, but as far as I know it's an independent implementation.
ihnorton··on Julia 0.6 is out
> testing and quality control

There have been major improvements in the past three years and code coverage is now consistently above 80%.

> Community is (apparently) a bunch of ...

I'm admittedly biased, but based on a number of years of experience and personal efforts, I think this is not a fair characterization. I don't know what happened in that private forum -- but I do know that the Julia community is thousands of people, with a huge, public archive of helpful, respectful interactions among newbies, non-Julia experts, core devs, and everyone in between.

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

(Disclosure: Julia committer)

ihnorton··on Julia Computing Raises $4.6M in Seed Funding
> So this is why every once in a while we see some article about Julia being as easy to use as Python while having nearly the performance of C.

Here's a performance testimonial with links to real code and benchmarks against Fortran (not Python), from Steven G. Johnson, one of the authors of FFTW:

https://discourse.julialang.org/t/julia-vs-fortran-complaint...

I implemented an erfinv function Julia (https://github.com/JuliaLang/julia/pull/29874), and it was about 3x faster than Matlab or SciPy's erfinv function, both of which are taken from standard Fortran libraries. [...] I have found similar gains (compared to Fortran code called in SciPy) for other special functions, e.g. polygamma functions (https://github.com/JuliaLang/julia/pull/71255) and exponential integrals (https://github.com/JuliaMath/SpecialFunctions.jl/issues/19).

The reason Julia can beat the Fortran code is that metaprogramming makes it easy to apply performance optimizations that are awkward in Fortran. We have metaprogramming macros (@evalpoly) that can easily inline polynomial evaluations, whereas the Fortran code makes function calls that loop over look-up tables of polynomial coefficients. Even greater speedups are possible for evaluating polynomials of complex arguments, where there is a fancy recurrence from Knuth that is almost impossible to use effectively without code generation. In principle, the Fortran authors could have done the same inlining and gotten similar performance, but the code would have been much more painful to write by hand. (They could even have written a program to generate Fortran code, but that is even more painful.)

> I'd rather deal with Cython apache license than deal with this GPL stuff for commercial use.

The Julia core is MIT licensed. The language distribution is currently GPL licensed due to linked dependencies, but there has been a no-GPL build flag available for several releases. GPL (and other) dependencies are continually being removed, and there are only one or two (GPL) libraries left in the currently nightly build.

ihnorton··on Amazon to Acquire Whole Foods for $13.7B
Not exactly a commune, but interesting nonetheless and on the same scale as Whole Foods (12 bln Euro turnover):

https://en.wikipedia.org/wiki/Mondragon_Corporation

Oneida is (was) the closest US analogy I can think of, though much smaller.

There are some very successful Kibbutzim spinoffs in Israel, into 100s of millions US$ (I don't know how ownership was structured).

ihnorton··on Coroutines are now in Clang trunk, libc++
Sure... I should have just quoted the documentation, because the point is that any of these concepts exist:

    set(<variable> <value> [[CACHE <type> <docstring> [FORCE]] | PARENT_SCOPE])
> Don't get me started about lists.

Yes, by no means exhaustive!

ihnorton··on Coroutines are now in Clang trunk, libc++
> What's wrong with Cmake?

One line summary:

    set(MYVAR 1234 CACHE FORCE PARENT_SCOPE)
ihnorton··on C++ Language Interface Foundation (CLIF)
LuaJIT limits both the number of registered callbacks [1], and re-entering the interpreter from a JIT'd callback [2] (it will try to detect and prevent JIT for such functions, but if that fails you get a panic).

[1] http://stackoverflow.com/questions/31042530/why-does-luajit-...

[2] http://stackoverflow.com/questions/25924755/c-and-lua-unprot...

ihnorton··on C++ Language Interface Foundation (CLIF)
Semi-related, in case you haven't seen it:

http://doc.pypy.org/en/latest/cppyy.html

ihnorton··on Why Are Ultrasound Machines So Expensive?
TeleMed [1] is slightly higher-end and has CE mark (IIRC in the $1-2k range for the uncleared/demo version). UltraSonix [2] used to be relatively reasonable option (IIRC under $10k), but they were bought by BK and prices may have increased.

[1] http://www.pcultrasound.com/ [2] http://www.ultrasonix.com/

ihnorton··on Why Are Ultrasound Machines So Expensive?
> For extra points, have alignment sticker targets you can attach to the body to track the patient if they move

This is roughly how surgical navigation systems work. The leaders in this area are companies like BrainLab and Medtronic, usually using optical tracking sensors (e.g. from Northern Digital), or sometimes electromagnetic, with accuracy in the 1-5mm range. For neurosurgery (the area I'm most familiar with), several companies offer tracked ultrasound integration, usually for live overlay and comparison with pre-operative MR or CT images.

> combine it with the positioning sensors of a VR system

For any folks interested in this, there is an active, excellent open source project called PLUS focused on ultrasound, tracking, and sensor data acquisition, as well as volume reconstruction [2]. There's also an associated 3d visualization ecosystem [3].

[1] http://www.ndigital.com/ [2] https://app.assembla.com/spaces/plus/wiki [3] http://www.slicer.org

ihnorton··on I'm giving up on PGP
Interesting, thanks. Am I understanding correctly that point 2 & most of point 3 are risks because of the possibility of either future device compromise, or e.g. quantum decryption technology? These are very general risks, so why do they apply here any more than elsewhere?

I realized I probably should not have replied to the part about OTPs specifically. What I'm curious about is remote trust verification via secure video.

ihnorton··on I'm giving up on PGP
I did say "exchange secrets" for a reason -- that secret may be a key for later use (e.g. for data dumps), or actual information.

What I'm trying to understand is whether the (relatively new) feasibility of interactive video channels allows for building roughly the same level of trust as would be provided by in-person key exchange. I'm basing this on the understanding, possibly incorrect, that encryption with a public key allows for creating a secure communication channel, but not necessarily a trusted one. The hypothesis is that the capability to conduct interactive video provides a way to verify identity and establish trust at roughly the same level as would be provided by in-person exchange (again, assuming 1-1 trust, and excluding TLA threat models).

ihnorton··on I'm giving up on PGP
> How do you distribute the one time pad in the first place?

I'm fairly naive to this area, but wouldn't video chat initiated with public keys suffice? Then confirm identities and exchange secrets. To me this seems substantially equivalent to in-person key exchange for non-Three Letter Agency threat models. 20 years ago this wouldn't really have been feasible, but today it (mostly) is -- from a quick glance at the FAQ, Signal may even support something like this already.

(If your threat model includes "abduction and coercion", then aren't you kind of hosed even with previous in-person OTPs?)

ihnorton··on Documents show that Apple has permission to sell three new portable computers
Here's hoping, once again, that the wrist-killing edge [1] will finally be rounded off.

[1] http://onemansblog.com/2010/03/11/video-rant-taking-the-shar...

ihnorton··on Fixing Python Performance with Rust
I've looked at Nim a bit, and it does have some nice features. But magic identifier equality [1] is an intrinsically disqualifying design choice.

> If a language's lexical structure is so tortured that I need a special tool to grep it, I'm going to skip it and go back to the sanity of C++. [2]

Nope, nope, no way.

[1] http://nim-lang.org/docs/manual.html#lexical-analysis-identi... [2] https://news.ycombinator.com/item?id=8936542

← PreviousPage 4 of 15Next →