Review: The Imposter’s Handbook by Rob Conery

This review is based off the initial version of the preview of the Imposter’s Handbook that Rob Conery made available for purchase. When the book is released, I will update this review should the Imposter’s Handbook’s content warrant.

Instead of shooting off fireworks on July 4, I was browsing Twitter and I came across this:

And after reading the description of the book on his website I thought to myself:

Holy crap! Rob Conery is writing book just for me!

I never set out to find a book that covered the topics that this one does… things that self-taught developers may have missed out on from CompSci classes… but when I saw this one, I knew instantly I would purchase it.

With that said, I will try not to let my initial positive reaction influence my review of this book. But I do want you to know that I came in wanting to like it … and I left liking it, maybe a bit more than I thought I would.

So, since I spoiled the ending already … the TL;DR of it all is that I recommend The Imposter’s Handbook without hesitation. Even if you write compilers for fun before going to bed – I’m confident this book will teach you something new. As for me, I learned both completely new topics and some new things about topics I already knew … and what more could one ask for out of a book?

Now let’s back up to the beginning…

The Imposter’s Handbook aims to fill in the blanks that self-taught developers may have by not completing a formal Computer Science degree. In other words, it covers a TON of topics. It’s broken down into 6 high level sections: Linux, Computer Science Theory, Data Structures, Database Theory, Programming Languages and Software Design. Each of those sections are then broken down into chapters, each covering a discrete topic. As you can imagine, each one of those chapters, if expanded upon in full, would be enough to fill an entire book. So in that respect, don’t expect to emerge from any of the high level sections of this book, much less the individual chapters, as an expert in the topic, much less proficient.

However, that’s not the point of this book. As Rob states in the introduction:

The first thing: this book is a compendium in summary form. I cannot possibly dive into things in as much detail as they deserve.

I’m going to give you enough detail so that you can have an intelligent conversation about a topic.

If you want to know more: that’s up to you.

And in this regard Rob succeeds.

Each chapter has enough information to provide context around why the subject matter is important and/or how it fits in to the topic of the section. The chapters also provide enough info to get started on the topic. At the very least, you’ll have a basic understanding … and know enough to start asking questions to further your education on it.

The book is peppered with links to more in-depth information throughout. Several times I found myself no longer reading the book, rather deep down the rabbit hole of exploration on one of the topics presented. Lambda Calculus in particular kept me away from the book for several days.

Everything in the book is well researched … and presented with enthusiasm (more on that below). The hand-drawn illustrations help greatly in making key points, and are entertaining. Overall, the way the content of the book is presented, it makes you want to go and find out more.

Each of the chapters is presented with the same diligence as the others. Which is great, because although I feel pretty solid on relational database theory, that doesn’t mean everybody will … so the enthusiasm apparent the chapters that I’m interested in and inspired me to dig deeper is also apparent in others that I’m … not so interested in.

All of this is a long way of saying … The Imposter’s Syndrome succeeded in giving me a head start on and making me want to find out more about a topic that I didn’t really know anything about.

In the days after finishing the book I was reading an article on machine learning, and I recognized the underpinnings of Lambda Calculus in the topic being discussed, though Lambda Calculus was never explicitly called out. At best I would consider myself some dude who knows what Lambda Calculus is, and could explain its premise. But by having only that basic understanding … I was able to divine deeper insight into the machine learning article, and really have it click. And now I’m starting to recognize it in more and more places, all because Imposter’s Syndrome gave me the curiosity to dig into Lambda Calculus.

Same thing with data mart schemas. Though the subject matter of data marts doesn’t interest me to explore those more, I did find myself in a meeting where star vs snowflake schemes were being discussed. And because of the corresponding chapter, I was able to participate more than quietly look at the floor.

Seems like this review is heading towards fan boy territory … so let me tell you about some things that didn’t particularly work.

The strength of containing a ton of information is also one of its larger weaknesses. I read the book in a linear fashion and found myself wanting there to be an overarching narrative. For example, how or why does knowing Linux lead in to needing to know Comp Sci Theory?

To be completely fair, Rob does state in the introduction that there is not a strategy on his part in presenting the content, he just wants to fill the holes. Even so, a book is naturally looked upon as the ultimate authority of the content presented within. More of an attempt to weave how and why the high level sections play into each other would be appreciated.

The content within the high level sections flow together fine, but the high level sections themselves don’t need to be read in sequential order (with the exception that Comp Sci theory section should be probably be read before Data Structures).

In my opinion there were too many walk-throughs in the Linux section. If somebody is only reading the book, not working the samples at the same time, the section gets a bit long. The walk-throughs seem to break the flow and would maybe be better served as a separate top level section.

Finally, there are some chapters that I still don’t understand. The chapter discussing P and NP in the Comp Sci section being one. I can’t put all the blame on Rob for that, heck not even the majority … but I did have to work through some of the examples and analogies explaining a topic several times. So some better, more clear, examples would help.

Fortunately, at least during the preview period, Rob is taking and responding to issues on GitHub for the book. So if you see something wrong, or want something added, or just think something should be more clear … open an issue. That’s pretty slick… So in the case of the P and NP chapter I mentioned above… all I need is to come up with some feedback from helpful than “I don’t get it”.

You’ve probably noticed by now that I’m referring to Rob Conery as Rob … it’s not because we hang out together, but rather he writes in such an informal style that when reading the book, it seems like you’re sitting around with him talking development. That’s a great attribute for a book that dives into some heavy content to possess. His enthusiasm for the multitude of subjects covered also comes through. I found myself reading fast, because that’s how I imagined it would be spoken – fast and with enthusiasm.

In other words – I’m saying a book that gets into some deep Comp Sci theory is an easy read!

Summing It Up

If you made it this far, you already know that I’m recommending the book. There’s a ton of information in it, and it’s presented in an informal and enthusiastic manner that it’s difficult to not want to explore more.

As for me … I have a ton of reading to do on Lambda Calculus now …

You can find more info on The Imposter’s Handbook here.

Matthew Soucoup on EmailMatthew Soucoup on GithubMatthew Soucoup on LinkedinMatthew Soucoup on Twitter
Matthew Soucoup
Matthew Soucoup
Matthew is a Xamarin MVP and Certified Xamarin Developer from Madison, WI. He started Code Mill Technologies and is the founder of the Madison Mobile .Net Developer's Group. 

Matt regularly speaks on .Net and Xamarin development at user groups, code camps and conferences throughout the nation, including Xamarin Evolve, That Conference, Prairie.Code(), MKEdotNET, St. Louis Days of .Net, and CodeMash.

When he's not developing cross platform apps, writing blog posts, or creating the next great talk, Matt enjoys brewing beer with jalapeños from his garden and playing 80s tunes on the piano.
%d bloggers like this: