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, the One Programming Language to Rule Them All
There's no need to switch Julia to an AOT model, it suffices to supplement it with one, which is exactly what happens for the Julia standard library on master. It's only a question to extend that capability to packages, which is ongoing work.
KenoFischer··on Try Julia
BTW, the invalid numeric constants thing was fixed

    julia> 55555555555555555555
    55555555555555555555

    julia> typeof(55555555555555555555)
    Int128

    julia> typeof(5555555555555555555555555555555555555555)
    BigInt (constructor with 7 methods)
KenoFischer··on Try Julia
To give some context, several common math constants are use the MathConst type to provide multi-precision constants. This allows e.g. a*pi to be extremely accurate if a is, e.g. a BigInt.

This issue was also reported at https://github.com/JuliaLang/julia/issues/5561

KenoFischer··on Why I'm Betting On Julia
Are you using the IPython protocol for communication with python? If so, extending it to julia should be fairly straight forward.
KenoFischer··on An example of fast numerical computation using Haskell
It's both. Declaring the `::Int64`, doesn't magically turn it into integer division, but it does insert a convert(Int64,...), hence all the speedup here is obtained through type stability, even though the algorithm is still different.
KenoFischer··on An example of fast numerical computation using Haskell
Indeed, the problem here is the type instability in the inner loop. There are a few optimization techniques that we intend to implement to deal with that but as you noticed, we're not quite there yet.
KenoFischer··on An introduction to libuv
And Julia! :)
KenoFischer··on Show HN: Drawingboard.js
I have a Wacom tablet that I routinely use for sketches. The only problem I always have is that most applications have trouble recognizing the eraser tip. I think Wacom has some sort of web plugin that comes with the driver when you install the table. Any chance of adding that style of tablet input?
KenoFischer··on Web development in C: Crazy?
Disclaimer: I'm a Julia core developer

