Skip to content
0:00 / 0:00

#julia#lisp#macros

Julia: to Lisp or not to Lisp?

European Lisp Symposium

1.8K subscribers • 4 videos on Hallway

YouTube
  • Recommended by 4 people: 4 on Hacker News.
  • A classic. People kept recommending it from 2016 to 2022.
  • Presented by Stefan Karpinski, Julia Computing and NYU

Advanced. Deep dive for people who know the field.

23K views10 years ago4 recommendations

Programming languagesSoftware designLanguage design and type systemsFunctional programmingCompilers and interpreters

Stefan Karpinski explores the Lisp-like design choices in Julia, including macros, homoiconicity, and multiple dispatch, alongside its departures like syntax and type analysis.

ELS 2016, 9th European Lisp Symposium, 9-10 May 2016, Department of Computer Science, AGH University of Science and Technology, Kraków, Poland. Stefan Karpinski, Julia Computing and New York University, New York, USA. Julia is a general purpose dynamic language, designed to make numerical computing fast and convenient. Many aspects of Julia should be quite familiar since they are "stolen" straight from Lisp: it’s expression-oriented, lexically scoped, has closures, coroutines, and macros that operate on code as data. But Julia departs from the Lisp tradition in other ways. Julia has syntax – lots of it. Macro invocations look different than function calls. Some dynamic behaviors are sacrificed to make programs easier to analyze (for both humans and compilers), especially where it allows simpler, more reliable program optimization. Julia’s most distinctive feature is its emphasis on creating lightweight types and defining their behavior in terms of generic functions. While many Lisps support multiple dispatch as an opt-in feature, in Julia all function are generic by default. Even basic operators like ‘+‘ are generic, and primitive types like ‘Int‘ and ‘Float64‘ are defined in the standard library, and their behavior is specified via multiple dispatch. A combination of aggressive method specialization, inlining and data-flow-based type inference, allow these layers of abstraction and dispatch to be eliminated when it counts – Julia generally has performance comparable to static languages. In the tradition of the great Lisp hackers, this talk will include lots of live coding in the REPL, with all the excitement, and possibility of failure entailed.

Why it's here

4 people recommend this

What people say. Recommended as an illuminating talk on Julia's design, language design tradeoffs, and how it generates optimized machine code.

Flowon Hacker News • Recommends

On “European Lisp Symposium 2016”

Ah, the Julia talk ( link to this video ) was just great. Showing the generated machine code is so hackerish yet so rare these days. :-/

e12eon Hacker News • Recommends

On “Nim Programming Language 0.14.0 released”

This reminded me of the recent brilliant talk about design of Julia: "Julia: to lisp or not to lisp?" link to this video

krzychukulaon Hacker News • Recommends

On “European Lisp Symposium 2016”

Best talks in my opinion: * link * link to this video Notable mentions: * link * link * link I liked OpenGL lightning talk as well: * link

e12eon Hacker News • Recommends

On “Why is Python slow”

…lied that it is the boxing of the numbers, which requires allocations for creating objects. Though an audience member did point out with a chuckle that you can increase the number of iterations and Python will still give the right answer, while JavaScript will not." Reminded me about the excellent talk about Julia: "Julia: to Lisp or not to Lisp?" link to this video One things he points out early is that both the C99 and the R6RS Scheme spec is 20% numerical. Because correct and (reasonably) fast numbers and arithmetic is actually pretty hard to get right on a computer - if you want to abstract away hardware "short-cuts" and allow for precise arithmetic by default. It will be interesting to see how muc…

e12eon Hacker News • Recommends

On “A Look at How Traders and Economists Are Using the Julia Programming Language”

Speaking of talks on Julia, I'll again recommend: link to this video "Julia: to Lisp or not to Lisp?" from the European Lisp Symposium in May 2016. I found it was rather illuminating on Julia in particular and lisps and programming languages in general.

e12eon Hacker News • Recommends

On “Some fun with π in Julia”

I'm not sure if "special language" is a particularly apt description of what Julia is. SQL is a "special" language. At any rate - a lisp-like language with llvm backend, package manager, and a (small, but not trivial) group of users writing real software - what's not to like? I (still) recommend the talk: "Julia - to lisp or not to lisp?", that gives a quick overview of some of the design choices: link to this video For me, I like that it has a real story trying to balance "actual integer math" (not this silly machine constrained twos-compliment hack" and "you could conceivably write a ray tracer that wasn't unusably slow" :)

e12eon Hacker News • Recommends

On “Common Lisp homepage”

You might also want to have a look at Julia. It's not really a lisp, but it sits on top of a scheme - and it has a rather interesting, pragmatic type system: "Julia: to lisp or not to lisp?": link to this video link Maybe compare and contrast with Maxima?: link

e12eon Hacker News • Recommends

On “Chicken Scheme 5.0”

I'm a great admirer of Julia, but I doubt it would appeal to those seeking a "true" lisp/scheme. Even if it's has a sane macro system, and much of the same power. You can indeed see s-expressions (search for "s-expression") : link This nice talk mentions a bit on how Julia is (not) a lisp (if I recall correctly): "Julia: to Lisp or not to Lisp?": link to this video This might also be of interest: link As well as (maybe) clasp: link

travisdon Hacker News • Recommends

On “From Common Lisp to Julia”

Stefan Karpinski (one of the core Julia contributors) gave a talk (in 2016, so rather dated as far as the Julia syntax and whatnot go) about how Julia is secretly more lisp-y than even lisp & Scheme. The core of this argument is that most language specifications dedicate many pages to defining how arithmetic works, whereas Julia is actually just able to define that in Julia code as part of the stdlib (the implementation just calls out to LLVM intrinsics, but nonetheless, super neat!). `Int64` is actually defined in a Julia file. link to this video

e12eon Hacker News • Mentions

On “Back to the Future: Lisp as a Base for a Statistical Computing System [pdf]”

My initial thought was that this was about a project building atop of clasp, like CANDO: link link link But this does seem a bit more like Julia? "Julia: to Lisp or not to Lisp?" link to this video Then there's also the Axiom system, which I guess is primarily for symbolic computation, but I don't know if it might make sense to use it as a building block for statistical software? link

steveloshon Hacker News • Mentions

On “Some Insights from a Julia Developer”

> Actually, in general Julia is surprisingly Lispy for a language with Algol-family syntax. It's less surprising if you know there's still a version of the Julia REPL that works with sexpressions: link to this video

e12eon Hacker News • Mentions

On “A Lisp that runs Python (2016)”

> ... a relatively fast functional language that replaces most of the brackets with indentation. You might like sweet expressions coupled with a common lisp, a scheme or racket: link link ... Or perhaps have a look at Julia: link "Julia - to Lisp or not to Lisp": link to this video ed: and as mentioned below, there's also wisp: [link ]

fault1on Hacker News • Mentions

On “PyTorch: Where we are headed and why it looks a lot like Julia (but not exactly)”

Personally, I think when you write Julia in shorthand form, it looks nothing like ruby or basic. for example, check out parts of the stdlib: link but in the end, julia really is a lisp: link to this video