excellent topic, well covered, with software for implementation
925308
This book just came out but I know a lot about it and about the author before I even got a copy.  In November of last year Mark Chang coauthored a book in this Chapman and Hall series that I reviewed with praise because of the importance of the topic and the way it was demonstrated to work in a variety of real problems in pharmaceutical clinical trials.  This book is even better as it goes more deeply into the methodology, the controversies and the results from simulation studies.  Also it is much more practical because for every case where an application is given a SAS macro is also included to allow the reader to try the methodology for himself.  In March of 2007 I actually designed a two-stage adaptive design with sample size reestimation for bioequivalence trials.  I met mark at a conference where he presented much of his recent work and he was instrumental in helping me through his first book and his journal articles.  This book had already gone to the publisher but he realized that this important design had overlooked.  He added it when the copyedited version came to him.  The design and the simulations related to it are very close to what I actually used.  For those who like to program in R, he provides R code corresponding to each of the SAS macros that he gave.  These programs make the new methodology readily available to interested users. The book is very comprehensive in that it covers a wide variety of applications for phase 2, phase 3 and combined phase trials.  With the FDAs new initiative to speed up the drug discovery process this book will be an invaluable tool to statisticians in the pharmaceutical industry who would like to learn and apply these methods that along with the group sequential methodsare gaining favor within the FDA.
1264197
This is among the best introductory texts on software metrics I've read in a long time. The author carefully and meticulously leads you through the basics of measurement and metrics, including some interesting views about how measurement is an integrated activity that has three distinct phases - cognitive, semantic, and quantitative.

Key software metrics are covered, divided into simple and complex classes, and traced to quality standards and a common metrics vocabulary. This part of the book is solid and especially suited to someone who is exploring software metrics and may have been put off by the dense, overly technical approach in other books.

Like the preceding material, the chapters on designing a metrics system and data visualization are basic, but straightforward. I especially like the three chapters on data analysis that classify metrics into frequency, time and relationship domains. This is one of the clearest approaches to cutting through the complex morass of data analysis, and will put metrics into perspective instead of overwhelming. The next chapters, covering process and estimation models were adequate in my opinion. They covered the essentials. However, the chapter on defect metrics was outstanding. I liked the complete and concise coverage of this topic.

The remainder of the book ramped down and seemed to lack the detail or clarity that characterizes the preceding parts of the book. However, this material was more operational and not (in my opinion) as important as communicating the fundamentals, collection and analyses, or metrics classification that were so exceptionally well covered in this book. I highly recommend this book to anyone who wants to quickly learn the basics of software metrics.
2880785
Managed Code Rootkits (MCR) is one of the best books I've read in 2011.  MCR is a one-man tour-de-force through the world of malicious software that leverages managed code for its runtime.  Prior to reading the book I was only vaguely aware of the concept and implementation.  After reading MCR, I am wondering when we might see more of this technique in the wild.  Author Erez Metula does almost everything right in MCR, and I strongly recommend reading it.

MCR is a great book because it addresses a topic that almost no one else covers in the published world.  The book is easy to read, clear, coherent, methodical, well-organized, and thorough.  The author doesn't limit the topic to only .NET; he also provides examples of Java and Android Dalvik code.

One of the best aspects of MCR is the author's recognition that readers are likely relying on the book for an introduction to the topic, so he makes sure to explain what he's discussing.  He keeps the readers' perspective in mind and makes the right assumptions about their level of familiarity with the subject and likely expertise.  It can be very frustrating to read a book written as if the author is talking to a colleague for whom the material is already well-known.  Authors -- if readers already know a topic, they're likely not going to buy your book!

MCR contains the right mix of background, justification, theory, implementation, and code to fit any technical reader's interests.  I'm not particularly interested in the topic as a matter of course, but I read the book because the author's excitement for the topic and his explanations hooked me.

The only weakness I found is that sometimes the screen captures are too small to be easily read.  The author took screen captures of a high resolution screen that did not reduce well on the printed page.  I find that simulating a 1024x768 screen and taking screen captures results in figures more legible in print.

Overall, I recommend reading MCR, especially if you are tasked with detecting and responding to these sorts of tools.
4314264
This book takes on a big topic and makes it simple, straight-forward, and easy to understand.  If you need to learn about OSGi and how to design large-scale applications that can plug into it, this book is one that you'll want to read.

The writing style is easy to read, so maybe that's some of why I liked going through it.  It also steps into the topic pretty logically.  And I'm immmensely interested in the topic, which is a big part of my occupation.