Julia's type system is very similar to Rust's. Julia has composite types, type unions and parametric dependent types. It is certainly designed with technical computing in mind, but that does not at all limit its ability to do general purpose programming and in fact can help significantly in high load situations. I personally have done more general purpose programming in Julia than I have done technical computing (and in fact, it's focus on technical computing was one of the least important reasons when I decided to become one of the Julia core developers). You have a good point that the ability to do easy technical computing certainly will influence the initial audience, but, I think, as the language matures, this will shift towards a more general audience.

KenoFischer··on Julia introspects: see the AST, LLVM IR, and native assembly for any function
Such a tool has been written and I've been trying to convince the author to open source it, but if that doesn't work out I might have a go at it myself. We can already look at the LLVM-level calling graph since llvm includes functionality to output GraphViz dot code.
KenoFischer··on Julia introspects: see the AST, LLVM IR, and native assembly for any function
Mostly vim, emacs and sublime (there's plugins for all of those). The folks at forio have also started an IDE for Julia, but last I looked they didn't have much more than an editor (and their website hasn't been updated in a couple months, so I'm not sure what the status is).
KenoFischer··on Julia introspects: see the AST, LLVM IR, and native assembly for any function
The parser and AST lowering is written in scheme. I can't really comment on all the design decisions involved, since I joined the project at a later stage, but personally I'm rather happy with it and I think especially people new to programming have an easier time with a syntax like this than with S-expressions.
KenoFischer··on Julia introspects: see the AST, LLVM IR, and native assembly for any function
Yes, certainly, our current REPL is somewhat inflexible, but the (fully functional, but not something we want to drop in last minute - probably next release cycle) version of the REPL in the REPL.jl package as well as the IJulia Notebook already do some of this for e.g. completion of fields of a composite type.

If you're interested you can see the code for that completer here: https://github.com/loladiro/REPLCompletions.jl/blob/master/s...

KenoFischer··on Julia introspects: see the AST, LLVM IR, and native assembly for any function
We're currently working on documentation. I assume you're talking about the reflection section? There's issue https://github.com/JuliaLang/julia/issues/2886 open about that and it will probably be addressed by the end of the week (since it's tagged for 0.2).
KenoFischer··on Metaprogramming – Julia Language
All toplevel expressions are evaluated within a module which is a first class object. Other than that you always need to place the expression into its environment (to construct top-level expressions). If you just place macros the environment is not accessible (i.e. macros operate solely on their arguments), however, you can distinguish whether a symbol will be evaluated within the defining scope (of the macro) or the scope in which it is used.

Regarding types, all expressions are of type Expr or Symbol (there's a few other things that can be in the AST, but that's mostly it). What kind of expression it is is determined by the head field. There as some discussion about making the Expr type parametric on its head field so you can dispatch on that, but nothing in that direction recently.

KenoFischer··on The Quantum Zeno Effect actually does stop the world
The problem with Quantum Physics (well, physics in general, but in classical physics it's mostly ignored) is that in order to make a measurement, you need to interact with the system thus changing it's state. You might for example measure perturbations in an electric field, but by applying the electric field you influenced the state of the system. This is also an important part of say the uncertainty principle. One way to think about why you can't measure position and momentum simultaneously to infinite accuracy is that perfect measurement of one would require shooting it with photons of zero momentum, while perfect measurement of the other would require shooting it with photons of infinite momentum. The real fun comes in when you leave a system alone for a while because then everything becomes probabilistic.
KenoFischer··on Clay – A language designed for generic programming
Note that this does work just fine in Julia however since tuples are first class objects ;)
KenoFischer··on LLVM Intermediate Representation is better than assembly
No, every LLVM frontend (e.g. Clang) has to do so all the time for things to work.
KenoFischer··on Dance in a Year
I can only agree with this post. When I got to college, I somehow ended up signing up for the Ballroom Dance Team (yes there is such a thing as competitive ballroom dancing). It's not something that I would have ever dreamt I would end up doing and people that know me usually have a hard time believing that I do ballroom. Nevertheless, it has been the single most fun activity I've ever participated in and it is a great way to get my mind off work.
KenoFischer··on Plotly graphing API for Python, Matlab, R, and Arduino
If you guys need help with that, do email julia-dev.
KenoFischer··on Rarely Asked Questions
> TIL Julia is a skin on Lisp.

It actually is more so than you might imagine. If you have julia installed try `julia --lisp` ;).

KenoFischer··on Julia webstack
Yes, that is possible as well. I don't think it's all factored out into a nice Python package yet, but the code to do so is part of the julia-ipython repo.
KenoFischer··on Julia webstack
Disclaimer: I'm one of the core devs.

You can call Python from Julia now: https://github.com/stevengj/PyCall.jl

And there is also an effort underway to get iPython notebook integration (we met with Fernando Perez when he was in Boston to receive his award from the FSF and spent an afternoon hacking to get to this https://github.com/JuliaLang/julia-ipython - it's still in the very early stages of development though)

KenoFischer··on Comparison of Matlab, R, and Julia for data analysis (2012)
There's a growing number of packages written in Julia (http://docs.julialang.org/en/latest/packages/packagelist/) and using the PyCall package you can call any python package if you're missing functionality. Do have a look to see if what you need is implemented. Other than that porting existing MATLAB code is extremely easy since the syntax is similar in many cases.

Disclaimer: I'm one of the core devs.

KenoFischer··on Julia, I love you (2012)
Have you looked at the various statistics-related packages? We moved most of the statistics stuff (and may other areas as well) into packages.
KenoFischer··on Julia, I love you (2012)
Well, if you're feeling really sadistic

    baremodule MyWay
    ref(x::AbstractArray, i::Int) = Base.ref(x,i+1)
    ref(args...) = Base.ref(args...)
    end
is not that far away (I'm oversimplifying a little, but not much). However, please don't do this as it breaks coherence within the community. I found 1-based indexes annoying at first, but have grown quite fond of them since.
← PreviousPage 17 of 17