Vulkan Programming Guide: The Official Guide to Learning Vulkan by John M. Kessenich

My rating: 4 of 5 stars

Vulkan Programming Guide is an excellent resource for experienced practitioners that interact with the Vulkan Graphics and Compute API, including device initialization, compute and graphics shaders, rendering, synchronization, and a ton more. If you use graphics cards pipelines, this book should be on your shelf.

Vulkan Programming Guide is not several things, however:
– Deeply informative about GLSL, which Vulkan pipelines consume.
– A Beginner’s Guide to Graphics or Graphics Compute.
– Easy to read from cover to cover.

VPG does not claim to be any of those things, but some readers might have the wrong impression.

I definitely noticed the frequent typos which I hope will be corrected in future printings, but they did not impede understanding the text. I still wish someone had run the final draft through spellcheck. I can’t believe we’re still dealing with transposed-character misspellings in 2016.

View all my reviews

Computer Architecture: A Quantitative Approach by Hennessy

My rating: 5 of 5 stars

An outstanding follow-up to Computer Organization and Design, Computer Architecture: A Quantitative Approach is exactly what it says on the tin: A Quantitative Approach to Computer Architecture. Shocking, I know.

I found Chapter One to be fairly uninteresting, the description of memory models in Chapter 2 and advanced pipelining concepts in Chapter 3 (particularly the discussion of Tomasulo’s Algorithm) enlightening, but Chapter 4 is where the book really heats up. It starts light with vector and SIMD approaches before discussing GPU Architecture. If you’ve ever been mystified by how the graphics card does its job and whether your problem maps to a GPU Compute approach, read Chapter Four of this book.

Chapter 5’s discussion of Thread-Level Parallelism was interesting, but not as riveting as Chapter 4, but Chapter 6 picks up again with a discussion of Warehouse Scale Computers. I didn’t know that I’d care about how WSCs work, the concerns associated with them, and, well, the sheer technological wonders that they actually are, akin to a power plant or water treatment facility! Even if you read nothing else in the book, Chapter 6 is worth a read all on its own.

In addition to Appendices A, B, and C, which are included in the hardcopy, there are also online appendices D through L. As of this writing, I’m still working through Appendix F: Interconnection Networks, because the online appendices somehow don’t count as part of the book in my mind, probably because they comprise more pages among them than the whole hardcopy textbook, including the references and indices.

All in all, Computer Architecture: A Quantitative Approach is a five-star book, appropriate for anyone who wants the gritty details of how hardware does its job, provided that the prospective reader started with this book’s younger sibling, Computer Organization and Design, by the same authors.

Engineering a Compiler is an excellent introductory text on compilers. I particularly enjoyed the textbook’s clean layout and design and cleanly written algorithms placed very close to the paragraphs where they are relevant.

Particularly after reading Muchnick, I found the amount of text explanation with a lack of concrete examples to be disturbing. Whole sections pass without any accompanying code examples. While I didn’t think that pseudocode would have particularly enriched these topics, and I could certainly look up the relevant papers provided in the bibliography, I found the lack of a concrete representation to work with left me somehow wanting more. This may trouble other readers less than it did myself.

All in all I suggest Engineering a Compiler as an excellent candidate for easy entry into a discussion on compilers, or an undergraduate text. After reading this textbook, if you’re still hungry for more on compilers, try Appel’s Compilers in ML and Muchnick’s Advanced Compiler Design and Implementation.

Due to deadline pressure on another project, I will be deferring the next part of the Neural Network series until next week. As a replacement, here’s a picture of a tiny white fluff.

When I set out to design a neural network for this project, I knew very little about neural networks, artificial intelligence, or anything along those lines, and so I can’t say that I chose as I did out of any deep knowledge — what I can say is that a coworker told me that a fully-connected feed forward neural network is easy to implement.

Software Engineering is a constant fight against added, unnecessary complexity so yeah, simplicity, let’s go with that!

So… what’s a fully-connected feed forward neural network and how do I build one?

Continue reading Neural Networks Part 2: What does Feed Forward even mean anyways? →

Oh look, more Anki stats!

Despite the fact that I skipped no days this week, I’m pretty worn out. This might have more to do with allergies and weather keeping me awake at night than the difficulty of the routine.