5 comments about Microsoft® Office SharePoint® Server 2007 Administrator's Companion.

1. If this companion where a living entity, I would kick it off my team.
   
   Having an O'Reilly safari account I read through it and was very disappointed in that it doesn't cover some of the basic functionality that might be expected from a companion.
   
   As for the hype, don't buy it to it!



2. The sheer amount of information presented in this volume is impressive in and of itself. The depth and quality of coverage into the many topics varies, and there's no one topic covered in totality, but this is the "one" book. English et al. nailed coverage across topics i.e. in scope and breadth. This is certainly not the book for beginners; there is a degree of basic SharePoint knowledge assumed, and you'll need to go elsewhere for deeper developer discussion (e.g. Pattison and Larson) or specifics on administration (various blogs). But if you're to make a career out of SharePoint 2007, you'll need most if not all of the information that's contained in this book. It's nice to have it in one reference.



3. This book is geared toward readers such as Web Developers, Information Management / Compliance Specialist, Administrators to name but a few. If you are a beginner to Sharepoint Server 2007, this book will be a most difficult read. The concepts and topics that are presented will have to be re-enforced with online research or the purchase of another book.
   
   To give an example.
   The book is composed of six sections, with the first three ( 663 pages in length ) being targeted towards administration and configuration. However, within this mix we have presentations on performance monitoring and MOM 2005, high level discussions on information security policies such as password and storage policies, data classification. We are introduced to advanced Enterprise topics such as the Business Data Catalogue and records compliance ( that is the Sarbanes Oxley Act etc. ). These discussions all assume prior expertise and should you be new to Sharepoint Server 2007 this will no doubt frustrate you. The Authors, in their quest to appeal to a wide variety of readers, cannot delve into the in-depth explanations, followed up by well worked out examples that a beginner to Sharepoint Server 2007 would require.
   
   Web Developers will tend to focus on Sections 5 and 6. While these sections do introduce Workflow Services, Webparts and products like Sharepoint Designer I found the overriding theme is again one of high level discussion and overviews. Expertise is assumed.
   
   Overall I would say that if you are coming from a background with some expertise in Sharepoint Server 2003 or you require a high level picture of the abundance of features that Sharepoint 2007 can bring to your organisation in addition to how it integrates with other server platforms, such as ISA 2006 for example, you will enjoy this book and the nuggets of useful information it provides. The writing style is not engaging; this book is not a joy to read but it will tell you what can be done with Sharepoint Server 2007, outline best practices and point you in the correct direction. The how-to part is very much left to yourself.
   
   If however, your goal in purchasing this book is an in-depth knowledge of the installation, administration and configuration of Sharepoint 2007 and you have no prior expertise with Sharepoint Server 2003 or indeed 2001, then you will gain little benefit from this book. You will find it difficult to read, difficult to digest and your understanding of Sharepoint 2007 will not improve. If anything, you may be discouraged from using Sharepoint Server 2007 which would be a shame as the product is in my opinion really good. Regards.



4. This book covers most of what an administrator needs to know, very acurate information. I use this book all the time for reference because you can't retain everything that's in this book, it's a great tool for studying for MS Exams.



5. Useful reference and the eBook (pdf) has been invaluable. Unfortunately, the pdf is locked which restricts copy/paste (which would be great for documentation). This booke is not a sit down and read from cover to cover, but a go to book for research/reference.

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.

5 comments about Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions (The Addison-Wesley Signature Series).

1. This is a fantastic book if you are looking for patterns to base your messaging designs and architecture around. The way this book goes about explaining some of the asynchronous messaging patterns seemed to provide a great deal of benefit to developers and designers who were stuck in the synchronous way of doing things. Great explanations and illustrations, would recommend to anyone researching EAI or ESB technologies or just a more structured, efficient way of messaging in general.



2. Upon recently changing jobs and focusing on messaging design and architecture, I was steered toward this book by my peers. Without getting into too much detail, before joining my new team, I had never heard of patterns (came from a product support area), much less asynchronous messaging design. Needless to say, this book has been invaluable in my learning process as well as conveying our direction to others.
   
   This book is written in such a way that it is very intuitive. Diagrams help support the concepts and code examples as well.
   
   I would highly recommend this as a must read/reference guide for anyone designing messaging solutions.



