5 comments about Inside Microsoft SQL Server 2005: T-SQL Querying (Solid Quality Learning).

1. Normally I don't write a review but I liked this book enough to do so. I am a programmer not an SQL developer. I knew the basics but not the details and I had to write complex queries in SQL 2005 so I researched books for couple days before I bought this one. I have never heard of CTE, APPLY, ROW_NUMBER or PIVOT to mention few. This book at the beginning gives you the basics to understand how queries are processed internally, the difference between the types of indexes and how to read the execution plans. Then it dives into the language. Each example is well thought. The example goes over the syntax, performance and also optimization. I read all of it and did most of the examples.



2. The MS SQL books have dramatically risen in quality in a few short years. When SQL 7 and 2000 were released, there were may be 1-3 book which were truly outstanding. For SQL 2005, however, there are at least 5-10 books which are truly worthwhile and this is one of them.
   
   The reason why the quality of books has risen is the expertise of the authors. For this book, the authors are either MS SQL MVP or have been involved with the creation of MS SQL at Microsoft.
   
   Generally speaking, the book has high level expert description of the underlying MS SQL 2005 architecture and T-SQL commands. But it lacks a nice flowing writing style which hempers the understanding to a willing reader. This book is an another example of authors who are inept at explaining the subject matter which they are an expert much like a professor who can't teach.
   
   I also felt some parts of the book were sloppy or not as detailed. For example, the authors state that one of the steps of T-SQL query tuning is the need to correlate wait stats with problematic queries. Yet they never provide an adequate example (other than providing a useless query of SYS.DM_OS_PERFORMANCE_COUNTERS table) of how to connect wait stat with a specific transaction. This is a huge missing link.
   
   PROS:
   1)Awesome details on Indexes and Query plans
   2)Solid advice on how to improve T-SQL for better performance.
   
   Cons:
   1)Not for the beginners. The book goes straight to the harder subjects (PIVOT, APPLY, complex joins etc).
   2)Does not cover simple or fundamental subject matters.



3. This is the 2nd book of the 4 part "Inside-SQL" series, with each book I imagine, appealing to a different reader. Having a programming background, I enjoyed this book more than the first in the series ("The Storage Engine"), which on it's own is also an excellent book.
   
   As mentioned in other reviews, this book is definitely not for beginners. The authors assumes a basic level of SQL knowledge from the reader as he launches into complex Transact-SQL examples - unlike most books which start the reader with simple SQL examples and progress through to complex ones.
   
   While reading this book, it was easy to compare it's contents with Ken Henderson's popular "A Guru's Guide to Transact-SQL", with the latter book becoming more and more outdated by the improvements in Transact-SQL since it was published. If you're a fan of Henderson, you will quickly become a fan of Itzik.
   
   A benefit of this book is that unlike most SQL 2005 books, this is not an update on SQL 2000 material, but instead starts at the 2005 level. The author focuses on the new syntax introduced in SQL 2005, and then, moves onto older SQL 2000 syntax and compares both the complexity and the performance differences between the two. This itself is invaluable to those of use that code in Transact-SQL and feel more comfortable using the "old ways". This book highlights how the new syntax is in fact simpler and more efficient - we just need to take the time and effort to understand and become familiar with the new language changes.
   
   The book starts by discussing the logical processing of a SELECT statement, which helps the reader to understand the hows and whys of writing a query. I finally understood why I can't use an expression's alias in a WHERE BY or GROUP BY clause (as the SELECT line is one of the last parts of the statement to be processed). Throughout the book, the author often defines a problem and allows the reader to formulate an appropriate solution. He then reveals MULTIPLE solutions and explains why each is good or bad. The book ends with a selection of "logic puzzles" that test the reader's ability to solve logical problems. This was both fun and informative.
   
   After reading this book, I found myself changing the way I constructed SQL queries at work - for the better!



