[[!meta title="Exploring shared philosophies in Julia and Emacs"]] [[!meta copyright="Copyright © 2024 Gabriele Bozzola"]] [[!inline pages="internal(2024/info/julia-nav)" raw="yes"]] # Exploring shared philosophies in Julia and Emacs Gabriele Bozzola (he/him/his) - GitHub: @sbozzolo Website: LinkedIn: gabrielebozzola [[!inline pages="internal(2024/info/julia-before)" raw="yes"]] While seemingly disparate, the Julia programming language and Emacs share a surprising kinship. This talk delves into the common design principles and philosophies that unite these powerful tools, focusing on their shared emphasis on extensibility, customization, and interactive development. I'll explore how both Julia and Emacs empower users to tailor their experience through powerful metaprogramming and a rich ecosystem of extensions. I'll discuss the REPL-driven workflows that foster exploration and experimentation in both environments. Furthermore, I'll examine how their active and passionate communities drive innovation. # Discussion ## Questions and answers - Q: As someone who uses Julia, Emacs and Julia *in* Emacs, I feel like Julia's integration with Emacs is lacking.  I haven't found any way to debug Julia code that works as well as edebug for elisp, SLY/SLIME for common lisp, or gdb for many other languages (with gud or realgud).  Both Debugger.jl and Infiltrator.jl are difficult to use interactively. Do you have any suggestions for interactive debugging of Julia code in Emacs? (Adding to my question: Do other editors do a better job of interactive Julia debugging?) - A: GB: Debbuger.jl and Infiltrator.jl are the main debugging tools available in Julia at the moment. Both of them are not great (yet) and can use some work. Debugger is going to see major performance improvements in future releases thanks to work in the core language. Unfortunately, I don't see anything better for interactive debugging that is avilable now or in the near future. Most of the julia community is clustered around VS code, but the situation is not better - Q: Can you call out something that Julia has that Emacs does not, and which could benefit Emacs? - A: GB: The Julia community is active and more tightly knit than other communities (e.g., the Python one), JuliaCon is an in-person event that brings people together. Emacs is also doing great in this. - Q: Is there a way to use lisp syntax with Julia, like hy for python or lisp flavoured erlang? - A: Julia used to have a femtolisp interpreter built-into its REPL. - A: GB: I am not aware, but it might be possible to write a package to do that. - Q: Have you tried the Julia Snail package for Emacs?  It tries to be like SLY/SLIME for Common Lisp. - A: GB: Yes, but I settled on julia-repl (with vterm). I didn't test julia-snail too much because I found julia-repl easier to setup and use the way I wished. - Q: Along the same lines as question 1 \-- is there a data inspector for a Julia REPL available that you can use in Emacs? - A: good mode, other good tooling; room for improvement in this area - A: GB: No, I don't think anything of that sort is available  - Q: Have you tried literate programming Julia (using Org babel or some other means) in Emacs? - A: Literate programming in Julia: Pluto (Jupyter-style, in the browser), emacs-jupyter (in Emacs) ## Notes - \ Great, now I wanna learn Julia\... :-) - \ Highly recommend it. Especially if you do any sort of scientific computing. It's an amazing language - \ Lots of things to like. Perhaps the most Dylan-like modern language?  - \ Got me interested in Julia, great talk - \ Sooooo emacs written in julia? - \ Amazing, thank you - \ M-x clap - \ Great talk \[13:10\] - \ Thank you for the talk! \\o/ - \ Thank you! - \ I've been so happy ditching python for julia for all my scientific research needs :) - Some of these features, like the interactivity and the decompiler reminds of Common Lisp - One of Julia's best features (multiple dispatch) was inspired by Common Lisp's defgeneric/defmethod. - I would also add that Julia takes the idea further than Common Lisp ever did, because you can't opt-out of being generic in Julia, so it's everywhere and used pervasively. - In Common Lisp, you had to opt-in, so it wasn't as apparent how powerful this way of organizing code could be. - \ Got me interested in Julia, great talk - \ Sooooo emacs written in julia? - \ akirakyle: First Guile Scheme (re: Robin's talk, next), then Julia! ;-) - \ Yes ;) - \ So julia is like using CLOS everywhere? - \ Sort of, but with the llvm runnig full optimized native code generation for every argument type a function is called with - \ also julia \--lisp is bulit in! - \ emacs-jupyter works with julia quite well btw [[!inline pages="internal(2024/info/julia-after)" raw="yes"]] [[!inline pages="internal(2024/info/julia-nav)" raw="yes"]]