Quick summary: "This NumPy release is the largest so made to date, some 684 PRs contributed by 184 people have been merged."
> Annotations for NumPy functions. This work is ongoing and improvements can be expected pending feedback from users.
> Wider use of SIMD to increase execution speed of ufuncs. Much work has been done in introducing universal functions that will ease use of modern features across different hardware platforms. This work is ongoing.
>Preliminary work in changing the dtype and casting implementations in order to provide an easier path to extending dtypes. This work is ongoing but enough has been done to allow experimentation and feedback.
> Extensive documentation improvements comprising some 185 PR merges. This work is ongoing and part of the larger project to improve NumPy’s online presence and usefulness to new users.
> Further cleanups related to removing Python 2.7. This improves code readability and removes technical debt.
> Preliminary support for the upcoming Cython 3.0.
Type annotations seem the biggest deal to me. I'd say if you care a lot about SIMD and the performance issues, you should be thinking of moving to Julia: it's still a valuable technical achievement.
I would rephrase your statement in : "If you care about SIMD, performance issues and type annotations, you should look into Julia".
Numpy is an incredible piece of software and provides performance for one of the most mainstream language. It has been one of the main building block in the python takeover in data science, ml, etc. But if I had the choice, I would have move to Julia during my precedent work/projects as soon as it reached v1.
The type annotation story is indeed better with Julia, but having type annotations for NumPy is beneficial for many users for whom Julia isn't a win, where number crunching isn't the main thing going on and Python's better library situation is important and you want to avoid the complication of calling Python from Julia.
We should be careful to appreciate the “types” in Julia for what they are at their essence: a way to direct dispatch of methods. Certainly the Julia compiler reasons about types in order to generate efficient code. But Julia types also affect the meaning of programs, not just the performance. In fact, the presence or absence of “type annotations” on arguments in a method definition don’t affect the code that that method generates. It simply affects whether that method gets dispatched to or not for a given function call.
I think it’s helpful to consider that this particular use of types is morally different from when type annotations are used to 1. Document intent, 2. Run programs faster, 3. Reason about correctness statically.
Comments
Quick summary: "This NumPy release is the largest so made to date, some 684 PRs contributed by 184 people have been merged."
Type annotations seem the biggest deal to me. I'd say if you care a lot about SIMD and the performance issues, you should be thinking of moving to Julia: it's still a valuable technical achievement.I would rephrase your statement in : "If you care about SIMD, performance issues and type annotations, you should look into Julia".
Numpy is an incredible piece of software and provides performance for one of the most mainstream language. It has been one of the main building block in the python takeover in data science, ml, etc. But if I had the choice, I would have move to Julia during my precedent work/projects as soon as it reached v1.
The type annotation story is indeed better with Julia, but having type annotations for NumPy is beneficial for many users for whom Julia isn't a win, where number crunching isn't the main thing going on and Python's better library situation is important and you want to avoid the complication of calling Python from Julia.
We should be careful to appreciate the “types” in Julia for what they are at their essence: a way to direct dispatch of methods. Certainly the Julia compiler reasons about types in order to generate efficient code. But Julia types also affect the meaning of programs, not just the performance. In fact, the presence or absence of “type annotations” on arguments in a method definition don’t affect the code that that method generates. It simply affects whether that method gets dispatched to or not for a given function call.
I think it’s helpful to consider that this particular use of types is morally different from when type annotations are used to 1. Document intent, 2. Run programs faster, 3. Reason about correctness statically.