-
Notifications
You must be signed in to change notification settings - Fork 3
/
index.html
270 lines (206 loc) · 42 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<title>reveal-md</title>
<link rel="stylesheet" href="./css/reveal.css">
<link rel="stylesheet" href="./css/theme/black.css" id="theme">
<link rel="stylesheet" href="./css/highlight/zenburn.css">
<link rel="stylesheet" href="./css/print/paper.css" type="text/css" media="print">
<link rel="stylesheet" href="./_assets/style.css">
</head>
<body>
<div class="reveal">
<div class="slides"><section data-markdown><script type="text/template"> <!-- .element height="10%" width="10%" -->
# Julia
A new programming language *specifically* made for scientists and engineers
<aside class="notes"><p>~5 years ago at MIT</p>
</aside></script></section><section ><section data-markdown><script type="text/template">
# Two-language problem
<aside class="notes"><p>to build complex compiled programs OR to have fast dynamic programs, you have 2 languages involved</p>
</aside></script></section><section data-markdown><script type="text/template">
## Building compiled programs
1. Brain-storm in a dynamic language for algorithm exploration and testing.
2. Deliver a performant final-version in a compiled language.
<aside class="notes"><p>Most compiled programs had a testing stage in a dynamic language</p>
</aside></script></section><section data-markdown><script type="text/template">
## Using dynamic languages
```none
Does a package/library do exactly
what you need?
├── Yes: Great!
├── Dunno: You need to read C/++ code.
└── No: You need to code in C/++.
```
<aside class="notes"><p>R, Python, and MATLAB are coded mostly in C/++. Anything that is fast in those languages is coded in C/++.</p>
</aside></script></section><section data-markdown><script type="text/template">
## What if the dynamic language was fast enough?
* [Benchmarks](https://julialang.org/benchmarks/)
* Solves the two-language problem
* `Julia` is mostly coded in `Julia`!
<aside class="notes"><p>Julia is mostly coded in Julia!</p>
</aside></script></section><section data-markdown><script type="text/template">
## LOC versus speed
<aside class="notes"><ol>
<li>I wrote a flexible and fast ray tracer in Julia. It's 100 LOC. </li>
<li>The study "Mash: fast genome and metagenome distance estimation using MinHash" used MinHashing -- a fast algorithm for comparing two sets of things -- for DNA sequence comparison. They implemented it in C for speed. Someone else made python bindings to the compiled C version. But someone implemented it directly in Julia and made it super fast in under 100 lines of very readable code.</li>
</ol>
</aside></script></section></section><section data-markdown><script type="text/template">
# Dynamic & fast, how?
1. Just-in-time compilation (JIT): User-level code is compiled to machine code on-the-fly.
2. Meticulous type system: Designed to maximize impact of JIT.
3. Multiple dispatch: Function dispatch determined at compile time when possible, run time when not.
<aside class="notes"><p>JIT compilation times are slow for first run</p>
</aside></script></section><section ><section data-markdown><script type="text/template">
# Easy code
Looks like `Python`/`MATLAB`/`R` but with prettier syntax.
</script></section><section data-markdown><script type="text/template">
## Syntax
<section style="text-align: left;">
Math:
```julia
2π√3/5α₀
```
`Python`:
```python
2*np.pi*np.sqrt(3)/(5*alpha0)
```
`Julia`:
```julia
2π*√3/5α₀
```
<aside class="notes"><p>Unicode characters, degree symbol, Greek letters, square root, units. Easy to read and understand, scientists are not programmers.</p>
</aside></script></section><section data-markdown><script type="text/template">
## Custom infix operators
```julia
# rotate coordinate `c` by `θ` radians
julia> ↺(c, θ) = [cos(θ) -sin(θ); sin(θ) cos(θ)]*c
↺ (generic function with 1 method)
julia> [1,0] ↺ π/2
2-element Array{Float64,1}:
0.0
1.0
```
<aside class="notes"><p>This opens the door to tons of cool syntax.</p>
</aside></script></section><section data-markdown><script type="text/template">
## Embedded units
It took a beetle 36 seconds to walk 25 cm. How many days will it take it to walk 3 km?
```julia
using Unitful:uconvert, cm, km, s, d
v = 25cm/36s
t = 3km/v
uconvert(d, t)
```
5 days
<aside class="notes"><p>if you use m, cm, feet, degrees, radians, etc</p>
</aside></script></section></section><section data-markdown><script type="text/template">
# Missing
The concept of `missing` and `NaN` is treated correctly:
```julia
julia> NaN + 1 = NaN
julia> missing + 1 = missing
julia> true | NaN ERROR!
julia> true | missing = true
julia> false | missing = missing
julia> true & missing = missing
julia> false & missing = false
```
<aside class="notes"><p>Consider that no other language has managed to get this concept of missing data correctly into their code.</p>
</aside></script></section><section data-markdown><script type="text/template">
# Zero overhead
Full access to all the libraries and functionalities you already know.
`MATLAB.jl`, `RCall.jl`, `PyCall.jl`, `JavaCall.jl`, `Mathematica.jl`, and `ccall` keyword to call `C` (and other languages, like `Fortran` and `Rust`)
<aside class="notes"><p>you can call Julia home without losing all of your furniture in the move.</p>
</aside></script></section><section data-markdown><script type="text/template">
# Some of my favourite things
* [AxisArrays](https://github.com/JuliaArrays/AxisArrays.jl): Arrays where each dimension can have a named axis with ranged values.
* [Images](https://github.com/JuliaImages/Images.jl) & [Colors](https://github.com/JuliaGraphics/Colors.jl): Treat colors as a unit.
* `github` integration: your code and its documentation accessible to everyone, automatically tested on multiple architectures, with coverage reports.
<aside class="notes"><p>Many many more, but it's outside the scope of this presentation, CI</p>
</aside></script></section><section data-markdown><script type="text/template">
# Free & open source
* Easy to share and collaborate with *anyone*
* Drives the language forward
* Highly specialized and niche solutions and tools
* Free from hardware requirements
* No "black boxes", everything is within reach
<aside class="notes"><p>This is true for Python and R, but not MATLAB. Julia got git integration really well.</p>
</aside></script></section><section ><section data-markdown><script type="text/template">
# Disadvantages
Mostly it's just too new…
<aside class="notes"><p>nothing is perfect.</p>
</aside></script></section><section data-markdown><script type="text/template">
## Too new!
* Ecosystems (e.g. packages, IDEs, debugger) not as mature as in other environments.
* Some of the more specialized libraries are missing.
* Harder to Google for answers.
<aside class="notes"><p>IDE (Integrated Development Environment). Maybe in 6 months or so the environment will solidify completely.</p>
</aside></script></section><section data-markdown><script type="text/template">
## Still working out all the kinks
* Loading some packages is still a bit slow.
* Plotting works but hasn't settled yet.
* Transitioning into `v1.0.0`: Major changes.
</script></section><section data-markdown><script type="text/template">
## General purpose
* Need statistics? `R`
* Need vectorized operations on matrices? `MATLAB`
* `Julia` (like `Python`) is more general-purpose → can be harder to find what you're looking for.
<aside class="notes"><p>apropos statistics, Douglas Bates, the developer of the <code>lme4</code> R package for GLMMs switched to Julia.</p>
</aside></script></section></section><section data-markdown><script type="text/template">
# Conclusions
* `Julia` is considered by many one of the best dynamic languages out there.
* A number of libraries already far out-perform their equivalents in other languages.
* People come to `Julia` because of its speed, but stay for the type-dispatch system ♥
* Suffers from being "too new": might not be suitable for early adopters.
<aside class="notes"><p>I've started using Julia about 4 years ago and never looked back.</p>
</aside></script></section><section data-markdown><script type="text/template">
<!-- .slide: data-background-color="#ffffff" -->
 <!-- .element height="100%" width="100%" -->
</script></section></div>
</div>
<script src="./lib/js/head.min.js"></script>
<script src="./js/reveal.js"></script>
<script>
function extend() {
var target = {};
for (var i = 0; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (source.hasOwnProperty(key)) {
target[key] = source[key];
}
}
}
return target;
}
// Optional libraries used to extend on reveal.js
var deps = [
{ src: './lib/js/classList.js', condition: function() { return !document.body.classList; } },
{ src: './plugin/markdown/marked.js', condition: function() { return !!document.querySelector('[data-markdown]'); } },
{ src: './plugin/markdown/markdown.js', condition: function() { return !!document.querySelector('[data-markdown]'); } },
{ src: './plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } },
{ src: './plugin/zoom-js/zoom.js', async: true },
{ src: './plugin/notes/notes.js', async: true },
{ src: './plugin/math/math.js', async: true }
];
// default options to init reveal.js
var defaultOptions = {
controls: true,
progress: true,
history: true,
center: true,
transition: 'default', // none/fade/slide/convex/concave/zoom
dependencies: deps
};
// options from URL query string
var queryOptions = Reveal.getQueryHash() || {};
var options = {};
options = extend(defaultOptions, options, queryOptions);
</script>
<script>
Reveal.initialize(options);
</script>
</body>
</html>