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 Llvm-Cbe: Resurrected LLVM “Bitcode to C Back End” with Improvements
From that email it sounds like there was more concern about the front-end side C/C++->LLVM-IR than the backend side, so this wouldn't affect that. As for the backend side of things, I know nothing about Plan 9, so I can't comment if their dialect would require modifications to this could base. However, I can't imagine that making the changes to support Plan 9 natively in LLVM would be significantly more onerous than changes required to this backend. In fact, a lot of the ABI work may have been done already since I believe Go shares the Plan 9 ABI.
KenoFischer··on Llvm-Cbe: Resurrected LLVM “Bitcode to C Back End” with Improvements
| I've heard that this focuses heavily on what Julia needs, and so the less exercised portions may need a bit of work.

Quite possibly yeah. Jameson had to do quite a bit of work to get the backend to a point where it would reliably work on the IR we generate. Now, julia does have a pretty wide coverage of LLVM IR, so it's probably not terrible, but as always the test cases used in development determine what works and everything else probably requires some work (actually very similar to the regular LLVM backends - whenever we port to a new architecture we first end up having to fix about a dozen bugs to do previously unexercised code paths).

| Is there a wider interest in resurrecting this for wider use?

We don't currently have an active use case. Jameson has been maintaining it on low flame and merging pull requests/doing some cleanup here and there, but since we're not actively using it, there is of course a limit to that. There has been some activity on the repository recently though, so you're not the only one interested.

KenoFischer··on Llvm-Cbe: Resurrected LLVM “Bitcode to C Back End” with Improvements
This has been passed around been a couple folks after it got ripped out of LLVM. Looks like we still have the most up-to-date version here. Happy to answer any questions if I can (if not I'll have to bug Jameson who did all of the work here ;)). See here for some context of what we used this for: http://juliacomputing.com/blog/2016/03/10/j2c-announcement.h...
KenoFischer··on Physical Cryptographic Warhead Verification
I believe the idea is that this is supposed to be used when decommissioning as part of a disarmament treaty, i.e. both parties witness the warhead being destroyed, but how do you know it's an actual warhead rather than a dummy that is being destroyed.
KenoFischer··on Physical Cryptographic Warhead Verification
Yep, I took Boaz's crypto seminar, so I was looking for how this was different from his work. I couldn't find the full text of the article (maybe it isn't fully published yet), but the supplemental information mention that one of the primary distinguishing factors is that this is not based on neutron scattering which apparently makes distinguishing between weapons-grade and depleted material easier.
KenoFischer··on Why Feynman Diagrams Are So Important
Generally if you look at the Feynman diagram for an interaction, you'll have some number of external legs which one thinks of as physical particles, as well as a number of interactions. The lines between the interactions may be particles whose mass exceeds the total amount of energy of the incoming particles, so they obviously can't be real. They are thus generally called virtual (or off-shell particles). How one can think of this is what I tried to address in the original response.
KenoFischer··on Why Feynman Diagrams Are So Important
There is many ways to think about virtual particles. From a particle point of view one can think of it as quantum mechanics allowing you to create a high energy particle for a short amount of time, even if that would not be allowed classically. From a field theory point of view, you can have excitations in the fields that are not sufficient to be a particle, but can still interact locally.
KenoFischer··on Why Feynman Diagrams Are So Important
If I remember correctly, there is no way to obtain a gauge invariant discretization if you try to put the gluons at the lattice sites. I can try to find a proper reference.
KenoFischer··on Why Feynman Diagrams Are So Important
Thanks for the correction! I never did any actual Lattice QCD calculations, just looked at the theory, so I was taking a bit of an educated guess on the feasible problem sizes.
KenoFischer··on Why Feynman Diagrams Are So Important
The simulation in question was created using Lattice QCD (which many people in the HPC world mostly know as a benchmark to optimize their compilers/systems on, but it's also a useful physics technique).

Basically what you end up doing is discretizing spacetime on some grid, maybe e.g. 100x100x100x100 (not much larger than that last I checked or the problem becomes intractable even on very large computers) and then sample field configurations monte-carlo style (the way to do it is actually really clever - it turns out that there is a mathematical trick that can take you from the description of your theory right to a distribution from which you can draw your field configurations). The number of fields is decently large (some discretization introduce extra auxiliary fields for every physical one) and in general you need to consider the entire field configuration to compute an observable. Then do that a few billion times (to bring down statistical error) at a couple different lattice spacings (to be able to extrapolate to the continuum limit) and you quickly end up with a very large computations.

There is a number of clever ways to reduce the amount of computation required, but in general it's a very different problem.

Hope that makes some sense. I had looked into this in detail about two years ago, but looking back, I feel like I only know every other word in my write-up ;).

KenoFischer··on APL compiler targeting a typed array intermediate language
It's just a shallow transformation to julia, so it's fast ;). Would be fun to compare with a production quality APL implementation (I hear they have some fancy optimizations that we don't yet have in julia).
KenoFischer··on How a comment on Hacker News led to 4½ new Unicode characters
Ideally yes. I'd have to confirm that this extends to Pizza and Koalas. We fixed that issue as much as we could, even going as far as generating our own unicode width tables extracted from unifont, but it wasn't possible to fix in general without support form the terminals. Now that the standard is fixed (hopefully), I don't see a reason why the terminals wouldn't update their tables.
KenoFischer··on iTerm2 version 3 beta released
Agreed on the shell integration, I had to take it out again because it made switching directories unbearably slow. The inline images however are absolutely magical. See e.g. the screenshot in https://github.com/mbauman/AxisArrays.jl#example-of-currentl...
KenoFischer··on Clojure.spec – Rationale and Overview
Usually I avoid splitting hairs, but since the terminology bikeshed is all about that, let me make a little correction. In julia, there is a data structure called `Expr`, which is what's used internally by the compiler to represent code and is exposed to julia. It's not a list, it's a tree, but the power of being able to access it like any other tree still remains. Of course julia's surface syntax is significantly more complicated than lisp, so macros are more complicated.
KenoFischer··on Stanza: A New Optionally-Typed General Purpose Language from UC Berkeley
Mhm, very sensible choice. We also recently started disallowing `f (x)`, it just ends up causing way more trouble than it's worth.
KenoFischer··on Stanza: A New Optionally-Typed General Purpose Language from UC Berkeley
Hi Patrick, this looks great! I'm glad there are more people exploring this design space. Language design is tough business, but it's also amazingly fun ;).
KenoFischer··on Stanza: A New Optionally-Typed General Purpose Language from UC Berkeley
In julia we switched to making method ambiguities a runtime error because you often end up with situations where even though there are ambiguous methods, you don't ever really want to call them (because they don't make much sense semantically or because they came from different packages, etc). Stanza looks a little more static than julia in this regard, so perhaps they do want to make it a compile-time error (or at least make calling it a compile-time error if types are declared).
KenoFischer··on Giving up on Julia
> Which just sort of makes me bitter you fail to acknowledge the problems.

