Keynote. Professor Steven G. Johnson | JuliaCon 2019
Keynote. Professor Steven G. Johnson | JuliaCon 2019 on HackerTube: recommended by 2 Hacker News commenters across 2 separate months, 2019–2022.
Steven G. Johnson, MIT professor and FFTW co-author, gives a JuliaCon 2019 keynote on metaprogramming and staged programming in Julia, showing how it enables high-performance numerical code and when not to use macros.
What HN commenters said
7 Hacker News comments link this video. Each one links back to its thread.
eigenspaceAug 2019Strongly recommends
If anyone is looking for video recommendations to get started: here’s a couple that I thought were great and should be interesting and approachable to just about anyone. Steven G. Johnson’s keynote address. It’s longer format but really interesting, informative, entertaining and well delivered. The main topic is metaprogramming. ▶ this video Stefan Karpinski’s talk on the unreasonable effectiveness of multiple dispatch. He discusses the fact that Julia has such dramatic code re-use and sharing between libraries and he discusses some reasons why he thinks multiple dispatch is uniquely able to offer this. [link]
in “JuliaCon 2019 Videos” · View on HN
ViralBShahOct 2020Recommends
You can write slow programs in all languages. There are many cases where Julia's language features enable higher performance than in comparable C libraries. Have a look at Steve Johnson's keynote from JuliaCon 2019: ▶ this video
in “CSV Reader Benchmarks: Julia Reads CSVs 10-20x Faster than Python and R” · View on HN
mwattsunJan 2022Cites it
When I first started writing asm code, it was accepted to write self-modifying code (programmatically create new code, then jmp to it.) Then I discovered and was told it was a bad idea. So that's how I view Lisp macros - creating code on the fly and executing it. When I was studying this issue, I came across femtolisp, which is a standalone Lisp by the author of Julia, Jeff Bezanson. Julia has metaprogramming so I wanted to look at it. In this video [1] Professor Steve G. Johnson explains metaprogramming (around 10 min mark) and says "most of the time, don't do metaprogramming." He points out in the base Julia there are 36,798 methods, but only 138 macros and 14 generated functions (.04% of the code), so I have the impression it is still frowned upon. [1] ▶ this video
in “Understanding the Power of Lisp (2020)” · View on HN
IlyaOrsonJan 2022Cites it
It is not necessarily better in all cases and should not be overused: ▶ this video However, it is useful to provide a nicer syntax and DSLs. Some examples: [link] [link] [link]
in “Julia Macros for Beginners” · View on HN
miguelrazJun 2021Cites it
What is the focus on numerical computing that you think Julia is missing? The ecosystem seems plenty healthy to me. (Maybe PDEs... but those are so close!) It's not uncommon for good Julia codes to smoke Fortran codebases, like the DiffEq verse or with staged programming, see Steven G. Johnson's keynote at JuliaCon 2019: ▶ this video
in “From Julia to Rust” · View on HN
neologJun 2021Cites it
Julia is great for numerical computing, but it's not as good as it can be, even in that area. Widening the community's base of expertise will help. I'll just list a few things that come to mind. Many Base functions are currently untyped, which means it's hard to abstract out the key properties that enable reuse, compiler optimizations, and parallelism. See [0] for a language expert's take on numerical computing, which involves defining traits like associativity that enable automatic parallelism by default. A stronger culture of functional programming could make your code faster and easier to understand. It's often (though not always) easier for tooling to optimize pure functions over immutable data structures (and arrays). Arrays are currently mutable, and there is too much emphasis on mutating functions. The iteration protocol can be made more memory-efficient for large collections and simpler, following Rust's implementation [1]. Macros are useful for high-performance computing [4], and Julia's macros can be made more composable [2]. In general, systems languages don't make language decisions lightly. They have committees, discuss how other languages do things, make proposals. This allows more perspectives on each decision. That would be an improvement over the more ad-hoc style of Julia development, as long as Julia can avoid adding every possible feature, which is a risk of expanding the decision-making body [3]. [0] [link] [1] [link] [2] [link] [3] [link] [4] ▶ this video
in “From Julia to Rust” · View on HN
Show 1 more comment
montalbanoOct 2020Cites it
Agree, but to add, there are many transcendental functions (e.g. I needed to use the Mittag-Leffler function many times in my work) which are near-impossible to implement in Numpy in a way that gives anywhere near usable performance. It's not a common enough function to be pre-implemented in Scipy special functions. In my case, I wrote the algorithm in Numpy/python myself which was almost unusably slow. I then outsourced it to a precompiled fortran program. Finally I just switched to Julia. There was already a library, MittagLeffler.jl which did everything I needed and was written in pure Julia. In the end everything was much faster than the Python/Fortran frankenstein code I had. Edit: For more info on Julia and difficult (computationally) mathematical functions see: ▶ this video
in “CSV Reader Benchmarks: Julia Reads CSVs 10-20x Faster than Python and R” · View on HN