Review: Vulkan Programming Guide: The Official Guide to Learning Vulkan

Vulkan Programming Guide: The Official Guide to Learning Vulkan
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

What I’m Reading: Operating System Concepts

Operating System Concepts
Operating System Concepts by Abraham Silberschatz

My rating: 5 of 5 stars

Operating Systems Concepts is a great undergraduate-level resource for its subject, focusing, as its name advertises, on the concepts behind building an operating system. Outside of the exercises, the text spends relatively little time on code examples or gritty details, relegating that to suggested reading or simply saying “Go look at an open-source operating system!”.

This emphasis on concepts makes a great deal of sense given the variance in how to accomplish goals and the sheer amount of groundwork which the book needs to cover. The book is already over 900 pages!

This book is a great read for any long-time user of operating systems who wants to understand the amazing piece of software that orchestrates their entire computing experience, as well as being great review for practitioners who want a refresher. Five stars.

Review: Computer Architecture: A Quantitative Approach

Computer Architecture: A Quantitative Approach
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.

What I’m Reading: Computer Organization and Design

This will be short not because the book isn’t good, but because I’ve got too many irons in the fire.

Computer Organization and Design by Patterson | Hennessy is the gentle introduction to hardware. The math is simple and easy to understand, the book layout is excellent, and the content is outstanding. If you want an understanding of how computers work on the most fundamental level, this is your book.

In addition to the main book, be sure to read Online Appendix C: Graphics Cards. Most software engineers already have an intuitive idea of programming on a traditional CPU, but this approachable yet thorough appendix teaches graphics card architecture and the CUDA multithreading model. I can’t recommend it enough.

What I’m Reading: Engineering a Compiler by Cooper & Torczon

Engineering a Compiler

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.

Why I Still Read Textbooks

“Perilous to all are the devices of an art deeper than we possess ourselves.” – Gandalf the White

I have a monthly textbook budget of $200/month. For the last year, I’ve exclusively spent that on hardcopy Computer Science and Software Engineering textbooks. Whenever anyone catches me reading these eight hundred page beasts, they always ask the same question:

WHY? 

I’m already employed as a Software Engineer, and I’m not reading these books to earn an additional degree, moreover, these books can’t be fun to read, so why would I spend time doing this when I could be smelling the roses or whatever normal people do with their spare time.

Normal People.

In the following thousand or so words, I’ll do my best to answer that question.

Continue reading Why I Still Read Textbooks

Screenshot from 2016-07-15 15-27-47

Neural Networks Part 5: So You’ve Made A Neural Network. What Can We Use It For?

In the last two installments of this series, I showed how we can use Haskell to define a dynamically-sized single-threaded Neural Network and explained things along the way. So yay! We’ve got a Neural Network! Great!

But now that we’ve got it, what in the heck do we do with it? Find out after the cut.

Continue reading Neural Networks Part 5: So You’ve Made A Neural Network. What Can We Use It For?