4. Inside Microsoft SQL Server 2005: T-SQL Querying (Solid Quality Learning)
   
   This is a great reference or review text. The content is fairly meaty and will take some chewing. For example, the book starts right off by breaking down the query engine process into it's processing steps and taking the reader through examples of the result sets at each step in the process. It might be overwhelming for someone starting out, but it's a great place to dive into a deeper understanding of the data engine.



5. As a programmer we go through many a book. And many of them read and feel like textbooks. So we skim, read in short bursts, simply would rather avoid the read.
   This book is so well written that it can't be put down. And it's packed with REAL WORLD examples. Instead of just defining syntax and using a lame example, this book goes FAR beyond that, and digs deep into real world examples that really shine a light on your work.
   I purchased this book almost a year ago, and it's still one of the most referenced books I have. I am constantly pulling it out when I reach a problem in my work, and this book always has great pointers to a solution.
   This book will make you a T-SQL junkie, get it.
   
   PS The logic puzzles in the back are great, too!

5 comments about Software Estimation: Demystifying the Black Art (Best Practices (Microsoft)).

1. Every. Single. Engineer. can get better at software estimation.
   
   This book shows how.
   
   Get this book.



2. Excellent book. It seems like it is more targeted at Project Managers than developers, but it's definitely worth the read for both positions.



3. Despite the fact that most software developers consider themselves engineers or scientists, many mainly rely upon gut instinct for estimation rather than data. The material in this book enabled me to persuade my developers of the limits of gut instinct, to guide them to develop more quantitative methods and to help them predict the precision of their estimates.



