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 Julia Computing Granted $600k by Moore Foundation
Well, last time I posted something like this I think I made it sound way too narrow, so I'm trying overly broad this time, to get people who are interested to get in touch, because even if we don't have anything for them at this very moment, we might in the near future.

To narrow down, what we're looking for in the immediate future, anybody with interest in core language development, compilers, tool chain support, etc. Additionally, we will probably be hiring for our applications development team very soon, so if you're interested in data science, stats, etc. and like working with people on solving their challenging problems, please do reach out as well.

KenoFischer··on Julia Computing Granted $600k by Moore Foundation
It seems like I should mention that we (Julia Computing) are actively hiring. If you think what we're doing is interesting and would like to join in, please do reach out!
KenoFischer··on Julia Computing Granted $600k by Moore Foundation
I was talking to the WebAsm folks at LLVM Dev a couple of weeks ago and the conclusion was that WebAsm does not yet seem ready to be targeted by us (in particular we would like run-time code loading support for the JIT), but may be there in a year or two.
KenoFischer··on The Big Bang project aims to create a typed language with the feel of scripting
Yes, that's the standard approach, but I was wondering how that meshed with not having to declare types (maybe the answer is just, that's the one place where you have to - or that's disallowed), but I was curious.
KenoFischer··on The Big Bang project aims to create a typed language with the feel of scripting
How do you handle, say deserialization of objects over a network (to give the canonical non-trivial example)?
KenoFischer··on Julia's Arraypocalypse Release
I'm really glad to hear this! I'd like to think that the community and inspectability argument for Julia is actually one of the strongest ones out there, but it's not easy convincing people who haven't had that experience.
KenoFischer··on Ask HN: Who is hiring? (July 2015)
Thanks, it's a thrill to be able to do this!
KenoFischer··on John Carmack working on Scheme as a VR scripting language
No need, Julia comes with a builtin lisp.
KenoFischer··on Ask HN: Who is hiring? (July 2015)
Julia Computing Inc [http://juliacomputing.com] | Cambridge, MA

Julia Computing Inc. is looking for an LLVM engineer to work on LLVM, LLDB and Clang to improve integration with the Julia programming language. Knowledge of Julia is not required, but deep knowledge of LLVM is. This position will involve significant contributions back to the open source to both the LLVM and Julia projects.

Immediate high-priority projects

    - LLVM’s JIT debugging and debug info
    - LLVM’s JIT threading support
    - Julia’s Clang-based C++ FFI – Cxx.jl
    - Julia’s (experimental) LLDB-based debugger
On-going responsibilities and longer-term projects

    - Working with Julia code gen experts to improve Julia’s generation of LLVM IR
    - Fixing LLVM bugs encountered by Julia (we use LLVM hard, so this happens a fair bit)
    - Tuning LLVM optimizations for Julia’s usage patterns (which differ somewhat from C/C++)
    - Porting Julia to new architectures by adding/enhancing LLVM backends.
    architecture of interest include ARM, Xeon Phi (Knight’s Landing), GPUs
    - Improving any relevant LLVM tooling
Both full-time employment and short-term consulting opportunities are available. This advertisement is for our Boston (Cambridge), MA, USA office and being local is ideal, but REMOTE engineers will also be considered. Applicants should possess demonstrable experience working in the LLVM ecosystem.

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

About Julia Computing

Julia Computing was founded by the creators of Julia in response to industry demand for professional support, consulting and training. As part of our mission to make Julia the best technical computing platform in the world, we’re pushing the boundaries of what can be done with tools like LLVM. Julia Computing has offices in Boston, New York and Bangalore.

KenoFischer··on Is there such a thing as half a derivative?
In quantum field theory you frequently do integrals in 4-ϵ as a way of regularizing divergent integrals.
KenoFischer··on Why the creators of Julia just launched a startup
Could you give an example of what you were missing?
KenoFischer··on Show HN: A tool that transforms your whole list with just one example
I tried a list of unicode characters and their codepoint numbers, but it doesn't seem to recognize the unicode characters probably. Perhaps a normalization issue?
KenoFischer··on Doctor Fortran in “The Future of Fortran”
So do Fortran and C. BLAS is written in assembly.
KenoFischer··on Conception – An experimental modern IDE written in Go
I like it! I've been thinking a lot about user interfaces for creating programs and gaining insight into execution lately, so I'm really glad to have seen this. From the demo video, it looked a little cumbersome to move everything around and it seems like your workbench can get disorganized quickly. Have you experimented with layouting at all? Also does it actually feel cumbersome in practice, or is that a misconception from just watching the video? Anyway, great effort. Looking forward to see this develop.
KenoFischer··on Announcing Rust 1.0 Alpha
Congratulations to the rust team! Committing to 1.0 is a scary step :).
KenoFischer··on Why String Theory Still Offers Hope We Can Unify Physics
You should probably have at least a good understanding of non-relativistic QM and special relativity. For the math parts a little bit of complex analysis helps, but any good book will explain the relevant parts.
KenoFischer··on Why String Theory Still Offers Hope We Can Unify Physics
Weinberg is pretty good. I also like Schwartz's new book, though I'm biased because I took his QFT class. The other book I really like is Peskin and Schroeder.
KenoFischer··on EC key generation is broken in all OpenSSL versions
If I'm reading this correctly it's only an encoding problem (which seems better than generating weak keys, etc.)? What are the security implications?
KenoFischer··on Julia is awesome, but..
Since I can't edit anymore, Dan pointed out to me that he did not include development branches in his Travis analysis.
KenoFischer··on Julia is awesome, but..
Even though there parent misspoke here, there's https://github.com/aviks/JavaCall.jl for interfacing with the JVM, though of course that's more the reverse.
KenoFischer··on Julia is awesome, but..
This is very fair criticism. Julia has yet to make the full transition from research project to production language. Having seen Julia evolve over the past 2+ years, I feel like stability and test coverage have improved a lot and I expect them to improve further.

