This February was quite a busy month for me, so I didn’t get through many books. Still, I managed to read a few.

Life 3.0: Being Human in the Age of Artificial Intelligence, Max Tegmark, ‎ Knopf, August 2017

AI is everywhere nowadays – it’s nearly impossible to have a technical conversation without mentioning it. The problem for me is that I don’t fully understand what’s happening in this field, and without that understanding, discussing AI feels challenging.

I’ve tried learning through YouTube videos (by the way, I highly recommend talks by my colleague Jodie Burchell, such as this one and this one), but video content isn’t how I learn best. I learn through books. That, however, presents another challenge: AI literature spans multiple genres.

Some books focus on practical tips for using AI tools efficiently. For example, I read AI Hacks for IT Pros by Chrissy LeMaire and Brandon Abshire (Manning), which is great for hands-on AI usage but doesn’t offer much depth in understanding the technology itself.

Then there are books about working directly with large language models (LLMs) and the concepts behind their implementation. Hands-On Large Language Models by Jay Alammar and Maarten Grootendorst (O’Reilly) was particularly insightful. It helped me grasp what an LLM is and why it works the way it does.

But AI isn’t just a technical phenomenon; it’s shaping society and the economy. Power and Progress: Our Thousand-Year Struggle Over Technology and Prosperity by Daron Acemoglu and Simon Johnson explores this impact and issues a call to action: how can we, as a society, prepare for a world where capitalists prioritize AI over human labor?

Yet one question still lingered for me: Is AI truly changing everything? Well, if you ask Max Tegmark, the answer seems to be yes.

Tegmark’s Life 3.0 is quite an old book – published in 2017, it almost feels like prehistory at this point. But it does a great job of building the bigger picture: in theory, nothing is impossible, and AI surpassing human intelligence is not just a possibility but a likely reality. After all, the human brain is just a physical object, which means it can, in principle, be replicated with the right arrangement of atoms. In fact, it’s even easier than that – we don’t have to recreate the brain itself; we only need to implement its functions. And once AI reaches that point, it could go far beyond what humans are capable of.

Tegmark explores different scenarios for our AI-driven future and warns that we must ensure AI remains aligned with our best interests. We need to define the right goals for it, but here’s the tricky part: do we even understand our own goals as a species?

One funny aspect of Life 3.0 is Tegmark’s admiration for Elon Musk. This polarizing figure is repeatedly mentioned as a visionary capable of shaping the future. Well, we’ve seen how that’s playing out.

Two chapters stood out to me in particular: Matter Turns Intelligent, which discusses how computation – something I already understand – evolves into intelligence, and Consciousness, which suggests we might soon have a mathematical theory of consciousness. That idea alone is mind-blowing. Other chapters felt closer to science fiction, though after finishing the book, I have to admit that what seems like fiction today might not be fiction forever.

Perhaps Tegmark is overly focused on a distant future, while more pressing concerns demand our attention right now. But then again, someone has to think about these things.

Would I recommend Life 3.0? Absolutely. And I have more books like this on my reading list – maybe I’ll find one that’s even better.

Building a debugger, Sy Brand, No Starch Press, 2025 (Early access)

Down to Earth! Or maybe even straight into the depths of software development hell. We’ve been writing buggy code since the earliest days of computing – Ada Lovelace even spotted some in Charles Babbage’s work! AI makes mistakes too. At some point, debugging becomes inevitable.

Now, here’s my personal story. For many years, I taught a course on Operating Systems, covering their internals, key concepts, and algorithms in process management, memory management, concurrency, security, and programmer-facing interfaces, among other things. While we’re on the subject, I highly recommend Operating Systems: Three Easy Pieces by Remzi and Andrea Arpaci-Dusseau – it’s the best book on the topic. I’ve always believed that understanding operating system internals is crucial for writing efficient code.

However, one topic never quite fit into my course: executable file formats and their relationship to memory layout and code execution at runtime. Last fall, I realized it was finally time to explore this, so I picked up a book about debuggers – because what is a debugger, if not a tool for exploring the runtime behavior of our code?

That’s when I hit a roadblock. The book relied heavily on the x86 architecture, and with my M1 MacBook, I had little to no chance of writing and running the example code myself. Bad news, right?

Well, not necessarily. As a Developer Advocate at JetBrains, part of my role involves working with the Rust ecosystem and our RustRover IDE. For some time, debugging on certain platforms – like Windows with the MSVC toolchain – had lagged behind. So I thought, why not look into it myself? And I did.

Of course, that meant I needed another computer – one with an x86 architecture, running Windows and Linux. What a coincidence! I ended up fixing some nasty bugs in our fork of the LLDB debugger while also diving into the theory and practice of building debuggers, thanks to the incredible Building a Debugger.

Now, onto the book itself. Did I already mention that it’s incredible? Well, it is. See for yourself.

Chapter by chapter, the author builds a simple debugger called sdb for Linux/x86 in C++. They start with project setup (because who doesn’t love writing some CMake files!) and an introduction to how computer architectures relate to compilation. Then comes the real stuff: how to attach to a running process, access registers in a debugging session, set breakpoints (both hardware and software), work with memory and assembly code, read debug information generated by a compiler, deal with object files, handle shared libraries and multithreading, evaluate expressions, and much more.

Each chapter explains the concepts, presents code, and even provides tests (which isn’t easy at this low level!). At the end of every chapter, curious readers find a summary and several questions to test their knowledge – answers are provided at the end of the book. I made an effort to answer them after each chapter, and let me tell you, they serve their purpose! Sometimes, they even made me go back and re-read a section or two. There’s also a glossary of important terms, and for the first time ever, I actually read one carefully.

Yesterday, I had an amazing moment: I was reading through chapters 19–21 on expression evaluation while simultaneously digging through LLDB’s code to understand what was happening and fix a bug I’m currently working on. Yeah, my boss lets me read books during work hours. And yes, it directly helps with my job.

If you’re into low-level programming, I have two more books to recommend. Atomics and Locks by Mara Bos focuses on Rust, but the concepts are broadly applicable and valuable for anyone writing native code. Systems Performance by Brendan Gregg is a classic. Give these two a try – you won’t regret it.

One more book

For those who read in Russian, don’t miss Табия тридцать два by Алексей Конаков.

For everyone else, imagine a book exploring what might happen if someone attempted to fix Russia’s imperial mindset by reshaping its cultural foundation – namely, by replacing Russian literature with chess. In this scenario, Russia is isolated from the world after invading a neighboring country and suffering defeat. Now, it is trying to rebuild. Chess could serve as a new cultural cornerstone, but what happens when computers “solve” the game?