3. This is the best book I've found that helps to organize the integration space within the industry. This book has helped to organize my thoughts and communicate with others effectively on how to leverage integration patterns. I highly recommend this book to help obtain a foundational understaning of the integration space.



4. Many books have been written about SOA, but most of them are just about the theory of SOA. It's important for Software Architects and Software Engineers to understand the theory, but just knowing the theory is not enough to develop system utilizing SOA principles.
   
   This book fits nicely to bridge the gap between theory and practice. It contains not only the theory behind the patterns that can be used to design a loosely coupled, scalable system, but also the code in Java and C# on how to implement the pattern to build the system.
   
   If you are serious on building a loosely couple system and strongly believe on the powerful of messaging system to accomplish this task, then you have to read this book from the beginning to the end, it will help you to design the system without reinventing the wheel.



5. I am an occasional buyer of reference works on software technologies I need to get familiar with, and I teach an evening section at a local area college in object oriented analysis and design. After reading this book, I am actively trying to construct a proposal for a new course based on its contents ... it's that good.
   
   Quite simply, Enterprise Integration Patterns blew me away, on both a technical and pedagogical level. On the technical level, it's all here (except for "aspect" patterns like security, robustness and scalability which would each have really required another book). All the patterns necessary to successfully support asynchronous messaging between groups of remote applications ... which is the basic situation facing anyone trying to do a mashup of web services and / or construct business processes by integrating internal services via an ESB. Even the Process Manager pattern is here.
   
   On a pedagogical level, the material is complete, very easy to read, well illustrated, and above all, well organized. Even a first look at the inside covers reveals this. The front has each of the 60+ patterns listed alphabetically, with its respective icon and 2 sentence paragraph. The back has the patterns (name and icon) clumped into 6 hierarchical "pattern buckets" (Message Endpoints, Message Construction, Message Channels, Message Routing, Message Transformation, and System Management), linked together in a single diagram, showing where the buckets fit when Application A is connected to Application B.
   
   And on both inside covers as well as every place in the text where a pattern is mentioned (quite a bit since patterns are extensively contrasted with each other), the page number where it is defined is given with its name. This makes it very easy to use this book as a reference, because all the patterns it contains are cross-referenced in so many ways.
   
   After an excellent introduction the first chapter explains what a pattern is, what the domain of integration patterns are, and introduces the Widget Manufacturing Company, whose problem grows as tools to handle those problems are introduced.
   
   Bottom line ... I read this book during the two legs of a round trip flight from Chicago to San Francisco, took copious notes within the pages of the book, and walked off the 2nd plane feeling that I had seriously increased my understanding of the entire topic of how to integrate loosely coupled applications.
   
   Not bad ... plus since I snagged an upgrade on the return flight, I can also report that two glasses of wine did not interfere in the slightest with the learning experience. The book is THAT good.

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!

5 comments about C# 3.0 in a Nutshell: A Desktop Quick Reference (In a Nutshell (O'Reilly)).

1. I'm a professional developer but I have no experience using C#. My current project required learning C# at a highly accelerated pace and this book did it for me.
   
   If you are an experienced developer needing to learn C# quickly and thoroughly without resorting to the "for Dummies" types of books this is an effective tool, use it.



2. sits on my desk as a reference when I encounter something I cannot remember or just need to brush up on!



3. For those who has experience with object-oriented programming, this is an excellent book both for learning C# and for being used as a reference book on the desk. The examples are carefully designed in general but can be made better in a couple of places.



4. Pure awesome - if you're a good programmer already and want the skinny on what's new (or even great explanations on what you already think you know), spend the $10-$15 and buy this book. I love it and I buy every version they put out. There just aren't enough people like Joseph and Ben writing tech books!



5. The "In a Nutshell" series has long been my favorite's. I am glad they did C# again with .NET 3.0. The format of the book changed quite a bit with a much better format and lenghthy explainations and demonstrations. I truly hope they redo ADO.NET in a nutshell as that was my favorite as well.
   
   This book is all you really need on C# and .NET framework. [I have many others, but always find myself coming back to this, and for good reason]

5 comments about Refactoring: Improving the Design of Existing Code (The Addison-Wesley Object Technology Series).

1. This book is required reading for anyone who is serious about software development. If you want to go from good to great then do yourself a favor and get this book.



2. This book is just a real easy read, with lots of good information. You can pretty much flip to any page in the book, read, and learn something. You don't have to read chapter by chapter - it's just real easy to jump into.
   
   Lots of tips seem self-evident, but I doubt they would be to rookie programmers. It's definitely a book new programmers should get their hands on early.



3. Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure. It is a disciplined way to clean up code that minimizes the chances of introducing bugs. In essence when you refractor you are improving the design of the code after it has been written.
   
   When I first got this hardcover in December 2000, there were no integrated development environments (IDE) that would have easily allowed applying refactorings like Extract Method or Inline Method. Now, in 2008, any IDE like Delphi allows to refactor in one click. So now this book is even more valuable than it was at a time of first publication.



4. I was referred to this book from a colleague after a quick discussion on "Replace temp with Query" in our projects code base.
   
   I thought I knew it all as a software developer, but reading this book, I soon came to realize that as a software developer I was leaving a legacy of code that was not at the standard it should be.
   
   This book opened my eyes to some really simple concepts, for example, when trying to understand code someone else has written (or yourself in some cases) take the time to re-factor the code (i.e. Extract Method) so that the code is understandable, since most of the work is spent in trying to understand the code in the first place. This concept of modifying code as you understand it is superb.
   
   I must say I was skeptical at first but the benefits are really starting to show. This book is written with the knowledge of Martin Fowler, and as such is written with experience of what it is like to be a developer in a commercial environment, for example, trying to explain to management the trade-offs of re-factoring first instead of "tacking on" that new feature. Something that is difficult in any environment.
   
   This book will by no means solve your problems, but it will empower you with a new found love to make the IT project(s) you work on better (i.e. not thinking of the now but the future) practice some of the smaller concepts this book presents on a daily basis and the rewards are well worth it, break those bad habits today.



5. What is better? Replacing delegations with inheritance or replacing inheritance with delegation?
   
   The answer is the ultimate answer to most software engineering decisions: DEPENDS, there is always a trade-off that has to be analyzed according to the context! This book addresses those trade-offs very well.
   
   Moreover, I like the examples in the book, good to use in class when teaching. They generate interesting discussions.

5 comments about Beginning PHP and MySQL: From Novice to Professional, Third Edition (Beginning from Novice to Professional).

1. I purchased this book because I needed to use PHP and MySQL for a project at work. I never had any exposure to either before reading this book. By using this book and the w3schools website I was able to successful build a meager database and have a fully functioning php front end. It was very pleasing to see the project come to fruition and I have this book to thank for that. I used it mainly as a reference book. For example, I knew exactly what I wanted to do so I would search this book for an example of that and adapt the code to my situation. I didn't use this book to "learn PHP." I think you need to have a project to do in order to best use this book.



2. Despite the title, this book is not for the novice. Even the introductory first 100 pages or so assume that you are above a novice level. The examples lead to more questions (for me, the novice) than they answer.
   
   Having said that, this book has a tremendous amount of information in it and, as other reviews mention, it will work well as a reference. Now, I hope to find a true beginning PHP book to provide the basis to use this book!



3. I have recently bought this book and have to say it is execellent, it does help if you have a little prior knowledge as some new readers could find it a little difficult to understand. But if you have an interest in PHP and MySQL it is a great book to get your hands on. I highly recommend it.



4. This book does have a lot of information, making it a great reference book. However, after 10 chapters I still do not know how to use any of the information to "build dynamic, database-driven web sites..." as the subtitle states. If you're a beginning programmer, as I am, try to find a true beginner's book (wish I could give a recommendation).



