Julia

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

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

Read This month in Julia world - 2024-01

https://www.juliabloggers.com/feed/

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

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 @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 @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.

Initial commit was June 11. Documentation is here.

Julia has hit the TIOBE index top 20. This is the first time in history! Born about 13 years ago, Julia is a really young programming language. So what makes Julia unique? Why does it deserve this top 20 position? Julia is especially used in the data science and mathematical computation world. But we already have got top 20 contenders in this field such as Python, R and MATLAB. So why then Julia?

I just tried my first problem on Codewars and realised: This solution feels like cheating

“We are very excited by this new strategic investment from AEI HorizonX,” said Dr. Viral Shah, Chief Executive Officer of JuliaHub. “In recent years, Julia’s superior speed and ease of use have been put to work for pharmaceutical companies such as Pfizer and United Therapeutics, and for aerospace applications at NASA, the Federal Aviation Administration and Boeing. This investment allows us to continue to develop and help deploy Julia’s capabilities across all industries.”

Hey, I thought I could spark some discussion here, so I'll just ask what I've been wondering about.

So, what is the difference between JuMP and Optim.jl? Or is it possible to use Optim's optimizers with JuMP?

Some ELI5 would be awesome.

Thanks

A quick overview of the Julia Programming language.

The 2023 Julia User & Developer Survey is now open!

Julia users and developers are encouraged to participate. The survey is available in English, Spanish, Chinese (Simplified and Traditional), Japanese and Korean.

Results will be presented at JuliaCon in July.