Cassette.jl

clude debugger interupts. This stuff also has a bunch of use for probabalistic programming languages etc. The thing is Cassette and IRTools implement this at the lowered code level. It runs on the SSA-form IR. This IR was never really designed for the user to write it. Though IRTools does a noble attempt to make it nice. Arborist instead runs at the Abstract Syntax Tree (AST) level. Just like macros. This is designed to be written and manipulated by users. Users do that all the time by writing macros. I haven't touched it in a while (apparently 2 years). Largely because AFAICT it's not useful outside of pedagogical purposes. AST is not actually that nice for any program tranforms i want to do, since there are so many ways to write the same thing. E.g. different kinds of loops and branches, where as in SSA form IR they all look the same. Probably could be made to work, but i just don't really have a usecase that I can't do easier on IR. (probably people who haven't been deep into IR on the other hand would think of some) There are a bunch of edge cases where it crashes still, for things that are not allowed to appear in generated code. It wouldn't be too hard to make it work though, not really. Particularly since we now have tools like https://github.com/SciML/RuntimeGeneratedFunctions.jl https://github.com/JuliaStaging/GeneralizedGenerated.jl

nctions, image processing libraries, special number types (mpmath), domain-specific libraries)". A julia library does not need to know of Zygote.jl to be autodifferentiable. A python library needs to be pure-python numpy-based library to work with jax. In order to try to contribute to the discussion: I think this paper describes relatively well what is so special about the Julia autodiff tools: https://arxiv.org/abs/1810.07951 For a separate approach, which is also very original, check out https://github.com/jrevels/Cassette.jl

multiple dispatch mean you only need one set of functions, and using an @generated function will generate whatever kernels you happen to need at compile time. Looking into the future, awesome projects like Cassete speak to the potential of what's possible: https://github.com/jrevels/Cassette.jl Cassete promises to let you do anything from getting automatic differentiation for arbitrary Julia code, even if it is strictly typed and buried in a chain of dependencies of the library you're using and written by someone who never imagined the idea of autodiff, to injecting custom compiler passes. Also, while I haven't tried it yet, many seem to like: https://github.com/timholy/Rebugger.jl Julia is more promise than practice right now, but that's largely because of just how much it promises. I (and many others) think it has done a great job delivering so far. That's why there's excitement, and why many are starting to embrace it.

g does not depend on a particular type system or whether the language is dynamic or static. There are only so many good ideas in programming languages and this is one of them. Though there is some overlap between pattern matching and multiple dispatch, the roles are different. The purpose of multiple dispatch is extensibility, but the purpose of pattern matching is destructuring. https://stackoverflow.com/questions/2502354/what-is-pattern-... Note the great disparity in the F# examples that do pattern matching and the C# examples that do manual reflection. https://github.com/mrakgr/The-Spiral-Language/blob/0741959ac... Here are a few very simple examples of it in action in Spiral. I use them as compiler tests. https://github.com/mrakgr/The-Spiral-Language/blob/0741959ac... Here is quite a complex example of how it is used in action. I won't go into detail of this here, but you can see how I repeatedly match on the contents of a module at different times in order to get more generic functionality for the kernel. The particular kernel shown here is the most complex one that exists in the library right now - I am yet to get to things like generic matrix multiplication and convolution, but I'll get there eventually. > I see how it sounds nice, but I can't really imagine right now how it would improve my life. Let me just say that it is really difficult to know ahead of time how a particular language feature would affect your programming life. I could have said the same thing about first class functions back in 2015. I am sure in the future there will be such features I can't even imagine right now. > And if we don't get it as part of the compiler, we can definitely do things like that with https://github.com/jrevels/Cassette.jl/ I'll have to watch the talk on this. Thanks for the link.

we needed more than that, we could put the effort into extending the language into that direction. But I think your use cases must get be pretty advanced untill you need something more complex. Can you recommend a nice article that shows off beautiful pattern matching for reflection? I see how it sounds nice, but I can't really imagine right now how it would improve my life. Concerning inlining, I do think we actually force codegen to always inline when compiling for the GPU. I don't remember a 100% anymore, but there might have been some problems with that. But it's definitely the goal, to have a flexible compiler that you can fine tune to specific domains like GPU programming. And if we don't get it as part of the compiler, we can definitely do things like that with https://github.com/jrevels/Cassette.jl/ Appart from that, I'm pretty happy that our GPU compilation infrastructure isn't making Julia less useful as a general purpose language ;) >Is it fully integrated or is it a wrapper style memory management? It's wrapper style. We're playing around with different kind of hacks to make it less worse, but those are hacks you could do in any GC language. The good news is, that the Julia compiler devs take GPU computing seriously and promised to work on a full integration that is aware of the GPU hardware.