I'm perfectly happy to acknowledge that there have been conflicts in the community. However, I maintain that the overwhelming majority of interactions in the community are immensely positive. Please do also consider that there may be parts of the story that you are not seeing in the public issues. I do hope you will consider giving the community a second chance. You have quite clearly identified some of the major technical challenges we face and we'd love to hear any ideas you have to address them.

KenoFischer··on Giving up on Julia
Also, I do thank you for taking the time to give feedback.
KenoFischer··on Giving up on Julia
> I remember plenty of cases I got simply from observing the Julia repo for a few months, I could list them if you like... But I've been told by Julia contributors before that discussing this on HN is not an appropriate place. So we can discuss it, where I start linking to public examples on HN, or you can ignore my opinion and we can not discuss it.

I do think HN is not the right forum to link to individual comments and call out people for their behavior. Perfectly happy to discuss the technical issues though. If you would would still like to discuss, or at least bring such instances to my attention, please do feel free to send me an email.

> People who suggest refactoring large sections of Julia's expansive base library (1600 symbols? a problem that causes parts of the slow startup time and memory usage) into other libraries (which would improve batteries included, etc. features) are summarily ignored / shouted down / (predicated on my previous paragraph) banned.

There are several recent examples where people have suggested such things, e.g. They were neither ignored nor shouted down nor banned. https://github.com/JuliaLang/julia/issues/16357 https://github.com/JuliaLang/julia/pull/16070

> Important improvements to the language go in circles on JULEP tagged issues namely any large improvement that would require multiple people and lots of dev work seems to gain little traction unless a core dev just takes the time to do it; rather than a timeline to reach consensus and then design a plan for implementing it.

I don't understand what exactly the criticism is. At first I thought it was about, too much dicussion, but then it seemed to be about too little dev time, please do clarify.

> There was a push to increase test coverage and then a few months later commits plummeted the code coverage numbers and no one seemed to care.

I'm not really sure which instance you're referring to, but last time there was a major drop in coverage, it was investigated, found to be a bug in the instrumentation (which was fixed). I don't really think it's fair to say that people don't care. There's somewhat of a tooling problem here, since we can't run the coverage tests on travis, so we don't get them integrated in the GitHub UI, but people do look at them and add tests as appropriate.

> Sections of important code are uncommented, undocumented, and untested on purpose.

Yes, there are undocumented and uncommented sections in the code base, but I wouldn't say that they are so on purpose. I do admit to having added such hacks in the past (and not documented them because they were gonna go away soon after), because I needed them in outside packages, but people don't let me do that anymore ;).

> Unpredictable un-typed exceptions, namespaces/modules being hard to use for non-trivial designs, interfaces without any sort of type enhancement.

These are fair points, which I'm sure you've seen the issues about. The problem is the availability of developer time, not some sort of unwillingness to fix problems. Putting together the road map of what goes into each release and prioritizing are very hard, because there's just so much that could be worked on.