The second part of the book goes through a dozen or so application design patterns, which were also well-presented, and certainly contribute to good application design.  That is great, but I took away an Amazon review star because I thought that should be a separate book.
50542
well done and useful with just the right amount of background
770254
As an engineer, I read a lot of technical books.  This one stood out to me in both its breadth and depth.  It covered a wide range of topics, but also went into a satisfying amount of detail on each.

The authors targeted a wide audience.  I found the book extremely useful, and the closest I have come to being a video professional is being paid for a few wedding videos, and making occasional software programming contributions to an open source NLE.  On the other hand, the proper use of high end equipment is covered enough that I can see it being useful to someone starting out as a full fledged professional colorist.

I liked that the authors didn't pick a favorite NLE.  They gave examples from all the major players and made sure to point out the differences so you could accomplish the tasks on any software.  My particular NLE of choice is not one on their list, but I was still able to apply what I learned without any difficulty.  For example, my NLE does not currently have an RGB parade available, but the authors provided alternative methods of getting the job done without one.  I also found most of the information readily applicable to still photography, which is another of my hobbies.

I liked that the authors gave equal weight to the technical and artistic aspects of color correction.  Yes, they showed how to fix an image shot with the wrong white balance or underexposed, but they also talked about the way people perceive color, how to achieve certain looks like the C.S.I. Miami look or day for night, why realistic color isn't always the "correct" color, and so forth.  The authors took examples from actual films and changed the color to illustrate how the feel is affected.

All the examples from the book are available on the included DVD-ROM to try on your own, interestingly enough including the script from an oft-repeated example to help illustrate how the color and the story were meant to interact.

The one weakness of the book is it covers so much that it can feel scattered at times.  However, this is most apparent when reading it cover to cover the first time.  The authors successfully cover the topics so well that this isn't an issue so much when using the book as a reference while working.

