HNHacker News
TopNewBestAskShowJobs

KenoFischer

4,368 karma · joined December 2, 2012

Julia Core Developer Co-Founder at Julia Computing

Reach me at keno@juliacomputing.com

submissionscomments
KenoFischer··on Try Out Rust IDE Support in Visual Studio Code
I haven't had the chance to try the Rust language mode, but I've been using VS Code for all my julia development lately, and I'm pretty impressed. It's quite a nice editor. I avoided using it for a very long time because I thought it'd match Atom's slowness due to their shared Electron heritage. But for some reason VS Code feels a lot snappier. Not quite Sublime levels, but perfectly usable.
KenoFischer··on Creating domain-specific languages in Julia using macros
1.0 is the next major version (there'll be an 0.7 to give us an extra deprecation cycle and start 1.0 without any depwarns, but 0.7 will essentially be identical to 1.0 otherwise). You can follow the 1.0-blocking issues here: https://github.com/JuliaLang/julia/milestone/4.
KenoFischer··on Linux 4.12 Released
Mailing List threads:

http://marc.info/?t=149861183900003&r=1&w=2 http://marc.info/?t=149864742900002&r=1&w=2

Oh and the one that got fixed:

http://marc.info/?t=149609949000002&r=1&w=2

KenoFischer··on Linux 4.12 Released
Breaks rr I believe :(. In fact there were two regressions of that sort introduced this release cycles. One was caught early enough to get fixed, I guess the other wasn't.
KenoFischer··on Ask HN: Who is hiring? (July 2017)
Julia Computing | Compiler or Systems Engineer | Boston, MA | FULL-TIME | ONSITE

Julia is an exciting new language in the increasingly important field of mathematical computing. As machine learning becomes part of every programmer’s stack of tools, increasing demands are being put on programming languages and compilers to meet the need of simple and efficient mathematical computing. Julia Computing, one of the top contributors to the open source Julia programming language, is seeking compiler and systems engineers to take the julia programming language and its tooling to the next level.

We work at all levels of the software stack, from the hardware up, in order to support julia and its applications. Any experience working at the kernel (Linux primarily), toolchain, compiler, language, or developer tooling level, would be highly beneficial. Since tasks often span a significant range of this stack, interest in and the willingness to learn about the rest of the stack are required.

Knowledge of or previous experience with Julia is not required, but would be beneficial. However, experience working with systems-level tools (C/C++/Rust/GDB/perf etc) would be highly desirable.

Substantial portions of this work will involve contributions back to existing open source projects (Julia/LLVM/Linux, libraries, etc.) or the development of new open source projects.

Example tasks may include:

    - Working with the core language team on future versions of the julia programming language 
      (Don't like something about the language? Here's your chance to fix it!)
    - Supporting and enhancing the performance of julia HPC applications at petascale and beyond
      (Obsessed about performance? Us too! Come play with supercomputers)
    - Enabling julia on next-generation hardware architectures and accelerators
      (Like fancy new hardware? Want to play with it before everyone else? Can do!)
    - Developing modern developer tooling (debuggers, profilers, static analysis/verification tools)
      (Think you can do better than the state of the art here? Come try it out!)
    - Enhancing the compile-time performance of julia and the underlying LLVM compiler
      (Cut down the iteration time for scientist using julia - help them come up with new ways to cure cancer, solve climate change or survey the sky faster)
    - Developing novel programming models for diverse kinds of hardware
      (What's the best way to program all these crazy architectures? We don't know yet, but we're planning to find out - maybe you have the crucial idea)
Both senior and junior full-time positions are available. This advertisement is for our Boston, MA, USA location. There are no formal education requirements. We are happy to sponsor US visas.

If this position interests you, or you have any questions, please contact us at jobs@juliacomputing.com

KenoFischer··on I found a bug in Intel Skylake processors
You can do multiple concurrent rr recordings. A non-deterministic cpu bug would generally cause a divergence in the recording vs replay, so rr would be a decent way to go about this. The way I'd have probably used rr when faced with this is to bisect the recording to find which code is responsible.
KenoFischer··on Julia Computing Raises $4.6M in Seed Funding
Unfortunately 1.0 is delayed for a couple of months. 0.6 was released yesterday though, which already includes many of the features that were originally scheduled for 1.0.
KenoFischer··on Julia Computing Raises $4.6M in Seed Funding
I'd encourage you to reach out to the Julia lab at MIT. They're generally very happy to help spread the use of Julia at MIT.
KenoFischer··on Julia Computing Raises $4.6M in Seed Funding
Yes, it's quite cool. The specification is a literate Julia program and the specification document is built from it. Simultaneously, they run large scale simulations to make sure that the specification behaves as the theory says it should. There was some discussion with them about deployment, and they funded us for a proof of concept Julia-to-C compiler, but the continuation of that discussion is probably still a number of years off. It's a very long term project.
KenoFischer··on Intel releases the last Itanium chip, the 9700
I was counting FMA as 2 operations ;).
KenoFischer··on Intel releases the last Itanium chip, the 9700
Yes, I understand. What I meant was that you don't want to be running those kinds of codes on a KNL, because the performance is absolutely terrible. Nevertheless, Intel is producing the KNL, so there's now a market for this kind of thing, which may not have been there 15 years ago.
KenoFischer··on Intel releases the last Itanium chip, the 9700
> I suppose a similar analogy would be doing everything in x86 with SIMD instructions and not using the scalar set at all.

With ever wider SIMD units this is actually happening to some extent. With AVX512 (e.g. on KNL) you can do 64 operations (single precision FLOPs) in vector units in the same amount of time as you can do 1 scalar operation. Combined with the low clock speed of the KNL, you really don't want to be doing scalar operations if you care at all about performance. Of course SIMD isn't the same as VLIW, since the operation you're doing has to be the same in all vector lanes, but with masking support in AVX512, it is getting a little closer to that.

Also compilers have gotten quite a bit smarter and with hardware die shrinks taking longer, I wouldn't be at all surprised if VLIW ISAs were to make a comeback. I guess the Itanium was a bit ahead of its time.

KenoFischer··on VME Broken on AMD Ryzen
Yeah, modern CPUs have tons of bugs in the obscure corners of the architecture. The x86 boot process is an amazing amalgamation of all the legacy CPUs of the past two decades. This does seem fixable in microcode though, so presumably they'll just do that. I very much agree with the other comments though that at some point we should just get rid of all of that junk and use software emulation.
KenoFischer··on Julia Language for Raspberry Pi
There's just something magical about blinking LEDs in programming. I fondly remember hooking up rows and rows of LEDs to the GPIO of an AVR when I was a kid (maybe I should find that board and hook up the LLVM AVR backend to julia ;), but the RPi does make that kind of thing a whole lot easier. I'm glad this collaboration worked out.
KenoFischer··on The Etiquette of the Victorian Ballroom: Twenty Tips for Single Gentlemen
I'd like give an emphatic +1 to this. Starting ballroom in college was probably one of the best decisions I ever made.
KenoFischer··on A deep dive into APL
You might enjoy this one: https://www.youtube.com/watch?v=XVv1GipR5yU
KenoFischer··on OpenSSL Licensing Update
LLVM's proposed switch included a provision to make it explicitly compatible with GPLv2. That seems like a nice precedent to follow for other projects that are considering Apache 2 as their license.
KenoFischer··on FCC to be led by Ajit Pai, staunch opponent of consumer protection rules
> Is there a sympathetic view of Ajit Pai that anyone could offer?

I met commissioner Pai in person last year (he was meeting with groups of founders in the Boston area). IIRC, the primary point of discussion was wireless spectrum policy and ensuring access to broadband internet for the greatest number of people, so I have little insight to offer into his thinking on other issues. However, in my impression he seemed to be a thoroughly decent and knowledgable person who cared deeply about the work that he is doing. I think it is important to separate the policy issues from the person.

KenoFischer··on Testing LLVM
I always find committing to LLVM very nerve wrecking, because of the post-commit CI testing. LLVM has so many architectures that more often than not something I write will fail on one of them. And the only way for me to find out is to commit it, wait for the buildbot to fail (which can take a few hours, during which I really can't leave my computer lest I leave trunk broken on some buildbot, which is a big faux pas), revert it and then figure out what went wrong. I'm hoping that at some point this will be improved, such that I can run the whole buildbot army on my commit before putting it on trunk.
KenoFischer··on LLVM's New Versioning Scheme
I should also note that the internal APIs are not the problem for Julia. We usually pick those up immediately. Rather, doing validation for a new release on all platforms, reducing, filing, fixing any regressions, etc is what takes the time (in addition to only a few of us knowing LLVM well enough to do so).
KenoFischer··on Ask HN: Best Monitor Around $300 for Dev Work?
I have a number of these as well (I ordered them for the office since I was happy with them I got them at home as well). Everybody has been generally very happy with these monitors.
KenoFischer··on Proposed server purchase for GitLab.com
I recently had to do this. The server I was putting up was rated for 3kW. To determine the expected load, I put it under a dummy load that I reasonably considered the maximum for what I would expect on the server (this was a dev machine, so I picked compiling the linux kernel as a benchmark). I ran that until the power stabilized (SuperMicro servers can measure power consumption in hardware and expose this via IPMI - very handy), because power consumption may keep creeping up for a few minutes as the fans adjust to the new operating temperature. I then repeated the same exercise with a CPU torture test (Prime95), just to see what the maximum I could possible get out of the machine was. The numbers turned out to be about 1.8kW for the linux kernel benchmark, and 2.3kW for the torture test. What I ended up doing was to provision for 2kW and use the BIOS' power limiting feature to enforce this. That would kill the machine if it exceeded its designed load, but that's usually better than tripping the breaker and killing the entire circuit. You may also want to talk to your data center provider about overrages. Some of the quotes I got wouldn't kill your circuit when you went over, but would just charge you (a crazy amount, but better than losing all your servers).

Hope that helps. Your deployment is larger than ours, so there may be other techniques, but that's what we did.

KenoFischer··on Dark matter may be hiding in a hidden sector
Haven't read the actual paper, so I'm infering from the article, but basically the argument appears to be that under common beyond-the-standard-model theories, it's likely that most heavy particles are unstable. Instead they argue that it's likely to be a weak particle that just happens to not be interacting with visible light. By no means a novel idea as the article makes it seem. Don't take that as a jab against the paper though. It's important to constrain what we would expect under existing theories, both as avenues for future theoretical research and to guide experiment. Frankly, until one of the experiments see something the standard model doesn't predict, everybody's just taking shots in the dark.
KenoFischer··on A Look at How Traders and Economists Are Using the Julia Programming Language
Yes, there's been some scientific workloads that used Julia/MPI to great effect. I don't think the paper is out of review yet, so probably can't link to details, but expect news on that front very soon.
KenoFischer··on Julia 0.5 Highlights
Nothing accidental about it, it took quite a bit of work to fix all the issues we had ;).
KenoFischer··on Julia 0.5 Highlights
LLVM 3.7.1 is a little less than 10 months old. Our RC period lasts for about 3 months, the start of which is the last point we'd have possibly upgraded LLVM. Upgrading LLVM is a little bit of a scary prospect for us since we find new bugs in every version (and fix them!), so though we considered moving to 3.8, 3.7 had been stable for a few months, so we didn't want to risk it. There's currently a PR to bump LLVM to 3.9 for 0.6, so I'd expect 0.6 to be released with LLVM 3.9.1.
KenoFischer··on Julia 0.5 release
Many people think this was added for support of 0 offset arrays, but that's only a side effect really. This feature was requested by people who work with rather odd arrays (e.g. diagonal slices through high dimensional data). I have mentioned in previous threads on the subject that julia's 1-indexed arrays don't matter much in practice because the generic APIs hide that fact most of the time. This just adds the last bit of code to make that completely true and adds documentation/cleanup. For those seeking more information, I'd recommend Tim Holy's JuliaCon keynote on the subject: https://www.youtube.com/watch?v=fl0g9tHeghA
KenoFischer··on Julia 0.5 release
Yes, there'll be an official announcement in a little bit. Tagging is just the first step (we haven't even added the release metadata to the tag on GitHub yet).
KenoFischer··on Llvm-Cbe: Resurrected LLVM “Bitcode to C Back End” with Improvements
Don't think that particular optimization was ever implemented. It looks straightforward, but one does have to be careful about re-ordering, so the legality check is slightly more complicated. We briefly considered writing a clang-based source-to-source transformation as a post processing pass to clean up, but it wasn't worth it for our use case.
KenoFischer··on Llvm-Cbe: Resurrected LLVM “Bitcode to C Back End” with Improvements
The improvements are better coverage of possible LLVM IR, and significant bug fixes to make this actually work.
← PreviousPage 13 of 17Next →