> setup a transparent community policy and actually follow it;

This is being discussed (as part of larger discussions around community governance) and as I mentioned will likely be a topic at JuliaCon.

KenoFischer··on Giving up on Julia
> I think part of this problem is the community, multiple people have reported having bad interactions with core language devs.

I can only think of a couple of instance where I've heard anything like this.

The first and most prominent is Dan Luu. I'm very sad about losing him from the community. I've met him a couple of times in person, I still read his blog and I very much respect him. I don't think any of us have the full story of what happened there, but I sincerely hope that time may be able to smooth things over.

The second was in an HN comment that I just went back to find, and discovered that is was you. I'm sorry if you had a bad experience with the community. I know my perspective is biased, but I've rarely interacted with a community that's as passionate, helpful and friendly as the julia community (LLVM is up there as well).

As for documenting the process, I agree there could be some improvement there. We do have a contributors guide (CONTRIBUTING.md in the main repository). As for policies for feature inclusion, we've considered having more formal code owners for parts of the code base (right now there's mostly de facto code owners for various parts), but haven't found it necessary so far. I definitely expect some of this to be discussed at JuliaCon in June.

KenoFischer··on Giving up on Julia
We do have various compiler flags, but the problem on startup is the initialization of external libraries and deserialization of the system image, primarily.
KenoFischer··on Giving up on Julia
I just realized that when I said, "this syntax is available", people might have understood it to mean, "you can use this syntax to index arrays" (which is not true for the array type defined in base). What I meant was, "you can define an array type with this indexing behavior without changing the language (since you can override the behavior of both () and [] on a particular type)".
KenoFischer··on Giving up on Julia
This syntax is available in julia as well, but I'm not sure it's a great idea to encourage mixing the two indexing behaviors, even if they have different syntax. As I hinted in the original reply, I have seen very few cases where the choice of index offset actually makes a difference. For example, loops over indices generally use `eachindex` which doesn't care about your choice of index base.
KenoFischer··on Giving up on Julia
I believe that author's point was the size of the resulting generated code, which is fair. The original intent of making it a macro was to get a faster version of printf. However, as it turns out the major time sink in printf is not the formatting, but converting binary into decimal, so specializing on the format string doesn't actually help.
KenoFischer··on Giving up on Julia
Happy to address these points:

  - Startup performance/memory usage
Yes, we are definitely very acutely aware of these. Julia is not currently optimized for frequently run short scripts. That's the price on pays for having to bring up the entire runtime system (initializing the compiler, RNG, external libraries etc). The good news is that there will be a solution to this soon, which is to statically compile your julia program. The area where this really comes up for most people using is package load times. We're very actively working on making that faster.

  - Syntax
A little subjective, so not sure how much I can say here. I can say that I'm not a huge fan of our multi-line comment syntax. It's not entirely clear what a better syntax would be though (the original issue on this had some suggestions, but some of them were worse).

  - One-based indexing
I think there has been plenty said on this topic, though interestingly this is one of the only times I've seen the argument made in a way that I actually agree with. That said, I do think there is an easy way to deal with this though. For packages that needs arrays of indices, it would be quite easy to define an `IndexArray` type that does the translation automatically.

  - String Formatting
Yep, you're right, it's a mess. It'll have to be cleaned up.

  - Unsafe C Interface
There's two projects (Clang.jl and Cxx.jl) which can help with this. The former automatically generates ccall definitions for you, the latter just parses the header and generates the call directly.

  - Slowing down in development
I'm really not sure where that impression comes from. Perhaps it is that we're adding fewer features, but rather working on cleaning up existing features. Also, I personally at least have been doing a lot of work outside of base (particularly on the debugger). Not sure. Would love to know.
KenoFischer··on Homebrew now sends usage information to Google Analytics
Since there is a lot of negative comments here, let me add the counterpoint here that I am totally fine with this. For me, any time saved by enabling you guys to build better software is well worth it. Thanks!
KenoFischer··on Show HN: QBE – a new compiler back end
Depends how much of C++ you need. In full generality you need a C++ compiler in the calling compilation unit (inlining, template instantiation, etc.). The name mangling and ABI itself really isn't that hard.
KenoFischer··on Retro on the Julia Programming Language
I'm glad julia was useful for you guys. Of course huge kudos goes to Miles, Iain and Joey (and the rest of the JuliaOpt folks) for building JuMP. I'm sorry you guys didn't end up being able to use it in production, but I can guarantee you that we (both as the open source community and as Julia Computing) are feverishly working on improving the language and tooling to get ready for a stable release. Thanks for being an early adopter!
KenoFischer··on LLVM based Just-in-Time-Compiler for C++
The instructions in the README should work fine to get it running. Please do let me know if they don't for you. We're planning to make it effortlessly installable with julia 0.5 once that's released, but we're not there yet.
← PreviousPage 14 of 17Next →