This book contains a lot of great information for Scala programmers, but it's kind of buried in a frustrating reading experience.

A lot of what you'llThis book contains a lot of great information for Scala programmers, but it's kind of buried in a frustrating reading experience.

A lot of what you'll learn in this book is that many of the ways you use Scala normally are slow, I particularly enjoyed learning how Option, something I take completely for granted but has the potential to hurt performance in critical areas. It's not just a complaint either, the author basically offers an alternative Option implementation that doesn't suffer from this (and also, isn't as expressive, and is basically Java). There are also some great sections about Free Monads and an absolutely fantastic coverage of the differences between Scala collection types and performance. It's a lot deeper than you might think, it's not just "oh this one is O(n) and this one is O(logn)", it's extremely detailed and informative.

The main issues I have with the book are the writing style and the example used for illustration. The writing style is fluffy and feels both padded and out of place. The author basically takes the reader through almost a choose-your-own-adventure story where "you" have started a new job, and you're talking to people to understand their performance issues, and helping them out. They all have names like "Dave from so-and-so department" and it just feels totally unnecessary. He gets in some cracks about "you" avoiding scrum masters to get real work done and how happy you're making this or that group and increasing the company's bottom line. One one point, "You double-check with Gary to confirm that MVT strategies are thread-safe. He responds with a thumbs up emoji, which gives us the green light to parallelize execution of trading strategies." It just feels so out of place, it kind of reads like the author wrote a dry, matter-of-fact book and then someone told him to make it more of a story to keep readers engaged, and then he shoehorned all of this stuff in like it's The Phoenix Project. It's kind of grating.

The other gripe I've got is that there's a single domain example used as a throughline through the entire book: a high-volume stock trading application. I recognize that this is a fitting example because these kinds of applications really REALLY care about throughput, latency, and performance concerns - I have a buddy who used to work at one of these places and they universally insist on using C++ with a lot of assembly callouts to get nanosecond improvements. However, if you basically know fuck-all about the stock market, a lot of the terminology and domain specifics might go over your head, and there's little to no attempt to explain any of it as the author assumes a base level of familiarity with these concepts. This is probably a personal failing on my part because I hate the stock market and I don't mess around with it much, but I found myself occasionally struggling to understand exactly how the domain worked, and since it's critical through the ENTIRE book, this affects the whole reading.

This book is definitely worth skimming, but I'm not sure if it's worth a full sit-down read. I think the sections can largely be read independently, they rarely build on each other so it's worth going through and picking up the areas where you're particularly interested in performance. If you do Scala full-time, it's definitely worth flipping through if only to find out what kinds of things to look out for, so that you can circle back to the book later on if you encounter particular performance issues....more

I really liked this book but also was a bit disappointed by it. I'm a huge fan of Robert Martin's work, I've read his previous books and I love CleanI really liked this book but also was a bit disappointed by it. I'm a huge fan of Robert Martin's work, I've read his previous books and I love Clean Code and The Clean Coder. Based on the title and artwork I had kind of assumed that this was just the next step of the Clean Trilogy, this time focusing on architectural concerns.

It is kind of that, but it's mostly not quite that. Really, this book is a lot of background information to understand the "meat" of the book, and the meat of the book is Martin presenting his Clean Architecture pattern, which he proposed in 2012 and has been presenting and training a lot on: https://8thlight.com/blog/uncle-bob/2...

In that way, this book feels much more specific than Clean Code or The Clean Coder. While those two books are general advice for software professionals, this comes off more as an extended design pattern book that only covers one singular pattern. It's presented as The Only Right Way, and while I personally agree with Martin's perspective and his loathing for framework-heavy architectures, it was a bit disappointing that the book was mostly a very deep dive on a blog post from five years ago.

The "buildup" stuff is actually more interesting. It's about applying SOLID principles to architecture and I really enjoyed this section of the book, I felt like I finally grokked dependency inversion at a component level, and there's a lot to apply to architectural problems I face. That section of the book feels very general, though like most of Martin's work it's yet another rehash of SOLID and talking about FitNesse, two things he's gotten a stunning amount of mileage out of to a point where you kind of wonder if he's ever done anything else (he has, but boy does he return to these wells a lot).

In a way this is two shorter books smashed together. One is Clean Architecture, a book about building clean architecture using SOLID principles (and a few new ones). The other is a book about the Clean Architecture Pattern, a particular way to architect systems that shares a lot with Allistair Cockburn's Hexagonal Architecture pattern. These two concepts use the exact same name to, I think, intentionally get readers to conflate the two concepts as one and come away feeling like Martin's proposal is the only possible way to architect a system in a way that is clean. But one of these things is "clean architecture" and the other is "Clean Architecture", and it's often hard to see what is what. This is by design, I think.

In any case, the book is really good and I got a lot of out of it, though it wasn't what I was expecting really. The first half (or so) of the book feels like 80% rehash of stuff I've seen from Martin before, with 20% extremely good and useful new stuff. Then the second half of the book is a completely different topic presented as the same topic, which I enjoyed but I can see a lot of readers being turned off by. I still would recommend the book and I think it's worth reading for anyone who feels like "architecture" is part of their job....more

This remains one of the most important books software engineers can read. The second edition is even better than the first, updated to fix a lot of thThis remains one of the most important books software engineers can read. The second edition is even better than the first, updated to fix a lot of the "outdated" criticisms the first book gets, incorporating the modern DevOps movement, microservices, and modern technologies used in software engineering.

I really just can't say enough about this book. It's required reading. If you're responsible for code that runs on networked production systems, failing to read this book should be a fireable offense. Skipping "Release It!" is professional negligence. Stop what you're doing and read this before shipping another line of code.

Release It! is all about how to build cynical software, and once you start down that path you find that you can no longer think any other way. This book changes you and your career, it's just phenomenal. Even if you think you know everything in it because the patterns and practices it describes have become widespread, it's still worth reading.

The second edition fixes - or at least somewhat improves - every minor complaint I had about the first edition, and reorganizes the information, adds a lot of great new sections, and removes outdated cruft. It's superior to the first edition in every way, and that was a 5-star book for me....more

I found this book kind of a struggle to get through. It didn't read like a lot of other patterns books, in which it often feels like an expert is presI found this book kind of a struggle to get through. It didn't read like a lot of other patterns books, in which it often feels like an expert is presenting patterns and you sort of wonder if the authors are the people who designed or came up with the patterns, but more like a nonexpert that is trying to catalogue patterns they are seeing for their own notetaking purposes. It feels kind of like a student Literature Review paper in a way, nothing ever really coalesces into a coherent educational book. It's hard to explain I guess, but suffice it to say that this book didn't really "work" for me.

It's got many issues throughout, a handful of grammatical mistakes, and technical issues ranging from misleading or confusing to outright incorrect. The example code is often a bit too short, it never really "illustrates" the point of a particular pattern, but instead seems to just be the bare minimum amount of code to implement a pattern and move on. Every section of each pattern just seems to be as terse as possible, almost like the author was unsure of what he was saying, and didn't want to risk being incorrect by saying any more than was strictly necessary.

The book's strongest section was its last, on Functional Patterns. This section was good but also contained some incorrect statements. One thing I found particularly odd is the mathematical approach to discussing these functional patterns (despite simple mathematical mistakes like incorrectly defining associativity) - it never really creates the bridge between academic functional programming and Scala. As a simple example, the author builds up definitions of Functor, Applicative Functor, and Monoid, then illustrates how a Monad is the combining of those three things. This is a common explanation/definition for a Monad within the world of pure functional programming - but Scala's author defines a Monad as anything that defines map() and flatMap(). I think it would have been nice to show how these definitions of Monad actually mean the same thing, illustrating how the methods can all be generically defined by relying on those, but the book never creates that bridge. Even the names of functions used like 'fmap' and 'join' are a bit strange - the entire book uses Scala but Scala's version of 'fmap' is typically just called 'map'. It's almost like somewhere out there there is a Haskell book called 'Haskell Design Patterns' which is character-for-character the same book, but then the author realized the book might get more eyes if he just changed all the code examples to be Scala and otherwise changed nothing else.

Compare this to the classic "red book" Functional Programming in Scala by Bjarnason and Chiusano, which covers similar material but is so perfectly in harmony with the Scala language itself that a good portion of the book is rebuilding a number of components in the standard library from scratch.

The weakest section of the book is by far the Gang of Four Design Patterns section, in which all of the classic GoF patterns are covered, but not really in a way that takes advantage of the fact that Scala is a functional programming language. Like rather than each pattern being something akin to "the purpose of this pattern in an OO language is this, so we can accomplish the same thing by doing that in a functional language", they're just straighforward GoF implementations in Scala. In other words, they're the kind of code you see when a Java programmer just translates working Java code directly into Scala without regard for FP as a paradigm.

The only other section worth mentioning is the Code Reuse Patterns section which is often decent, but contains coverage of 3 patterns for dependency inversion that were covered in just the briefest, most cursory way imaginable. Once again, it almost felt like it was being sped through so as to not make any additional mistakes, as if it was written by someone that didn't really feel confident in the material and didn't want anyone to notice.

Overall this book doesn't feel like it was meant to be read by someone looking to learn anything. It seems like a student's semester project that was published by Springer without being copyedited. Like someone's personal Wiki page got printed out. It feels very minimal effort, not like the kind of book an author writes with their audience in mind and a goal of educating. There are some other patterns books, like the aforementioned red book (not strictly a "patterns book") or Functional Programming Patterns in Scala and Clojure by Bevilacqua-Linn, which are vastly better ways to spend time.

I think the Scala programming community is desperate for a fantastic patterns book on functional patterns using the language but so far every book I've found falls a bit short. Of them, this one falls the shortest. Skip it....more

I wanted to like this book a lot more than I did. I see Microservices as a "fad" that's picking up a lot of steam, and I work with microservices but wI wanted to like this book a lot more than I did. I see Microservices as a "fad" that's picking up a lot of steam, and I work with microservices but want to know how to be more effective building them. The notion of a book entirely devoted to discussing how to make your microservices production-ready was very appealing.

However, like many other reviews of this book, I found it to be far too high-level to be very useful. Almost every section makes the reader think "that's really interesting, I'd like a little more detail on that" only to have the subject change for the next section. You never get that detail you're craving, and it's very unsatisfying. In fact, I don't think there's almost any part of the book where an engineer could read it and then come away thinking about what to do next to improve their microservices. The only "next step" after reading anything is to read something else. The only exception to this is the Documentation section, which actually provides a fairly decent template for writing microservice documention, because documentation is so high-level that a high-level discussion of it actually felt appropriate.

The author states "each section of each of the chapters within this book could be expanded into its own book" as a way of basically dismissing the idea of incorporating direct useful details into this book. And yet, Eberhard Wolff's "Microservices" does exactly that - containing almost all of the information in this book, PLUS all the details you'd need to actually incorporate the information from the book into your microservices, and it clocks in at 395 pages, a mere 2.5x this book's 153 pages. Why would you ever bother reading this one?