I fully agree on the need for more testing. We've been trying to make sure that new functionality and all issues reported come with tests where possible and I actually think we've been making progress on that front (and especially compared to two years ago), but we need to do a lot more of this. For a significant number of the core contributors (myself included), Julia is probably the first big project we're working on and we're still learning proper release engineering and making software for a large number of users.

That said, I think we've been pretty good about keeping master functional recently and I don't remember the last time I pulled from master and had something break (I think the travis status analysis is misleading here, because it probably includes development branches as well as instances where the CI system itself is failing - either because travis is down, or because the servers for dependencies are down etc). I also don't think that we've ever left master broken for days at a time when there was an easy fix available (of course bugs that come up and you don't know how to fix can always happen).

On that topic though, I think we have room for improvement. I've been thinking about moving to a pre-commit CI system (you push to a branch and the CI system merges once everything's green), especially now that we have CI coverage for all 3 supported platforms. I'll bring that up on the mailing list.

So much for the Julia core. Packages are a different issue and I agree that we have a problem with package quality. That are a few very high quality packages (I'm thinking e.g. Color and Distributions) and a long tail of packages of varying quality. Iain has been doing great work on this front with http://pkg.julialang.org/pulse.html and making sure that packages keep up with changes in julia and at least pass their own test suite, but there's obviously a lot of work to be done there.

The good thing is though that since these packages are completely decoupled from Julia core, this can be easily parallelized. One of the advantages of Julia is that the core is pretty small (admittedly bigger now than it should be and we need to split some stuff out) and it's in general pretty easy to look at the code which hopefully makes it easy hack on packages. Making high quality packages requires a lot of time and work and since Julia is such a young language, the ecosystem is still immature.

If you have thoughts on what we can do to improve package quality or make things easier on package developers, please let us know, we'd love to hear them.

Finally, I also would like to ask to please, please file bug reports for things that don't work the way you expect them to or for any bugs you encounter. One of the things mentioned in the OP was the REPL rewrite (which I worked on). The original REPL was a messy readline based hack, which really needed to be replaced. Admittedly, readline has a lot of features and I originally only implemented the ones that were part of my workflow, but I fully expected people to file issues for any features they were missing (and they did) and I and others quickly implemented lots of features (including quite a number not present in the original rewrite). Of the REPL issues currently open, I can see only one that may have worked with the original REPL (emacs keybindings). In any case, if you're missing features in the REPL please file an issue.

I'll end with my general disclaimer that while Julia has a lot to offer, it is not yet a polished system and I don't yet recommend using it if that's the experience you want.

Sorry for making this so long

TL;DR I agree, Base needs more testing, but I think we've been making progress on that. Another big issue is package quality, which I'm not sure how to fix. If you encounter bugs please file issues.

KenoFischer··on “I am not authorizing you to release a Ruby port of Metaphone 3”
This is an interesting question. I was at a talk at this years's GsoC summit where this was discussed and indeed, the language of the BSD license does not issue an `irrevocable` license as the language of a lot of other licenses does. Nobody has every tried revoking an MIT or BSD license before, but it would be an interesting legal argument to see if the courts would allow it.
KenoFischer··on JuliaCon 2014 Opening Session Presentations
Note that these are just the first three videos. As I understand the rest of the videos are being edited and uploaded right now.
KenoFischer··on This is a motherfucking website. And it’s fucking not completely perfect
Not exactly true. The standard library is precompiled and the same is worked on for packages.
KenoFischer··on Scientific computing’s future: Can Haskell, Clojure, or Julia top Fortran?
Ok, looking at the code is seems like you could probably get another 2x by switching to views rather than slices which will be the default sometime in the julia 0.4 timeframe. That would probably put julia perforamance at 1.2-1.5x Fortran, which while there of course is always more optimizations to be done is at least pretty good.
KenoFischer··on Scientific computing’s future: Can Haskell, Clojure, or Julia top Fortran?
> Julia appears to be to slow for a lot of large real-world uses

I'm curious what kind of application you are referring to and where you get that impression. We are always looking for examples where we don't get good performance, so we can optimize, so I'd love to hear your experiences.

KenoFischer··on JuliaCon, first-ever conference for the Julia language
I am certainly excited. I think this will be a fantastic event.
KenoFischer··on Efficient Aggregates in Julia
Note that this is a year old. Not that that makes it any less accurate.
KenoFischer··on Julia, the One Programming Language to Rule Them All
Yes, actually, this is quite easy. Basically the I/O model uses cooperative coroutines. For TLS, you'll want to look at https://github.com/loladiro/GnuTLS.jl. Then, after setting up the stream with the underlying socket, protocol information, etc. (see the README for how to specify this), you can just use it as any other IO stream...

    # Set up stream `sock` here
    @async begin
        println(sock,"Hello World")
        line = readline(sock)
        println(sock,"You typed ",line)
    end
Basically the encryption happens on the fly and the stream can be used just like any other socket. For example, in the http client code here: https://github.com/loladiro/Requests.jl/blob/master/src/Requ..., the only difference between HTTP and HTTPS is how the socket is set up, the actual reading and writing is the same. Hope that helps!
KenoFischer··on Julia, the One Programming Language to Rule Them All
This is basically what I meant. Julia doesn't really have a bytecode. There is a lower, type-inferred form of the AST as well as the llvm IR representation. However, instruction selection itself takes quite a bit of time, so if we're caching the IR, we might as well cache the generated machine code (the challenges are basically the same). As I said, it's work-in-progress (it's not that it's hard or anything, but it's a bit of work do it properly, which isn't done yet).
← PreviousPage 16 of 17Next →