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 Organizations announced for Google Summer of Code 2021
I do wish they would let organizations apply earlier in the year (or even better the year before) so the organizers can know whether or not the organization will be accepted. In fact, many students start talking to us even the previous fall in preparation for an application to gsoc. But certainly, immediately after org announcements things really start, so everything, including project descriptions, mentors, etc. need to be set up. Handling the inquiries, getting the mentors set up, etc. is a nontrivial amount of work. We (Julia) missed out in 2015 and it was quite a scramble. We ended getting sponsorship to run a Summer of Code outside the Google umbrella to avoid disappointing the students, but more of a heads up would have been useful.
KenoFischer··on Jet.jl: A WIP compile time type checker for Julia
Oh, you just don't do correctness proofs over the same type system that is used for dispatch (i.e. "the Julia type system"). We already use an expanded lattice internally for reasoning about Julia code, so there's really no problem just doing something completely general.
KenoFischer··on Jet.jl: A WIP compile time type checker for Julia
This package basically exposes information that the standard Julia compiler already knows internally (extracted using some hooks I added last year to make the compiler more extensible) and uses for optimization. As such, it has quite good information about whether or not its analysis is complete, because we need that information to generate correct code. It is very possible to just error when the information is incomplete, which we do e.g. when compiling for GPU or TPU. In such a mode, the absence of type errors (or any other kind of error you wish to exclude would be proven). Of course Julia's type system is designed for semantics specification, not proofs, so it's not really what you'd want to use there. I think the most promising way to go is basically to let the users specify their own correctness criteria (for example, some people really care about correctness of array dimensions), and then just go to a full theorem proving system for that. I really like F* in this area as a design point and have played with some ideas in that direction. A package like JET.jl is of course a good step in this direction, since it can at least make use of the static information that the compiler does already need to prove for its internal optimization purposes.
KenoFischer··on New 10 Terapixel Image of the Night Sky Contains 1B Galaxies
This work is four years old (with development happening before that), so the Julia GPU capabilities probably weren't good enough at the time. If you wanted to do it today, that'd probably be the way to do it, but would need some benchmarking.
KenoFischer··on New 10 Terapixel Image of the Night Sky Contains 1B Galaxies
It's not entirely embarrassingly parallel because photons from nearby light sources interact, so you need to do a parameter exchange. That said, it is true that it doesn't need the low latency fabric that supercomputers traditionally used (though these days the architecture isn't all that different from what you'd have in a traditional data center). We were actually approached by Microsoft to duplicate the demo on Azure, but they ended up being unable to find enough spare capacity for us to run it at full scale, so we showed off a small scale demo. In this particular case, the supercomputing center was quite interested in our application because they wanted to test their setup with more "data analysis heavy" workloads, since they had invested a lot in SSD caches for this kind of work, but most of their workloads didn't require it.
KenoFischer··on New 10 Terapixel Image of the Night Sky Contains 1B Galaxies
Counting the number of galaxies in these image datasets is actually a highly non-trivial, supercomputer-scale problem. I worked on this a few years back! Paper link for those interested: https://arxiv.org/pdf/1801.10277.pdf
KenoFischer··on Enzyme – High-performance automatic differentiation of LLVM
Also see the Julia package that makes it acessible with a high level interface and probably one of the easier ways to play with it: https://github.com/wsmoses/Enzyme.jl.
KenoFischer··on Julia adoption keeps climbing
That's more on the "nice to have" list (at least from my perspective - others may have different opinions).
KenoFischer··on Julia adoption keeps climbing
I was talking specifically about the ARM ISA extensions. The accelerators are a different question of course. I understand the folks working on the Linux port are trying to reverse the GPU ISA. Apple could of course also just publish that, but I'd put the odds on that lower than the ISA extensions. That said, Apple has sometimes surprised me on these kinds of things.
KenoFischer··on Julia adoption keeps climbing
I'm expecting somebody to add them to LLVM soon. I'd talked to folks at Apple about that some time back, but they weren't able to tell me at the time what their plans were for adding it. That said, I am fully expecting them to just add it to LLVM themselves. If not, somebody in the community will do it. Once that's done, Julia will just pick it up.
KenoFischer··on Julia adoption keeps climbing
Agreed on error handling actually. It doesn't quite have the feel that it should in a modern language. I think error handling and lifetimes/mutability are two of the top things we're looking at for a fundamental remodel in 2.0.
KenoFischer··on Reverse Engineering the Source Code of the BioNTech/Pfizer SARS-CoV-2 Vaccine
Would be curious what the differences in the Moderna vaccine are (at this level - I know the lipids are different).
KenoFischer··on Google partners with SkyWater to enable open source manufacturing of ASICs
Glad it was useful to you!
KenoFischer··on Google partners with SkyWater to enable open source manufacturing of ASICs
I just gave an example, I didn't mean to say it was the exclusive source of info. Every discussion I've seen of what the layout would actually be was always "roughly 10mm^2, pending finalization of the harness". Also, it was talked about many times on the slack. Look, I have no dog in this fight. All I meant to say was that this was not some sudden last minute change of plans. Could things have been communicated more clearly? Sure. But that's par for the course for an alpha program like this.
KenoFischer··on Google partners with SkyWater to enable open source manufacturing of ASICs
It was talked about all over the place. E.g. see https://youtu.be/EczW2IWdnOM from June around the one hour mark. As I said, I'm very far from an insider.
KenoFischer··on Google partners with SkyWater to enable open source manufacturing of ASICs
I agree the submission process has been somewhat chaotic, but I don't think it has been exceedingly so. The fact that this was gonna be an alpha test of new technology was clear from the start. Taping out with a modern PDK and open source tools just hasn't been done before. Also, the caravel requirement has been known for at least three months. True the design wasn't done yet and the details were sparse, but saying it was added two weeks before the tapeout deadline is disingenuous when it was announced at the start of the program. As for not taking your money to get your own tapeout, I'm sure they'll be most happy to do so once they've worked out the kinks, which is exactly what they're using the shuttle runs for.

