Interesting exploration of the performance for web resources when they're bundled or not. Also dabbles in the reasons behind the exhibited performances, definitely to keep in mind.
Looks like an interesting serialization framework. If it holds true to its claims it could be very useful in some place.
Will AMD really turn this around? Wait and see.
Very thorough paper on optimization techniques when dealing with GPUs. Can be a useful reference or starting point to then dig deeper. Should also help to pick the right technique for your particular problem.
A good reminder that depending what happens in the kernel, the I/O time you were expecting might turn out to be purely CPU time.
Good list of things to keep in mind when thinking about performances. Of course, always measure using a profiler when you want to be really sure.
Interesting way to approximate how loaded a system is.
Interesting tale and exploration on how a change in includes impacted cache misses. This is sneaky (and solved with more recent compilers).
The claim is huge. The story doesn't quite say how much is really about Elixir and how much from the revised architecture. That being said, going for something like Elixir has definitely an impact on the architecture... could it be that it pushes for better patterns?
Another partial quote which led to misunderstanding. One should indeed think about performances early on.
Obvious advice perhaps, but so easily forgotten somehow...
OK, this could be big for Python. Let's see how they execute this plan. It carries some risks as well, but they seem well aware of them.
Interesting optimization on this somewhat common data structure.
Unsurprisingly, it's not as simple as it sounds. Type hints in Python can be used for various reasons but performances is rarely the main motives. It'd need other adjustments to the runtime. People are working on it, and this article is an interesting dive on how things work under the hood.
This compilation technique brings very interesting results. Hopefully should find its way in some JIT compilers.
Interesting research turning to genetic algorithms to optimize bytecode handler dispatchers.
Deep dive on a proper benchmarking and implementation for 1M task on the Erlang runtime. Clearly the previous benchmark had room for improvements.
Nice and thorough workshop on vectorization, where it comes from, what it can do and how you can write code which is easier to vectorize for the compiler.
Doesn't give the whole picture (memory isn't the only important parameter) but interesting results nonetheless. A few surprises in there, Java and C# do much better than one might assume for instance.
Interesting take. Will it lead to paying more attention to performance in software? Will it be the rise of the specialized CPUs? Time will tell.