I bought a nice stack of books recently, and I'm planning on buying some more. There's a lot of good stuff, not only new books, but also some older books (as in from 2004, I'm not talking about the C++ books on my shelf).

Currently reading:

On the stack (in no particular order):

Yet to arrive or to be bought:

Books I'm considering to buy:

  • xUnit Test Patterns. More than 800 on refactoring tests. The website already offers a lot of material, but also states that it might've been outdated by the book already.

There's also the occasional novel to be squeezed in. Oh well, lots of stuff to read I reckon. Thank goodness that the weekend is near. Time to read.

Tags: books, links

legacy_code

"Working Effectively With Legacy Code" by Michael C. Feathers starts off with a bang, and probably the best and shortest definition of legacy code: "Legacy code is simply code without tests." I couldn't agree more.

The book is for all of us who have to deal with all kinds of code that is tangled, caught in a web of endless dependencies, or methods and classes that are simply too long, and/or do too much. Of course, said code usually comes along without unit tests. Now there you are, having to add a new feature or fix a bug. Where do you start? What's that scary piece code over there doing? Why is it staring at you?

That's where this book comes in. It's split into three parts. The first will give a general introduction to the subject, introducing the mechanics of change, the need for testing, the seam model and the tools you need.

The second part is where the dirt is thrown right at you. In a style of "I need to do this" or "How can I do that?", this part will shock you to your very core. No, probably not, but it will give you a lot of good advise on how to deal with a particular legacy-type situation. This part is where the book really shines. The examples given might be simple sometimes compared to real-world legacy code, but they give you a very good idea how to handle a particular situation.

In the last part Michael lists techniques for breaking dependencies. I'm not sure if I'd recommend reading these before the second part, but you should be aware that all of these techniques are regularly referenced in the first parts of the book. So be prepared to skim to this part if you need to know what a particular technique is about.

Consider "Working Effectively With Legacy Code" a companion to "Refactoring" by Martin Fowler. And while Fowler's book taught you all about refactoring and the things you can do with it, this book will teach you how to put these things into practice, how to get code untangled, so that you can finally write tests for it, and add those new features.

This book will not solve all your problems, but it will give you an excellent head start, and guide you through the process of handling legacy code. I found this book to be of great value, and I couldn't believe it took me so long to finally read it. Michael Feathers' writing style is most excellent and thankfully, entertaining. Even if you're not having the pleasure of working with legacy code right now, the time will come. You'll be glad to have this book on your side.

Tags: books

A couple of months ago I set out to write a book on NoSQL. It's about time I give an update on how it's been going, and when you can expect a book in your hands, or rather, on your screen.

After an initial burst of writing, I took somewhat of a break, so please excuse the delay in general. I spent the last weeks writing (a lot), and I'm currently trying to polish and finish up the existing content so that I can throw something out there for the world to peek at. Currently, the book covers MongoDB, Riak and Redis in varying detail, and I'm working to finish up loose ends to get into a good shape, before I'm starting work on more chapters.

A lot of people have asked me about pricing, distribution model, updates, and so on, so I'm following up with an FAQ section. In general, I'm as keen to get something out there as people have expressed their interest in reading it, believe me.

Turns out though: writing a book is hard. It takes a lot of work, a lot of discipline and creativity to come up with the right words and code examples. I'm not complaining, it's just something you don't realize from writing even slightly longer blog posts. It's still an incredible learning experience too, because I (and you) get to play with pretty much all of the features the databases covered have to offer.

So bear with me, I'm on it.

The book is not built around the idea that a big application is to be built with each database. I'm not a fan of that approach myself, as it makes it too easy to lose track of details. It's full of small examples, focused on specific features.

How many pages does it have?

As the book is still growing, and I'm still playing with layouting details, I can't give you an exact number, but the final book is probably going to have more than 200 pages.

What's the pricing going to be?

I haven't decided yet. It's not going to be in the single digits pricing range, and as the book is pretty dense with content, I don't want to undercharge. I'll keep you posted.

Will there be early access to the book?

Yes, there will be. You'll be able to buy the beta of the book for a reduced price, and follow the updates. Maybe even the commits on GitHub? I don't know. Let me know if that's something you're interested in.

Do you have some samples I can peek at?

Not yet. Layout is still far from final, but I'll throw something out as soon as an early access will be available.

What databases are being covered?

To reach my goal for a final release, I'm covering Redis, MongoDB, CouchDB, Riak, and Cassandra, all in varying detail. For some it makes more sense to go deeper than for others.

Are future updates included?

Yes, as content gets added, typos get fixed, and new databases pop up, I'll send updates to everyone buying the book. The updates are free. Consider buying the book a subscription for more chapters on other databases.

Are you extending the book with more databases over time?

Yes, I have an insatiable thirst to play with more databases, and I don't want to deprive you of experiencing that too.

Are you covering database SomeDB? I hear it's the next big thing!

For now, the list of databases is fixed. What's coming after that, on the other hand, is not. I'm open to suggestions, but I'd prefer some non-exotic over a very domain-specific database you wrote for a recent project. I'll set up some sort of voting when the final release is done.

What formats will be available?

I'm currently working on PDF and ePub, with Kindle to follow. Gotta have my priorities. A good-looking and readable PDF is my first priority, an ePub after that. Buying the book includes access to all formats.

Is there going to be a print edition?

Print is not a priority right now.

What are you using to write and generate the book?

The book is written in Markdown (I hate LaTeX), converted to HTML using Redcarpet, using Albino for syntax-highlighting, and converted to PDF using the awesome Prince XML library, I hope to eventually use DocRaptor to create the final result, as a Prince license is slightly out of budget, but DocRaptor is pretty affordable.

Where can I get updates on progress?

Mostly be following me or the handbook itself on Twitter.

Tags: nosql, books

I've been a fan and user of continuous integration for quite a while now, yet I've been keen to pick up the book "Continuous Integration: Improving Software Quality and Reducing Risk" by Paul M. Duvall et. al. to see, if it can live up to be the first book dealing exclusively with the topic. They don't have to sell me on the idea anymore, but still, there's always something to learn.

The book is separated into two parts. The first one introduces the basic principles of continuous integration, and how it could/should work for you and your project. For me, this is the valuable part of the book. It introduces what CI can do for you, and the practices usually surrounding a project using CI are. If you didn't know that CI is more than just using CruiseControl or a similar CI server, I suggest you go out and pick up this book right away.

The second part describes five parts of a continuous integration system in detail. It deals with database integration, testing, inspection, deployment and feedback. A collection of recipes accompany each section to help you structure your project, code, configurations to make continuous integration a "non-event", as Martin Fowler put it.

Just as it should, the book emphasizes the importance of a good test suite to really find value in continuous integration. Without each other, continuous integration and testing can't unfold their full potential. The book is full of examples including configurations, code and build scripts, so you're not left standing in the rain, wondering how you can get that continuous integration magic to work for you.

Though I wouldn't say I'm the target audience for it, I still think there's a lot to learn from this book. Say, you just read Martin Fowler's original essay on the topic (which you should, anyway), and want to get more into detail, this book is for you. You'll find a good reference that'll help you introduce continuous integration into your project step by step.

The book focuses a lot on Java and its tools for examples, but you can easily apply the techniques in similar ways for, say Ruby/Rails projects or any other language. Database integration luckily is a topic you don't have to worry about that much in Rails projects.

It ends with a nice collection of tools that can be used for or with continuous integration, and an evaluation of CI servers and automated build tools.

My main gripe with this books is that when it comes to whys the book falls short from time to time. For someone who can make her own conclusions this shouldn't be a problem, but I think there would've been more in it. Two examples:

  • The book uses short dialogues to explain how a specific technique would work in a team, or how a line of reasoning could come about. In my opinion they're too short. What they want to emphasize could've just as well been written in a paragraph and would've had the same result. They're missing a bigger picture, and personally, I never had conversations like that.

  • The book states on two occasions that continuous integration should happen on the baseline of your project, and seems to imply that using it on branches is not a good idea. Why that is the case it doesn't explain. That the mainline is always the integration point of a project is pretty clear, but why that doesn't mean you can't integrate important branches remains unclear.

What struck me as odd was the constant mentioning of code inspection as part of continuous integration. I value code metrics for what they are (in fact, I used to be a big fan of them), and for what they can tell you about your code base, especially code coverage, but I have mixed feelings about including all of them in an integration build, because I have seen what time waster code metrics can be. But that might just be a matter of personal experience.

All that said, I still think this book is well worth the money, if you want to see what continuous integration can do for you and your project, and how you can apply the principles to your team. Paul M. Duvall did a great job compiling his experiences of applying and using continuous integrations, most of which I also had in one way or the other. In any way, I suggest reading Fowler's article firsthand, since it will give you a big picture about continuous integration, and then you can delve into the glory details with Duvall's book.

The book also has an accompanying website, where you can find a growing stack of videos explaining a lot of the principles of continuous integration in practice. If you're living in Germany, the book is currently on sale at Lehmanns.

Still a classic on the topic is Mike Clark's "Pragmatic Project Automation", one of the first books by the Pragmatic Programmers and, though slightly outdated, still a good reference. This book got me hooked onto the ideas of continuous integration and push-button builds in the first place.

Been a while since the last reading list (here's a handy link, in case you're looking for more to read). Time to remedy that. Disclaimer: All links below are Amazon affiliate links. You'll be feeding my reading habit. Thank you in advance!

Pricing With Confidence by Reed Holden

I know I already mentioned this on the previous list, but it's just so good. A must read for pricing products or even your time as a freelancer. Must. Read.

Poke the Box by Seth Godin

A nice and short manifesto about starting (and finishing) things. If you don't finish, technically you never really started, right? Pretty delightful read and a nice kick in the pants about starting something, anything, about making things happen. Because if you don't, who else is there?

Fool's Gold by Gillian Tett

An excellent rundown of how the 2008 financial crisis came about and how derivatives and collateralized debt obligations came about. The interesting bit is that they were created with good intentions originally, but as with a lot of things, the short-sightedness and greed of investors and banks turned it into a mind-boggling web that was bound to end up as a cataclysmic and cascading failure across the entire financial system.

Start Small, Stay Small by Rob Walling

If you're interested in running a small business, built around profitable products, marketing and building them yourself, this is a great little introduction on everything you need to know. I got quite a few ideas from this book for my next ventures.

After you're done with it, and you want to keep going, Amy Hoy's 30x500 class is highly recommended.

Architecture of Open Source Applications Vol. 2

The second edition of this great compilation is upon us, and it's great. I loved the chapter on ZeroMQ in particular, but there's still a lot I need to read, e.g. the chapter on nginx or the one on PyPy

How To Win Friends and Influence People by Dale Carnegie

This book is now 80 years old yet its content is pretty much timeless. The title might be a bit misleading about what it's really about. If you're interested in improving your people skills, how to make people want something you have to offer and how you can turn them over to your side, this book is for you. If you're running a business of any kind, this is a must read. The single most revealing book I've read in a while.

It turns out, people and how we interact have barely changed at all. Still so much to learn.

Predictably Irrational by Dan Ariely

A delightful and pretty revealing book about how irrational yet predictable human behaviour is. Driven by scientific experiments, this book is also rather revealing when it comes to marketing products, for example. I'd call this another must-read if you run a business of sorts or sell something for a living.

It Will Be Exilirating by Dan Provost

A very short but nice read about how Studio Neat, makers of the Glif and the Cosmonaut, came about. Talks a bit about successfully running a Kickstarter campaign, but also about running their small business in general. A few bits and pieces to pick up in this one. Most importantly, it's another inspiration to start something.

Happy reading!

Tags: reading, books

Jenifer Altman did it. She finished the book for our Polaroid project. 25 Polaroid photographers from all over the world say farewell to a piece of photographic history. Here's a sneaky peek at the cover:

the book

The book is available for pre-order, and will ship in the first weeks of July. It's strictly limited to 500 copies, so get it while you can.

Did I mention I'm in it? I can't wait to hold it in my hands, and browse through all the photos.

If you're living in Berlin, there's currently an exhibition on Polaroids called "The Last Ten" at the Bongout showroom.

The book market is being swamped with new books. It seems like every day I discover a new announcement for an upcoming book on Ruby or Rails. Let's see what's currently in stock, and what's waiting for us next year.

The first ones to start are, obviously, the Pragmatic Programmers.

Apparently some of the authors of RSpec are also writing a book about Behavior-Driven Development for them.

Apress quickly became big on the Ruby/Rails bandwagon, and speaking of RSpec, they also have a book on it due in February, though it's not officially in their catalogue yet.

Just recently they put out several books:

  • Pro Active Record. I'm still wondering how it's possible to write an entire book on Active Record, but apparently it's possible.

  • Practical JRuby on Rails Web 2.0 Projects. I don't fancy the title, but I ordered this book anyway, since it's pretty much the only one on the topic of JRuby.

  • Practical Rails Projects. Shows different aspects of Rails by using them in very different project. A nice approach compared to just developing one or two applications over the course of a book.

Upcoming books from Apress:

O'Reilly already put out their share of Ruby and Rails books, but right now the queue looks rather slim.

  • Advanced Rails. Seems to cover several topics of Rails that are, well, advanced, covering topics like Meta Programming, REST, developing plug-ins, etc.

  • The Ruby Programming Language. Mats itself is writing this one together with David Flanagan (who wrote a lot of books on JavaScript). I'm not sure if it can replace the PickAxe as the most valuable Ruby book for me, but that might just be for strictly melancholic reasons, what with it being my first Ruby book.

Manning has only put out one book on Rails yet, the excellent "Ruby for Rails" by David Black. But they have some interesting stuff in the queue for 2008.

  • Ruby in Practice. This could become the mother of books on advanced Ruby topics. The topics include testing, integration, indexing, asychronous messaging and much more.

  • Flexible Rails. I can't say much on that topic, but maybe this book will change that. Flex and Rails. Nuff said.

Addison-Wesley recently released kind of the companion book to "The Ruby Way", a most excellent book.

  • The Rails Way. Just been released, covers a lot of Rails grounds, from basic to advanced. Should make for a nice desktop reference.

  • Design Patterns in Ruby. Though I have mixed feelings about design patterns and their overuse in the Java world, it should be interesting to read about how they can be useful in the Ruby world.

There, lots of new stuff to read for the new year. I'm sure there's more to come, as it naturally happens with a technology on the rise. The downside is that the quality of the books becomes more and more average over time, but there's a lot of talented people writing on these, so hopefully the Ruby/Rails book market will see more and more great books coming out in the near future.

Tags: books, rails, ruby

There's a lot of complaining, especially from people coming to Ruby from the Java world, about the lack of a language specification. And while a lot of effort is put into the RubySpec project to at least have a test-driven specification, the written word has been silently ignored for a long time. At least in terms of information technology.

There used to be a book called "Ruby in a Nutshell", written by Matz himself, but it mainly dealt with Ruby 1.6, and is therefore seriously outdated.

David Flanagan (author of several great books on JavaScript and Java) set out to fix that problem. With the help of Matz he dove deep into Ruby and wrote what I can only describe as its only valid written language specification. The result is "The Ruby Programming Language".

The book doesn't take any unusual path when it comes to its structure. It deals with the basic structure of a Ruby program, datatypes and objects, expressions, operators, control flow, methods, procs, lambdas, classes, modules and finally, reflection and metaprogramming.

Whatever you consider part of the Ruby language, you'll be sure to find it in one of those chapters. David manages to get the whole of the language into a mere 300 pages. Both a testament to the compactness of Ruby and David's skill to explain each part as simple as possible.

You'd expect something like a language specification to be boring (if you don't, you obviously haven't read the Java Language Specification or The C++ Programming Language), but I'm happy to report that is not the case. While you shouldn't expect an entertaining read, you can expect to learn all the little details you somehow have not yet grokked about Ruby. The book finally opened my eyes on the difference of proc and lambda. The book ends with a discussion of the core classes of Ruby, including API changes between 1.8 and 1.9.

It is up-to-date with Ruby 1.8, and includes most of the features of Ruby 1.9 including of course, fibers.

My verdict is simple: If you work with Ruby, buy this book. It's pretty much the most complete book on Ruby you'll find. While "The Ruby Way" is an excellent reference "The Ruby Programming Language" is meant as a guide through the language. You can read it once, and get back to it when you need to. And seriously: You should read it. There's very likely some parts of Ruby you haven't worked with in all detail yet. This book does a good job in helping you uncover them.

Disclaimer: O'Reilly provided me with a copy of the book for reviewing purposes. My excitement about it is real.

Tags: books, ruby

I've been on vacation in France for most of June, and that means lots of time to read. Originally I planned on reading more on distributed systems, but I had a decent backlog of books on my Kindle, so this was just the right time to plow through them. By the way, if you don't have a Kindle yet, you should get one. It's a great little device. I've been reading so much more since I got it. Anyhoo, here's the list of books I've been reading in June.

Java Concurrency in Practice by Brian Goetz. This is a classic on programming for concurrency in Java. While all the code examples are Java, they're just as easy to understand, and should be easily applicable to your programming language of choice. Given, of course, that there are libraries offering similar data structures.

The book goes through great length discussing what's wrong with just using threads and synchronizing access to data and how newer concurrent APIs in Java can help you avoid the hassle. It covers a mind-boggling number of details and data structures. Concurrent collections, designing thread-safe code, latches, barriers, queues, atomic data types, locks, semaphores, deadlocks, thread liveness, execution pools and so on. The part that really surprised me was the insight on the JVM's memory model, and why you need to protect data structures when it's shared across threads and multiple cores and processors. A must-read when it comes to programming for concurrency, and not just on the JVM. This book is a true gem.

Designing With Data by Brian Suda. A great, short introduction to visualizing data. The book is for everyone new to the area of graphing and exploring data. Don't expect a thorough introduction on statistics and everything around the numbers. The book focuses more on introducing the reader to the different types of graphs, why and when they work and also why some of them don't work.

Scalable Internet Architectures by Theo Schlossnagle. This book was written in 2007 and was way ahead of its time. Never mind the examples being mostly in Perl, this book covers all the little details on what it takes to build scalable web applications. Heck, it even shows you how you can build your own cross-vendor database replicator. A highly recommended read. It's right up there with Release It! by Micheal Nygard, which you should read too.

Small Is The New Big by Seth Godin. I gotta admit, I haven't read anything by Seth so far, but this was a great start. It's a collection of 183 posts from his blog, carefully selected to represent little stories on why big companies fail and how small companies can succeed. It's a great read, I'm amazed how well Seth can take small examples like chucking a large pile of jewel cases and extrapolate them into a big picture to examplify why the music industry is doomed. Looking forward to reading more of his books.

Drive: The Surprising Truth About What Motivates Us by Daniel Pink. The title says it all, the book explores, through scientific (but not at all boring) analysis, why money is not our sole motivator. We have an inner drive to expand our personal horizons, to master what we do every day and to work towards a purpose bigger than ourselves. Tom Preston-Werner (of GitHub) recommended the book at a conference, and you can see how it reflects the work culture at GitHub. Fits in very well with the aforementioned book.

Programming Concurrency on the JVM by Venkat Subramaniam. This book picks up where "Java Concurrency in Practice" left off. To recap things in terms of more traditional synchronization and concurrency APIs it builds on several simple examples that are being rebuilt constantly using new tools as the book progresses. The interesting bits are the part that covers software transactional memory and actors, both mostly focusing on Akka.

As the title suggests this book is very code-heavy, which sometimes, at least on the Kindle, is a bit unreadable. It takes you through all the details of using STM and actors, both in Java and Scala, but also with examples in Groovy, JRuby and Clojure. This is pretty neat, because you pick up some new things along the way. I'd wish for some more depth here and there but I feel much better informed on STM and actors after reading it.

Knack by Norm Brodsky and Bo Burlingham. A book focused around founding, running and growing a business, this one is full of stories from the author's experiences with his businesses, beginning as start-ups, growing into big yet still customer-focused and in their own right still small companies.

Added to the mix are stories from people and companies the Norm has advised over the years. You don't have to believe or take for granted everything he has to say and recommends doing or not doing, but this one is a great read either way, very much so because it is full of stories. If you read "Drive" and "Small Is The New Big", you'll find similar patterns occurring in all of them.

As days go by this book keeps coming back to me. Lots of little details that I want to apply to my own business practices. The more I think about it the more I think you should read this book.

Clojure Programming by Chas Emerick, Brian Carper and Christophe Grande. Clojure pushes all the right buttons for me as a language, and this book so far has helped me grasp more and more of it. While some of the code examples aren't very practical and introduce new concepts without discussing them here and there, the book is still a great introduction to the language. I just wish it wasn't > 600 pages, but still, lots of contents to plow through.

Pricing with Confidence by Reed Holden. I came across this book by way of Amy Hoy's blog posts on pricing. The book deserved an emergency spot on my reading list because it's very relevant for the product I'm currently working on. The book's focus is on basing the price of a product on its value to the customer. Granted, I just started reading it, but so far it reads well and the points make a lot of sense. If you're looking to dive deeper into pricing your products, there's also Don't Just Roll The Dice, whose PDF version is available as a free download.

Now go read!

Tags: reading, books

There are some interesting books on Ruby and Rails related entering the fierce market, let's have a quick look.

The first worth mentioning is "Enterprise Recipes with Ruby and Rails" by Maik Schmidt, author of "Enterprise Integration with Ruby" (also highly recommended). Why should you read it? The book introduction answers that question short and painfully:

"Every web site project is really an enterprise integration project in disguise."

Though it's still in Beta it seems pretty complete already.

The next one is "Refactoring: Ruby Edition". It's not secret that Martin Fowler is a Ruby fan, so he teamed up with Jay Fields to bring the refactoring classic up to par, and port it to Ruby.

After "Design Patterns in Ruby" this is the next classic to be coming to Ruby. If you loved the original "Refactoring" book, this is a must. It's available as a Rough Cut, and is likely to come out in February.

Tags: books

I got to read a lot of great books in 2013, shaping a lot of my current thinking both in terms of business and web operations. If you're looking for something to read, follow along!

Effective Monitoring and Alerting

I've developed an interest in improving our monitoring, and this book delivered some good insight. The book is a quick read, and it ends up delivering a great idea for how a monitoring system could be structured, without going too much into implementation details.

There's a distinct lack of books on this topic, so this one is good to start with.

The Signal and the Noise: Why So Many Predictions Fail — but Some Don't

From the guy who predicted the 2012 election results, a great introduction on statistics, probability, written in an entertaining style (i.e. not boring you with too much math). Gives lots of examples from Nate's personal history of getting into numbers and probabilities. Very entertaining read and will definitely make you think about these topics some more.

The Black Swan: The Impact of the Highly Improbable

Nassim Taleb has an interesting writing style, to say the least. Among slews of bashing other people and polishing his own ego, you'll find streaks of genius.

The Black Swan is a great read on managing risk, or the inability of managing certain risks. If you're running any kind of application in production and are actively involved in operations, this book is a must-read.

The book's point could be made in a significantly shorter version of it, but that would of course deprive you from the joys of reading about Taleb's personal feelings.

The Art of Capacity Planning

This book is a classic, and I only got around to reading it this year, shame on me.

It's wonderfully short and to the point, dealing a lot with monitoring and making your capacity planning work in the best ways possible.

If you haven't read this book yet, start right now. It's timeless for anyone working in web operations.

Friendly Fire: The Accidental Shootdown of U.S. Black Hawks over Northern Iraq

A book describing in great detail the shootdown of two helicopters over the no-fly zone in Iraq in the early nineties.

Why is this relevant and interesting? It's pretty terrible that people have died during this incident.

The fascinating parts of this incident and the book are in what happened in all the parties involved in the incidents and in the organizations as a whole, for years leading up to the event.

This book was an eye-opener for me on how I think about production incidents. It covers in great, great detail the events in a socio-technological organization, the US military.

There's so much to learn in this book that can be applied to web operations.

The Field Guide to Understanding Human Error

Sidney Dekker is a great writer on topics are very relevant to web operations: humans.

Human error is a common excuse for production incidents, all the more so when a plane crashed or other bad things happen.

Dekker puts these things in perspective, and he's helped shape my thinking a lot. What a human does in a particular situation, why he does it and how the organization and the work environment have shaped his understanding of a particular situation.

A great and highly recommended read, goes nicely with Snook's "Friendly Fire."

Managing the Unexpected: Resilient Performance in an Age of Uncertainty

I didn't know what to expect from this book, I bought it on a hunch.

It turns out it's an important read when it comes to managing risk and achieving organizational resilience. Fits in perfectly with the books mentioned just before.

It looks at a slew of different industries and on how they handle risk and risky situations. Fire departments, air travel, and lots more.

It introduces the concept of a high resilience organization and a lot of great ideas, which are picked up by Dekker in a book introduced below.

Thinking in Systems

The book on complex systems and systems theory.

I was amazed, only in hindsight, how important this book is. It introduces the idea of complex systems and how parts in a complex system interact with each other, how they influence each other, how even just small changes in one can have long and delayed effects on others.

The book introduces these concepts in ways not directly related to web operations and software, but you'll notice the relationships right away.

This is the book to read. Read this one first, read it now. The most influential book I've read in 2013.

After reading "Thinking in Systems", you'll see systems and complex interactions between systems everywhere. You know why? Because there are systems everywhere.

Small Giants: Companies That Chose to Be Great Instead of Big

Running a small little business myself, I strive to get as much inspiration and insight on how others running their companies as possible.

This book has been a big inspiration for me. It covers a dozen or so companies that did everything they could to build a balanced workplace with happy employees and a long-lasting legacy rather than go for the big buck or for outside funding.

Lots of great stories in this book. If you're running any kind of business, this is a great read.

The Challenger Launch Decision: Risky Technology, Culture, and Deviance at NASA

This book is so chock full of insight on behaviors and interactions in socio-technical organization, it kept blewing my mind over and over.

It's about the Challenger incident in 1986, and everything contributing to this incident over years leading up to it.

The level of detail extracted by Diane Vaughan is amazing. She introduces the term "normalization of deviance" in the book, a term that stuck with me, and that I'm now seeing everywhere. It provides a description for something that naturally happens, whether we want it or not, but that seems unavoidable.

Again, this book isn't directly related to software, but it's so very relevant to what we do in web operations. Humans, human interaction, organizations and culture. I found these bits to be the most interesting and fascinating bits when it comes to running anything in production.

If you're curious about these bits too, then this book is for you. Together with "Friendly Fire", it provides amazing insights and learnings for running your own operations team or how to improve human interaction and culture at your company overall.

These books are very relevant to the ideas of DevOps.

Drift Into Failure

Now that you've read "Thinking in Systems", "Managing the Unexpected", "Friendly Fire", and "The Challenger Launch Decision", here comes Dekker putting all of them together, quite literally.

I was quite amazed to find references to all of them in this book.

The books left me wondering a bit on how you can detect normalization of deviance, what you can learn from the Challenger and Iraq incidents, from high-resilience organizations.

This book is Dekker helping you find answers.

Read "Thinking in Systems" first, then "Friendly Fire", "Managing the Unexpected" and "The Challenger Launch Decision", and then read "Drift Into Failure" to find more practical applications of what's been introduced in the other books.

I've had my mind blown several times by all of them. They're pretty amazing eye-openers.

Thinking, Fast and Slow

Just started reading this, but it seems relevant to the topics of biases. Had it on my reading list for a while now, so it's about time to read it.

Will have to report back on this soon.

Free Bonus Reads

If you need more business-related reading, I posted a list of the books that influenced how we run our company over at Travis CI.

Here's to more reading in 2014!

Tags: books