|
|
[[!meta title="Exploring shared philosophies in Julia and Emacs"]]
[[!meta copyright="Copyright © 2024 Gabriele Bozzola"]]
[[!inline pages="internal(2024/info/julia-nav)" raw="yes"]]
<!-- Initially generated with emacsconf-publish-talk-page and then left alone for manual editing -->
<!-- You can manually edit this file to update the abstract, add links, etc. --->
# Exploring shared philosophies in Julia and Emacs
Gabriele Bozzola (he/him/his) - GitHub: @sbozzolo Website: <https://sbozzolo.github.io> 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
- \<martinl\> Great, now I wanna learn Julia\... :-)
- \<vidianos\> Highly recommend it. Especially if you do any sort
of scientific computing. It's an amazing language
- \<sctb\> Lots of things to like. Perhaps the most Dylan-like modern
language?
- \<gs-101\> Got me interested in Julia, great talk
- \<akirakyle\> Sooooo emacs written in julia?
- \<xlarsx\`\> Amazing, thank you
- \<mretka\> M-x clap
- \<vidianos\> Great talk \[13:10\]
- \<mretka\> Thank you for the talk! \\o/
- \<martinl\> Thank you!
- \<akirakyle\> 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.
- \<gs-101\> Got me interested in Julia, great talk
- \<akirakyle\> Sooooo emacs written in julia?
- \<martinl\> akirakyle: First Guile Scheme (re: Robin's talk, next),
then Julia! ;-)
- \<akirakyle\> Yes ;)
- \<jkm\> So julia is like using CLOS everywhere?
- \<akirakyle\> Sort of, but with the llvm runnig full optimized
native code generation for every argument type a function is called
with
- \<akirakyle\> also julia \--lisp is bulit in!
- \<akirakyle\> 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"]]
|
