Olivier Langlois's blog

The book proposes you to teach you how to build and implement a streaming system. First, as a software developer, when I read building and implementing a software solution, I usually expect a book about programming. This is not the case, the book proposes to build and implement a system by plugging together components directly off the shelf. I was a little bit disappointed but still it could have been an interesting book. Unfortunately, the book only consists of a catalog of products used in a streaming system without proposing a comprehensible clear picture of how all these components interact together. It looks like:

Chapter on cameras:
 camera X: bla bla bla
 camera Y: bla bla bla
 camera Z: bla bla bla
 
Chapter on encoders
 encoder from company A

and so on...

I am implementing streaming servers for a living and I could not make much sense of this book so do not expect that it will for you if you are looking a book to get introduced to digital streaming.

ACE is an amazing C++ application framework to create portable networked applications. I wish that I could praise as much the first volume describing this framework but it has some weaknesses in my opinion. It enumerates one by one the different low-level ACE classes that encapsulates, by using the wrapper facade pattern, the differences in services provided by the supported platforms. These services include sockets, threading, process management and synchronization primitives. One strong point of the book is that it demonstrates how using C++ features (like strong typing and RAII idiom) with ACE classes can make programs safer and less prone to bugs. The book also briefly discusses how to design networked services based on the service requirement. My complain about the book is that it covers many topics but since it does not focus on any of them, unless you are totally new with C++ or TCP/IP applications, it is likely that you will not learn much. You will find the book interesting if:

• You have not yet seen the benefits of abstracting the implementation from the users with OO encapsulation
• You have little experience in programming TCP/IP applications

My expectation for this book was that I would learn details about the inner working of the ACE classes. The type knowledge that should have complemented the official documentation provided with the framework. I have found out that it is not really the case. Except for less experienced developers, I think that someone should be able to become able to use all the covered classes in the book with only the documentation coming with the framework. There are few places in the book where I would have like to get this extra information such as in the section on ACE_InputCDR and ACE_OutputCDR or by making sure it is clear for the readers why calling ACE_Handle_Set::sync() is needed after having called select().

I have started to read the second volume and I believe that the second one will fit better my likings as it covers high level patterns built on top of the low-level classes presented in the first volume.

This book presents how the now defunct company Numega, who developed the famous debugger SoftIce and BoundsChecker, managed software development. It has a very generalist approach by covering a broad range of topics from human resources management to release cycle. It is an ok book presenting very good practices but the problem is that it lacks focus. Instead of covering some topics in depth, it covers a lot of small things for few pages each.

This is the sequel of the book 'Writing Solid Code' that I have also enjoyed reading. In this book, the author simply applies the same mindset used to debug software to analyze development process and this makes the result very interesting. Instead of just giving a methodology for managing development, the author brings readers to think about the goals behind these methodologies through real life anecdotes and colorful analogies. In my opinion, this way of teaching is much more efficient than just showing a methodology and asking to follow it without showing the motivations behind it.

Covered topics include: how to keep a team motivated, what not to do to avoid demotivating a team, how to deliver on schedule without overwork,etc...

This is a book easy to read that could take you just few hours to go through. Some people could say that it just state the obvious but unfortunately too often this is exactly what is out of sight for many so I would say that you might get new insights from it or, at worse, a refresher on good strategies by reading a nicely written and entertaining book.

It could have been a good book since the topic is interesting. All developers know what spaghetti code is or how adding features quickly on top of a prototype without modifying the software architecture can lead to a big blob of unmaintainable code. I took this book in hope to learn other bad software development habits in order to avoid them. Despite the potential, this book does not deliver it. It start with a lengthy and half comprehensible 60 pages introduction followed by a catalog of antipatterns where most of them are empty of value. Out of around 30 antipatterns, I would estimate to less than 5 the number of antipattern descriptions interesting. Examples of useless antipatterns are:

Bad management; proposed solution: The manager must become aware of his problem in order to change.
e-mail arguments; proposed solution: Call a meeting to come to an agreement instead of wasting time writing e-mails.