Someone who is not willing or able to learn a fair bit of technical jargon will not be able to follow this book, but very little prior background knowledge is assumed.  I highly recommend this book to anyone who is willing to put in a little mental effort in exchange for a great improvement in the quality of their video.
3204046
What I like most about this book was the wide variety of applications and the diversity of examples, including examples ripped from recent headlines. Also, I couldn't help but think of immediate applications I'd otherwise never have though of. For example, my company is going through a spasm of voluntary early retirement (offering a bonus) and involuntary layoffs (which don't), but the probability of getting laid off depends on how many other people take early retirement. A lot of strategizing going on right now.

This book does an excellent job of building intuition for the basic game theory cases (zero sum, Prisoner's Dilemma and other non-zero sum games), then guiding the reader to broader and broader situations -- imperfect information and signalling, cooperative games and fair division problems, voting systems, auctions. These cases and their solution approaches are explained clearly and in an engaging style. There are many examples, including several very interesting real-world case studies, for example Blu-Ray vs. HD-DVD, Cuba missile crisis, tobacco advertising, various elections, auctions for transmission rights, Coke vs. Pepsi, and many others.  One important theme is that lose-lose situations can sometimes be transformed into something better, for example by building trust among parties.

The last section expands to very wide-ranging and unexpected applications. For example, game theory models are now successfully used by biologists both at the level of individual organisms and of entire populations. Paradoxes of traditional economic behavioural assumptions are addressed, with discussion of both alternative theoretical models and the fascinating results of game theory experiments that test those alternatives.

Credit is given throughout the book to the individuals who developed these ideas, a nice touch that humanizes the field and gives some historical context. There's an excellent list of further resources for deeper investigation.

One thing I learned is that the solution strategies can be quite different for slightly different games. It's rather like solving differential equations -- very different strategies for slightly different problem variants. It's a bit unfortunate since it makes the field seem less elegant, without a simple core solution concept.

It's easier to read this book in paper than on a Kindle. Since later chapters build on concepts and examples introduced earlier, one sometimes wants to quickly jump back to review, and that's still easier to do with a real book where you can flip through pages quickly.
4798917
An excellent software book that I have read in years. It is too the point and explains all the topics nicely and has good enough examples to get you started right away.
17951
"The D Programming Language" by Andrei Alexandrescu is a
thorough and well written description of this relatively new,
well-designed and powerful software development paradigm.
The book explains complex language features in a clear and
concise manner and builds understanding of the language
starting from the basic concepts and building up to rather
advanced topics.  It is packed with examples and has quite
a few motivational discussions justifying why certain design
decisions were made in creating the language.

The writing is precise for the most part, as one would hope to
find in a definitive work.  But it is laced with allegories and
humor that both clarify the content and make it a lighter read
than might be expected.  As you can tell, I liked the book.
I came away with a good understanding of the intentions
and capabilities of the "D" language, although I am sure it
will take another pass through the book and a few hands-on
programming projects for me to really feel comfortable with it.
During that learning phase this book will never be far from
my hand.

In the interest of completeness, let me list a few things that
this book is not.  It is not a text on how to write programs.
The examples are laser-focused on the language feature being
described, and many of the descriptions start a step or two
above "beginner" level and are somewhat terse.  One would do
better with this book coming from a solid software development
background and familiarity with the concepts and terminology
of, for example, object-oriented programming.

Curiously, only a little more than half a year off the
presses, there are aspects of the book that are out of sync
with the existing "D" infrastructure.  The canonical "Hello,
World!" program will not compile without changes that align it
with the current run-time support libraries.  Also, I have run
across a couple of keywords that don't work quite as described
or are not recognized at all by the current compilers.  In this
regard, my guess is that the book is a description of how
"D" should be, and the implementation is trying to catch up.
This is certainly not a fatal flaw and perhaps something to be
expected in a dynamic situation, but try out a feature before
you commit large amounts of effort to it.

My only other caveat is that this first edition is somewhat
lacking as a reference manual.  The index needs some work;
entries could at least highlight which of a half-dozen page
references is the primary one.  At one point I wanted to
clarify use of the "binary '!'" operator.  It took me quite a
while to find it on page 234 under "Parameterized Classes and
Interfaces."  Some of the "Summary and Reference" sections at
the end of chapters contain useful tables of statement types
or operator precedence, but there is no "List of Tables" to
guide one to the best reference.  I'm sure the next edition
will be much improved as a language reference, in the meanwhile
my copy is full of pencil notes and bookmarks.

Note that I have just started coding in "D" and my comments
should be interpreted in that light.  I hope that you have
found this review useful.
522755
Very comprehensive, both in it's approach to research methods, to the examples used to illustrate ideas and concepts.
I was particularly impressed with how the authors presented user research and needs analysis, and then proceeded to translate that into a functioning design which addressed those discovered needs.
Another point that I really enjoyed was the breadth of skill sets it appealed to. They talked about the need for user profiling, which would imply cultural anthropomorphic research, and also talked about staging areas and versioning control to appeal to the techies. Not only does this serve to show the various disciplines how they interoperate, but also helps to keep the readers attention and gives everyone a sense of position in the process.
Finally, they covered most bases of design, but did it in a way that it is really done. For example, in the design section, the use of thumbnail sketches and page grid layouts are shown to illustrate how you begin to build a site. While these methods are entirely personal to the designer, they offer a method of understanding to those who have no context, and a starting point to those learning.
All in all, this is a great "road map" to building a site from A to Z. While it may not drive to the depths of any particular skill or discipline, it does a fabulous job of talking about all of them and how they interoperate to accomplish the goal of building a web site.
2049335
The examples aren't only helpful to visualize the point, but they are giving me ideas on how to implement some of these things in my own code, for instance displaying linking info when hovering over a link. Very well thought out. This book is crammed with useful and pertinent info. No editorial comments that add to the heft (but not the content). For getting the  basics - and also as a handy reference - this hits the spot. It's also not so technical that it's either boring or frustrating to read.
3168664
Expert Cube Development with SSAS Multidimensional Models is a thorough, in-depth tour of SSAS 2012 from the Multidimensional models perspective.  The authors state up front that this is not a book about SSAS Tabular models and this is an important distinction to keep in mind, as it affects the entire approach to SQL Server BI, from the installation of SSAS forward.
We are taken through a basic cube setup, mercifully not using the Northwinds sample database. I like how the authors repeatedly caution that a number of key elements need to be gotten right in the data mart before cube setup begins. While these elements can also be dealt with in the cube definition, it doesnt mean they should be, and that distinction is borne out by experience, which the authors clearly have, in spades.
We are presented with a number of useful components of SSAS Multidimensional Models including Measure Groups, Drillthroughs, Calculations (with a smattering of MDX code, about as much as I could handle)  and some useful chapters on security and performance tuning.
I was relieved that this was not a 1,000+ page book designed to monopolize shelf space in the tradition of old school technical book publishing. For me, it struck a good balance between level of detail and keeping things moving, so I was able to productively work through it in a reasonable amount of time. For a fairly dry topic the authors managed to keep it interesting, although it helps as a reader if you have some cube exposure (as I did) prior to attempting this book.
1128182
*** The Good ***

Opening the table of contents, I was immediately impressed by the
selection of topics. Computer vision is a broad field, and PCVwP manages
to cover plenty of ground. Over the course of few chapters you
automatically create panoramas, build an image search engine, implement
an optical sudoku solver, and more. The underlying theory is developed
and built upon as you go, so you never have too long of a slog before a
fun demo. I especially enjoyed how the author capped Chapter 4 on camera
models - pretty dry stuff, to be honest - with a demonstration of
augmented reality (placing 3D objects into images) using PyGame and OpenGL.

I paid special attention to Chapters 2, "Local Image Descriptors", and
7, "Searching Images"; I've implemented these algorithms myself. Both
are presented well. The author covers the theory accurately but
succinctly, without getting bogged down in detail. The image search
algorithm presented in the text is simplified but not dumbed down. In
fact, the ambitious reader who completes the end-of-chapter exercises
will have a pretty state of the art image retrieval system.

One of the book's strengths is the elegantly written code samples. They
are a great advertisement for Python as a scientific computing tool. I'm
personally most at home bit-banging in C++, but even with powerful
libraries (Boost, Eigen, OpenCV) it's hard to match the terseness of
Python. I appreciate the focus on free, open-source software, and the
star libraries in this book - Numpy, SciPy, Matplotlib - are
high-quality and well documented. MATLAB users, take notice.

As a developer of OpenCV (the Open Source Computer Vision Library), I
was happy to see it featured in the final chapter. OpenCV's Python
bindings were totally redone in the last couple years, but the book's
treatment is up-to-date. If the book inspires you, playing with OpenCV
is a logical next step.

*** The Bad ***

The omission of the Kinect disappointed me. Cheap, ubiquitous 3D sensing
(exemplified by the Kinect) has changed the game for the hobbyist
computer vision enthusiast. When it hit stores, it took only a month for
open-source hackers to gain access to the device. Ever since then we've
seen a steady stream of "Kinect Hacks" repurposing the sensor for
robotics, mapping, security, interactive displays - whatever you can
imagine. The author missed an opportunity here; a Chapter 11 introducing
libfreenect (or even OpenNI, its industrial counterpart) would have been
a great addition.

*** The Ugly ***

Computer vision is a math-heavy field, and the author isn't going to
hold your hand through the tough spots. Some basic linear algebra
knowledge (working with matrices and vectors) is necessary to get much
out of the book. Depending on the example, you'll get concepts from
statistics, signal processing and optimization theory thrown at you. To
be fair, you don't need to understand everything to get the gist and
appreciate the examples, and Wikipedia is your friend.

If computer vision intrigues you - and it should! - I recommend PCVwP
highly. It's fun, hands-on, and covers a remarkable amount of ground in
its brisk 10 chapters.
3447656
When I first started flipping through this book the diverse set of topics threw me for a loop. Then I read the introduction where the authors say, "This publication aims to provide development information on the intermediate-to-advanced topics that are otherwise not worthy of standalone books. Its not that the topics are uninteresting or lackluster, its that they are not large enough topics."

This book covers a wide variety of topics, and it covers them in enough detail that you have a good understanding of them by the end of the chapter. Only Game Center and Core Data are covered in more than one chapter. The book is not a cover to cover read, but rather a pure reference.

I have listed the chapters below to show you what is covered.

1. UIKit Dynamics
2. Core Location, MapKit, and Geofencing
3. Leaderboards
4. Achievements
5. Getting Started with Address Book
6. Working with Music Libraries
7. Working with and Parsing JSON
8. Getting Started with iCloud
9. Notifications
10. Bluetooth Networking with Game Kit
11. AirPrint
12. Core Data Primer
13. Getting Up and Running with Core Data
14. Language Features
15. Integrating Twitter and Facebook Using Social Framework
16. Working with Background Tasks
17. Grand Central Dispatch for Performance
18. Using Keychain to Secure Data
19. Working with Images and Filters
20. Collection Views
21. Introduction to TextKit
22. Gesture Recognizers
23. Accessing Photo Libraries
24. Passbook and PassKit
25. Debugging and Instruments

One thing that you should be made aware of is that the authors decided to present all their examples in the book without using Automatic Reference Counting (ARC). At the time of this review all the chapters have non-ARC code samples are available, and only 9 of them have sample code using ARC.

They said the reason for not using ARC is that it is easier to mentally remove the memory management than to add it. Personally I find it annoying, but it isn't that big of a deal. The authors do cover ARC in chapter 14 along with literals, properties, blocks, fast enumeration, and method swizzling.

The authors' writing styles make the topics easy reads, and they do a great job of explaining things, but this book is for someone very comfortable with iOS, Xcode, Objective-C, the Developer's Portal, iTunes Connect, and Instruments. Although the authors do cover some of the basics in a few chapters, and includes a primer on Core Data, most of the topics assume the reader has some prior working knowledge about the topic at hand.

Over all I found this book worth the shelf space. I had an immediate need for more information on a few of the topics they included in the book and was satisfied with the coverage they included. I did have to dig for more information on the topics, but I had solid ground to stand on and knew what else I needed to find.

If you are an iOS developer, and are using Xcode, this book will at some point offer you information on a topic you need to get your head around quickly.
3978808
This book can be specially helpful for those starting (some Puppet knowledge is recommended) or those who have already taken the first steps implementing Puppet as the author, Thomas Uphill, walks through many useful topics, like scalability, types/providers, reporting, exported resources, etc.

Through all the book, the topics are well explained and with a strong hands-on approach which I really appreciated, as it can be taken as an starting point to improve the reader's knowledge about Puppet's ecosystem.

Sometimes, the reader really needs to keep in mind what the chapter is really about, as it easy to think that some topics are not explained deeply enough but if the chapter is about reporting, then the topic is not Puppet dashboard or the Foreman, they are just mentioned as tools for the reader to get an idea on how to make use of their reporting facilities.

For the more experienced reader, there are always new tricks to be learned. I personally found some topics explained in a very detailed way and as I haven't started to implement them in a production environment, it's always good to know what and how other people is using them.
590420
Right up front I want to mention that I received a free copy of this book to review.  After reading the book, I would say I would have been more than happy to have paid for it.

Windows System Programming is a great book.  I was really impressed with a number of things about the book, including both its production and its content.

First of all the book is very well designed by Addison-Wesley.  I am reviewing a hard cover edition of the book.  The binding is quite strong and the paper is excellent.  The pages are nicely laid out with very readable text;  just the right size.  It is big enough to be readable, but not so big as to needlessly increase the number of pages in the book.  The editing of the text is also very good.  I can't recall any misspellings or grammatical errors.  (I have read several programming books which contained so many errors that the text was almost impossible to understand).  I also appreciate Johnson Hart's writing style.  He is very thorough while being highly readable.

Now for the content.  I liked the way he compares how Windows with Unix in the area each area of functionality he covers.  Also, he doesn't ignore the standard C/C++ libraries. He explains the difference between them and the native Windows api functions and provides guidance for choosing which to use based on your requirements.

The title of the book is appropriate for the contents.  This books focuses on systems programming on Windows and he spells out the difference between the different versions of Windows where its appropriate.  This is a very practical book.  It focuses on the function calls needed to accomplish system tasks rather than on the low level details of how the operating system works.  This includes file io, memory management - including allocating heaps, memory mapped files, process management and communication, thread management and synchronization, network programming, windows services, and more.  There is also an appendix on Windows - UNIX/LINUX portability and another on performance which compares the results of different methods of handling the same task (like processing multiple files).  From this list you can see that GUI programming is not is not included.

I felt that information was very well organized.  Each chapter focused on a specific aspect of Windows system programming.  It's often impossible to present a topic without other subjects entering in, like security which to some degree affects every aspect of Windows programming.  Johnson did a good job of providing enough information to satisfy, while not loosing the main thread of thought.  Overall, I was very impressed by how well he covered each subject clearly and fully.  He included all the details that are needed to actually be able to write code, while communicating his subject in an engaging and clear manner.

In addition to this, I thought the examples were very clear.  I also liked the way that they were handled.  The book did not print full code for the examples.  It only contained enough of the code to illustrate the point being discussed.  The full code for the examples along with additional examples could be downloaded.  This code contains the complete code for the examples as well as additional useful code.
2562253
I started with this book coupled with some online articles and wiki and what I really liked most about this book is explaining complicated topics in simple language. More in detail:

Chapter 1: deals with installing Infinispan. That is pretty clear and is pretty simple to complete.
Chapter 2: discusses about Infinispan Core API: this introduces a basic Ticket booking example which will be the main theme of the book. This chapter is well focused on the core API and wisely structured.
Chapter 3: Introducing Infinispan Configuration shows how to apply changes and customizations to the default configuration,
Chapter 4: Developing Advanced Configurations provides a comprehensive introduction to clustering. It is not intended to explain production use cases deeply, but will be able to get far with it, once you have completed the chapter.
Chapter 5: is about monitoring Infinispan: that's one of my favourite chapter since it explains how to use some advanced monitoring instruments like using and installing RHQ, which will be pretty useful also in other contexts
Chapter 6: is about Configuring and injecting Infinispan components into your CDI beans. That's a pretty clear and concise chapter.
Chapter 7: provides some advances topics like asynchronous API, the Query API and Interceptors.

I'm quite satisfied with this book, as I managed to come to grips with Infinispan with as little as a week. I'd  recommend it to anyone who wants to understand and use this technology.