The answer is, you wouldn't. At least, not as an engineer. Susan Fowler's "Production-Ready Microservices" isn't a book for engineers. Wolff's book is for engineers. "Production-Ready Microservices" is for managers. If your engineer team has found itself building microservices (or, as is increasingly common, told to build microservices by management because it's en vogue), but you need to do something to convince management that you need to put more time into this or that aspect of your microservice architecture to make it production-ready, hand your manager a copy of this book. It's only 153 pages, and it even contains checklists. You can point directly at the checklist and say "look, we're not doing this, that, or this - we're not ready for production yet" and it looks official enough because it's in a book. It's an effective tool in this regard, I think.

Otherwise, the book kind of feels like a consultant coming in and looking at your microservice architecure and poo-pooing it, just being judgemental about what you're building or you've built. "Nope, you're not doing these three things on my checklist, this isn't production ready." Oh, okay. So, do you have any concrete suggestions for how to fix this? "Look, that'd be an entirely different book okay? I don't have time to tell you that, I just want you to know that I know what you've built isn't good." Oh. Alright well, thanks for nothing.

The checklists are indeed super handy, I can easily see referencing them when discussing production readiness with co-workers. But aside from that, this is a book I'd give a manager to help them understand the architectural situation, but otherwise never really reference myself. For engineers, I'd definitely recommend Wolff's "Microservices" over this book....more

I'm starting a new job soon, decided I'd give this a read. It's short and sweet, easy to get through in a single sitting.

The book definitely seems outI'm starting a new job soon, decided I'd give this a read. It's short and sweet, easy to get through in a single sitting.

The book definitely seems outdated, even antiquated in many ways. Some of the advice feels like something you'd hear 20 or 30 years ago. I especially like all the attention to cleanliness and well-manicured fingernails, that feels super relevant in a world where my coworkers have sleeve tattoos and 5-inch ear gauges.

The book also suffers from broadness. It's meant to apply to any new job, blue collar, white collar, office, bagging groceries, whatever. In that way, it often felt too broad to be terribly useful. A lot of the advice is about dealing with your manager, getting help, asking for guidance and evaluation from them, etc. I can see this being useful if you're the newest waiter at a restaurant or something, but as a software engineer I assure you that my supervisor will want me to be much more self-sufficient than this, and a lot of it would be seen as a nuisance. I particularly laughed at the sheets at the end you're supposed to print out to go over your first 30 day performance with your manager, I imagined handing that to my boss and having them just laugh me out of the room. It stinks of desperation and a lack of self-confidence.

Overall, a useful read, I'll definitely be keeping in mind in my first 30 days. I liked the weekly goals, and what to focus on each week. I particularly like the idea of focusing my first week mainly on personal relationships, and my second week on actual job performance. This isn't in my nature and I think it's a good idea. My natural inclination is to get in there and start kicking ass immediately to prove I was a good hire, but the book basically convinced me this is a super-stupid thing to do because it ignores the value of creating personal relationships at work, and it creates an unsustainable pace. I'll definitely be taking this advice to heart....more

Short and sweet. Light on details but contained some pretty good tips. Worth the price of admission, you can read the entire book in one sitting, evenShort and sweet. Light on details but contained some pretty good tips. Worth the price of admission, you can read the entire book in one sitting, even right before an interview and you'll be able to easily put it into action....more

I absolutely hate the way technical interviews are done for programmers. Can you imagine if a heart surgeon went to interview at a hospIndispensable.

I absolutely hate the way technical interviews are done for programmers. Can you imagine if a heart surgeon went to interview at a hospital, and they handed him a game of "Operation" to play? That's how we interview programmers. It's so stupid, I could go on and on about it for paragraphs.

But, if you want to work at the top tech companies in the world, you have to play the game, incredibly stupid and poorly aligned it is to the task at hand. And if you're about to head out on some coding interviews, reading Cracking the Coding Interview is the single most important thing you can do for yourself. It's simply phenomenal.

There are definitely some sections that Gayle doesn't seem particularly interested in. For example, the coverage of Bit Manipulation seemed a bit cursory, like it's an area that she's not super familiar with or comfortable with herself. But for the most part, all of the major stuff is covered, in the right level of detail. It's good to review but if you weren't already somewhat familiar with a lot of these data structures and concepts, I'm not sure that the book works as an introduction.

One major omission is the coverage of Tries. They get a shout-out as a data structure that basically doesn't show up in interviews, but I interviewed at 5 major tech companies after reading this book and Tries were the right solution in three of them.

Overall though, the reason to get this book is for the set of questions. Questions that are exactly the kind of things you get asked in coding interviews. Each question has some hints, as well as the answers in the back. Take the book, and practice solving the problems on an actual whiteboard. Don't skip to the answers, but feel free to read the hints (most interviewers will provide similar hints).

There's simply nothing else you can do that better emulates the coding interview than practicing the problems in this book. It's a must-have....more

Debugging to me feels like an extremely imperfect process - while most aspects of software engineering I do on a regular basis are informed by a mix oDebugging to me feels like an extremely imperfect process - while most aspects of software engineering I do on a regular basis are informed by a mix of learning/reading with a heavy dose of experience/wisdom, debugging is one part that is purely experience, without ever having read a single book on the subject. Given how much I read and how much I learn from reading, I have assumed that while I'm good at debugging I'm really in a "tip of the iceberg" situation, and with the right kind of reading material I'd really max out my skills.

I first read "Debug It!" hoping it would provide the academic and formal learning that would turn me from an okay debugger into a master debugger. But in the end, that book wound up saying nothing new and I largely felt it was a waste of time.

I had hoped Effective Debugging, with it's subtitle of "66 Specific Ways" to debug and the "Effective *" moniker that I've come to associate with excellent books traditionally, would really teach me a lot. But alas, nope, it was stuff I already do. Sometime around Chapter 2 when Item 13 suggested I enlarge my window so that the entire line of a log file would fit, I started to realize that there probably is no book that will take me from an okay debugger to a master debugger. I think everyone's just an okay debugger and that's it.

I guess this book is worth skimming, especially if you're new to software engineering. But if you've been at it for any length of time, you could likely write this entire book if only you could be hyper aware enough of your debugging process to simply write down the stuff you're doing as though it was noteworthy, rather than second nature. Overall, I just didn't get much out of it, and I was really hoping I would. Two disappointing books in and I've given up, debugging can't be taught....more

I kind of always had this hunch that Domain-Driven Design was something of a buzzword fad, that it likely described something I was already doing reguI kind of always had this hunch that Domain-Driven Design was something of a buzzword fad, that it likely described something I was already doing regularly and that the book and the approach likely just lent formality and terminology to common sense activities. After all, the biggest thing I see referenced seems to be this Ubiquitous Language stuff, which I think just means using the same nouns for stuff as the domain experts, which I try to do anyway so I'm sure I'm already doing everything in the book, right? Nope. I was flat wrong, which is why I consider this book a must-read for engineers who do a lot of greenfield work, domain modeling, and architecture.

Early on, the author provides a sort of toy example that will stay with us for the duration of the book, designing the domain for a Scrum management product. I've actually worked a job where I did this very thing, so this resonated fairly strongly. The book suggests that, if engineers are left to their own devices, they'll design around code generality to reduce duplication, so there might be like a ScrumElement that could be a Product or a BacklogItem, and there's like a generic ScrumElementContainer which could be either a Sprint or Release. I'm just reading this section like, yeah, that's exactly what I would do... in fact I did that. Is that bad? But the rest of the book explains exactly why that's bad, and exactly how to do it better. Chapter after chapter, the book showed me the ways in which my approach to domain modeling was disastrously bad and how much better it could be. It also explained how, with this alternative approach, my domain would lend itself more easily to modular system design along service-oriented boundaries.

In short, this book is excellent and completely changed how I think about and model domain objects at work. The book can sometimes be light on detail, I often found myself wanting more information, or stronger examples of exactly how something should work, but at the end of the day that's the purpose of this book - a short introduction that encourages the reader to dive in deeper with Domain Driven Design or Implementing Domain Driven Design. As such, I can't really complain about the general lightness of this book, as it's the primary reason it was such an easily digestible 197 pages.

Overall, this book is a must-read, I wish it existed years ago. I think back to all the times that a group of coworkers and I would gather in front of a whiteboard and model domain objects together without a single domain expert in the room. It makes me slap my head at how idiotic my approach has been for over a decade, the ways that I let database and technical concerns dictate the design of domain objects rather than the business's needs. I can never look at this regularly-performed process the same way, which is why it joins my list of Career-Changing Books....more

UPDATE: Given what has happened with Patton's wife since I wrote this review, it all seems a bit petty now. I'm only leaving it here because there areUPDATE: Given what has happened with Patton's wife since I wrote this review, it all seems a bit petty now. I'm only leaving it here because there are a few comments, and if I delete it they won't make sense. TL;DR of the review: I wound up reading this book for a weird reason, and it was alright.

----

Why did I read Patton Oswalt's "Silver Screen Fiend"? To answer that, I have to first tell a bit of a story.

A few years back I wrote a blog post introducing a new order for watching the Star Wars films. I named it "Machete Order" after my blog ("Absolutely No Machete Juggling", don't ask) and published it randomly without much of a thought. A year or so after publishing it, Wired.com linked to it in an article, and for the remainder of the year after that it sort of "went viral". I was interviewed on a local news station as well as NPR, the post was mentioned in various magazines, it got a shout-out in an episode of The Big Bang Theory and King of the Nerds, and was even mentioned on CNN. Clearly this was to be my fifteen minutes.

But by far, the absolute coolest mention of my dumb Star Wars post was on an episode of Late Night with Seth Meyers, in which Patton Oswalt mentioned the order as an "amazing" way of watching Star Wars. I went through the roof, I've listened to every single comedy album Oswalt has ever released, and seen every special he's ever taped. He has been one of my favorite comedians for years and the very notion that his eyeballs were looking at my dumb blog utterly floored me. To date, this is still the highlight of my fifteen minutes of fame, which have since subsided after the release of Episode VII.

Shortly after the Seth Meyers plug, I saw that Patton was touring and would actually be in Denver a few months later. I bought tickets simply because I'd never seen him live, and then I was struck by a silly idea. What if I messaged him on Facebook, told him I was the Machete Order guy, and asked if I could meet him when he comes to town? "No," I thought, "it's too presumptuous, it's awkward and weird. I'm just some guy on the internet, why the fuck would he want to meet me?"

But my own curiosity got the better of me and I convinced myself, hey, I'm nothing to sneeze at, after all HE'S the one who referenced ME. Hell, maybe he'd be a little excited to meet me like I would be to meet him. So I worked up the nerve to message him on Facebook and asked if he'd like to meet me after his Denver show. I assured him "I'm not some rabid, crazed fan - just a hello and a cell phone pic or something would be awesome." I told him I'd understand if he didn't feel comfortable with it, that I understood the internet is full of weirdos and I'm just a name on the internet to him. I thanked him for the shout-out on Seth Meyers either way, and pressed send.

To my immense surprise, Patton responded within minutes. "Sure! This should be no problem." Holy shit. I'm going to meet Patton Fucking Oswalt! He followed up with "You + 1 will be on the backstage visit list!" I was beside myself with excitement.

But then panic set in. What the hell would I say to him? I'm just some guy with a blog, what can he and I possibly talk about? Okay, one, Star Wars for sure. I didn't want to talk about Machete Order itself, that seemed to self-absorbed. But the date of his show was actually AFTER the release of Episode VII, so I figured I could ask him what he thought of the new movie, we could chat about that a bit. Two, cell phone picture. My wife can take it, and that'll take a little time too. Or wait, what if he wouldn't want that since I'm so much taller than him? Oh, I know, I could get him to sign something! Oh but shit, what would he sign? A comedy album? Who even owns physical CDs anymore, plus he's not a rock star so that's weird. "Wait," I thought, "I've got it! He just recently published a book called Silver Screen Fiend, I'll buy a copy and he can sign that!"

So I ordered a hardcover copy of the book. I honestly had no intention of reading it. I've read a few autobiographies by comedians and frankly haven't enjoyed them much, they're always too young to have enough life experiences to impart wisdom, and the funniest life experiences they've had are already part of their comedy routines, so the books always just seem like extremely long and watered-down sets. Patton's book in particular didn't interest me as it looked, from the cover and description, like it was mostly about movies he liked, and I hadn't seen a lot of the older films he seemed to discuss. But I figured, hell, I don't have to tell the dude I'm not gonna read his book, I really just want to meet him and it'd be nice if I had something he can sign. The book signature would just be a neat memento of what would definitely be the biggest celebrity encounter of my life.

The date of the show, the wife and I drove downtown and sat down in our seats - pretty far in the back, unfortunately. By this point, my wife was actually pregnant with our first baby, a girl. I knew Patton also had a young daughter from listening to his comedy, so I figured if I ran out of things to say my obviously-very-pregnant wife could be a topic to end any awkward silences. I was feeling pretty good, I just had to keep telling myself not to act like an insane gushing fanboy and treat the man like an ordinary person.

Patton came out on the stage in Denver's Paramount Theatre and bellowed "Hello Dallas!" Oof. Not a great start. The crowd was nearly silent, some people nervously laughing trying to figure out if he was messing with them. Patton then made some jokes about the local Dallas area, which were met with almost total silence from the audience. He seemed taken aback by the reaction, like he knew that normally name-dropping attractions gets the locals riled up. There was an awkward pause and I heard someone in the front row say something to him. Then Patton jumped, "oh fuck, am I in Denver?" - big laughs. Patton had a pretty good show that night, he rescued the set and won the audience over eventually, but I could tell the Dallas flub rattled him, he even made another crack about it and called himself an idiot later on. He talked about Star Wars Episode VII and shared his thoughts on the film as well. I tried hard to focus on the show and enjoy myself, but the thoughts of meeting him kept creeping in. When he made the Dallas flub, I wondered if it would put him in a bad mood after the show. When he mentioned Episode VIII, I realized it would no longer be a viable conversation starter.

When the show ended, I looked around and tried to figure out where to go or what to do. I'm not a famous person, I have no idea what the procedure is to go backstage because you're "on the list" - I've never been on a list before. The best I could tell was, up front near the stage were some curtains with guards standing in front of them. Me and my pregnant wife tried to make our way to the curtains, but struggled against the force of the crowd moving in the other direction to exit the theater. I could hear people muttering about me, snickering. One guy laughed when his girlfriend asked what I was doing, to which he responded "he thinks he's going to be able to go backstage." Yeah, I get it. I looked like some douchey nerd fan, holding my stupid Patton Oswalt book like an idiot. But little did that guy know, I'm on the list, motherfucker!

I finally pushed my way past everyone and got to the front. I walked up to the security guard and said "hey, I'm Rod Hilton, I should be on the list." He looked me up and down, then replied, "we weren't given a list." My face fell. I thought there might be some kind of mistake. "Can you just go ask--" I started, but he interrupted "nope, sorry, can't do that. You can feel free to call him yourself though" he said, smirking. Well, shit. I didn't have his number, we only talked on Facebook. I pulled out my phone and tried to show the guard my conversation with him, but when I held my phone out he pushed my arm back down and said "sorry, can't use that, he has to actually come out here and get you."

So I messaged Patton on Facebook. "Hey Patton I don't know if you're still here but they say they don't have a list..." I knew every minute that ticked by made it more likely Patton had already taken off for the evening. And now I was asking for so much more than being a name on a list, he'd actually have to walk all the way back out of the dressing room and come get me to let me come backstage, it seemed like a lot to ask. I quickly followed up with "I won't keep you or anything just wanted a quick signature" desperate to salvage the whole endeavor. And then I stood there, against the wall. All of the people I had to push past were still glancing back, seeing if Patton was going to show up to sign books or something. But they saw no Patton, just me and my wife, standing against the wall, waiting, having been completely rejected by a few large security guards. I felt my face flush with embarrassment as I tried to think of things I could say to the security guard to convince him to let me go back stage, but I realized everything I could think of saying only made me seem even more like a crazed fan, which to a security guard likely meant security risk.

Minutes went by, feeling like hours while I waited. I kept refreshing my Facebook messages over and over, hoping Patton would respond. After some time, the entire auditorium was empty aside from the guards, a few ushers picking up trash, my wife, and me. Eventually they told me they needed us to leave the room so they could close up, so we did. I stood in the lobby for a bit instead - there were a handful of other fans there, also holding books for him to sign. I guessed they were all fans who thought Patton might show up after to greet folks, but who didn't have the audacity to actually try and get backstage like I did. I stood there until the staff indicated that Patton had "probably already left" and other fans started filing out, their unsigned books in hand.

My wife and I walked back to the parking garage very quietly. She could tell I was upset, but she had no idea what to say. I kept flashing between feelings of intense disappointment and embarrassment. The faces of all the friends and family I told I was going to meet Patton Oswalt flashed in my mind as I imagined having to tell them all one by one I didn't actually get to meet him. I mentally rehearsed how to say it in a way that played it cool like it didn't bother me and was no big deal.

We drove home in near-silence as I thought about what happened. I found it odd that the security guard hadn't told me that my name wasn't on the list, but instead that there was no list at all. If Patton had simply forgotten to add me to the list, then him remembering would have meant that I was the *ONLY* person on the list. How awkward would that have been for him? No entourage of people drinking and mingling, just him, me, and my wife. No celebrity would put himself in that kind of situation. It doesn't seem possible that he could have intended for me to be the only person on this list. Hell, that's not even a list, you can't have a list with one item on it.

And then it dawned on me. The problem wasn't that my name wasn't on the list. The problem wasn't even that the guard hadn't been given a list. The problem was, there never was a list.

I finally realized what you probably realized twelve paragraphs ago, that "You + 1 will be on the backstage visit list!" was actually just a nice way of saying "no" without making a fan think you're a jerk. This way, Patton could say yes and keep a fan, and just rely on that fan to blame the security guards for being stupid. This way, there was no risk of a disgruntled ex-fan taking a screenshot of his Facebook conversation and posting about a famous person telling the fan to fuck himself. He gets to stay cool, but also doesn't have to meet some random guy on the internet. It was the equivalent of an attractive person giving an unattractive person a fake phone number in a bar. I realized, I was just some random noncelebrity bothering a famous person and being told he'd have his people call my people. I was the waiter who tries to give Steven Spielberg his screenplay, the limo driver who tries to hand Dr. Dre his demo tape. I was a sucker.

I walked through the door of my house at the end of a very disappointing evening and looked down at my hands. There it was. "Silver Screen Fiend". A hardcover copy of a book I never had any intention of reading - purchased only so I'd have something that one of my favorite comedians could sign - completely unsigned. A rectangular object whose purpose for existence now seemed to only be to serve as a reminder of a humiliating experience, a totem of my commoner status. And there it would sit, on my bookshelf, untouched by black sharpie, mocking me for entertaining the thought that my fifteen minutes of fame was the same as actual fame, just shorter.

So I read it.

I figured, if I at least read the book then it served some purpose other than mocking me. Its placement on my bookshelf would be germane to it being a book that I read like everything else on it, rather than a waste of money that I bought too long ago to return to Amazon. And hey, maybe it would completely suck and I could give it one star on goodreads.

But in fact, the truth is that it's pretty good. It's not a terribly funny book, but it's an honest one. And though it does START with a huge stress on Patton's goal of watching classic films, that's pretty much done by the end of the first chapter, with only occasional callbacks later on. The rest of the book mostly deals with his career, covering his early start as a stand-up comedian, talking about his first acting gig on Down Periscope, and his time as a staff writer on MADtv. These sections of the book were weirdly fascinating and extremely honest - I particularly enjoyed Patton's self-introspection as he recounted his first-ever speaking line on film and how he overanalyzed all the ways he might say it. It reminded me of my own thoughts working through what I'd say to him when I met him.

Given the personal experience I've recounted in this review, you can imagine how hollow Patton's words rang for me when he discussed meeting Jerry Lewis, or how nerve-wracking it was sharing a stage with his "idols" like David Cross, Dana Gould, and Laura Kightlinger. Imagining Patton as a giddy youngster meeting celebrities he admired was difficult while also imagining him as an A-lister callously dismissing a fan by telling him that his name would be on a nonexistent list.

Overall though, and particularly for anyone who wasn't personally cast aside by Patton Oswalt, Silver Screen fiend is actually (unfortunately) a really good book. Entertaining without being "jokey," and very honest. It's a great look "behind-the-scenes" at show business, and it offers a lot of insight into Patton as a person and what made him who he is today. If you're into Patton Oswalt's comedy, don't let the title or even the book's description turn you off the book, I think you'll enjoy it.

Patton eventually responded to me on Facebook, long after I'd already given up and gone home. He assured me "you were supposed to be on the list" doubling down on the fiction. He asked me what I wanted signed, and offered to mail it to me. I told him no thanks....more

This is just about the most you could expect from a book about Docker. It's far, far better than the documentation, it talks about best principles andThis is just about the most you could expect from a book about Docker. It's far, far better than the documentation, it talks about best principles and practices, and every single suggestion is accompanied by detailed commands to type to accomplish the tasks. The book has a great throughline of developing and improving a small application, which is used as a reference in every single chapter.

It covers almost everything you want to know about Docker including more operational stuff like monitoring, orchestration, and security. Pretty much no stone is left unturned, what you want to know about using Docker for real is covered eventually.

Occasionally I wished the book went into a bit more depth, or I felt like the author was sort of hand-wavey. There were a lot of times when he'd say something like "don't do this in production" without much explanation of what you WOULD want to do in production. Additionally, there were frequent mentions of how this or that aspect of Docker will be fixed or changed soon, leaving the reader to both wonder if Docker is truly ready for prime time, as well as if this was the proper time to publish a book on the subject with the technology so in-flux.

My biggest complaint is actually about Docker itself. By later chapters, Mouat would show incredibly complex and lengthy commands to type that left me wondering if it was even possible for documentation to be good enough to get a person to the point where they'd be able to type that command from scratch. What would you do if you wanted to do something slightly different than Mouat's example? It seemed almost impenetrable at times.

One thing I felt was lacking was an example of persistent data storage. The identidock example that runs through the entire book is all non-persistent, every single container could be restarted with complete loss of state and have no effect. The closest thing to a database used, redis, was used as a simple cache that could be emptied upon restart with no penalty. But many applications need real-live databases that need to persist across container restarts, and there's basically no coverage of how one would accomplish such a thing. From my own Googling it looks like the agreed-upon pattern is a data-only container volume linked to the system needing to store data, but it would have been nice if the example application could have incorporated such a fundamentally basic need.

Overall the book is fair and does a great job of helping the reader understand the pros and cons of containerized deployments, and it takes you through pretty much everything to know, at least in the world of Docker. In terms of how you might want to change your applications to make them more containerizable, it's largely left to the reader. Nonetheless, I can't imagine there even being a book on Docker that's more thorough and properly-paced than this one, it's basically a Missing Manual....more

I have consistently written a short little review of every book I've read for the last few years, and I'm not willing to let this one break my streak.I have consistently written a short little review of every book I've read for the last few years, and I'm not willing to let this one break my streak. The problem is, I usually read programming books, and I've read hundreds of them so I have a lot to compare to, and thus my reviews of programming books are pretty well informed.

However, this is my second "new dad" book and, I dunno, it's fine I guess? I just have little frame of reference here. I learned some stuff, it's good good advice, and it's easy to read. I basically have no idea what I'm doing as a first-time-father-to-be, so any advice is good. It's a low bar.

There's a lot of breadth here, it covers every trimester as well as the first few weeks with the new baby, which is good. A lot of these books only focus on the pregnancy itself which, yeah I like being helpful to my wife, but it's kind of her thing and I'm not super involved.

One thing I should point out is the tagline of the book "Dude, relax; you’re going to be fine." didn't ring true for me. In fact, I found that I had to stop reading this book immediately before bed, as it would give me anxiety that would cause me to wake up and be unable to sleep. The book didn't relax me at all, quite the opposite. I appreciate all the "heads up" type moments the book conveyed, but relaxation was a distant memory while reading.

This is just a simple but rock-solid book on unit testing in Java 8. I wouldn't let the titleFull disclosure: I was a technical reviewer for this book

This is just a simple but rock-solid book on unit testing in Java 8. I wouldn't let the title fool you - it doesn't seem to be a big Java 8 book, in fact it doesn't really even seem to leverage the features Java 8 introduces very much. I think mostly it's a book about Unit Testing in Java, and Java 8 happened to have been released at the time, so it got thrown in the title. The code definitely IS Java 8 (not 7), but I wouldn't say that it's a book all about how Java 8 introduces new features, and here's how to unit test code that uses them, which is kind of what the title implied to me.

Mostly the book seems geared to people who are brand new to unit testing, maybe people who had never written a unit test before. The different mneumonic devices (CORRECT, FIRST, etc) underscore the targeting of newbies. However, it does NOT seem like it is a book for people new to Java itself, or even Java 8, since very little explanation is provided for any of the code aside from the unit tests themselves and why they are the way they are. If you're a big unit tester, you might find a lot of the book doesn't provide you with anything new, but honestly I actually recommend reading it anyway.

Part I is going to be familiar to anyone with background unit testing - it's just the basic mechanics of testing itself. Part II however might give even unit testing veterans some stuff to think about. It's basically all about how to write effective tests that really stress the system - and it introduces a number of mnemonics to that end. A little cheesy but I actually learned quite a bit here, and was surprised at how useful I found it, given how much experience I have writing tests.

When I first started reading Part III, all about the overall design of your code, my reaction was thinking, gosh, a lot of other books cover refactoring... it seems out of scope for a book on testing. I was very skeptical, and I didn't understand why it was included. But once I kept reading, I saw the point, and saw how using mock objects were going to allow us to refactor the book's primary example code into something more testable, and better-designed because of it (it even fixed an issue I had with the code when I first saw it, the side effects in the scoring method). By the end of the section, I was fully on board, and to be honest an entire chapter about refactoring tests was simply amazing (and easily my favorite chapter). To be frank, these later chapters are worth the price of admission alone for the book, I can't remember any other single book that covers refactoring to improve quality of tests themselves (especially in a step-by-step fashion). I can't even remember a book that covered testing multithreaded code, and for it to just be a chapter at the end of a book on testing in general was a real treat. This book covered absolutely everything, mock objects, refactoring, TDD, SOLID, and of course the basic principles of unit testing in general.

I was pretty impressed with how thorough and useful parts I and II were, but I was blown away by III and IV. Simply put, this is probably my favorite book on unit testing I've ever read. If you're new to unit testing and use Java (even if it's not Java 8), this book is a must-read. If you're a unit testing pro, there might not be that much for you here, but I still recommend giving it a read anyway and just skipping bits and pieces. Parts II and III in particular have a lot of valuable insight to share....more

There's not really a lot to say about this book - if you're interested in CoffeeScript, then it's great. It summarizes a lot of what CoffeeScript is aThere's not really a lot to say about this book - if you're interested in CoffeeScript, then it's great. It summarizes a lot of what CoffeeScript is about, the syntax, and is basically very good documentation on the language.

Personally my experience with CoffeeScript is pretty limited - in fact on a few projects where CoffeeScript was the default language for client-side code, I wound up writing JavaScript and then using a converter to convert it to CoffeeScript. The CS was definitely shorter, but I always found it confusing. There's something about the syntax that I just generally find baffling for some reason.

This book helped things make a lot more sense for me. The weird language and syntax quirks started making a lot more sense, and the weirdness around variable scope finally clicked for me. That said, I still prefer writing JavaScript to writing CoffeeScript, and I realize that makes me a cranky old man but it's true. This isn't really the fault of the book or anything but I felt like it's worth mentioning that it didn't make a "convert" out of me or anything.

Your Code as a Crime Scene has a lot of extremely interesting ideas, and for those alone it'sFull Disclosure: I was a technical reviewer for this book

Your Code as a Crime Scene has a lot of extremely interesting ideas, and for those alone it's worth reading. The essential idea is exactly what the title says - this seems weird or impossible at first but I assure you, the title is genuine. Effectively what this book is about is using forensic techniques to figure out which spots in a large code base are most in need of improvement/refactoring.

There are lots of different kinds of things to look for and visualize in your code to help figure out dangerous areas in it, and the book takes you through each one, how it works, and how to get at the data to find these areas. It's really, really interesting, in fact it's one of the most interesting books on software I've ever read. At a previous job, we did something similar to find good candidates for our weekly Refactotum meetings - it was a script that used Git and our ticketing system to find files that were frequently modified, very large, and the source of a disproportionate number of bugs - the function for a evaluating the sort order of the files was kind of complex and involved, and I was actually pretty proud of helping develop it because it was such a neat way of viewing a codebase. I had no idea that some day there'd be a book all about stuff like that, with even more techniques. Really cool.

My main complaint with the book is that the author frequently uses a tool he wrote, code maat, to perform the analyses. I'd have much preferred more stress on the actual methods - I often came away feeling like I'd be unable to employ these techniques without code maat because I didn't get enough detail on the thinking behind the tool. In fact, I think the book often comes off as a code maat tutorial that was renamed. The other thing that bothers me is that often the code base analyzed to illustrate one of the book's ideas is the code maat database itself. This just seemed so self-referential to me, weirdly meta or something. It made it hard for me to really understand things - the code itself was already one step removed from the ideas, and then the codebases being looked at wound up kind of having the same leap. It's hard to explain, but the book would be much better if it analyzed popular open source projects that people use every day, and personally I'd have preferred less involvement from code maat itself - maybe a little paragraph or section at the very end showing how code maat could be used to automate a lot of the more manual work that the previous pages employed.

Overall, I actually highly recommend checking this book out - especially if you work on a large codebase and are concerned about its quality. There are lots of cool ideas in the book to help you find the biggest "bang for your buck" areas to improve the codebase....more

Meh, it's fine. Covers some basic stuff, as a first-time dad-to-be I found it useful and informative, but I have no idea what I'm doing so pretty muchMeh, it's fine. Covers some basic stuff, as a first-time dad-to-be I found it useful and informative, but I have no idea what I'm doing so pretty much any book will hit that mark.

The book is very light on details, but it's also very short and very easy to read. It took me two bus rides and I was done with it. Good way to tell the wife (or FPP as this book likes to call her) that I finished a "Dad Book" so that I don't look like a lunk....more

Data and Goliath is an eye-opening read. I mean, I understand how I'm under constant surveillance due to things like my smartphone or cookies or FacebData and Goliath is an eye-opening read. I mean, I understand how I'm under constant surveillance due to things like my smartphone or cookies or Facebook, and I understand that the government gets access to a lot of this information via the Snowden leaks, but I guess I never fully connected all the dots enough in a single unified understanding of my world. Bruce Schneier provides it.

Most of the book is somewhat technical, helping the reader understand how data about them is collected and used. It does a good job of disseminating the Snowden whistleblowing information as well, so it's all very informative. That being said, the level of information often made me feel hopeless, like there was nothing that could be done and I almost had to just accept that this is how life is now.

The final few chapters offer some respite from this feeling of hopelessness. It contains sections on what governments ought to do, what people should do in the macro sense, and even what people should do in the micro sense, just for themselves to avoid surveillance. Schneier isn't idealistic about it either, he's pragmatic, and fully admits that there are some data people will be willing to turn over for convenience, security, or usability. There's nothing wrong with that, everyone's got to find their sweet spot.

Mostly though, I just came away feeling like Bruce Schneier is a national treasure. Can I vote for him for some kind of public office? Anything really? In a world of seemingly limitless insanity, he's a consistently sane voice. I highly recommend everyone read Data and Goliath....more

I'm a big fan of the #NoEstimates movement. I've seen multiple talks, I fight against "story points" and other forms of estimate waste whenever possibI'm a big fan of the #NoEstimates movement. I've seen multiple talks, I fight against "story points" and other forms of estimate waste whenever possible, and I trumpet the "new" movement in agile of having no estimates. I recognize that estimates are a tremendously bad way of achieving predictability in software development - in short, estimates simply do not accomplish what they are meant to accomplish, and are thus a total waste of time. But I do have a dirty little secret... I don't really have an alternative.

I go around various places of employment saying that estimates are a waste of time, and they are, but when stakeholders, product owners, and business people try to get me to explain how they're supposed to get a sense of when products will be delivered without them, I wave my hands and mutter something about how you can achieve greater predictability using real data and tracking your team's throughput, cycle time, and lead time. I know I've heard people say this, and it makes sense to me, but I don't really know the specifics, and I've had a hard time finding them. I seem to get away with this nonsense simply because, as it turns out, businesses don't really need predicability as much as they think they do. Marketing teams and salesmen tend to work better when they're selling or marketing what's already done, rather than what's going to be done "soon". And business stakeholders, for all the claims to the contrary, never actually seem to use the relative estimation/cost for various projects to actually decide what projects to do - it always seems like there's a "most important thing" that needs to be done no matter what. We have an industry where tons of people are convinced that they need to know the exact date features are going to be done, but my experience has shown me time and time again that they actually don't need that, most of the time.

Notice I keep saying "most" or "usually". There definitely ARE times when companies need to get a sense of when something's going to be done. I know estimating doesn't work for that purpose - I'm fully convinced and on board with that idea. But I've been long seeking an understanding of how to achieve it for those situations when it's needed, and I've mostly gotten away with simply not having to know. My hope going into this book, which presents itself as largely the complete guide to the #NoEstimates movement, was that it was going to answer this for me.

In the end, it still felt pretty hand-wavey, I don't think I came away with what I wanted. The book plays a lot of lipservice to the notion of predictability without estimates, but I felt like it largely does what I keep doing, which is kind of deal in vague terms and assure the audience that it's possible, without really making someone understand exactly how. The final two chapters deal most directly with this question - everything leading up to it is mostly about why estimates are worthless and how much better off you'd be without them. But the last two mostly attempt to deal with predictability and they do an admirable job, but still felt a tad vague. There's quite a bit about how one can measure progress and know if your project is going off the rails, which is helpful I guess, but not what I was looking for.

Agile books can be kind of "culty" in nature, like they come across like someone trying to convince you to join their religion. This one is no exception, a tone that I felt was exacerbated by the unfortunate decision to write much of the book as a hypothetical fictional novel. There are characters working jobs and trying to deal with problems, and of course there are super-smart characters who explain the principles of the #NoEstimates book, and of course they wind up being completely right. One particularly hilarious scene near the end has the big boss character excitedly telling the main character, Carmen, that he's never seen anyone work so well, and he demands that she and her #NoEstimates buddy (Herman, get it, "her man"?) come work directly for him. It's so dorky and ridiculous, kind of has the same vibe as an infomercial where someone can't open a soda bottle right until Billy Mays comes in and says he's got the perfect product that will solve all their problems. It reminded me a lot of how The Phoenix Project was written, but at least that book stayed consistently in "novel" mode, not switching back and forth. At one point, Herman actually gives Carmen a copy of the #NoEstimates book in which they are characters, Neverending Story style, wrap your head around that one.

But here's my fundamental problem: #NoEstimates, the movement, is something of a new agile cult, and I know it - but I'm WAY bought in. Estimates are a complete waste of time, and I'd rather simply avoid them entirely. If this is a religion, I'm a devout member, even though I don't really understand all the sacraments or whatever. So even though I didn't feel like this book really helped me come away with how to answer the "okay smart guy, how do I get predictability then?" question, I'm still way, way bought into it. Like I said, I think people need these dates/predictions far less often than they think they do, and in my opinion it's better to simply say "I don't know" than to outright lie, which is what estimating is.

I recommend everyone working in this space read this book, at the very least to absolve you of the notion that estimates are valuable and worthwhile things to produce. I loved most of the book, but I had to knock a star off because it ultimately DOES fail to provide the sort of "silver bullet" I'm looking for. I'll have to keep searching for the book/post/video/lecture/conference that actually helps me understand how to have predictability without estimating - I mean, I'm sure it's possible, using cycle times and throughputs and whatever. Right?...more

I know I say this every time I read a fiction book but I'm not much of a fiction reader. I generally find fiction written in a way that irritates me -I know I say this every time I read a fiction book but I'm not much of a fiction reader. I generally find fiction written in a way that irritates me - too much describing by an author in love with his or her own writing. Simple descriptions of a location or an object go into far too much detail, droning on and on with flowery prose that I feel like is wasting my time.

But, I loved The Martian movie, and people keep raving about this book so I gave it a shot. I really wound up enjoying it a lot - the vast majority of the book is actually just log entries from the main character, Mark Watney, so the thing that annoys me most about fiction was entirely avoided. All of the writing seemed crucial, and the only time it went into "unnecessary" detail were the explanations of the science behind Watney's decisionmaking. I had no problem with this, because I'm a nerd.

In fact, this really isn't much of a "novel" in a lot of ways. The main character doesn't grow or change, nobody really has anything like an arc. Like the movie, this is just a science geek joyride - nerding out on science and space and problem-solving complex challenges on Mars. It's great.

I found pretty much every part of the book that WASN'T a log entry from Watney somewhat annoying - prose sections on the other ship, or back on Earth, for example. These sections were critical since they gave the reader information Watney didn't have access to (and thus couldn't be in log entries) so I get why they're included, but that doesn't make them enjoyable. Like I said, I really don't like reading fiction much. Luckily, these sections don't make up much of the book - most of it pure science awesomeness.

Anyway, really enjoyed this. I saw the movie first and was worried that I'd find the book boring since I knew what would happen, but there was enough content trimmed out for the movie version that there's still a lot here. If you enjoyed the movie, I highly recommend the book, and I'm really not the type of person who says that about movies and shows adapted from books (seriously, fuck Game of Thrones, the books are exactly what I hate in writing). And if you're into science or space in general, I'd recommend this book to you as well - it's a good time and relatively short and to the point....more

At work, we selected this book for our development team's book club. So I'm going to be giving my thoughts as well as the thoughts of the rest of my tAt work, we selected this book for our development team's book club. So I'm going to be giving my thoughts as well as the thoughts of the rest of my team.

First and foremost, I thought this book was very well written. It's organized well, the "days" are paced well, and the code examples are excellent - easy to follow for the most part (the Wikipedia examples struck me as a bit odd in that they required substantial XML parsing that was not directly included in the book) and did a good job of illustrating the concepts.

While clicking around Goodreads, I clicked the author's name and saw that he actually wrote a book I've read and reviewed previously, "Debug It!" - I kind of eviscerated that book, and I'm happy to report that Paul Butcher's writing has substantially improved since then. I was very impressed with the quality of the writing in the book, the clarity of the prose, and the way in which Paul preemptively answered questions I was having, or told me they'd be addressed soon. It's the sign of a good author who is in touch with his audience when they can anticipate bumps.

One of my complaints, and in fact the complaint of my dev team, was that it simply had too much Clojure. I don't know if this is a fair criticism, but of the 7 concurrency models covered, 3 of them used Clojure (and one of them, the first, only used Java to show how crappy it is to use threads directly, and didn't cover a lot of the concurrency utils in Java).

I did finish this book, but to be completely honest the rest of the team stopped after during Week 4. The book was abandoned and we selected another book for book club. The reason was that people were growing increasingly irritated with the book's overreliance on clojure, and Week 4 was the straw that broke the camel's back. The chapter was on Actors, and rather than doing the obvious thing and doing all the examples with Akka, Elixir was chosen. So this was yet another language to adjust to, and in fact one in which Actors aren't even called Actors (they're Processes in Elixir). This set off my team's "blowhard" alarm and nobody wanted to continue further. It's a shame I didn't get to see their reaction to Butcher's conclusion, where he humblebrags about predicting that parallel programming was going to mainstream two decades ago.

In any case, here's a week by week breakdown, not in order:

Week 1 (Threads) - Great, really good overview, excellent examples of direct threading, and decent use of concurrency utilsWeek 3 (Software Transactional Memory) - also great, and since this is clojure's bag it makes sense that this was a clojure chapterWeek 2 (Functional Programming) - this chapter was the first that irritated me and my co-workers. With all the functional programming languages out there, chosing Clojure (an impure functional language, of all things) seemed kind of obnoxious. I have a hunch this was chosen so as to introduce unfamiliar syntax before Week 3, which is fair, but it started to make it feel like this was "a clojure book"Week 4 (Actors) - Bad. Use Akka, that's what everyone thinks of when they think actors, at least in the non-academic space (and using Clojure rather than Lisp or haskell puts you in a non-academic space).Week 5 (CSP) - Fine... another Clojure chapter, but I'm honestly not familiar enough with CSP to judge if this was the best tool for the job. I generally find Clojure hard to read so, it's not my personal first choice, but I think it's the right tool for Week 3 because I'm semi-familiar with STM.Week 6 (GPGPU) - This was a weird chapter to include. Parallelism using GPUs is a bit of a niche, and something that I'd imagine would be covered better in a book devoted to it. It just doesn't seem "general purpose" enough to be in a book about breadth, I found its inclusion odd.Week 6 (MapReduce) - Fantastic. Really good hands on examples with Hadoop and Storm and EMR. Great stuff, learned a lot here.

So overall, the book is more good than bad, though Butcher makes some frustrating decisions. If you have no interest in Clojure, I think you might want to pass on this book, it's a bit overly reliant on that language and if you dislike reading it I think the book will irritate you. Otherwise it's good and I'd recommend it.

The problem with the "Seven Weeks" series is, every chapter you read it seems like it would be better in its own book. I have to remind myself that these books are about breadth and exposure, not detail. So the fact that there are better books on Hadoop, MapReduce, Threads, STM, and so on out there isn't relevant, because the point is exposure.

That said, I'd be remiss if I didn't suggest Venkat Subramaniam's "Programming Concurrency on the JVM" over this book. Like this book, it too is a breadth/overview book, but rather than covering the second half of this book, it instead focuses on the first few chapters worth of content, namely Threads, STM, and Actors. It goes a bit deeper on each of these subjects by utilizing the room saved by dropping CSP and GPGPU techniques, which I think both didn't really need to be included in this book. I really liked the Lambda Architecture chapter about MapReduce, Hadoop, and so on in this book, but I'm willing to lose it to get an improved version of the chapters on Threads, STM, and Actors. And it has to be mentioned, Venkat's book utilizes the right languages and libraries for those techniques (Java, Clojure, and Scala/Akka respectively).

So this book provides a bit more breadth than Programming Concurrency on the JVM, but it provides it to areas that I think are largely unnecessary. PCotJVM is a bit more focused on the stuff that really matters, and uses better tools for job in my opinion....more

This is a pretty good book introducing Kanban to teams. There are some overview chapters on Kanban in general, some specifics about implementation andThis is a pretty good book introducing Kanban to teams. There are some overview chapters on Kanban in general, some specifics about implementation and issues that can arise, as well as specific chapters on transitioning to Kanban from Waterfall or from Scrum, and how to make Kanban work in an Enterprise.

I switched to Kanban at my last company, but the various agile coaches and experts largely handled the specifics. I loved Kanban, and tried to introduce it to my next company, but unfortunately that put me in the position of being the agile expert, and I lacked the knowledge to really make it stick. My typical pain points are actually using the process to come up with predictions for time-to-completion of work, which is only worsened by the fact that my last gig was part of the #NoEstimates movement and I can't figure out how to help my product owners and management types know when to expect work to finish, putting me in a position of advocating something that I know works, but cannot actually help make work.

I picked up this book because it was highly rated and very short, so I hoped it could get me up to a point where I'd be able to help my teams be more effective at implementing the kind of process that I have been advocating. It did a decent job of accomplishing this, I definitely know more now than I did (enough to realize how frustrated I am with JIRA as a Kanban tool), but I found the bits on predictive engineering and particularly estimate-less planning (which gets a sidebar mention with nothing else) lacking.

Definitely worth a read if you're interested in Kanban or looking to bring it to your team. The short length makes it an excellent book to introduce team members to Kanban as a 'required reading' sort of thing, and the chapter organization makes it easy to skip chapters that aren't relevant, such as chapters on transitioning from Waterfall (if you're not a Waterfall organization).

I'm still looking for the "perfect" Kanban book that's short, simple, straightforward, and answers all of my questions without presenting Kanban as a magic bullet. Most of these books present a sunshine-and-rainbows view of engineering without getting into the actual issues that can arise in Kanban with advice for how to deal with them, and this book isn't much of an exception to that. I haven't found this theoretical perfect book yet, but so far Agile Project Management with Kanban is one of the better candidates....more

This book has an interesting premise - a former HR person writing a book about companies and HR in particular, basically getting down to the truth ofThis book has an interesting premise - a former HR person writing a book about companies and HR in particular, basically getting down to the truth of corporations even when it's not politically correct. In other words, these are all the things your HR department at work knows to be true, but can't say are true while they work there.

Most of the book is pretty interesting, if somewhat predictable. Basically it just confirms that the worst suspicions you have about corporations are true. There are lots of little interesting tidbits though there are a number of things I flat-out disagree with. One thing the author says is that you should ask for raises and be offered promotions - never ask for a promotion. I totally disagree, I wouldn't have gotten my latest promotion unless I'd asked for it. Every company is different, so take what you read with a grain of salt.

If you're cynical or pessimistic, most of the book won't come as a surprise. Yes, your company age discriminates. Yes, your company fires people by making their work life suck so bad that they leave. Yes, you are never, ever, EVER to trust HR at your company - they are there to protect the company from you, not the other way around. The book does offer some useful advice for navigating around these issues, however.

The final section of the book went on for far too long and was mostly concerned with how to handle a promotion where you start managing people. I found this an odd inclusion - none of the content seemed like "insider secrets" consistent with the book's premise, it really just seemed like an ultra-light "10-minute-manager" type book. It's all stuff that's covered better in other books, it seems like it was included just to get the number of "secrets" up to 50.

All in all, I think this book is worth reading for anyone who works in a large-ish corporation, a great deal of it rang true for me and it offered solid advice in navigating the waters of corporate life through the lens of HR. It's a short book and a quick read, you should be able to get through it on a plane ride....more

I've become somewhat wary of "how to be a better programmer" type books in recent years. I really want to become a better programmer, but I've been doI've become somewhat wary of "how to be a better programmer" type books in recent years. I really want to become a better programmer, but I've been doing this for over a decade and it's gotten to a point where every book I pick up feels like rehashing the same stuff from Pragmatic Programmer, or adding codified common sense. I know it sounds like I'm tooting my own horn, like I think I'm some great programmer, but that's not what I'm trying to say - it's just that a lot of these kinds of books have little new to offer someone who has been in the industry as long as me.

I probably wouldn't have bothered picking up Beyond Legacy Code if not for the fact that the author actually mentions my master's thesis in the last chapter of the book (though he gets my name wrong, grumble), because I think it mostly fits the bill of "general book about being a better programmer."

I'm really glad I wound up reading it though, because for the first time in ages one of these books actually gave me a lot of new stuff to ponder and think about. Naturally there was a lot of head-nodding, as the book reiterates lots of things I already know, but David Scott Bernstein definitely did put these ideas to words in extremely novel and useful ways. In particular, I loved the CLEAN code acronym, which I'd never seen before and have now mentioned multiple times at work. It's not that CLEAN (Cohesive, Loosely coupled, Encapsulated, Assertive, Nonredundant) is a new way to look at code, but it IS a very handy pneumonic that's easy to reference and remind yourself of, like SOLID, DRY, YAGNI, etc.

Bernstein's chapter on Practice 2: Build In Small Batches, is particularly excellent. Not merely content with reiterating common sense ideas about building code, the chapter cites tons of studies and figures to back up the claims, really showing the value of building and releasing in small batches and avoiding huge team utilizations. I've directed people to read this chapter on multiple occasions since reading it, it's fantastic.

I think the title of the book is a bit misleading - I was kind of expecting something like Michael Feathers's excellent Working with Legacy Code, but I think the "Legacy Code" aspect of this book is pretty minor, in fact only Practice 9 deals with it directly. The rest of the chapters are more, how to write good code in general, and I suppose you could argue that all code is Legacy code once it's written, but the book title still had me expecting something a bit different. I also felt like the final chapter, Learning from Our Legacy, went on a bit too much, the final section in particular seemed to restate the exact same thing over and over, it kind of had a "can't figure out how to end" vibe to it. Part 1 of the book, which establishes how much of a "crisis" we're having in software development, was similar, you kind of read it going "okay, I get it" and wanting to get to the meat of the book.

Those minor gripes aside though, I think the book is definitely well worth reading, and I think it's earned a place on the shelf right near The Pragmatic Programmer as mandatory reading for junior and senior developers alike. Definitely highly recommended....more

I heard about "The No Asshole Rule" in a technical conference talk about building out an engineering team. The notion of the book struck me as simultaI heard about "The No Asshole Rule" in a technical conference talk about building out an engineering team. The notion of the book struck me as simultaneously obvious and groundbreaking. The basic premise is this: we all know that it sucks to work with assholes, so let's not beat around the bush and actually formulate an official company policy to not hire assholes.

It made me think back to so many interviews I've done with various candidates over the years, and the pow-wow meetings after where we tried to decide on hiring or not. I remember one in particular, where we all recognized one candidate had a fantastic skillset, and we felt like we'd regret not hiring someone of his caliber. But there were a lot of coded messages in the discussion as well: "I'm worried he may not be a good cultural fit", "will he be an effective member of a team?" and so on. What we were really asking, though I'm not sure we were willing to say so at the time, was "this guy was kind of an asshole, right?" We wound up hiring him and quickly realizing that he was a dipshit, and he became the first person I've ever seen outright fired at that company. For a time, he was actually part of the interview committee as well, and the book was dead on saying that assholes hire other assholes, because he threw a fit about us wanting to hire someone that he despised. He basically made a "him or me" ultimatum, and we chose the candidate over him. If we'd had the No Asshole Rule in place, we could have more openly discussed his assholishness, and decided not to waste our time.

Now, one struggle I had was thinking, well, I'm kind of an asshole. So how does this affect me? Author Robert Sutton's definition of asshole came in very handy for me in this regard. There are two tests for an asshole. Test One, when talking to the asshole, does the target feel oppressed or humiliated? I'm definitely guilty of doing this, so things weren't looking good. But Test Two is, does the asshole aim his or her venom at people who are less powerful? Ah, good, I'm in the clear. My venom is always directed at equally-powerful peers or more powerful individuals. It's true, I can be very blunt with criticism, and I've on more than one occasion called people out for being unprofessional. I've even used the phrase "professionally negligent" a few times. I'm sure this has made people feel bad, but there's something I appreciate about brutal honesty, and I appreciate the same level of honesty directed at myself. But I've never directed this at people who were less senior than me, or in a lower position, generally it was senior engineer to senior engineer. So I guess I'm safe?

The book contains references to a number of studies in which assholish behavior was found to be detrimental at work, as well as a number of stories about specific companies who suffered from assholes, and stories of companies who went out of their way to weed out assholes and were rewarded for it. A lot of these stories and studies, I felt, needed stronger citations. There's a collection of 'Additional Reading' at the end, but the entries aren't cross-indexed with the actual mentions in the book, I'm not sure if a lot of the claims are cited at all. Anecdotes about companies I can understand, but public studies and experiments are another matter, I think they should have been easier to source.

One particularly interesting point made was, if you find you have assholes at your company that you can't do anything about, don't let them be involved in the hiring process, as they're likely to hire additional assholes. The book overall had lots of good tips, I also highlighted the suggestion to "Fight as if you're right, listen as if you're wrong" as a good tactic for conflict resolution at work (or really, in life). My favorite bit: treat certified assholes as incompetent employees. Dead-on.

There are lots of issues I have with the book, however. For all the great advice, it's got plenty of terrible advice as well. There's a very large section on how to deal with assholes at work that you can't get rid of. This follows the sections on how not to hire assholes in the first place, and how to get rid of assholes, so it's reasonable to have a section on how to work in an environment with permanent assholes, or asshole bosses. But I found the advice generally depressing. The advice basically boils down to, "don't let them get to you." One particular story is cited where a woman was being harassed regularly by her co-workers, and in a particularly assholey meeting she just relaxed and didn't care about what people were saying. This example is mentioned repeatedly in the book as a stellar example of how to deal with assholes. At one point the advice is given to "develop indifference and emotional detachment." This just seems like horrible advice to me. Maybe it's because I'm privileged to feel comfortable leaving a hostile job, but the advice seems to boil down to lay down and take it, but don't let it affect you. Man, FUCK THAT. Stand up for yourself, tell asshole dipshits to fuck themselves with a rake, get physical if you have to. Maybe it's pride or machismo or I don't know what, but if I was being treated the way that some of the examples in the book were being treated, there's no scenario that plays out where I just tolerate it and try not to let it bother me. I'd just leave, or make it my life's goal to get that person fired so I didn't have to. I'm absolutely not going to let someone talk to me like that, and nobody else should either. I'm not a human being at home and someone else's doormat in the office; I'm a human being 100% of my day, and I deserve to be treated like one, no exceptions.

In fact, a lot of the "just put up with it and don't let it bother you" advice came off like the kind of advice an asshole would give to people with no backbone, to keep the author and other assholes elevated above everyone (the book acknowledges that assholes do tend to get promotions). It's like the advice a fascist would give to the disenfranchised to keep them quiet. These sections of the book made me wonder about the authors intentions, like maybe he was actually a secret asshole trying to keep oppressed people oppressed for his own benefit. Here are a few choice quotes: "just get through each day until something changes at your job or something better comes along" and "passion is an overrated virtue in organizational life, and indifference is an underrated virtue" and "hide from your tormenters". The book also advises to win little battles against assholes to "sustain your spirit" and tells the story of someone who put laxative in treats that she knew an asshole would eat. This is just petty, childish bullshit (and criminal, in the laxative case). Passive aggressive little wimps and weaklings do stuff like this, and quite frankly it makes me feel like they DESERVE to be stepped on and steamrolled by people. Stand up for yourself, call assholes out for being assholes, and if you get fired for it, so be it. How could you live with yourself saying "yes sir" to someone mistreating you all day every day, but then snickering to yourself because you put ex-lax in his coffee? Just fuck off with all that, grow a pair. Shit.

There's also a section how to keep your inner asshole in check. This was very valuable to me, as I definitely can be an asshole, and it's probably something I should reign in. That being said, the book acknowledges the advantages to being an asshole, especially with regards to promotions and rewards. And I've seen the same thing in my professional career, the assholes tend to stand out among the crowd, and are promoted to leadership positions for it. In recent years, I've actually tried to be MORE of an asshole because I've seen the advantages it offers and yes, I've seen it work quite well for me. I almost want to separate Assholes into two categories: Truth-tellers and Bullies. The key difference between these two kinds of assholes is that Bullies punch downward while Truth-tellers punch upward (and sideways). Both kinds of assholes seem to get rewarded for it, but I have few qualms about being a Truth-teller. Being a truth-teller gives you so much practice acting like an asshole that it's easy to transition into Bullying, and I need to be careful about that - that's good advice. But don't throw out the baby with the bathwater, there are nontrivial virtues to asshole behavior, and it's easy to live with yourself while being an asshole as long as you aren't picking on people who are lower on the foodchain.

Overall, the sections of the book about not hiring assholes, and making The No Asshole Rule an official policy at your company are great. The discussions about how to treat assholes at work, and how to get rid of them are excellent. But the sections on how to tolerate assholes at work made me depressed, and even angry at both the author and the would-be advice-follower. I highlighted a lot of things from the book, and I think I've come away from it a better person (or at least, with a heightened awareness of when I cross over into Certified Asshole territory). I think the book is worth reading for anyone who is in a position of power at their company, such as managers (to avoid being assholes), or people with enough seniority that they do interviews for new team members (to avoid hiring assholes). But for lower ranks who want to simply know how to deal with assholes at work they can't do anything about, I don't recommend this book. For those people, it's full of passive aggressive little nuggets of immaturity, and advice to mentally check out of work and just hope the problem goes away. I cannot stress enough how repulsive I find that advice, and how much more effective I think it would be for those people to simply fight fire with fire and become assholes themselves. Being an asshole sucks, but it's better to be an asshole than a coward....more

I didn't particularly like this book, but I want to start by saying that it's really my own fault. I should have taken a closer look at the synopsis aI didn't particularly like this book, but I want to start by saying that it's really my own fault. I should have taken a closer look at the synopsis and the table of contents, I basically read it based on the title alone and it wound up being a very different book than what I was expecting.

I was expecting a technical book for architects, or even any engineer doing architectural work and making decisions of an architectural nature. Ultimately the book is entirely nontechnical, and what it tends to view as "architects" I tend to think of more as "managers". The book is mostly about soft skills for management types and yeah, it's not really focused on management skills in terms of managing people or anything, so it's fair in that it's still focused on the skills of individual contributors.

A more accurate title for the book would be something like "Ivory Tower Architect Soft Skills: How to Interact With The Rest of the Business When You're The Most Senior Person on the Team and You No Longer Write Code".

If that's up your alley, the book is actually pretty good. Very thorough, well written, covers a lot of ground and is organized and broken up into right-sized chunks. If that's not appealing to you, I'd say give it a pass. Most of it is common sense anyway....more

First, some context. I'm really big on the "Software Craftsmanship" movement - I'm signer #227 of the Software Craftsmanship manifesto, and my businesFirst, some context. I'm really big on the "Software Craftsmanship" movement - I'm signer #227 of the Software Craftsmanship manifesto, and my business card says "Software Craftsman and Computer Science Geek" because I think that's the phrase that delivers the best bang-for-the-buck in terms of getting across what I'm all about. Moreover, while I liked Pete McBreen's original 'Software Craftsmanship' book, I didn't love it, and I've been looking for a book that I'd suggest as the first book to introduce a reader to the Software Craftsmanship ideology. Finally, I've been excited about Sandro Mancuso's book for a while, I've been following it's creation on Leanpub for over a year, eagerly awaiting the day it was 'done'; when I saw that it was picked up by Prentice Hall and made part of the Robert C. Martin Series, I was pretty excited. All of this is to explain that I really, really wanted to like this book. I wanted this to be the new go-to book for the Software Craftsmanship ideology, the book I could suggest to people who think it's elitist and annoying of me to have the title on my business card. Unfortunately, it came up very short for me.

The biggest problem with the book is one that I can't quite speak about without seeming unfair, or possibly even offensive. But I want this to be a thorough review of the book, in order to help others decide if they want to read it, so I feel like I have to mention this. The book is written... oddly. That is not to say it's full of grammatical errors or anything like that, but the style of writing is very off, something doesn't feel quite right about it. As I was reading, it felt like it had been intentionally written for a very low Flesch-Kincaid reading level or something, with very short sentences and words arranged in a clunky, somewhat unnatural order. Not incorrect, but off-putting. I kept reading and eventually commented to my wife: "you know what this book reads like? It reads like the book of someone who wrote it in English even though English is not their native language." Sure enough, sometime around Chapter 8 the author himself confirmed that English is not his first language. Now, I'm not trying to knock the guy for not speaking English natively, and his grasp of English is very, very good. Again, nothing was "incorrect". However, the book is kind of unpleasant to read as a result of this, particularly if you read a lot. It's not that it's written incorrectly, but it's far from being "well-written" - it sits somewhere in the zone of mediocrity.

The book tries to distill the entire Craftsmanship philosophy/movement into a single book, a point of reference for anyone curious, and he tries to cover every aspect Software Craftsmanship. Since I think SC is full of great ideas, it's no surprise that I found the book full of great ideas. I love the notion of engineers owning their own careers, buying books and going to conferences on their own if their company won't pay for things like that, because the company doesn't own your career, you do. The book has a great analogy of how bizarre it would be if you hired a plumber to fix your kitchen sink, and he asked if you could buy him a book or send him to a conference first. There's a small section on how to be a good manager of a team of craftsmen that I also enjoyed.

However, a lot of the best parts of the book were simply taken from other books. Done with attribution of course, and the whole idea of this book is to distill wisdom for various sources into a single reference, but I can't help but notice how often the things I enjoyed the most were from elsewhere. There's a great section on Autonomy/Mastery/Purpose that was taken right out of "Drive". There's an entire chapter on Driving Technical Change lifted from a book of the same title (with a bunch of extra stuff added that was more in line with the quality of the rest of this book). The things that were not directly lifted but were instead reworded/summarized tended to be the bulk of the book, and tended to be mediocre. The things that I felt the author really added, the original contributions to the topic, were often poor. The Driving Technical Change chapter had the author adding all sorts of different categories of people who resist the changes you're pushing for, including "The Indifferent", "The Wronged", "The Inept" and so on. It really highlighted for me the complete lack of an entry for "The Person Who Actually Has A Good Point Against What You're Pushing For, Who Maybe Should Cause You To Rethink The Technical Change You're Driving."

The worst parts of the book, by far, were the stories. The author frequently regales us with tales from his career to help illustrate points, and it very much came off like someone trying to present a very young career as though it was much more lengthy and significant. Some of the attempts to link concepts to career occurences seemed like a bit of a stretch, and it served to actually work against illustrating the concepts in a lot of places. Many of his stories simply made the author seem obnoxious, to be perfectly blunt. I'll give a few examples.

In Chapter 9 he tells the story of when he was brought in to help another development team improve. It seems pretty clear from the outset of the story that the person who hired him thought he was bringing in "The Bobs" to evaluate the team members and make recommendations on how to change staffing. But the author takes this moral high-ground stance and says "you called me here to help the developers and not to get them fired" and refuses to answer the question. He goes on to explain that it's not the developers' fault that they are bad, since they didn't "kick the front door" to work there. As someone that has worked with horrible developers, I found this stance to be completely irritating. Sure, the hiring team bears some responsibility for letting people through that aren't up to snuff, but quite frankly it's much more costly to pass on a great developer than it is to hire (and then fire) a bad one, since great developers are so rare and the missed opportunity cost is immense. Teams *SHOULD* try to err on the side of hiring rather than non-hiring, but they have to also be willing to let people go that aren't good enough. So this whole notion of not "kicking down the door" somehow absolves bad engineers from being bad is absurd - they DID send their resumes and interview and accept the offer, and that's as much "kicking down the door" as you're going to get. The author ends this section hilariously, after refusing to help fire bad engineers since he didn't take the job to get people fired, he concludes with "the selection process must be changed and whoever is behind it should be fired."

In Chapter 14 he tells the story of an argument he got in with a Software Architect at a job. He gives us an entire line-by-line script in which the Software Architect keeps walking into debate traps and the author keeps supplying him with Epic Zingers to completely shut him down. The whole thing reads like an absurd fan fiction, like the 'ideal conversation' that you have with yourself in the shower the next day where you think of the perfect thing to say to respond to everything, and completely destroy your opponent with your wit and cleverness. I'm just reading the whole thing thinking "right, that happened." And what's great is, the author himself, in his own idealized version of this fake conversation, STILL manages to come off pompous and elitist (two of the main criticisms lobbed at the Craftsmanship movement). The argument is basically around a theoretical Ivory Tower Architect who makes all the tool/technology decisions and other teams have to follow those decisions when building their software. The author, rightfully, finds this position problematic since it creates a separation between who is responsible for the decisions, and who is accountable for them. But he completely shuts the architect down in a half-page rant (that I'm TOTALLY sure happened as described, on the spot) ending with him threatening the Architect by saying that he'll tell stakeholders "to talk to you about any delays and problems that may be caused by the technology choice." Again, he's not WRONG about this dynamic being dysfunctional, but he SURE is kind of an asshole about it.

In Chapter 12, he tells the story of how he was working with a team that refused to write unit tests because they couldn't afford the time. He says he tried for 8 months to get people to work more like him, but was unsuccessful. The entire effort took "seven years to complete and cost more than ten million pounds." Sure seems like a terrible project, but then the author goes on to say "Looking back, our rough estimation was that the same project with [...] five talented and passionate developers would have taken between 18 and 24 months to complete, costing less than two million pounds." Look, I'm a huge fan of TDD and passionate engineers and craftsmanship but really, how is this even a serious argument? Compare a failed project's numbers to numbers you COMPLETELY MADE UP to illustrate how much better your philosophy works? This isn't even an "I told you so" argument, it's simply saying that he's confident it'd have gone better if people listened to him more, therefore people should have listened to him more. Well, uh, oh yeah? If you guys had hired me for the project, by my rough estimation I'd have completed the entire project in under 2 hours for less than $200. Therefore, I'm great. Ridiculous.

The most irritating story to me was one in which the author and his team wanted to give business folks something "real" to work with instead of mockups while developing. So they created a fully-styled version of the entire web application they were asked to build, but made most of the pages 'read-only' or backed by an in-memory data store that vanished on restart. He argued this allowed stakeholders to really see what they'd be getting, building a horizontal slice of the application instead of a steel thread/vertical slice. This worked out great for the author at that particular organization, but I consider it massively, massively bad advice for almost any team, and I think it borders on professionally irresponsible to advocate it in a book that people are going to read looking for guidance on how to be a Software Craftsman. Building a perfect-looking "fake" web site that can't actually be launched because it follows no nonfunctional requirements such as persistence, scalability, etc, is a surefire way to have your stakeholders think the product is "done" when it's nowhere close. When building usable interfaces to hash out the details of how a product should work, the WORST thing you can do is spend the time to fully style it with CSS and the like, because it gives off a sense of completeness that is completely inaccurate. It's far better to avoid using the corporate colors, and even use Comic Sans as the main font, simply so that it visually conveys "work in progress" to anyone who gazes upon it. Never show your business stakeholders a product that *LOOKS* like it works perfectly, they will want to launch immediately, and now you're having to explain databases and concurrent user load to business people who care about functionality and features. Terrible, terrible advice.

The book is needlessly contradictory in many places as well. The author explains that practices like TDD shouldn't be done sometimes but "must be adopted wholeheartedly", but then explains that the way to get other people to adopt practices you like is to be an example, and do those practices on your own until others join in. Isn't the team doing the practice "sometimes" by that very thing? I love TDD, I love pairing, but I'm also pragmatic and there are plenty of times when it's not the right thing to do - lots of code where writing the tests afterwards is better than before, or cases when pairing is just not going to work for a task. I'd never agree with the "all or nothing" approach the author advocates early in the book, and I find it humorous that even he couldn't agree with it for the entire duration of his own book.

The most frustrating chapter for me, by far, was Chapter 9: Recruitment. I think that recruiting and hiring good engineers is the biggest challenge facing the entire software industry, and it's bizarre to me that this is one of the things we're worst at with so few books being written about improving it. It really seems like, as a group, we simply don't know how to do it well. So whenever a book comes along, or even a chapter, devoted exclusively to talking about recruitment, I get pretty pumped up about it. But I found the advice in Chapter 9 to largely be just dreadful.

The author falls into the classic problem of relying on things like a person's blog, twitter, github account, and OSS contributions to evaluate them as a candidate. It's been shown time and time again that these kinds of criteria disproportionately exclude certain groups of people, and rely on a 'free time privilege' that is lacking in a lot of socioeconomic groups. In other words, this kind of filtering is a really good way to hire exactly one type of engineer over and over again. The author argues that 'passion' is the most important trait in a good engineer, but seems to largely define that passion in terms of what the engineer does outside of work hours. I find this extremely unfair, I've worked with lots of engineers who are excellent and passionate, but whose passion exists from 9 to 5. They may read blogs and books after hours a bit, but they have children and families and simply cannot push those things to the side to be more passionate about code. I'm not sure I even want to meet someone who is more passionate about his code than his children. This whole "it's what you do outside of work that defines your employability" movement has been taking a lot of flack recently and rightfully so, and it pained me to see this same dangerous mentality repeated in a book as though it's an integral part of the Software Craftsmanship movement to which I subscribe.

The specifics of recruitment I found just as problematic. The author argues against asking interview candidates specific questions that align the candidate with what they believe to be 'good' (fine), or asking questions that have specific right answers like API questions (fine). But then he also argues against using algorithms. He makes a decent argument against using them in interviews (the most common problems in a codebase are not algorithmic in nature), but leaves little alternative. Don't conduct phone interviews. Don't have them write code on a whiteboard. I'm sorry but what exactly am I supposed to do to evaluate someone? Is it really THAT unreasonable to ask a candidate to code a 10-20 line function on the whiteboard to solve a well-defined small problem? The value of these kinds of questions is that the 'domain' can be understood in seconds. Shuffle a deck of cards. Write fizzbuzz. Find all the anagrams of a word. I can explain these problems in no time at all, and coding the solutions should take just a few minutes. You're telling me that this is useless because it's preventing the candidate from using their "real tools"? It's not okay to make sure that a candidate can write a single function in the language of their choosing?

The author instead advocates two approaches for interviewing. For the on-site interview, a full pair programming session solving a real problem using tools that they are comfortable with. I love this approach myself, but the fact is, if the company doesn't regularly do pair programming it's extremely misleading and unfair to the candidate. So if you haven't adopted pair programming team-wide, what are you supposed to do? It would seem the answer is that you can't be a team of craftsman unless you're pair programming, which is the exact kind of XP practice dogmatism that Craftsmanship is frequently criticized for, and the entire Appendix of the book is attempting to dispell.

The other approach is the "programming assignment" approach, in which candidates are given a programming task to complete ahead of time. Then the interview consists largely of discussing the implementation. Again, I like this approach as well, but it's not always going to work everywhere, and it strongly filters out people who simply cannot carve away the time outside of work hours for this kind of stuff due to their lives not being as charmed as the author's. The most jaw-dropping section of this book is so stunning that I simply have to include the entire excerpt:

"During times when we are not ready to hire but still have applicants, we tell them at the very start of the recruitment process that we are not hiring straight- away. We suggest that if they want to go through the selection process and pass, they would be the first ones we would call as soon as we were ready. As part of our selection process, we ask developers to complete a code assignment that may take at least a weekend to complete. In order to convince them to go through the process, even knowing that we are not ready to hire, we promise to provide them with a very comprehensive review of their code. With this approach, applicants at least get some valuable advice on their code, and we can build a pool of tal- ented developers who have passed our selection process, and we can call them when we are ready to hire."

Man. Just... screw you. It's okay you wasted your weekend completing an assignment for a company that's not hiring, because we'll give you a half-assed code review and we're great so you should appreciate that. This attitude is contemptible.

Overall, this book had some good tidbits here and there but they seemed to be drowned out by the preponderance of bad advice and infuriating writing. The book exemplifies the exact kind of snotty elitism and cockiness ("Testers should find nothing. Zero. Nada.", "only incompetent people are scared to lose their jobs", "asking candidates to write code on a whiteboard is a very stupid idea", "[introducing abstractions early] is not smart; it is stupid", "Developers who are experienced with test automation will very rarely use a debugger") that plagues the public view of Software Craftsmanship. It even does this while the author specifically addresses that criticism in the appendix, simply stating that the author finds this claim "surprising" since the Craftsmen he's met are great. And on top of all that, it's written poorly, which I largely attribute to the author not learning English until his adult years, as well as the fact that this book was written almost entirely on Leanpub with no editor until it was rebranded as a Prentice Hall book.

I'm still looking for my perfect Craftsmanship book. At present, it remains the duo of Clean Code/The Clean Coder and augmented with "Apprenticeship Patterns". I'd recommend all three of those books well above this one. I honestly can't recommend this book to those who are curious about Software Craftsmanship, because I think I think it will mislead then. Nor can I recommend it to those who consider themselves Craftsmen and want to improve their craft, as I think the content consists of a mix of things you already know, and things you will find actively irritating....more

A lot of authors seem think they can gather together what is essentially a ton of short blog posts and compile them into a book that will become as noA lot of authors seem think they can gather together what is essentially a ton of short blog posts and compile them into a book that will become as noteworthy and reference-able as The Pragmatic Programmer. Maybe The Pragmatic Programmer is also really just a collection of simple blog posts, and the only reason I liked it so much and disliked this book was because I read them at different points in my career. When I read Pragmatic, I needed to read it, and it was very influential for me, and when I read Becoming a Better Programmer, I'd already learned and started doing most of the things in the book because I've been at this gig too long. Maybe if the books were swapped, I'd love this book and roll my eyes at the basic-ness of Pragmatic.

But as it happens, that's not the timing of when I read these books, and so for me Pragmatic Programmer was life-changing, and this book was an incredibly long and tedious collection of what I'd argue is common knowledge.

The book is probably fine, and I might even recommend it to a newcomer, but it just didn't do much for me. I'm not trying to say I'm above it, this isn't me tooting my own horn, I just genuinely think that there's nothing particularly insightful or noteworthy at play here. Just a standard collection of common programmer wisdom that anyone who has been working for a few years knows. I frankly found the book a slog to get through, and I kept hoping I'd eventually happen upon something worth bookmarking, quoting, or highlighting, but I just never did.

I think this is a definite "your mileage may vary" book. There are a lot of positive reviews from career newbies who clearly found it to be, for them, what I found Pragmatic Programmer to be for myself. So I don't know, it's probably worth reading if you're fairly new to programming, or perhaps unsure of yourself or suffering from imposter syndrome....more

Soft Skills is a book for software development that isn't about software development. Author John Sonmez discusses how to manage your career, how to iSoft Skills is a book for software development that isn't about software development. Author John Sonmez discusses how to manage your career, how to interview, how to prepare a resume, how to market yourself, how to improve your ability to learn and take in new information, how to experiment with new technologies, how to improve your productivity and, surprisingly, even how to manage your finances and how to stay in physical shape.

The book is, for the most part, extremely valuable. A lot of the material in the Career section has been covered in other books such as The Passionate Programmer and Land the Tech Job You Love, but the section is still somewhat useful. The section on Marketing oneself was similar, I've heard a lot of the same advice for programmers before: have a twitter account, use github, contribute to OSS, speak at conferences, write a book, etc. The section on Learning was okay but a bit abstract, and mostly common sense. For the most part, those were really the sections I was expecting from the book honestly, based on the title. I figured the book would mostly be about enriching the skills that help you thrive at work, that's typically what I consider "soft skills" at the office. I expected some stuff about navigating corporate ladders or even communicating with coworkers but there really wasn't much of that. I expected the career/marketing/learning stuff as well, and that was there though not particularly stellar.

However, the chapters that I wasn't expecting were phenomenal. The section on Productivity was great, with lots of useful tips for how to be more productive, track your productivity, and get past hurdles like procrastination. When I saw the section title I thought it was just going to be a lot of "OMGZ POMODORO TECHNIQUE!" which was there of course, but there was a lot more that was useful too.

The Financial section is the one I consider the "worth the price of admission" section of the book. If you're a software engineer, you owe it to yourself to at least read this section. It's about salary negotiation, investing, stock options, debt management, retirement plans, and more. These are things that I always wished I knew more about, but it's not taught in school and the internet is rife with scams rather than useful information on these topics. It's weird because it's always tough to ask about this sort of thing at work - people somehow expect everyone to understand 401k's and stock options, and folks are weirdly cagey about giving advice/help on these matters. The chapter on Stock Options was the first thing that finally made the subject make sense to me, and there's two sections in the Appendix about money and stock markets that are required reading as well.

The Fitness section was also great, good solid advice contained therein. There are also two more appendix sections on nutrition and fitness that are phenomenal, and they alone were better than the entirety of O'Reilly's Fitness for Geeks book. The final section, "Spirit" is largely useless. Lots of froo-froo garbage and nonsense, I found myself skimming a lot of it because I was hurting myself rolling my eyes.

Overall, the book is pretty well-written and conversational. Information is pared down into consumable chunks, and each chapter is generally only a few pages long so it's easy to pick up, read a little, and put back down. There's a bit of a vibe/tone of a sleazy car-salesman to Sonmez's writing, you sort of occasionally feel like you're listening to a Tony Robbins self-help lecture, there were multiple times when I sort of felt like I was taking advice from a douchebag. Later, on page 334, the author includes a few pictures of himself from his male-modeling days and confirms, yep, you're reading the words of a douchebag.

Tone/eyerolling notwithstanding, the book contains tons of useful advice and practical information. There's a large amount of stuff that should probably be taken with a grain of salt, especially regarding finances because the author seems to think he's in a position to give financial advice due to "retiring" at 33 years old, but includes a section on how he accomplished this that basically boils down to "I got really really lucky" and even includes a bit of "I'm a Christian and I was rewarded for my tithing". He also rented gumball machines for a while. Er, what?

In any case, I highly recommend this book to software developers, particularly the section on Finances and, if you've never seen it in another book, the sections on Career and Marketing Yourself....more

Really neat idea that went somewhat wasted on a mediocre book. I'm a Palahniuk fan, but this just didn't seem as strong as a lot of his other books.

WeReally neat idea that went somewhat wasted on a mediocre book. I'm a Palahniuk fan, but this just didn't seem as strong as a lot of his other books.

We meet our main character and find out she's died and gone to Hell. But Hell isn't just a bunch of Saw-movie traps or anything, it's like a real place, with demons and monsters and Lakes of Vomit and a desert of dandruff and a Swamp of Partial-Birth Abortions. She meets up with a group of people and they basically set out on what starts to feel like an adventure through Hell. Really neat idea...

...until they get where they're trying to go within a chapter. And it turns out that where they wanted to go was a kind of hall of records, where they get jobs as telemarketers. The notion that Telemarketers are actually working from hell is worthy of a chuckle at first, but frankly this part of the book drags on for most of the middle. It also contributes to an irritatingly confusing mythos - there's talk of how the dead can come back and go trick-or-treating on Halloween (har), that every time you get a cold sore or hairs in your ear, that's the dead trying to communicate (har har), and then Maddy directly speaks with people on Earth and tells them she's from Hell and to bring candy bars for her when they die (har har har). She even gets to have a phone conversation with her still-alive parents. So why are the dead blowing window curtains and shit? It's all just not very well thought-out, all of the mythos seems invented on the fly to make a joke. And frankly, the jokes are a bit lame, like on the level of a crack about how all of the lawyers are in Hell too.

Overall, the book is okay, starts out really strong but then really really sags in the middle. It picks up a bit towards the end, but then there's a completely asinine "twist" that's utterly nonsensical and tacked-on. Kinda disappointing, it's astonishing that this book, of all of Pahlaniuk's books, is the only one to get a sequel. I haven't decided if I'm going to bother reading Doomed yet, there was a lot unresolved in the story but I felt like getting through Damned was a bit of a slog....more