Kodsnack 80 - Where numbers don't have to be special anymore

We chat with Stefan Karpinski, creator of the Julia programming language, live on stage during Øredev 2014. Topics include defiding to build a new language, the interesting unsolved problems of numerical computing, concurrency solutions, developing with and on LLVM, handling deprecation nicely, things (possibly) in the future for Julia and why Swift is exciting for Julia and other languages.

This recording exists as good as it is thanks to Stephen Chin of nighthacking.com for providing and masterfully wrangling all the necessary technology.

There is a minute and a half of worse audio quality just after the nine minute mark, where microphone problems forced us to fill in with audio from our backup microphone.

Comments, thoughts or suggestions? Discuss this episode at Techworld!

Stefan Karpinski
Julia programming language
Scientific computing
Viral Shah
Jeff Bezanson
MATLAB
R programming language
Python
C extension
Goldilocks
Goldilocks principle
Dylan
Garbage collection
Unboxed data
Complex number
Julia Webstack
Numerical computing
Concurrency
Distributed computing
Threading
Julia on Github
Transactional memory
Goroutine
Coroutine
Channel
I/O
LLVM
IFDEF
JIT - just-in-time (compilation, in this case)
Shared library
libclang - C Interface to Clang
Template instantiation
Quake2.jl
Go
Hacker school
Matrix multiplication
Vectorization
Generational incremental garbage collection
SNOBOL
SPITBOL
Icon
Perl 4
C99 standard
Immutable composite types
Multiple dispatch
Monkey patch
radd-trick in Python
Common Lisp
CLOS - Common Lisp object system
Polymorphism
Self
BLAS - Basic linear algebra subroutines
Fast fourier transform
Gofix
Tracing
Static compilation
MIT - Massachusetts institute of technology
Courses taught using Julia
Function pointer
Scipy
Steven Johnson
FFTW
Pycall package for Julia
Call stack
GDB
LLDB
ABI - application binary interface
Clang
Rust programming language
Swift
Chris Lattner - creator of LLVM and Swift
WebKit FTL JIT - compiles Javascript using LLVM
Shadow stack
‎Dynamic stack frame deoptimization
MATLAB matrix concatenation syntax

Titles

Some of the interesting tradeoffs
Bridge that gap between high-level and low-level
A huge pointer graph of some kind
It’s good to have a focus, initially
The point where we’re pushing things
The classic tradition of a ton of IFDEFs
This brings us back to garbage collection
Specializing for numerical work
Where numbers don’t have to be special anymore
(The question is:) How useful is that generalization?
You don’t necessarily know what code you’re going to need in advance
Trading off memory for performance
Really doing the deprecation process
A situation where normally you’d JIT something
You might end up in a slow case
You can always just fall back on an interpreter
A partially compiled interpreter
Nobody needs to know that it was written in Julia
A really capable C library
As easy as walking a linked pointer list
I’m really glad someone else implemented it