Computer, Enhance!

I will just plug https://www.computerenhance.com/ which goes into great depth on all of this stuff. I highly recommend it, I learned a lot.

I'd recommend: https://www.computerenhance.com The author has a strong game development (engine and tooling) background and I have found it incredibly useful. It also satisfies the requirement for "A genuine fear, hate, and anger, towards unnecessary allocations, copies, and other performance killers."

This is great, nice work! I just recently started going through a performance programming course (https://computerenhance.com/) and have learned about SIMD and other techniques and it is awesome to see something out in the wild.

For Elixir specifically, I liked Dave Thomas’ Elixir for Programmers. https://codestool.coding-gnome.com/courses/elixir-for-programmers-2 For learning about performance and low level stuff, Casey Muratori’s Performance Aware Programming course has been great. https://computerenhance.com For higher level software design stuff (beyond just GoF patterns), check out James Koppel’s writing at https://www.pathsensitive.com/ and his courses at https://mirdin.com

Casey Muratori's https://computerenhance.com is a good resource

You may enjoy “"Clean" Code, Horrible Performance”, from Casey Muratori. https://www.youtube.com/watch?v=tD5NrevFtbU Casey specialises in game engine research and development https://caseymuratori.com/about And has an ongoing course on computer performance for programmers. https://www.computerenhance.com/

He finished the game engine. It came to a natural end. He started a new series on performance-aware programming[0]. [0]: https://www.computerenhance.com

Python takes ~180 assembly instructions to add two numbers, where „compiled to machine code“ languages only take one. Casey Muratori has a real in-depth course on why Python is slow and how to make it fast, among many other things why software can be slow. https://www.computerenhance.com/

Casey Muratori’s content has had a profound influence on me as a programmer. I’ve enjoyed going through his articles (check out “Stable Filter” [1] if you haven’t yet), as well as his course “Computer, Enhance” [2]. 1. https://caseymuratori.com/blog_0035 2. https://www.computerenhance.com/

Casey Muratori did many lectures. Check out his yt page playlist. Start with the one titled software quality https://www.youtube.com/@MollyRocket/playlists I heard good things about his course https://www.computerenhance.com/ Agner Fog manuals are good too https://www.agner.org/optimize/#manuals A site to look up instruction timings is https://uops.info/table.html

See the following: https://www.computerenhance.com/p/game-development-post-unity I would suggest just using Godot for 2D. With time it should be fine. For 3D, even AAA have been going to Unreal so that may be best. It's not ideal but the business model of 5% works compared to Unity promising to avoid revenue splitting.

I do not think that book is a good suggestion for good or readable code, and also there is this (which in many situations will not matter, but still): https://www.computerenhance.com/p/clean-code-horrible-performance Someone who does writes quite clean code is in my opinion Tsoding: https://www.youtube.com/@TsodingDaily Strongly recommend his YouTube channel!

Casey Muratori's Computer Enhance: https://www.computerenhance.com/

Casey Muratori (of Handmade Hero fame, works/worked at RAD Game Tools for a long time) just did that as part 1 of his Performance Aware Programming series he’s doing on his Substack: https://www.computerenhance.com/ The “homeworks” only require implementing basic data transfer, arithmetic, and logic instructions, but I enjoyed it so I implemented everything except the interrupt handler stuff (into, etc.), and the BCD stuff (aaa, etc.). I agree that it’s a good way to learn, and Casey provides a reference implementation.

From: https://www.computerenhance.com/p/clean-code-horrible-performance > The speed differences range from 20-25x — and of course, none of the AVX-optimized code uses anything remotely like “clean” code principles. If clean code limits your default performance to 20 times worse, those high level optimizations might not even be worth it.

Casey Muratori's blog (everything stuff): <https://www.computerenhance.com/> Max Bernstein's blog (compiler stuff): <https://bernsteinbear.com/blog/> Michael Stapelberg's blog (Linux stuff): <https://michael.stapelberg.ch/posts/> Göran Weinholt's blog (Scheme stuff): <https://weinholt.se/>

I like a lot of Muratori’s writing but… is it really wise to take code architecture tips from game devs, of all people? I’m willing to trade lots of performance in exchange of extensibility and stability over the long term. I’m not a huge fan of overwrought OOP either, but modeling everything with scalars and comments makes it sometimes harder to add new behaviours. I’m also not a fan of video content, here is a transcript of the above video, https://www.computerenhance.com/p/clean-code-horrible-performance If you look at the “not clean” code in the above, it’s fine, it’s still relatively easy to follow etc. Now think about extending it so that some shapes are the result of summing multiple sub-shapes, like a general polygon tiled out of triangles. That’s straightforward in the OOP case, but not so much in the flattened array case, and means that we need to reintroduce pointer indirections if we don’t want our shape union to be as large as our biggest shape etc. (I still might use a switch statement over inheritance.)

Answer posts: 1) https://www.computerenhance.com/p/microsoft-intern-interview-question 2) https://www.computerenhance.com/p/microsoft-intern-interview-question-… 3) https://www.computerenhance.com/p/microsoft-intern-interview-question-… 4) https://www.computerenhance.com/p/efficient-dda-circle-outlines

No, it's not really good. It's a pain in the ass to work in, and it produces slow code. https://www.computerenhance.com/p/clean-code-horrible-performance

At some point "Premature optimization is the root of all evil" morphed into "optimization is evil". Your PR will always get shot down if it tries to improve perf by making code less clean. Imagine applying this handbrake to every single layer of every single thing running on your computer https://www.computerenhance.com/p/clean-code-horrible-performance

This interview with AMD Zen chief architect Mike Clark validated that the efficiency gains are not due to ISA https://www.computerenhance.com/p/an-interview-with-zen-chief-architec…

There's a nice interview with Mike Clark where he talks about this a bit. His take basically matches this. He says that, in his view, any efficiency benefits of ARM are just that's been the market for ARM. In his view, if x86 had a market motive for ARM levels of efficiency, they'd be able to deliver it. But, historically, the x86 market wants performance more than efficiency, so that's what it gets. https://www.computerenhance.com/p/an-interview-with-zen-chief-architec…

I just encountered the term "The Ultimate Sadness" reading https://www.computerenhance.com/p/the-case-of-the-missing-increment immediately before this post and I feel like you've found an even worse sadness to deal with on a regular basis. My sympathies, and I appreciate your willingness to wade through neck deep licensing excrement to produce something that still works.

Article version: https://www.computerenhance.com/p/zen-cuda-and-tensor-cores-part-i

Give Performance-Aware Programming series by Casey Muratori a try! https://www.computerenhance.com/p/table-of-contents

From the footnotes https://www.computerenhance.com/p/clean-code-horrible-performance

Code is run more than it is read especially if you count users. And so-called "clean" code is a performance disaster[0]. It's also, if that link is an accurate representation of what "clean" code is, a readability disaster. The more readable code, in my opinion anyway, is the version that is also an order of magnitude faster. [0]: https://www.computerenhance.com/p/clean-code-horrible-performance

I'm taking Casey Muratori's online class : https://www.computerenhance.com/p/table-of-contents The goal of the course is to give people a feeling for how fast code can be by teaching how it runs at the cpu level. I like it so far.

Associated blog post: https://www.computerenhance.com/p/the-apple-m-series-gofetch-attack