5. This books is written for someone who is familiar with other programming languages and databases and now wants to use PHP and MySQL. It is not written for somebody completely new to programming. For example, if you came from Perl or ASP, and you wanted to know how arrays, loops, and objects in PHP, this book will cover that.
   
   The topic coverage is broad but not deep. The book has a feel of "semi-reference" in that each topic stands on its own. This is not a cookbook or "learn by example" book. There is enough information to get you started, but if you have a complex/niche problem, this book will not help you. For more information, you will have to consult books that specialize on the topic you are interested.
   
   I have one major gripe with this book. There is not any significant coverage of XML manipulation or XSL/XSLT aspects of PHP. When you look at the table of contents or index, there is no mention of XSL/XSLT and only a brief mention of XML (and RSS) in the Web Services chapter. For a book that covers a lot of subjects, this is a weak area.

5 comments about Software Requirements, Second Edition (Pro-Best Practices).

1. This book is a classic. Well written and to the point. It helps resolve what requirements are and should be. I have done requirements for 30 years and I learned a lot! Wish it had been out sooner in my career.



2. Needed to understand and learn how to get software requirements. Very informative and helped me fit into my new role at the time.



3. I work for CDW and this book came highly recommended. It did not disappoint as it is clear, well written, and organized in a logical format. I have been writing requirements for many years and this is by far the best overall book on the subject that I have read. The suggestions for labeling and writing requirements alone make it worth the price of admission.



4. Absolutely happy with it. Having recently completed a project this book gave me the opportunity to look back and think about things I could have done /planned better.



5. 
   I have had this book for some time and recently realized how often I use it as a reference when I am trying to figure out a way to document or model a feature. This book is well worth the price, I have definitely benefited from keeping this book near my desk.
   
   Although this book is not to replace books dedicated to topics such as Use Cases, technical writing, UML and modeling, change control, or test case development it is a great place to see them all work together in context.
   
   Don't forget to visit the `Requirements Engineering" section of the authors' site. There you will find the samples from the book and other useful articles.

5 comments about Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series).

1. As a newcomer to enterprise architecture this book educated me on possibilities for decisions to be made in designing an enterprise architect. It will also give you a language for describing existing characteristics of an existing enterprise application which may use some combination of the patterns describe in this book. The discussion of where to keep session state for a webapp was particularly helpful to me.



2. For me, this book is an invaluable reference for building business apps.
   
   Want help choosing a framework? Want some guidance for solving common business problems? These patterns help solve these kinds of problems.
   
   NOTE: I have tried to find other sources for these patterns, and I have only found Fowlers website, which is really only a summary and recommends purchasing the book.
   
   This book has examples in both Java and C#. You can certainly use these patterns in .NET.
   
   Under .NET you are not actually forced to use the Table Model. I think the purpose of this book is to help you realize this.
   
   There are frameworks for .NET that use the Domain Model and Data Mapper patterns, but you would never know this unless you were familiar with the patterns in this book.
   
   For me, reading this book didn't allow me to write new code, but it did allow me to understand my choice to use a particular framework/technique over another.



3. This is a must read book if you are a developer, architect or in anyway related to technology.



4. Even if you don't do "Enterprise Application" development, this book is a must have in your library. If you have been developing for more than a couple of years and you haven't seen 1/2 of the patterns in this book, then you are probably doing something wrong and this book could greatly help you.
   
   Even if you do know 1/2 or more of the patterns in this book it is a great reference to the details of these patterns. Unless you are a Sophomore Software Engineering Student I'd recommend this book over the GoF book. Gof is a must have too, but if you can only have one. Get this one!



5. This book is a complete beginner's handbook for enterprise patterns.
   
   1) The "Mapping to Relational Database Patterns" section discusses patterns that are completely intuitive. I recall logically coming to this conclusions when I started programming in Visual Basic in 99. Nothing new in this section.
   
   2) The "Concurrency" section is criminal in nature and assumes that the application runs on high-cost server. Process-per-session? Thread-per-request? Come on!! Has the author missed out on the Reactor, Proactor and Active Object patterns (he does reference ACE but only as a reference). These patterns have been recognized as not scalable in the late 90s.
   
   3)The distribution patterns are clearly incomplete and desire a lot of details.
   
   If you're just starting out,as a System Architect :-), you'll find this useful. Otherwise, use MSDN or ACE for enterprise patterns.