
Calculus with Julia - adamnemecek
https://calculuswithjulia.github.io/
======
eggy
I loved working through Ken Iverson's, the creator of APL, books in J:
"Calculus", "Algebra", and the "Concrete Math Companion" (a companion Knuth
and Patashnik's book "Concrete Math" in J)[1].

I also like the Physics and Math in SICM (Structure and Interptretation of
Classical Mechanics), and Scheme maps well to math equations, at least for me
[2].

Julia does follow the way math is written, but I prefer Haskell. The book "The
Haskell Road to Logic, Math and Programming" [3] is great, and this article on
Geometric Algebra (GA) in Haskell is excellent [4].

[1]
[https://www.jsoftware.com/books/pdf/](https://www.jsoftware.com/books/pdf/)

[2]
[https://mitpress.mit.edu/sites/default/files/titles/content/...](https://mitpress.mit.edu/sites/default/files/titles/content/sicm_edition_2/book.html)

[3] [https://www.amazon.com/Haskell-Logic-Programming-Second-
Comp...](https://www.amazon.com/Haskell-Logic-Programming-Second-
Computing/dp/0954300696)

[4]
[https://crypto.stanford.edu/~blynn/haskell/ga.html](https://crypto.stanford.edu/~blynn/haskell/ga.html)

------
xrd
I would love to see the sections annotated with "approximately twenty minutesb
to read" (like Medium does). In fact, if Google added this to every link, that
would be amazing. I'm always excited to book mark things like this, and then
when I visit my bookmarks tell myself "I'll read this when I have more focused
time". Inside my head I'm assuming it'll be hours of work and I never find or
make that time, and as such, never read those articles. This looks great and I
bet I'll never make the time because of my mistaken assumptions.

~~~
supermdguy
I've been thinking of making a kind of bookmarks manager that automatically
adds time information. Ideally it would also support things like podcasts or
videos. Then, when you have x amount of extra time, you could see find
something to do easily.

~~~
O_H_E
That actually sounds great

------
applecrazy
This is good, looks like something I might read this summer.

Small question though: are infinite series and Taylor polynomials not part of
calculus? I don't see them here.

~~~
m4x
Strictly speaking they aren't a "part of calculus" \- they aren't directly
related to continuous rates of change - but that's a pretty arbitrary
distinction and both are almost always taught as part of a calculus course.

~~~
_hl_
How would you define and reason about integration without infinite series?
Genuinely curious if someone has tried to do that.

~~~
applecrazy
I'm pretty sure that's not possible, since the integral is defined as a limit
of Riemann sum.

~~~
m4x
There are actually a number of different ways to define integrals - see
[https://en.m.wikipedia.org/wiki/Integral#Formal_definitions](https://en.m.wikipedia.org/wiki/Integral#Formal_definitions)

------
eigenspace
People interested in this should really check out TaloySeries.jl. It's a
pretty awesome tool for playing around with a lot of calculus concepts in
Julia.

[https://github.com/JuliaDiff/TaylorSeries.jl](https://github.com/JuliaDiff/TaylorSeries.jl)

[http://www.juliadiff.org/TaylorSeries.jl/stable/userguide/](http://www.juliadiff.org/TaylorSeries.jl/stable/userguide/)

------
nerdponx
Why are they writing every program name in code formatting?

~~~
setr
I do that pretty often as well, mostly because backticks looks better in
plaintext than asterisks, and the text ends up looking more 'programmatic'
than bold (italics/underlines are pathetic, and I rarely consider them as
emphasis options).

It's also very rare for inline code to be useful (versus multiline), so the
backtick is generally wasted in markdown anyways.

~~~
nerdponx
But why use special formatting at all? Just capitalize the name.

------
mymythisisthis
Is there a tutorial like this but based on Python or R?

~~~
adamnemecek
I like julia better than either of the two. It also has insane interop with
both of those so like any numpy and R functions are a line away.

[https://github.com/JuliaPy/PyCall.jl](https://github.com/JuliaPy/PyCall.jl)

~~~
athroway
I remember trying out Julia for the first time. There weren't many libs but I
found out about @pyimport and I was like "cool, let's try some stuff" and I
found out that pretty much all I wrote was calls through Python bindings, so I
thought "wait it's probably simpler to just use Python then", and left it at
that.

Point is, I hope the ecosystem has gotten better last time I tried it ~3 years
ago, and I also hope the interoperability didn't turn out to be "too good" for
the ecosystem's own health.

~~~
adamnemecek
The ecosystem is pretty amazing.