4. Basic premise: that "the goal is software estimation is not pinpoint accuracy but estimates that are accurate enough to support effective project control. To that end, a "good estimate" is one that "provides a clear enough view of the project reality to allow the project leadership to make good decisions about how to control the project to hit its targets."
   
   Software estimation is inherently nontrivial. The resulting product is virtually invisible until it is finished---and you rarely end up with the same product that you initially estimated anyway. Early on, requirements are difficult to state (and measure) precisely, and as Rittel stated "the true nature of the problem only emerges as a solution is developed."
   
   Many PM's still believe that estimates are based on multiples of a gut feel. However, the ambiguous nature of software reality requires multiple and varied quantitative methods just to define the estimate space in terms of order of magnitude.
   
   This book provides a basic and superficial description of a number of these methods, including how and when to best apply them. It is an excellent primer to reading other more exhaustive texts (such as Stutzke's Estimating Software-Intensive Systems) and an indispensable desk-reference for Program Managers, Project Managers and Parametricians. Highly recommended.



5. I have just completed the reading. Not that, I didn't know estimation, nor that I was struggling to do a right kind of estimation. I am already fairly accustomed with standard tools and techniques in the world of professional software estimation. What I found appealing in this book is the approach towards estimation at the start.
   
   Today, I was sitting in an informal discussion session with a bunch of college graduates who barely completed 1 year in this industry. It was an open discussion set, and one point came up on right estimation. Many of them had gone through 20 hour workday regimen during the difficult times of the project, and all of them were convinced that somebody did not do the estimation right. To explain that estimation is not that easy math work like a college paper, I started with a quiz: What's the latitude of Sanghai. And as I continued speaking on estimating the latitude of Sanghai, I found increasing number of approving nods all around the room. Happy me! It was not always the case where I found an immediate place to apply my book reading in past, that too with the nods of approval.
   
   Coming back to the book, I will definitely recommend this book to all software project leaders and project managers to get a feel of the subject and how to address the problem at large. To gain deeper knowledge there are tons of research papers and books waiting for you, but if you are a busy professional, go through this book first.

5 comments about Python in a Nutshell (In a Nutshell (O'Reilly)).

1. 
   The author Alex Martelli is Uber Technical Lead at Google, Inc. Martelli holds a laurea in Ingegneria Elettronica from Bologna University. He wrote Python in a Nutshell two editions, and also co-edited the Python Cookbook. He's a member of the Python Software Foundation, and won the 2002 Activators' Choice Award. Martelli spent 8 years with IBM Research, earning three Outstanding Technical Achievement Awards, and on.
   
   The book is a great reference and full of insights and good programming techniques. It moves pretty fast to make a good introductory book, but once one has a reasonable understanding of Python fundamentals, anyone wishing to advance their understanding and application of the language can benefit from Python in a Nutshell.
   
   I found that this book has been able to cover every thing from fundamentals of the Python language to a comprehensive description of some of the more esoteric newer language features and at the same time address many of the applications of the language. The presentation style is clear and very readable with concise examples, and not full of extraneous fluff. The subjects are well laid out beginning with a swift comprehensive introduction to the language, and a good description of the basic elements including classes, methods exceptions, modules, decorators and built-ins. There are sections on the Python library and extension modules, Network and web programming including some discussion of some of the existing python web frame works and socket programming. There is material on extending and embedding Python and alternate ways to extend python beyond c-extensions. The book was released just prior to the final release of Python 2.5, but there is considerable material covering most if not all of the latest 2.5 features such as the with statement.
   
   I have found Python in a nutshell 2nd edition a valuable learning tool and reference resource and would recommend it for anyone interested in using Python to its fullest.
   
   
   Reviewed by Max Slimmer user and proponent of Python since release 1.3.



2. This is simply the best reference book for Python.
   
   As a reference book it not suitable for learning Python from scratch, even if there is a not-so-short introduction to the basic language features. The book is well organized and informations can be found quickly.
   
   The only con is a bad index. It is really complete, but sub-topics are organized as a tree without any graphical feedback of the current indentation level, and often you do not understand wich topic they belong to.
   
   The 2nd edition of the book was published on July 14, 2006 and is obviously highly recommended: Python in a Nutshell (In a Nutshell (O'Reilly))



3. 'Python In A Nutshell' is one of those de facto standard O'Reilly books that is required reading/owning for anyone that develops in said language. In this case it's the long time popular scripting language Python. Originally released in 1991, this language has grown and expanded into the juggernaut it is today. With around 700 pages of material, this book will show you the ins and outs of everything yummy that Python can do. From the basics of talking about to define variables and create conditional statements to object oriented programming, you are going to quickly see why Python is popular and USABLE.
   
   This book goes further than just a teaching book and/or just a language reference. It's meant to bridge both necessities as you learn to progam in Python or want to improve your existing skillset. With this book you will achieve all your Python goalssssssssssssssssssssss (pathetic snake joke attempt here)
   
   ***** HIGHLY RECOMMENDED



4. The documentation that comes with Python leaves a lot to be desired. Try understanding and using internationalisation, for example. Any help that comes along will be welcome, especially in the form of examples.
   Alex Martelli really knows his stuff and it's very convenient to have the information by your side in this format, so even if it's a little condensed at times I would recommend this book as well as Python Cookbook, for advanced examples.
   I do wish that Python 2.1 Bible would come out in a new edition: it was fantastic for basic sample code.



5. I keep coming back to this book, either to clarify what other books needlessly complicate or simply don't include. As a nutshell book, I would say it is more of a fairly comprehensive reference. Its discussion and explanation of python elements, which tend to make it more of a comprehensive manual and less of a nutshell are very much appreciated. The book's well thought out layout and well self-sustained sections allow you to actually sit down and read this book to learn from and not just use as a passing reference from time to time. I pair this book with Beazley's Python, Essential Reference, which I think actually takes more of a 'nutshell spirit of presentation'. Between the two, they are my most often go-to books while in the coding process.

5 comments about ActionScript 3.0 Game Programming University.

1. I can't recommend this book more than if I had written it myself, Gary makes writing games in AS3 so simple to follow and what did seem like a jigsaw puzzle of programming now has had the curtain lifted and left me feeling confident that, even with my limited programming skills, I could make a game in flash that wouldn't be too bad.



2. Lets face it. There are a lot of Actionscript game books out there. This one is good because 1) It is entertaining and readable & 2) It's the first game book I have found that works for the new actionscript 3.0.
   
   The code itself isn't exactly as object oriented as I would like, but thats true of all the other game books out there too. It does have enough object oriented content to show some amazingly different, and simple methods for making game characters, detecting collisions, and managing objects that are possible with actionscript 3.0. I value this book as a 'how to upgrade' from 2.0 to 3.0.
   
   The games themselves are pretty good and there is a nice variety of game styles to appeal to a wide audience. For a basic game programming book, it omits or glosses over a few important topics such as caching vector objects as bitmaps, pseudo 3-D and optimization in general.
   
   All in all, I suggest this book if you are upgrading skills to actionscript 3.0 or want to write flash games. If you get this book, I also recommend Foundation Actionscript 3.0 Animation: Making Things Move! to round out your collection.



3. I got interested in this book after discovering Gary Rosenzweig's AS3 tutorials on his Flash Game University Website. I was impressed by his ability to explain things clearly and simply. As other reviews have already stated "AS3 Game Programming University" is an excellent and highly readable book for learning AS3. In practice I find it much more helpful than Colin Moock's book "Essential ActionScript 3.0", which is a little too academic for me (although I'm glad I have it!). I'm also finding that code snippets in Gary's book are just as useful to me as those in Joey Lott's "ActionScript 3.0 Cookbook" (which covers more topics). It's helpful to me that Gary writes from a Flash authoring perspective rather than Flex. He doesn't hesitate to include timeline based assets and code when it makes sense to do so, rather than use the Flex style of generating everything in code.
   
   The actual games are surprisingly varied and complete, but not so complex that they become difficult to understand. The code that I downloaded from the website works well. It is written in a practical concise manner with proper use of classes and other object-oriented techniques as required by AS3. However, as other reviews have noted, this book is not for advanced programmers that prefer a pure object-oriented style.
   
   I recommend this book if you are moving from AS2 to AS3, even if you are not interested in writing games. Gary does not claim it is suitable for beginners without any programming experience but it is more suitable than Moock's "Essential ActionScript 3.0" (which does make such a claim). However it is not for web designers that don't want to learn programming and it is not for advanced programmers that appreciate Moock's AS3 book.



4. This book is a good as they come. It is well written, well organized and well supported with demo files. I have a wide variety of programming experience, but not much experience at all with Flash. Rosenzweig gives enough general Flash instruction to give the reader enough general Flash understanding to do this type of programming. I think the book is perfect for readers with some programming experience and perhaps less Flash experience. I am not sure it would work as well in the other direction, but the author is clear, concise and easy to follow. I think most anyone with sufficient motivation can find this book a usefull guide into basic game building with the latests versions of Flash.



5. The book is in excellent condition and I got it before the deadline,
   It was great!

5 comments about Head First Object-Oriented Analysis and Design (Head First).

1. This book is very much like the others in the Head First series. It's makes it easy to learn, and fun to work with. Thumbs up!



2. Unless you are a very experienced object-oriented developer/architect, this is a great book.
   The methodology is very intuitive and it is not a dense heavy book to read. It's actually very fun.
   Be careful not to read it too casually though, as it has a lot of contents.
   I like the fact that it repeats itself after every important concept, so you are less likely to skip it.
   My recommendation is to do every exercise and try to think careful about the solutions the authors go through.
   This is a must-have for every developer, in my opinion.



3. This book is very good. Like many other Head First books, it presents material in a very fresh way that is easy to understand. If you are new to Object-Oriented programming, this book is great. If you are very well versed in Object-Oriented programming, you may find yourself a little more bored with this book. Still, it is worthwhile for all people interested.



4. I'm a supporter of the Head First approach to learning, but this one has failed to hit the mark. I can live with a fair number of typos (which this book certainly has), however bad or broken code in just too many places is not so easily forgiveable. The authors hammer on principles of good OO design, but clearly did not test-drive the code that is supposed to show-case those design principles. To mention a few: missing return statement (p6), ClassCastException (p212), NullPointerException (p254), an Inventory search method that will fail to find anything if an instance of type InstrumentSpec (as opposed to a derived type) is passed to it (p211,212,238) (while authors suggested on the previous page to re-design InstrumentSpec to be non-abstract for this reason), non-standard UML for implementing an interface (p224). I could probably go on, but stopped reading (maybe I'll pick up later).
   Another thing I find is that there is too much fluff and repetitiveness. Some may argue this is a trademark of the Head First series, and that it helps you conquer the learning curve. I will agree on the Head First classics (you know 'm), but here it starts to get boring quickly, and you find yourself flipping instead of reading after a while...
   To conclude, you'll learn a thing or two if you're relatively new to OOA&D. And although the book definitely has some good points, like the explanations of object-oriented design principles (the foundations of patterns), there are better (spell-checked and peer edited) and denser books out there.



5. How I wish I'd had this book earlier in my programming career!
   
   The Head First series use a novel teaching style that is designed to be engaging and informative and to work for a wide range of people. We all learn in different ways so this book uses them all to make sure you get the point.
   
   The examples are clear and the concepts presented in a way that I was able to understand them and immediately began to see ways to effectively use them in my daily design, coding and testing tasks.
   
   Even if you have been doing object oriented programming for a while you will still get a lot out of this book.
   
   I can't recommend this book too highly.
   
   Ray

5 comments about Bulletproof Web Design: Improving flexibility and protecting against worst-case scenarios with XHTML and CSS (2nd Edition) (Voices That Matter).

1. I am very skeptical about the value of IT related books. Having been in the industry for 17 years I have read very few that deliver what I am looking for and instead have tended to rely upon articles from disparate sources across the web.
   
   There are of course exceptions - and this book is a shining example of how to make a subject understandable for many levels of experience AND be of value to all.
   
   If you are interested in making your site CSS friendly, want to unravel what all the various things mean, or have a working knowledge of CSS and want to go beyond what most average developers know about CSS then I would strongly recommend buying this book. It won't solve world hunger, but it will solve many of your CSS questions and designs.



2. After building enough sites from scratch, and wanting to make darn sure they were browser friendly and accessible, I got this book due to it addressing cross-browser problems and techniques for accessibility.
   
   Now the practical knowledge in this book is great. It's the no-hold-bars dirty hacking of CSS/XHTML to force it to work in browsers, and address how to get sites to be more accessible (like addressing text sizing that scales accordingly in IE 7 and FF, and to look similar in each browser). Added benefit it even shows you how to tweak the Blogger Tic-Tac template, to be even better -- for beginning bloggers, this is very sweet.
   
   But, I learned that this book is geared to the 10% of the web browser market (Firefox), which meant code examples to experiment with weren't friendly to IE 7. Worse, the code explanations were quite elementary -- dictation/narrative style -- which didn't give me enough info to know WHAT I was doing. Efforts to tweak examples (like in Chapter 4) required over an hour trying to get the floats to not break, if I resized them -- all because the explanations were so scant to know what variables to tweak.
   
   Really wanted to like this book, as it's tailored for two main headaches in web design (cross-browser friendliness; accessibility tweaking) that's not often covered in other CSS/(X)HTML books. Alas, the search is on for a CSS/XHTML book that is truly cross-browser friendly. :/



3. This book is very readable, and the examples are presented in building block style, step by step. Practical benefits of XHTML and CSS are provided, and the code needed for the samples to work in the major browsers. I highly recommend the book!



4. I purchased this book in the hopes it would have fixed my floating issues. It did, to a point. A couple of the examples didn't work well with Firefox. I found this book was helpful to fix a few things, but I did find that I was able to find other fixes online. I still enjoy this book, I just wish it worked better with Firefox browsers.



5. This is easily the best CSS book I have ever owned. It's very easy to read and provides excellent, and sadly few, examples. Most importantly, the author does a wonderful job helping the reader understand concepts and how and why certain things are implemented.
   
   Other books are FULL of examples... although they usually lack the details that someone like me need. The details, writing, and illustrations make this book much more attractive. Sure, Bulletproof Web Design isn't the end-all of books of this nature. It's short. You'll need more books. But any serious developer needs to read this book.
   
   If you like "Don't Make Me Think" by Steve Krug, then you'll adore this one as well.

5 comments about Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (Microsoft .NET Development Series).

1. If you need to write C#/.Net or even Java, this book is a must have.



2. I don't personally think that all developers will find this book useful. In fact, I have a feeling that some may find it highly useless and disruptive as it is abstract in a sense (one must apply the lessons to each library and scenario independently, taking into consideration many different aspects of usability and readability) and it does require some "retraining" of bad practices which have been long since ingrained due to years of usage.
   
   But whether this book deserves a five star rating or a one star rating - whether this book is for you - can be answered by asking yourself the following question: are you obsessed with quality? Quality in the sense of creating a library that is:
   
   - Easily reused by others, even first timers encountering the library or even first timers to .Net
   - Well thought out with well designed classes
   - Consistent within itself and consistent with the base libraries from Microsoft
   
   The importance of the little things like naming classes, properties, methods, using one type of construct over another, using one type of accessor over another, etc. cannot be stressed enough in the overall picture of creating a library to a higher standard of quality, usability, and extensibility.
   
   As Confucius is to have said:
   
   "If names be not correct, language is not in accordance with the truth of things. If language be not in accordance with the truth of things, affairs cannot be carried on to success.
   
   "When affairs cannot be carried on to success, proprieties and music do not flourish. When proprieties and music do not flourish, punishments will not be properly awarded. When punishments are not properly awarded, the people do not know how to move hand or foot.
   
   "Therefore a superior man considers it necessary that the names he uses may be spoken appropriately, and also that what he speaks may be carried out appropriately. What the superior man requires is just that in his words there may be nothing incorrect."
   
   As I wrote in an e-mail to my team, I think that digesting this book will lead to: higher quality public facing APIs for our customer development teams seeking to extend the functionality, increased readability and more consistency internally in our teams, increased usability and decreased maintenance costs for the support teams as well as new developers on our team, and of course, increased skill, knowledge, and competency as developers of each of the team members.



3. As a professional I have worked many times on building re-usable and extensible frameworks. Therefore, I had to read several books in order to make sure that the framework I was building was doing what it was supposed to do. However, in all these years I had never the luck to get a complete guide of "building a framework the right way" and I had to always put together pieces from different articles in order to make my own guide. Well, there you have it! Buy this book, read it and you will have a complete guide of how to do things the right way. Another great thing about this book is that different professionals make their comments about almost every guideline. As a result you are not only exposed to writer's view but also to the views and opinions of many well respected software professionals. Do buy this book and as hard as it might seem try to apply its recommendations to your daily development process.



4. I think this is one of the best books on this subject that I have read so far- very practical, very useful. There is a lot of information, real-life examples and experience from the .NET framework design team.



5. Very well organized, and good content.
   Id like to see more diagrams or so, so we can se how they decide to build the things... but it still is great.

4 comments about Core Java, Vol. 2: Advanced Features, 8th Edition.

1. Updated for Java 6, "Core Java Advanced Features" does not disappoint. This is for those of you who have finished volume 1, either this 8th edition or the 7th edition. Quite frankly, I think in the case of Volume 1 you can skate by with the older 7th edition. However, in the case of the eighth edition of Volume 2, there is quite a bit of expanded coverage to the tune of the resulting book being over 1000 pages in length. It follows the same format as past versions of Core Java Advanced Features. The authors start at the beginning of each topic and walk you through increasingly difficult programs and very well done illustrations and screen shots of applications that are really quite helpful. I include the table of contents since it currently is not included in the product description.
   
   1. Streams and Files
   2. XML
   3. Networking
   4. Database Programming
   5. Internationalization
   6. Advanced Swing
   7. Advanced AWT
   8. Javabeans Components
   9. Security
   10. Distributed Objects
   11. Scripting, Compiling, and Annotation Processing
   12. Native Methods
   
   Before you go out and buy expensive books on the topics in any one of these chapters, get this book and read the corresponding chapter. It will make whatever you hear or read from that point forward much clearer.



2. In my review of Professional Java JDK 6 Edition, I said I didn't think one book could cover such a wide variety of topics and expect to do a good job overall. This volume is, I think, an exception that proves the rule.
   
   It is indeed a monster book, easily several months of steady work to get through, and an useful reference afterwards as well. It is well put together, clearly written, methodically presented. I wouldn't put it down if that were possible. The coverage is broad and the examples are interesting. The topics also feel complete, not because they are thorough, but because they leave off right where intermediate-level programmers could work out most details on their own.
   
   I read the first and second editions years ago, and I must say this title has become a case study in steady, disciplined, tireless improvement and refinement of the original. It's 990 pages, but I haven't come across a useless sentence yet. The authors haven't just added on. They've refined their examples, improved and replaced others. Most importantly, they've realized a format that puts boilerplate and API tables to the side, allowing the reader to focus on the concept at hand. Complete code listings are in the text, presented in a way that makes it easy to gloss them in favor of the soft copy available by download.
   
   If you need lots and lots of code work on different topics to burn Java into your fingertips -- and there really is no other way to do it -- this book is an excellent choice.



3. The Core Java (vol 1 and 2) are simply superb books. If you are a developer looking for thorough books on this subject, look no further.



4. Like many reviewers I find the the Core Java series to be very valuable. However, be forewarned that the kindle edition is not a good representation of the book. The figures are completely useless either because they have not taken the time to convert them properly or because the kindle technology is simply incapable of displaying non-text content properly. I wish I had known this before I paid for the kindle edition of this book.

5 comments about Agile Estimating and Planning (Robert C. Martin Series).

1. I have been acting as the Scrum master for my team for about 6 months. We have gotten pretty good at planning and executing an iteration at a time. Our customers have always wanted to see a longer-term plan. I've read several other books but none of them have come close to this one. It has been invaluable in helping us to prioritize, estimate, plan, and communicate several iterations in advance.



2. This book is a well written synopsis of how an agile methosology should work, with adhering to a hard and fast methodology ( be it XP or SCRUM or Crystal). I would recommend this book to anyone who is using or is planning to implement an Agile setup. This book shows that Agile, does not mean 'no' planning, far from it, but shows that estimating project size is key to delivering on time and what is expected.
   I recommend it to project managers and developers who are mature enough to understand that guess work makes everyone's job harder and that software is developed to support business needs that must lead to profit



3. I've read this book because of the "Planning" in the title. It does cover planning, but not in the depth that I was looking for.
   
   It shows a lot of good concept ideas, like prioritizing based on mandatory, linear and exciting features. Or when it talks about using a story as tracer bullet to provide more info to the team. I really like the idea of the theme parking lot.
   
   For someone that uses scrum on a daily basis, the idea of creating tasks just before comitting to a story sounds silly, but it makes a lot of sense.
   
   The book gets really very good after page 200. It's where most of the "planning" is.
   
   The Case Study on last chapter is really very good.
   
   I would recommend this book to everyone interested in agile development, but it's not a introductory book. It's more for the middle practitioner.



4. Mike takes agile planning to a new level with this one of kind book. Its a pretty simple read, not to high level but enough detail to get you through in the weeds of your day.



5. I enjoyed this book...I found it helped with the project management aspects of Agile while keeping grounded in common sense.

5 comments about Programming Erlang: Software for a Concurrent World.

1. I got interested in learning more about Erlang when I discovered that some of the Amazon web services use it underneath (SimpleDB). And I consider these services to be very well designed.
   
   I enjoyed the book as it gave a good overview of the concepts and capabilities of Erlang. But now I'm wanting for more -- more depth on concurrency and fault tolerance; more complete real world examples; how to use for building web apps; and of course how to use with Amazon web services.
   
   So what this book needs now is a sequel!



2. Erlang really appears to be an interesting language, and the author's enthusiasm for the subject shows - which is good. It helped me to keep going, when at times the code was a little hard to follow.
   
   The book does a good job of introducing the language. In particular later chapters give emphasis to the topics of concurrency through multiple processes, multi-cores and distributed programs. All very timely subjects for a world that is connected to the Internet, and where even laptops have multi-core processors
   
   I gave the book a 4 star rating because I feel the author somewhat forgot who his audience is.
   
   On page 5 he starts out with a description that fit me almost perfectly, and probably many other readers: "Once upon a time a programmer came across a book describing a funny programming language. It had an unfamiliar syntax [...] it wasn't even object-oriented. The programs were, well, different....Not only were the programs different, but the whole approach to programming was different."
   
   After reading the book I don't feel like the "Erlang Master" that the road map described (pg 9). While the syntax is now familiar, I still look at the Erlang code and it feels foreign. I still have to "decipher" the code instead of read it.
   
   I would have liked the book to more fully address the items from the "Once upon a time" paragraphs. Being that "the whole approach to programming" is different than the OO that many readers are used to, I would have liked to have seen a chapter (or three) on how to best get into that mode of thinking.
   
   I do think the book is a good jumping off point. It gives you more than enough to get started.
   
   However, if you are unfamiliar with languages where functions accept functions which also accept functions as parameters and return another function as a result, you may end up feeling (as I did) that you only have half the puzzle.



3. This book was recommended by a colleague and I was hesitant at first, but it really is an excellent read.
   
   After flipping through the first few chapters, taking in the examples and absorbing what it was spelling out, it really altered the way that I fundamentally look at software modeling. Joe Armstrong's style of teaching by example and breaking things down into the smallest possible space makes this book worthwhile.



4. I've been working through this book and am very glad for it. I'm not sure how else I'd efficiently have gotten up to speed on Erlang.
   
   The book does need lots of minor work, though - it still feels like a beta piece of software. There are examples / explanations that make use of not-yet (or never) explained functions/modules. The appendix describing some of Erlang's modules only claims that the set of documented modules is incomplete, but doesn't mention that the set of functions within some modules is also incomplete. Etc.
   
   Another issue is the license of the code examples. The author shows some example code for how to do certain things, such as a distributed map function (pmap). After reading the book, it's hard (at least for a newbie) to imagine a different solution than the author's. But if you go to the website containing the example code from the book, you find a pretty restrictive license on the example code. So this leaves the reader in a difficult position: the book only shows you one way to do something like pmap, and the author has a license on that code that makes it unusable to many readers. This is more than a little frustrating.
   
   Finally, the index is very incomplete.
   
   If you're new to Erlang you still want this book. But it would really be a good thing for the author to gather criticism (if he hasn't already) and go a second round.



5. I made an attempt at working through this book 6 months ago and didn't feel quite comfortable so I dropped it and instead pursued Programming in Haskell. Yesterday I decided to get back into Erlang and found it a complete breeze, powering through the entire book in a few hours.
   
   A lot of things seem to become really easy after working with Haskell, not to say that programming in Haskell is hard, just it twists and bends your mind into a different shape.
   
   Now that I'm abreast of the material covered in this book, I am leaping into a large project with great confidence.
   
   5/5, excellent book!