Using Juno for Interactive Test-Driven Package Development

February 19 2018 in Julia, Programming | Tags: | Author: Christopher Rackauckas

I found myself explaining my development workflow all of the time, so I thought I'd show it in a video. This is some of the stuff I do. You can do it other ways. I like this way.

Algorithm efficiency comes from problem information

This is a high level post about algorithms (especially mathematical, scientific, and data analysis algorithms) which I hope can help people who are not researchers or numerical software developers better understand how to choose and evaluate algorithms. When scientists and programmers think about efficiency of algorithms, they tend to think about high level ideas like temporary arrays, choice of language, and parallelism. Or they tend to think about low level ideas like pointer indirection, cache efficiency, and SIMD vectorization. However, while these features matter, most decent implementations of the same algorithm tend to get quite close in efficiency to each other (probably <3x if everyone is using a performant enough programming language or constructs). If you're sitting down thinking "what is the next algorithm that I am going to invent that will be truly a step beyond what existed before?", ... READ MORE

Solving Systems of Stochastic PDEs and using GPUs in Julia

What I want to describe in this post is how to solve stochastic PDEs in Julia using GPU parallelism. I will go from start to finish, describing how to use the type-genericness of the DifferentialEquations.jl library in order to write a code that uses within-method GPU-parallelism on the system of PDEs. This is mostly a proof of concept: the most efficient integrators for this problem are not compatible with GPU parallelism yet, and the GPU parallelism isn't fully efficient yet. However, I thought it would be nice to show an early progress report showing that it works and what needs to be fixed in Base Julia and various libraries for us to get the full efficiency.

Edit: When I first wrote this I forgot I was on a machine with a GTX1080, and thus Float64's on the GPU were extra slow. ... READ MORE

Some tips for your Google Summer of Code Application

November 13 2017 in Programming | Tags: | Author: Christopher Rackauckas

Google Summer of Code (GSoC) is a highly prestigious and rewarding opportunity for both students and the mentoring institution. Lots of people want to participate in GSoC, yet institutions are limited in who they can take. This means that applications are competitive. How do you break out of the pack?

I wanted to write this blog post because I believe there is a big gap between what students believe is important in an application and what is actually important in an application. This will be a very frank and straight to the point (but purposely pessimistic) explanation of why some things matter, and why some things don't. What I would like to do is help you (some student) re-orient your thinking about application processes. While this is written for GSoC, this thought process definitely applies to things like graduate school ... READ MORE

DifferentialEquations.jl 3.0 and a Roadmap for 4.0

I am pleased to announce the release of DifferentialEquations.jl 3.0. In the last DiffEq blog post I described the current state of JuliaDiffEq and DifferentialEquations.jl along with the trajectory that we hoped to take. We identified (at that time) current shortcomings of the software and our plans to remedy them. I also recently did a survey of differential equation suites in order to understand where we stand and see where we need to improve. These research efforts were used to put together a list of goals that were systematically achieved during 3.0. What I would like to do this time around is give a broad overview of what we have released in the 3.0 timeframe, the goals that we have achieved, and the goals that we are putting off (for next Google Summer of Code?). And then, ... READ MORE

I Like Julia Because It Scales and Is Productive: Some Insights From A Julia Developer

October 13 2017 in Julia, Programming | Tags: | Author: Christopher Rackauckas

In this post I would like to reflect a bit on the Julia programming language. These are my personal views and I have had more than a year developing a lot of packages for the Julia programming language. After roaming around many different languages including R, MATLAB, C, and Python; Julia is finally a language I am sticking to. In this post I would like to explain why. I want to go back through some thoughts about what the current state of the language is, who it's good for, and what changes I would like to see. My opinions changed a lot since first starting to work on Julia, so I'd just like to share the changed mindset one has after using the language deeply.

Quick Summary

Here's a quick summary of my views.

  1. Julia is not only a fast language, but ... READ MORE

A Comparison Between Differential Equation Solver Suites In MATLAB, R, Julia, Python, C, Mathematica, Maple, and Fortran

Many times a scientist is choosing a programming language or a software for a specific purpose. For the field of scientific computing, the methods for solving differential equations are one of the important areas. What I would like to do is take the time to compare and contrast between the most popular offerings. This is a good way to reflect upon what's available and find out where there is room for improvement. I hope that by giving you the details for how each suite was put together (and the "why", as gathered from software publications) you can come to your own conclusion as to which suites are right for you.

(Full disclosure, I am the lead developer of DifferentialEquations.jl. You will see at the end that DifferentialEquations.jl does offer pretty much everything from the other suite combined, but that's no accident: ... READ MORE

Video Introduction to DifferentialEquations.jl

Videos can be much easier to follow than text (though they usually have fewer details!). So, here's a video introduction to DifferentialEquations.jl from JuliaCon. In this talk I walk through the major features of DifferentialEquations.jl by walking through the the tutorials in the documentation, highlighting usage details and explaining how to properly think about the code. I hope this helps make it easier to adopt DifferentialEquations.jl!

Type-Dispatch Design: Post Object-Oriented Programming for Julia

May 29 2017 in Julia, Programming | Tags: | Author: Christopher Rackauckas

In this post I am going to try to explain in detail the type-dispatch design which is used in Julian software architectures. It's modeled after the design of many different packages and Julia Base, and has been discussed in parts elsewhere. This is actually just a blog post translation from my "A Deep Introduction to Julia for Data Science and Scientific Computing" workshop notes. I think it's an important enough topic to share more broadly.

The tl;dr: Julia is built around types. Software architectures in Julia are built around good use of the type system. This makes it easy to build generic code which works over a large range of types and gets good performance. The result is high-performance code that has many features. In fact, with generic typing, your code may have more features than you know of! The ... READ MORE

Video Blog: Developing and Editing Julia Packages

May 16 2017 in Julia, Programming | Tags: , , , | Author: Christopher Rackauckas

Google Summer of Code is starting up, so I thought it would be a good time to share my workflow for developing my own Julia packages, as well as my workflow for contributing to other Julia packages. This does not assume familiarity with commandline Git, and instead shows you how to use a GUI (GitKraken) to make branches and PRs, as well as reviewing and merging code. You can think of it as an update to my old blog post on package development in Julia. However, this is not only updated but also improved since I am now able to walk through the "non-code" parts of package developing (such as setting up AppVeyor and code coverage).

Enjoy! (I quite like this video blog format: it was a lot less work)