(Not affiliated with the project in any way, just watching closely out of professional interest).

KenoFischer··on Differentiable programming for gradient-based machine learning
The differentiable programming framing is quite useful in the scientific simulation space, because it lets you couple traditional physics simulations to either neural surrogates or some sort of bayesian model. Enough of it is happening in the Julia world that were very actively improving the compiler to support it.
KenoFischer··on Indistinguishability Obfuscation from Well-Founded Assumptions
You can use FHE to encrypt functions, but the more standard use is to encrypt inputs and evaluate plain text functions (e.g. in a two part sort of protocol, see e.g. [1]). Regardless, the important difference to obfuscation is that once you're done computing, the output from FHE will still be encrypted. Somebody has to have a key to decrypt that and that key can most likely also be used to decrypt the function. In iO, the result comes out plain text.

[1] https://juliacomputing.com/blog/2019/11/encrypted-machine-le...

KenoFischer··on Indistinguishability Obfuscation from Well-Founded Assumptions
In FHE, you need some sort of key to decrypt the result. In obfuscation the result comes out clear text. General obfuscation is impossible, but iO gives you basically the best possible result which is "given any method of computing the same function (for some complexity parameter of the function in question) you will always be able learn at least as much from said method as from the obfuscated function" (in other words iO gives you a circuit that is as hard to reverse engineer as the hardest circuit of a given size that computes the same function, but it doesn't give you a guarantee on how hard that actually is).
KenoFischer··on Indistinguishability Obfuscation from Well-Founded Assumptions
The article isn't about FHE, it's about iO. As you point out there's no reduction from FHE to iO, but there is one going the other way. Worth noting though that when Boaz et al wrote that paper, even FHE wasn't known to exist. As for the iO result, not sure whether you were saying you thought the result wasn't solid because of the Boaz paper, but my understanding from people in the field is that it's expected to hold up and of course Boaz is quoted in the article.
KenoFischer··on Pernosco Omniscient Debugger is now available for individual developers
We use rr extensively for Julia development [1] (for a sense of scale, I probably look at hundreds of rr traces a month). There's two big challenges for us there 1) Many cloud environments are broken in various ways for rr recording - I spend way too much time guiding our users to the few that do work 2) The GDB frontend really isn't the best way to view all the underlying information

Pernosco is well on its way to address the second part of this. Its replayer is quite a bit nicer than the open source rr one and I have high hopes for the platform in general.

For the first one, all I can do is plead with the cloud vendors not to mess up the environment. Since this is HN, if you're working for a cloud provider, please ask your engineering team not to break rr. Otherwise I'll have to spend time migrating our users off your platform, which will be fun for neither of us.

Anyway, congrats to Robert and Kyle on the launch. Wish you all the best.

[1] https://julialang.org/blog/2020/05/rr/

KenoFischer··on The Fatal Flaw of Ownership Semantics
Yes, I think you're onto something. Essentially what if we modeled linearity like in Rust, but then did GC over the maximally linear data graph we can find. I've been wanting to play with some ideas in this direction, but haven't had the time.
KenoFischer··on Julia: Dynamism and Performance Reconciled by Design (2018)
I think that's observation is fair, but I would also argue it is neither unusual (e.g. Python doesn't have one and it's probably one of the most popular language on the planet at the moment) nor a bad thing. In programming language design, you need to implement things and try out how they feel to use in practice. Programming language design is mostly about interfacing with humans, not computers. Something that has a beatiful proof on paper, but feels clumsy to use is bad programming language design. Eventually one of the efforts to make Julia an ISO standard will win and we'll be doing language design by committee and have a formal specification, but until then we'll try to build the best language we can ;).
KenoFischer··on Julia: Dynamism and Performance Reconciled by Design (2018)
The subtyping system is fairly complicated, but in practice users only need to really think about situations where the LHS is a concrete type, since that's primarily what determines runtime semantics (not to say that there aren't situations where specificity really matters, but it's quite rare). That simplifies the mental model considerably and our users tend to find it relatively intuitive. For a formal discussion, the group at Northeastern has been doing great work in phrasing some of the Julia internals in more traditional PL language, including a formal subtyping model. That paper is at http://janvitek.org/pubs/oopsla18a.pdf
KenoFischer··on Nearly 12M Square Feet of Vacant Office Space in S.F
The Fed does a lot of macroeconomic modeling and forecasting, so their analysts being interested in the effects of the pandemic on particular sectors of the economy doesn't sound particularly unusual (I have no insight in the the particular circumstances referenced in the parent comment of course).
KenoFischer··on The unreasonable effectiveness of the Julia programming language
Probably not in default configuration, but we have some people interested in this kind of thing. The compiler candy definitely be configured to make that work, but so far interest hadn't been sufficient to implement that. If you have a particular use case in mind, do let us know to see if we can help you out.
KenoFischer··on The unreasonable effectiveness of the Julia programming language
This is not true. Indexing works very differently in julia than it does in Matlab. There is some overlap in function names, but less than you're implying, mostly in the names that everyone uses anyway (sin, cos, etc) and even where the names are the same, the API details often aren't. Ironically the number of overlapping method names has increased because Matlab has been copying method names from Julia in recent years. That said, Julia and Matlab are completely different languages, so I'd encourage you to look in one step further.
KenoFischer··on The unreasonable effectiveness of the Julia programming language
Julia is in that class of languages. We regularly look at roofline plots when performance tuning.
KenoFischer··on The unreasonable effectiveness of the Julia programming language
Give us some more time, there's just so many things to do and the reliance issues favor getting the fundamentals right first (much easier to switch the debugger UI than the names of functions that'll get put all over the place). We certainly understand the value of good tooling, so just stay tuned and maybe try it again every once in a while to see if it's good enough for you yet. Too much to do, too little time :)
KenoFischer··on The unreasonable effectiveness of the Julia programming language
Yeah, fair enough. I've filed an issue internally against the website copy. It should definitely tell you what it is above the fold.
← PreviousPage 4 of 17Next →