Learn You a Haskell for Great Good! (Currently Reading and liking!)
By Miran Lipovaca
The Elements of Computing Systems
By Noam Nisan and Shimon Schocken (Currently Reading and liking!)
By Robert Nystrom
The Art of Assembly Language (Currently Reading and liking!)
By Randall Hyde
Game Engine Architecture
By Jason Gregory
The Rust Programming Language
Wow! I was pressed into Rust by some very persuasive hackers. Having been a managed language boy for my whole life, I could never make friends with memory.
I dabbled in C and C++, but I could make friends with neither heap nor stack.
One day someone showed me some single-digit latency web server shenanigans. That convinced me to give systems programming another go (NPI).
I’m no rustatcian, but RustLang is an excellent power tool. It should be part of any professional programmer’s kit. You should be able to write some low-level code.
Aside from the safety features, I like the language a lot. It is very opinionated. It has a package manager, a sane standard library, and a built-in testing framework. I did not feel nearly as lost as learning some of the competitors.
As for the compiler, it’s a strict relationship that you slowly learn to appreciate and love. It’s not a foolproof system by any means. But it feels good to know that someone else is at least pushing me in the right direction.
I went through the regular Rust books, blogs, and tutorials, but I caught myself in too many lousy GC and JIT habits. This was the first book that made it all click together. If you already have a problem you need to solve, and you already have some experience, then this is the book for you.
By Steve Klabnik and Carol Nichols
Solving Identity Management in Modern Applications
You will have dealt with auth when you’ve been around the block in the web space. When dealing with consumer-grade software, auth often looks like a solved problem. This is false. Grown-ups have counter-intuitive and irreconcilable ideas about what auth is and should do. There is no silver bullet that absolves you from understanding the problem. You might have heard of OAuth, OIDC, SAM, and others. Techniques and protocols that facilitate auth of all kinds. You might have used a library implementation or a framework. Maybe, you built an OAuth flow by hand at some point. But things get hairy fast when you grow out of a single login point and a handful of social identity providers. This book gives an overview of all these techniques and examples for each. You might find new and surprising features. You will discover where some IdPs go off-spec and how to correct for that. You can create your implementations from scratch if you need to. After reading this, I felt a bit safer dealing with auth.
By Yvonne Wilson and Abhishek Hingnikar
Learn Python 3 the Hard Way
This is one of my favorite books. Zed’s original blog got me into programming at a later age. I was a budding artist when I first fell in love with computers. At the time, learning to code was a frustrating affair. This book was the first one I could come out on top of.
The hard way is indeed the easy way, and it does two things very well. First, it teaches you the language practically, without getting bogged into minutia. Second, this approach gives you the confidence to take ownership of the computer.
In contrast to the tutorial books and reference tomes of the time, the book doesn’t explain much. It makes you do the exercises and build your intuition. This way, I learned to recognize and solve problems almost subliminally.
The book frowns upon the use of fancy IDEs and virtual environments. It was the first book that made me use the terminal, notepad, and nothing else. After working the hard way for a bit, I felt like a computer owner, instead of merely a tenant for the first time.
By Zed A. Shaw
Enterprise Integration Patterns
I was a latecomer to the microservices thing. Previous experience kept me skeptical of wild ecosystems with a billion side effects. Moving to the cloud didn’t convince me to change. The cloud is efficient and scalable, but it’s not consistent and not guaranteed. So the more you could keep in memory and on the clock, the less possibility of transient errors.
Yet, your software will inevitably succeed. And when it does, you will have to start integrating other systems into your horizon. First, you will have to connect to third-party systems. Then, your business will acquire others. Eventually, you will have integrated with dozens of partners and government systems.
This turns your project into a kind of microservice in a more extensive ecosystem. You can’t escape these integration patterns.
This book focuses on messaging for integration. It’s a comprehensive taxonomy of the different messaging patterns. Furthermore, the author gives endless examples of how to apply these patterns. You will see what problem each pattern solves and how to implement it. You will be combining different patterns into complex message systems by the end.
This is my go-to when trying to connect large systems. First, identify their components, then apply the correct adapters. Using messages in the cloud makes it scale like nothing else.
By Gregor Hohpe , Bobby Woolf and friends
Make Your Own Neural Network
I love this book so much. ML and neural networks were only starting to get hyped up when I was starting out. I wanted to know more about neural network training and layering principles. Still, I got too bogged down in matrix and tensor implementations of Keras and Pytorch. These never made much sense to me. This is the book that changed that for me.
The author takes small, simple, illustrated steps through the fundamentals of neural networks. Each step is so small that you could model it with pen and paper. By the end, neural networks will make intuitive sense. You understand enough to be able to build your very own training framework.
By Tariq Rashid
Working Effectively with Legacy Code
Software swallowed the world, and now everything we touch is a legacy migration. This book helped me through my first job working with a ’legacy’ project and migrating it to a better place. This book contains some ideas and tricks for working with code that’s not your own. None of these tricks are ‘good practices’ or ‘beautiful solutions. But, these methods have helped me make those scary critical changes. I moved the mountain of legacy code to a better place, one piece at a time.
By Michael Feathers
Game Programming Patterns
As a beginner programmer, trying out game-dev resulted in many messes. Before this book, I did not get OOP patterns at all. I had a hard time recognizing specific problems. After reading Game Design Patterns, something clicked. I finally understood how to look for particular issues and apply proven patterns.
The author lays out the chapters with visual aids, diagrams, and code samples. There is tons of context and examples to drive home the core of the problems.
I was left able to recognize the problems these patterns were trying to solve and able to understand the solutions.