Search
Think Julia is available under the Creative Commons Attribution-NonCommercial 3.0 Unported License.
A paper version of this book is published by O’Reilly Media and can be bought on Amazon.
> ### Preface > > In January 2018 I started the preparation of a programming course targeting students without programming experience. I wanted to use Julia, but I found that there existed no book with the purpose of learning to program with Julia as the first programming language. There are wonderful tutorials that explain Julia’s key concepts, but none of them pay sufficient attention to learning how to think like a programmer. > > I knew the book Think Python by Allen Downey, which contains all the key ingredients to learn to program properly. However, this book was based on the Python programming language. My first draft of the course notes was a melting pot of all kinds of reference works, but the longer I worked on it, the more the content started to resemble the chapters of Think Python. Soon, the idea of developing my course notes as a port of that book to Julia came to fruition. > > All the material was available as Jupyter notebooks in a GitHub repository. After I posted a message on the Julia Discourse site about the progress of my course, the feedback was overwhelming. A book about basic programming concepts with Julia as the first programming language was apparently a missing link in the Julia universe. I contacted Allen to ask if I could start an official port of Think Python to Julia, and his answer was immediate: “Go for it!” He put me in touch with his editor at O’Reilly Media, and a year later I was putting the finishing touches on this book. > > It was a bumpy ride. In August 2018 Julia v1.0 was released, and like all my fellow Julia programmers I had to do a migration of the code. All the examples in the book were tested during the conversion of the source files to O’Reilly-compatible AsciiDoc files. Both the toolchain and the example code had to be made Julia v1.0–compliant. Luckily, there are no lectures to give in August…. > > I hope you enjoy working with this book, and that it helps you learn to program and think like a computer scientist, at least a little bit. > > Ben Lauwens
Julia's numerical derivative following Numpy gradient - gist:996e0745e820dde0610ada9e9e025844
![Julia's numerical derivative following Numpy gradient](https://programming.dev/pictrs/image/aabcaeac-f12f-42ff-b22a-1c4bc6481ed0.png?format=webp&thumbnail=256)
Victor Buendía (@[email protected]) writes:
> Turns out that #julialang does not have the equivalent of Numpy's gradient function. So I went to Numpy docs and source code and adapted it. > > Numpy's gradient is great because it uses centered differences, so it's way more accurate than naively getting the forward differences. Also, supports non-equally spaced grids. > > In case someone needs it (for 1D arrays only), here it is: > > https://gist.github.com/VictorSeven/996e0745e820dde0610ada9e9e025844
Julia Programming Tutorial | An effective tutorial for science and engineering
This introductory tutorial about Julia focuses on its use in Science and Engineering.
Martin D. Maas writes:
> Julia is an is a general-purpose, open-source, dynamic, and high-performance language. By leveraging a clever design around a just in time (JIT) compiler, Julia manages to combine the speed of languages like C or Fortran, with the ease of use of Matlab or Python.
> This is a hands-on tutorial series, which focuses on understanding the most important aspects of the language from a practical point of view, and focusing on the needs of scientists and engineers. > > In particular, we won’t be introducing much more syntax or language features than what is required to solve the different problems we will be tackling. > > As a quick reference, and if you have experience with Python or Matlab, it might be worth to check out the Matlab-Python-Julia Cheatsheet.
Read Julia Programming Tutorial Total: 37 posts Last updated: November 13, 2023
My Target Audience | The Two Culture Problem
What kind of people do I have in mind while writing this blog? People who share my professional mission of course! What is that mission you ask? Let me elaborate. From Research to Engineering I am a scientist who danced with startups and moved into i...
![My Target Audience](https://programming.dev/pictrs/image/7b2b4521-0491-4f8d-8965-413bd59894de.jpeg?format=webp&thumbnail=256)
Apr 18, 2023 Matthijs Cox writes:
> The “two language problem” was globally accepted for several decades. You just learn to live with it. Until one day it was challenged by the Julia language, a programming language that promises both speed and ease of use. As I feel the pain of the two language problem deeply, I wanted to try out this new solution. So together with several allies I went on a mission to adopt this new technology at work, and remove the bottleneck. > > While we had initial success and attention, we quickly stumbled into resistance from the existing groups of researchers/scientists and developers. Over time I have named this the “two culture problem”. In the beginning I didn’t see the cultures clearly, which limited our success. I was too focused on the technological problem itself. > > I will refer to the two cultures as “scientists” versus “developers”. However, the “scientists” group generalizes to anyone who codes quick and dirty to explore, such as domain experts, data analysts and others like that. I do hope everyone is doing their exploration somewhat scientifically, so the generalization should makes sense. Scientists typically want to get their stuff done, perhaps with code, but they don't care about the code. Software developers care deeply about the code craftsmanship, sometimes obsessively so, but often developers barely understand the business domain or science. There are people near the middle, trying to balance both, but they are a rare breed.
Read My Target Audience
A monthly newsletter, mostly on julia internals, digestible for casual observers. A biased, incomplete, editorialized list of what I found interesting this month, with contributions from the community. “Internals” Fora and Core Repos (Slack/Zulip/Discourse/Github): Julia 1.10 was released around ...
![This month in Julia world - 2024-01](https://programming.dev/pictrs/image/b5cc500b-dc1c-41b6-9962-7c51b4b16643.png?format=webp&thumbnail=256)
Jan 31st 2024 Krastanov writes:
> A monthly newsletter, mostly on julia internals, digestible for casual observers. A biased, incomplete, editorialized list of what I found interesting this month, with contributions from the community. > > “Internals” Fora and Core Repos (Slack/Zulip/Discourse/Github): > > - Julia 1.10 was released around Christmass. See the release highlights. > - It seems we all agree that it would be incredibly valuable to have better ways to call julia from inside python. This discourse thread has plenty of discussion on the topic, but specifically check out Chris’s comments which has a bunch of constructive suggestions towards the end. > - Rounding operations on Complex numbers (into presumably complex integers) are pretty difficult to do consistently. On the issue tracker folks have been discussing various ways to do it, and the dangers of being too permissive in what interfaces might emerge by accident. It is not feasible to summarize the entire story, as the thread is a bit meandering and has some contextual miscommunications, but a valuable read nonetheless. Arbitrarily, consider starting with this comment. > - A lot of ongoing discussion in various places on how to deal with asynchronous exceptions (interrupts from the outside or stack overflows, that can happen at much weirder ill-defined times compared usual exceptions). This is a good starting point for the discussion. There are comments with interesting references to how other languages deal with this as well. > - Now that we have a public keyword, people are thinking about how to better protect (or mark as sensitive) package internals, to avoid accidental dependencies on unstable implementation details. > - A wonderful explanation of how “world splitting” used to be a great optimization in the compiler that can now lead to invalidating large amounts of code, cause recompilation, and de-optimization. The thread as a whole has other useful pieces of wisdom, but it is a bit meandering. > - A wonderful case study in fixing method invalidations and compilation latency (using Pkg.jl as an example). See this related older post on similar topics. > - An interesting discussion on the idiosyncrasies of computing type intersections (the set of types that are at the same time subtypes of two given types) in Julia. The operation is not commutative. > - Fun examples of how the update to a new LLVM is now changing the loop unrolling behavior (occasionally to detrimental effects) on slack and github
GPU-based ODE solvers which are 20x-100x faster than those in #jax and #pytorch
![](https://programming.dev/pictrs/image/a3d8f881-851b-47bc-8058-05cec1566fd7.png?format=webp&thumbnail=128)
![](https://programming.dev/pictrs/image/a3d8f881-851b-47bc-8058-05cec1566fd7.png?format=webp)
Dr. Chris Rackauckas (@[email protected]) writes:
> #julialang GPU-based ODE solvers which are 20x-100x faster than those in #jax and #pytorch? Check out the paper on how #sciml DiffEqGPU.jl works. Instead of relying on high level array intrinsics that #machinelearning libraries use, it uses a direct kernel generation approach to greatly reduce the overhead.
Read Automated translation and accelerated solving of differential equations on multiple GPU platforms
Statistical Rethinking - A Bayesian Course with Examples in R and Stan (and PyMC3, brms, and Julia too)
Contribute to rmcelreath/stat_rethinking_2024 development by creating an account on GitHub.
![GitHub - rmcelreath/stat_rethinking_2024](https://programming.dev/pictrs/image/f336f8a3-0366-441c-948f-5b28285f0cb1.png?format=webp&thumbnail=256)
Richard McElreath has made his course materials available on GitHub.
However, the course follows the 2nd edition of McElreath's book Statistical Rethinking which is not available in a free digital format.
After watching the first lecture in the Statistical Rethinking 2023 YouTube Playlist, I might go ahead and purchase the text and use this course instead of Trevor Hastie and Rob Tibshirani's An Introduction to Statistical Learning (with Applications in R or Python) course.
I also like that this resource has made an explicit attempt to provide code examples in Julia as well as the more popular Python and R.
I wasn't sure who Richard McElreath was so I did a quick search which revealed his position as Director of the Department of Human Behavior, Ecology and Culture at the Max Planck Institute for Evolutionary Anthropology in Leipzig.
Last week I was in Münster, Germany, to discuss Spatial Data Science across the (https://programming.dev/c/julia), (https://programming.dev/c/python), and (https://fosstodon.org/t
![](https://programming.dev/pictrs/image/6fdb50bb-4be8-4273-a40a-cee33271e425.jpeg?format=webp&thumbnail=128)
![](https://programming.dev/pictrs/image/6fdb50bb-4be8-4273-a40a-cee33271e425.jpeg?format=webp)
Last week I was in Münster, Germany, to discuss Spatial Data Science across the @julia, @python, and #r languages (https://r-spatial.org/sdsl/). I think it is fair to say that everyone learned a lot from one another and there are now several efforts to align the ecosystems in terms of teaching, file formats, and others. In JuliaGeo we still have to implement some geography methods. Thanks to @edzer and Yomna for organizing.
Last month I taught (https://programming.dev/c/julia) and its geospatial stack at the (https://fosstodon.org/@opengeohub) summer school 2023 in beautiful Poznań, Poland. I had a g
![](https://programming.dev/pictrs/image/799f84de-5c04-4269-86b0-756b1b50c695.jpeg?format=webp&thumbnail=128)
![](https://programming.dev/pictrs/image/799f84de-5c04-4269-86b0-756b1b50c695.jpeg?format=webp)
Last month I taught @julia and its geospatial stack at the @opengeohub summer school 2023 in beautiful Poznań, Poland. I had a great time together with other open-source developers. Pictured is me calling in from the train home, because I won a hackathon by using Julia 🥳.
My materials (including the notebooks for the hackathons) are at https://github.com/evetion/OGH2023 and the recording(s) are at https://www.youtube.com/watch?v=UgMdr8vE9uM&list=PLXUoTpMa\_9s1C8LrkslIctOU31Oi0LAQa.
Mousetrap, a new GUI engine for Julia.
Initial commit was June 11. Documentation is here.
I use both Julia and Rust, I did shot a few times in the foot with Julia (for instance, getting memory leaks on the GPU). Now, I use Julia (the REPL) when I want to quickly script some code and use Pluto.jl to plot data and teach programming.