5 comments about CMOS VLSI Design: A Circuits and Systems Perspective (3rd Edition).

1. This edition is as useful as the earlier editions. Besides providing insight on almost all the topics of VLSI, the third edition also addresses several issues related to the sub-micron technology.



2. I recently taught a senior undergraduate/first year graduate introductory course with VLSI with this book as the text. I found this book to be confusing and frustrating to the students. In order to lecture on VLSI topics in what I thought was a logical order, I had to jump around in the text book. My main complaint is that the book is organized more like an encylopedia and not like a textbook. As such I think it makes a very good reference for those with previous training or experience in the VLSI field, but confusing and unhelpful for those learning the field for the first time.
   
   Oddly, the second edition of Weste (Weste and Eshragian) is far better organized and much more coherent in its development of topics within VLSI. I found myself often going back to the second edition when I was preparing lectures.
   
   A second complaint is that the book introduces logical effort as a primary topic early on in the discussion of switching delays, in my opinion at the expense of discussion of the fundamental circuit mechanisms in switching delay (which again are discussed in detail in Weste 2nd Ed). The emphasis on logical effort continues throughout the text. Again, a choice that is reasonable if your audience is experienced engineers but not for an introductory course.
   
   I will probably change texts for next year, most likely to the text by Rabaey et al, which appears to be much better organized for an introduction to VLSI. In sum, Weste 3rd edition might make a good text for a second or third course in VLSI, or a good reference for practitioners in the field, but not a good text for a first course in VLSI.



3. Good book covering CMOS VLSI design. Excellent turtorial on Verilog in the appendix.



4. Comprehensive treatment of the subject, very clear and easy to understand. Also has advanced topics.



5. After just going over the first few chapters, have found that book does live up to it's title. It's a good book to have handy when designing basic chips.

5 comments about MCITP SQL Server 2005 Database Developer All-in-One Exam Guide (Exams 70-431, 70-441 & 70-442) (All-in-One).

1. The end-of-chapter exam questions were perfect for helping me know what I know and what I don't know. I already passed the 70-431 and 70-441 exams and the questions I looked at in the back of the chapters hit the knowledge needed to pass these exams.
   
   Unfortunately I failed the 70-442 exam before this book was released. However, after reviewing the end-of-chapter exam questions, I saw exactly what I needed to brush up on. I spent several days in a marathon study session doing the exam questions in the back of each chapter for the 70-442. For anything I missed, I studied the material in the chapter. In addition to learning what I needed for the exam, I also learned a couple things I didn't know about in SQL Server 2005. I then took and passed the 70-442.
   
   This book was just what I needed. I only wish I had it before I took the 70-442 the first time.



2. For the 431 exam, I used the (Tom) Carpenter book as my primary study guide and this book as a side reference. My main reason for purchasing this book is for the next two exams (441,442). After taking the 431 test and looking up some questions I guessed at in this book, I regret not using this book as my primary study guide. This book seems to point out the exact information needed to get through the test. I look forward to using it for the next two exams. Note that the author of this book is the technical editor for the Carpenter book.
   
   Update to previous review:
   I just passed both exams (441 & 442) without difficulty and with plenty of time remaining (each exam took about 2 hours). This is definitely the book to use for these exams. The topics and sample questions are on target with the actual test. Be sure to review the topic list for each exam in the front of the book before taking the test. The 'what you need to know' section at the end of each chapter is not always accurate. Also - the explanation of cascade deletes is incorrect in the book.



3. Well written and in depth, this book should cover everything necessary to pass these tests.
   
   I have two complaints:
   
   1) The book is laid out functionally for SQL Server, not for each test. So, for example, when you are studying for the 70-442, it may involve a portion of chapter 3, 4, 5, and 8, but all of 12 and 13. All this information is entwined with the stuff for the other tests.
   
   2) You choose to only take one of the tests on the CD. For example - you couldn't say just test for the 70-441 test. I found the CD questions less useful than books dedicated to one test because of this.
   
   These are minor complaints though, and I'm not really sure the issues can be avoided to begin with. Don't let them stop you from using this as your resource to pass these three tests.



4. After having completed Microsoft's MCAD certification, I am using this text along with the Tom Carpenter text to prepare for MCTS and MCITP certification. Though I haven't taken the exam yet, the material appears to be covered in a thorough and in-depth fashion. Yet, it does not get bogged down in unnecessary detail.
   
   Excellent book!



5. I actually bought this book by mistake, BUT I started reading it while I waited on the MCITP SQL Server 2005 Database Administration All-in-One Exam Guide (Exams 70-431, 70-443, & 70-444) (All-in-One)to arrive. It's the PERFECT book to have for either a developer or DBA! As a matter of fact, just because of this book, I'm going to start on the developer certification right after I pass my DBA tests (I have all three tests in the next two weeks!).
   
   I've got several friends that are developers (.NET, SQL, C#, etc, etc) and they all said if they had a book like this when they were learning they would have passed their tests with half the amount of time/effort!
   
   The best part about this book is that I've had several questions regarding the content and decided to try and email Darril (the Author) for clarification. SURPRISE, I got thoughtful, through responses to all my questions extremely fast! Thank you Darril for doing such a great job putting this book together and being such a great help!!!
   
   On top of the book, there's two great websites & a CD with all the scripts/info that you would need!

5 comments about Continuous Integration: Improving Software Quality and Reducing Risk (Addison-Wesley Signature Series).

1. Any software developer who has spent days in 'integration hell' handling a complexity of software components will appreciate the invaluable information in CONTINUOUS INTEGRATION: IMPROVING SOFTWARE QUALITY AND REDUCING RISK. From the initial concept of CI and its practices to over forty CI-related practices from database integration to development, this book covers the entire cycle of CI development and surveys all kinds of events, repetitive processes, and more. An outstanding guide any serious software development library needs.



2. This book is an excellent overview of why Continuous Integration is important and about more than just compiling frequently. The book helps you to understand why to do CI, what you can do beyond building, and how to do it. In addition to general principles, the book points you to some excellent tools and resources. This book is an excellent companion to Software Configuration Management Patterns: Effective Teamwork, Practical Integration; it provides teriffic information that support the build patterns in that book. You might already know some of the information in this book, but it is worth buying if you need to encourge CI in your organization for the clear discussion of why CI matters and the for the detailed advice on how to implement it.



3. As a software developer, you know that one of the critical period in a project is when you try to make integrate your code in the overall application and push it towards the final user. It is sometimes a long process that you would like to accelerate so that you could obtain a quicker feedback on the quality of your code. This book written by Paul Duvall, with Steve Matyas and Andrew Glover, will help you improve the way you build and deliver software.
   
   After a initial presentation of the continuous integration (CI) concepts and objectives, the content of the book goes far beyond the simple "continuous build" aspect to cover all disciplines concerned by CI: risk management, configuration management, database evolution, software testing, inspections, deployment. It is clear that CI is just not installing a suite of tools, but is mainly changing software development practices and process. Each chapter is well structured with practical examples related to real life situations. The book reach also nicely the objective of maintaining a balance between a somewhat tools- and language-neutral position, but still giving enough practical advice so that you could quickly adapt the advice to your own software development environment. Final appendixes give valuable information on CI resources and evaluating available CI tools.
   
   Finally, you can get more and updated information on continuous integration and download book's chapter two from the Web site associated to the book: http://www.integratebutton.com



4. As Martin Fowler says in his foreword to this book, all of this information is available on the internet. However, that should by no means demean the value of this book. This is an extremely readable and well-organized presentation of this important development practice. Often the organization and comprehensive analytical thought are themselves important contributions to a given topic, and that is what Duvall, et al deliver here. Highly recommended.



5. If you have not been exposed to continuous build/integration, this book covers the approach along with the advantages and points you to some references.
   However, if you already have an understanding of CI or have decided that you need to set up a CI environment, this book doesn't add much: few details, little discussion of fine points, etc. That is, don't buy this book if you want concrete help setting up CI.
   There is quite a bit of repetition (how many times does one have to list the advantages of CI, or a dedicated build machine, or whatever?).
   I found Ant in Action (Manning) much more useful: both in providing the motivation for CI, explaining fine points, providing examples, and in breadth (even if "Ant in Action" is nominally about a Java build tool).

5 comments about Software Security: Building Security In (Addison-Wesley Software Security Series).

1. I read six books on software security recently, namely "Writing Secure Code, 2nd Ed" by Michael Howard and David LeBlanc; "19 Deadly Sins of Software Security" by Michael Howard, David LeBlanc, and John Viega; "Software Security" by Gary McGraw; "The Security Development Lifecycle" by Michael Howard and Steve Lipner; "High-Assurance Design" by Cliff Berg; and "Security Patterns" by Markus Schumacher, et al. Each book takes a different approach to the software security problem, although the first two focus on coding bugs and flaws; the second two examine development processes; and the last two discuss practices or patterns for improved design and implementation. My favorite of the six is Gary McGraw's, thanks to his clear thinking and logical analysis. The other five are still noteworthy books. All six will contribute to the production of more security software.
   
   Gary McGraw's book gets my vote as the best of the six because it made the biggest impact on the way I look at the software security problem. First, Gary emphasizes the differences between bugs (coding errors) and flaws (deeper architectural problems). He shows that automated code inspection tools can be applied more or less successfully to the first problem set, but human investigation is required to address the second. Gary applauds the diversity of backgrounds found in today's security professionals, but wonders what will happen when this rag-tag bunch (myself included) is eventually replaced by "formally" trained college security graduates.
   
   Second, Gary explains that although tools cannot replace a flaw-finding human, they can assist programmers trying to avoid writing bugs. Gary is the only author I encountered who acknowledged that it is unrealistic to expect a programmer to keep dozens or hundreds of sound coding practices and historical vulnerabilities in his head while writing software. An automated tool is a powerful way to apply secure coding lessons in a repeatable and measurable manner. Gary also reframed the way I look at software penetration testing, by showing in ch 6 that they are best used to discover environmental and configuration problems of software in production.
   
   Third, Gary is not afraid to point out the problems with other interpretations of the software security problem. I almost fell out of my chair when I read his critique on pp 140-7 and p 213 of Microsoft's improper use of terms like "threat" in their so-called "threat model." Gary is absolutely right to say Microsoft is performing "risk analysis," not "threat analysis." (I laughed when I read him describe Microsoft's "Threat Modeling" as "[t]he unfortunately titled book" on p 310.) I examine this issue deeper in my reviews of Microsoft's books. Gary is also correct when he states on p 153 that "security is more like insurance than it is some kind of investment." I bookmarked the section (pp 292, 296-7) where Gary explained how the "19 Deadly Sins of Software Security" mix "specific types of errors and vulnerability classes and talk about them all at the same level of abstraction." He's also right that the OWASP Top Ten suffers the same problem. Finally, Gary understands the relationships between operators and developers and the importance of security vocabulary.
   
   I was pleasantly surprised by "Software Security". I reviewed an early draft for Addison-Wesley and wondered where the author was taking this book. It ended up being my favorite software security book, easily complementing Gary's earlier book "Building Secure Software." In my opinion, Gary is thinking properly about all the fundamental issues that matter. This book should be distributed to all Microsoft developers to help them frame the software security problem properly.



2. The root cause of many security vulnerabilities is poorly written software. Often, software applications are written without security in mind. The logical, yet elusive, solution is to ensure that software developers are trained in writing secure code.
   
   Software Security: Building Security In is a valiant attempt to show software developers how to do just that. The book is the latest step in Gary McGraw's software security series, whose previous titles include Building Secure Software and Exploiting Software.
   
   In past decades, writing secure code was left to the military and banking industry. Today, with everything on networks, all sectors must get into the act.
   
   Much of the problem is that organizations target their security elsewhere--specifically on networks--rather than on software. But so many malicious attacks are directed at software that it is foolish to leave this vulnerability exposed.
   
   McGraw goes into detail not only about writing secure code but also about key related areas, which he terms "the seven touchpoints of software security."
   
   These points comprise code review, architectural risk analysis, penetration testing, risk-based security tests, abuse cases, security requirements, and security operations. A major portion of the book effectively discusses these "touchpoints," making the work a recommended tool for inculcating software developers with a security mind-set.



3. A required reading for anyone involved with software development and implementation. This book drills-down to security in coding and testing practices and how to avoid security related bugs and vulnerabilities. The concepts illustrated on secure coding, white box and black box testing are excellent. As a developer/architect, I thoroughly enjoyed this book and I suggest to everyone who wants to get started on secure coding and testing practices.
   
   Couple of things I QUIBBLE with are... the book does'nt realize the emerging issues and how-to's for build/refactor security for distributed application proliferation as your it - Portals, Web Services and SOA. The way we develop software is changing, the applications are becoming more pervasive and no-longer contained standalone to a system which makes the built-in security brittle impeding the agile business requirements for application/process orchestration, b2b federation and Web based application mashups. I am sure, the author will realize those gaps in the next edition of this book.
   
   Havingsaid - This book is still a must-read for the budding security developer who wants to focus on secure programming and testing.
   
   What is MISSING - You will not find answers for how you do secure web-centric applications, XML Web services - message-level security, identity federation and other b2b application complexities.



4. Software Security is the best book for learning to integrate security throughout your software development lifecycle. It contains all the security material that is missing from software engineering books. The author understands that your software development lifecycle is different from his, and so focuses on seven touchpoints that can be introduced into any software development lifecycle, instead of attempting to sell you a new lifecycle. He also understands that no matter how important security is to you, you can't change everything about you develop software tomorrow, so he introduces the touchpoints in order of effectiveness based on his extensive consulting experience, starting with tool-assisted code reviews and architectural risk analysis.
   
   If you're a software developer, Software Security is an essential book to have on your shelf, and you'll also want a secure programming book like Secure Programming with Static Analysis (Addison-Wesley Software Security Series) or the author's own Building Secure Software: How to Avoid Security Problems the Right Way.



5. Excellent high-lvel book for anyone involved with software development and implementation. This book digs deep with enough details of security in coding and testing practices and how to avoid security related bugs and vulnerabilities. The book also does well in terms of secure coding, white box and black box testing very well.
   
   Few things where this book falls short "Ignorant" to emerging application landscape and the coding complexities in a multi-platform and application integration environment - J2EE, .NET, XML Web Services and SOA. I am sure, the author will agree on those gaps hopefully we see in the next edition of this book.
   
   The book deserves 5 stars for the concepts + illustrations and 3 stars for those keen on development details for distributed applications.

5 comments about The Definitive Guide to SQLite (Definitive Guide).

1. Folks, I don't have a lot of time to write a long review. I usually don't bother writing them at all. But, this is a *terrific* book. My advice: Use Sqlite. It's awesome for its size! Use Python. What an amazing language! Use PySqlite for the binding to Sqlite from Python. And, *read this book*!!!!!! You won't find better documentation on this wonderful product. Thanks to Dr. Hipp for Sqlite and to Mike Owens for the original PySqlite and this book. Happy reading!



2. I am writing this review after 4 weeks or so of receiving the book. I have been developing a project on the weekends during that interval.
   
   I bought this book to use in conjunction with TCL for organizing a lot of online data obtained from web scraping for my business needs. I am an experienced C programmer (20+ years), but relatively new to both TCL and SQL. I was under the impression that SQLite was a fairly complete subset of MySQL, both from this book and other online hype. But from my limited exposure thusfar, there are gaps in thinking that one can apply most MySQL syntax to SQLite. I also bought O'Reilly's "MySQL Cookbook" hoping to find some good example code to springboard from, but many of these examples didn't work with SQLite. That said, the old adage that one can do a lot with a little is still true, so don't necessarily give up on SQLite. I've yet to find some missing feature that couldn't be handled with a little added script programming.
   
   After reading through the introductory chapters of the book, I was ready to start trying things. This is where the fun began. I quickly learned that the command line interface so well illustrated in the book either did not work when used with TCL queries, or had a very different syntax. This mainly applies to the dot commands of the shell (i.e., .help, .schema, etc.), but I have also found it true for some SQL statements that were used in the examples. (FYI: the subset of dot commands are called methods when implemented by TCL). This is not a fault of the book so much as it was a realignment of my expectations that one should be able to do anything with a script that one can type in from the command line. However, it would have been nice if there had been sections of the book alluding to the fact that all that was demonstrated for the command line is not possible with TCL scripts (I have no experience with the other scripting languages and the C interface). It would not surprise me if this deficiency is news to the author (hint for version 2 of the book).
   
   Here is one simple headache I encountered: I had a long battle (many fruitless hours) trying to deal with entering records and getting the PRIMARY KEY value to increment automatically as advertized - I cannot make it do that consistently without having to specify the incremented index value myself (I was using SQLite 3.5.1) when adding records. The examples in the book that show how to do this flat did not work in my TCL script based versions. Autoincrementing would sometimes work once the database was primed with existing records entered from the command line, but not for a brand new table. I may have also uncovered a bug, since this is supposed to be such a basic feature.
   
   In fairness, I've not tried all the command line statements with the shell as specified in the book to see if they work, but I would suspect that they do. What I have tried did work as described, so I have a good confidence in the book. To be clear, these problems are not so much the fault of the book but really my high expectations for what could be done with the scripts. If there is another syntax to allow these things, I've yet to find documentation on it.
   
   I also learned that many features in the syntax for MySQL will not work with SQLite, and this is not made clear from the limited set of things mentioned on the http://www.sqlite.org/omitted.html page. You will have to find a way to accomplish those tasks with your scripts in addition to what the SQLite commands offer.
   
   Regarding highlights of the book, I really liked the introduction to SQL under the heading of "The Operational Pipeline". The author takes the standard SELECT statement and breaks it up into the steps that SQLite must go through to parse and sequentially execute the statement. This is tremendously helpful in understanding the capabilities and potential pitfalls that are inherent in the syntax vs. what you are trying to accomplish. The book also has what appears to be good advice (although I've not read that portion) dealing with database design issues. That may contain further information that could have reigned in my expectations.
   
   I also really liked the example databases and the tremendous flexibility that was illustrated with the examples. This is a help for a newbie learning the capabilities of a data base manager, and getting some ideas for what sort of things SQL could handle versus what should be done with external programming. I thought the author did a very nice job coming up with the examples, and the wide variety of things one could do to process the data. These explanations of capabilities made it worth the price of the book for me.
   
   On the neutral side, I felt the pages dedicated to how to compile your own version were a little pointless given the number of binaries that are supplied by SQLite.org ready to go. However, if I'd been a Linux newbie, or had an unusual target environment, this may have been more appreciated.
   
   On the deficit side, another negative is that the book's index is not as comprehensive as it might be. I went looking for things that I had read only to be disappointed by not being able to find a reference for them. It would be nice if the printed version could be supplemented by Apress online with an electronic concordance (easy to generate these days). This was promised by their ad for the online "SuperIndex" in the back of the book, but I found it woefully lacking in practice. They do offer an eBook PDF version of the book for only $10, so if I was willing to buy this, I could solve the problem (assuming the PDF is fully searchable).
   
   Since I was using TCL, I can't vouch for the Python, Perl, Ruby, Java, PHP or C API interfaces, but its nice to know there is some information there. I was disappointed with the limited TCL information (only 3 pages) but thankfully, this is the best documented script interface with online sources, given SQLite's author's personal dedication to supporting it. Given all the problems I had, I must give the book low marks for not doing a better job of warning would be developers of the pitfalls. While the TCL syntax for commands is trivial enough, actually getting things to work is another issue and should be better explored, since most applications will want to use this inconjunction with an external language.
   
   While I've griped about the problems I've encountered, I must say that I have been able to accomplish my original goals of setting up databases to manage the reams of information I have been amassing. Without a database, this would have been a formidable task indeed. I can't complain about the price of the software (free!), although one has to pay for this with a lack of complete documentation, and much trial and error in figuring out how to make things do what they are supposed to do. As with many open source projects, one has to do with what one is given. To the best of my knowledge, I think the online documentation for SQLite in conjunction with this book is the best that is available thusfar (as of fall 2007). Given my inexperience with SQL, I don't think I would have been nearly as successful if I had relied solely upon online documentation - rather I'd still be slugging it out. The book has enough shortcuts, explanations of capabilities and other information to make it worthwhile.
   
   For application development, I'd also highly recommend the use of an alternate tool for checking what your databases look like after they have been built. The standalone SQLite browser on the SQLite.org website has proven to be a very useful tool. I understand there is also a good Firefox extension/plugin that has similar functionality.
   
   Best wishes to your development projects!



3. Whether you are new to SQLite or even new to SQL genereally, this book will have you using SQLite -- fast. SQLite is used in products and projects ranging from mobile devices to Firefox to Apple's Leopard to Google's Android. Getting to that level might take a little longer. :) A neophyte, I read straight through and found the quasi-historical introductory chapters on data modeling helpful. If you already know SQL and the theory behind it, go ahead and dive right into the details of SQLite. The API reference is extensive.
   
   The text is relatively free of serious errata. The biggest complaint I have is the weak index. The index is so weak as to make me wonder if APress deliberately neglected it as a strategy for selling the companion e-book. The e-book is $10 if you have purchased the book and worth it to get something searchable. But I would have gladly paid $10 more for the paper book with a comprehensive index. Also, be advised that the e-book is a password-protected PDF. This is somewhat insulting to honest customers, since anyone lacking respect for copyright could quickly find a free PDF-cracker on the 'Net. Taken together, these minor annoyances clip one star from what would otherwise be a perfect book.



4. I read this book cover-to-cover, except for most of the C API material. It contains a useful SQL overview, along with Sqlite3 specifics. I have done corporate database programming in my younger days; but even so, the overview was a helpful refresher. However, a person current in SQL would consider this material fluff.
   
   That said, the Sqlite3 specifics make the book worth the price. It is written well enough, and I enjoyed the read. I'm a perl guy, and I was disappointed that there wasn't more perl-related info. I got the feeling that the author was unfamiliar with perl, and lifted the information from elsewhere.
   
   Other reviewers have complained about the index, and they are right. It is incredibly inadequate. This fault makes the book annoying to use as a reference. I have been penciling page numbers into the index as I use the book.



5. This is the best available source on SQLite 3. It thoroughly covers how this junior version RDBMS differs from the big boys (like Oracle, MS SQL, PostgreSQL, etc.) It covers especially well the unusual variable typing and the special role of SQLite as an embedded relational database. For my purposes, the book spends too much time on the internals and the background C and C++. I wish it had covered in more detail the language extensions for embedding SQLite in Perl, Python, Ruby, Java, Tcl, and PHP; but I did learn a great deal about these extensions that I have found nowhere else. Free open source software can only document so much: at some point, one must consult a book written for profit such as this one.

5 comments about Programming C#: Building .NET Applications with C#.

1. A very good buy, this book goes into just enough detail to stay interesting. The only reason that I won't give it 5 stars is because I don't really like C#/.Net.



2. 
   A natural first step for me when looking for a book is to see what O'Reilly has available. This book was the first hit in my search results. And that hit was a homerun. Jesse Liberty has written a rare Dot Net book, a book that does not waste precious text (read time) editorializing on the wonders of Dot Net or prediciting the extinction of all things not MS. The organization of material is natural and intuitive and Liberty's writing style encourages the reader to keep turning pages without resorting to corny jokes to do so.
   Sections are handily decorated with comments pointing out areas where C# diverges from the legacy of its C++ and Java heritage. I've read more books than I care to mention that would have doubled their value had they included such annotations.Example code is relevant and well thought out; and it's available for download. Between this book and the near-infinite resources online, I don't think I'll need another C# book in my library.
   This was a great book and I'd recommend it to anybody.



3. This is one of, if not the single most poorly written book I've ever read. If you want to read from a monotonous author who is overly presumptuous about your prior programming knowledge, then buy this book! But if you want to learn anything about programming C# in a somewhat reasonable, logical way that doesn't make you want to jump off a bridge - buy another book.
   
   I'm an experienced php programmer with moderate knowledge on the principles of object-oriented programming, and this author just confused me more. Don't ever buy this book other than maybe as a reference if you're already an expert.



4. I found this book one of the most confusing I've owned and I've bought 20 books in the past two years. The Author has a choppy writing style that leaves me highly confused. An example is the chapter on delegates and events...a short introduction, a complex example, a little more complex example, then more of a complex example...too much code samples and not enough concepts! I think a book should explain a basic concept with a short example first, then develop upward. Out of my collection of a few dozen books, I'm sad to say this ranks the lowest.



5. I never got the book. I emailed the seller and he did not reply to my emails.

5 comments about SOA in Practice: The Art of Distributed System Design (Theory in Practice).

1. Service-oriented architecture is more than just another IT buzzword. Most companies, large and small have heard of SOA and have either jumped on the bandwagon or have plans to do so in the near future.
   
   SOA in Practice covers a lot of ground and provides definitions and descriptions of the complex world of SOA. Initially, the book describes the motivation to adapt a service-oriented architecture. It then proceeds into a discussion of the elements of SOA and reiterates that SOA is no silver bullet.
   
   The author makes it clear that SOA is an ideal solution for a specific set of circumstances: "heterogeneous distributed systems with different owners." If that simple definition doesn't fit your organization, SOA may not be for you.
   
   If you are still committed to learning about or implementing SOA after understanding what it is and what it can (and can't) do for your organization, read on! The remainder of the book present an in-depth look at all elements of service-oriented architecture.
   
   I particularly enjoyed the chapters covering the enterprise service bus and message exchange patterns. In a nutshell, they show some of the many possibilities of how SOA can be implemented - indicating that there is no 'one right way' to do it.
   
   Web Services (not a requirement of SOA) is discussed, as well as the management of services, model-driven service development, and advice on establishing SOA in your enterprise.
   
   The book is light on technical details. This is obviously intentional as its core focus is not the nitty-gritty of how to make it work. It is more of a high-level, conceptual view of what SOA is all about and how it can help your enterprise solve difficult challenges when faced with integration of heterogeneous systems.



2. Having experienced my first service based, distributed system beginning around the 2000 - 2001 time frame, I feel well qualified to review this book. Through the years, I've heard and read a lot of SOA fluff and contradictions. This became a huge problem for me in 2005 when I was tasked, for the first time, with the job of designing a large, service-oriented, distributed system for a national observatory.
   
   The challenge was in explaining why all the hype the stakeholders had read about SOA didn't make it any easier to implement it and that, in actual practice, building the system would require hard work and a good understanding of distributed systems. You simply cannot buy this on a disk. In all fairness, you cannot buy this in a book, either, but what you do buy in this book is a way to explain what it is you are doing.
   
   Management and domain experts will read this and understand that there are challenges they had not thought about when they were told how easy it is to just 'wire' together services to build business processes. Developers who are new to distributed systems and/or the SOA paradigm will begin to get a 'feel' for how it differs from other approaches to distributed system design.
   
   If you want to really begin communicating with your stakeholders, point them to this book. I've read many books and articles on SOA and found the clear, complete, and concise approach taken in this one to be most effective.



3. This is an excellent book to understand SOA. The Author has put in a lot of valuable architectural views on SOA best practice which would be useful for anyone who cares about design rationales. The only small complaint is the coverage on implementation details; For example, the section on WS-Security is really lack of details, not even a sample WSDL on WS-Policy. However I appreciated that code details could be left out and I think it is very effective for a book of 300 pages to cover so many key items of such a wide-spread topic, it would be very helpful if the writer can refer to some URL links so that audience can go into details by themselves. Overall I think this is a very good SOA book to read



4. [posted on [..]]
   
   Yesterday I've finished reading this interesting book from Nicolai Josuttis. I've been following Josuttis' work since my C++ times (which, btw, are a few years away now - enough for letting me sleep without thinking on memory management :)) and I was pleased to see that he still has the some easy reading writing style. This is a book on concepts. Unlike his previous work (which were on a specific technology - or should I say, language), you won't find any references to specific problems you may face while trying to "realize SOA".
   
   Instead, you'll find an objective book which presents several aspects on SOA and offers several good advices which will really help you if you want to implement SOA in your company. And he manages to do all this in just about 300 pages (which is really cool because we don't really have time for big books, right? :) ). That means that I'm giving it 8/10.



5. Josuttis managed to write an excellent book on the practical essence of the Service Oriented Architecture. He describes in precise words and with well thought examples how the new SOA paradigm will help shaping the future world of computing and he draws paths how an enterprise can gradually implement and benefit from SOA. Other than the popular but theory loaded book by Thomas Erl, Josuttis finds a way to teach the principles and pitfalls on the example of real-world experiences. Although the work is not a tutotrial, it is one of the best books out there in the markets to cover the topic. A must read for those who are more interested in "how-to" than a catch-all theory. Simply brilliant.

5 comments about CSS Cookbook, 2nd Edition.

1. There are just too many "bugs" (typos, coding errors, misplaced figures, etc.) in this book to recommend it. I could forgive the many grammatical errors (though there's really no excuse for them), but when you're supposed to be passing along coding solutions and there are this many errors in the very code you're recommending, it's just unacceptable. I spent way too much time trying to unravel the coding errors to make this book really useful.
   
   I also agree with the reviewer who said he couldn't figure out who the book was for (e.g., beginner, advanced programmer, etc.). I think the problem lies largely in the way the book was organized (or rather, wasn't organized). They need to take this book back to the workshop, clean up the errors, re-arrange the content and then, perhaps, they will have something worthy of publishing.



2. The CSS Cookbook is written for those starting out with CSS and advanced users. It is not written as a tutorial in order to learn CSS but anyone with a basic grip on CSS will find the book a valuable companion. The clear explanations of many of the pitfalls we come across when writing CSS are simply stated in an easy to look up format.
   Even though you may not want to read the book front to cover I think its a great experience to just pick your chapters by what interests you most and to work through a complete chapter following along and rewriting the code as indicated in order to get a good feel of what problems are solved so that if along the way you run in to a problem you find it back without mach ado. You might learn things you never knew where that simple ore useful. For those who are transitioning from table based layouts to CSS it might not be to book to get familiar with CSS because it is a technical book, a little to dry for just getting into using CSS. Once you have gone through the initial learning curve using books like Head First: HTML and CSS from O'Reilly or Eric Meyers on CSS from New Riders you will be ready to use the book as it is intended: A constant companion within reach whenever the going gets tough,
   Chapter 9 on page layout for example clearly explains what took me a long time to understand when starting out trying to use floats for layout. A common problem like columns floated to the left being shorter then the second column located on the right and the resulting overflow of this right column below the left -floated column, I almost forgot that that took me hours to solve when starting out with CSS. In "CSS Cookbook" these behaviors/problems are explained almost in order of appearance as we are working to accomplice more complicated layouts using relative or absolute positioning. There are many resources out on the web but wadding through them is time consuming and being able to find your solutions in a one or two page example including code and images are a big time saver. After each problem there is almost always a "See Also" referral to either another recipe in the book or a link to a more detailed explanation online directing you not only to reliable CSS resources but also to the direct location of the particular problem at hand within these CSS online community resources.
   In the same chapter on layout Christopher Schmitt takes us trough as step-by-step tutorial on Alex Robinson's influential article on creating the "any order Columns" published at postitioniseverything.com. A great exercise in understanding floats and how to be creative with code.
   In chapter 4 on page elements you will find a great example on some creative ways to add java in your pages and I really appreciate the precise instructions here since that is still kind of new to me. The results are truly beautiful, and would inspire any visual designer and can even be applied to background images placed from a style sheet as you can see applied at [...] a small testing / playground of mine.
   
   A whole chapter is dedicated to forms, another to print.
   You will find a clear explanation of how to run multiple versions of i.e. and how to install them. I always new where to find them, just could not get them to work until now! I wish the same simple explanation were given on how to implement Shaun Inmans "clearing a float" in a absolute positioned design since it still is not working for me. (patience, patience...)
   
   The books focus is on solving CSS problems so don't expect all files/example that accompany the book to be validating. I find that a bit of a draw back since the document type used is XHTML Strict in most example files. I think the book as well as the accompanying files may need someone to go through them one more time with a fine comb to correct some of the minor coding errors.
   It's really not to be picking but the book is meant for those familiar with code looking to switch over to CSS and for those more advanced. Using a XTML strict Doc declaration in most documents, would it not be neater if the document where written and validated as such? Text without a paragraph surrounding it or a
   inside a paragraph, missing closing tacks, make it hard for those who are starting out to find confidence when the CSS is somehow not working. Is it I, is it the book? Honestly, when I get stuck I like to know it's something I did wrong and not the book I am learning from. I did however not find any CSS errors in any of the samples I worked trough!
   
   I never read the first edition of the CSS Cookbook but with the release of IE 7 the book has been updated.
   In chapter 3 on images it is stated that at press time IE 5x and 6 do not support a fixed background image in a header to receive a particular effect. I tested in IE 7 and its now is now behaving as it should, so the book I think was released before IE `s 7 official release. Would it have been wiser to wait for this? I think there would have been a more structured outline then of what is still missing and a clearer picture of what to expect in the future working with multiple browsers and demands.
   
   In a ocean of resources in print and online, in the midst of so many tutorials and inspirational articles written on CSS we need a book that works like a Swiss Army Knife to help us solve the problems and issues we come across when we are working on a project and don't have the time to wade trough some of the indeed fascinating and very valuable recourses we can find online. We need a direct solution...We need to know that when we do get stuck or want to push the boundaries that there is a resource that is not lost in a endless list of valuable bookmarks, however well organized, one we can access immediately. Therefore it can be a valuable reason to work through the chapters of interest so that when time is of the essence we know where to go.
   Especially when working on commercial project and when we are not at liberty to suggest that, well maybe IE users will not get the full experience of some more advanced and also very popular browsers, but...
   
   In short it is imported to know what works or not and
   to have some workarounds or at least to hide from those browsers who don't support what you are doing.
   Me personally, I am passionate in my belief and the reasoning behind it, to not letting a product of lesser quality hold down a development....
   And especially because of this is it so important to have the tools at hand to know when to support or bypass older browsers to know what works and what not etc.
   
   I almost want to keep the book a secret just because of the fantastic light box example in chapter 4.6. What a beauty. The book really makes you want to explore and experiment with some more java code added in to your designs. A true gem released a bit to hasty. I don't want a refund and you cannot borrow my copy!
   
   
   • In general, this is a helpful book if you need to research a particular design solution, but it should in no way be used exclusively to learn CSS. It's helpful to have CSS and javascript experience to fully take advantage of everything this book offers.
     
     Unfortunately, the book contains some organizational flaws. The "General" chapter, which is meant to serve as an introduction to CSS, is a brief background to concepts and tools, but it doesn't always point out that certain selectors are not supported in every browser (child selectors and pseudo-elements are the most notable). I think it'd be helpful to state straight-up that many aspects of CSS are interpreted differently in various browsers, if supported at all, and then note which browsers support each feature as the feature is introduced to the reader. To their credit, they do include a "pitfalls/warnings" icon at the end of some sections, but it'd be helpful to know about them before you continue on to work through one of their examples, only to discover later that it doesn't work in IE6. Since most people would like to design for a cross-browser experience, they might just want to skip over certain CSS features that are not widely supported, so indicating browser support up-front would be very helpful. And I wonder how valuable it is to mention something like "text-shadow" if it is only currently supported by one browser? In addition, some important concepts are buried in the book (such as the fundamental concept of inheritance and the !important rule) - they might be better placed in the "General" chapter (introduction).
     
     Though this book does have its flaws, I have to say that it does assemble some nice formatting tricks. I have previously scoured the Web searching for many of the techniques that are all nicely packaged in one place in the "Images" chapter, so I am sure this would be a real time-saver for many, as the leg-work is already done for you. Among some commonly sought out techniques are rounded corners, dropshadows, and the lightbox effect. The "Lists" and "Navigation" chapters are also pretty useful. The "recipes" this book includes are not only a means to accomplish a particular goal, but the solutions are creatively achieved so that you start thinking about using CSS in less out-of-the-box ways. And kudos to them for mentioning accessibility/usability in the "Typography" chapter - those concepts often fall to the wayside in comparison to glitzier topics.
   
   
   
   • In the past I've had confidence in the quality of books published by O'Reilly, but this book was a huge disappointment. There are so many errors--both typos and grammatical errors--coupled with awkward writing, that I find it almost unreadable. Even the diagram for the box model on page 67 is messed up. How is it possible that this sloppiness could get published (again!) in a second edition? There may be some valuable information in the book, but with all the mistakes I don't trust it as a resource. Look for authors Eric Meyers, Jeffrey Zeldman, and Andy Clarke for better CSS books.
   
   
   
   • Unfortunately, this book has too many errors, right from the very first chapter. It's unacceptable to have sample code that does not even match the description of the accompanying text, and output pictures that show something different than what the code actually does (ie: text is supposed to be displayed underlined in bold, and shows normal, when the point of the example is how to do that).
     
     I'm returning it until they get a new corrected edition. It just pointless to spend time figuring out what the author really meant, I'd rather spend that time learning from another source.
   
   
   

2 comments about WPF Recipes in C# 2008: A Problem-Solution Approach (Recipes: A Problem-solution Approach).

1. This very well written and organized book provides comprehensive coverage of WPF features. The authors get down to business right away, assuming that most readers already know basic WPF concepts such as Dependency Property, Attached Property, etc. because they don't waste time explaining many such building block concepts, and yet a few of the recipes are surprisingly beginner-ish material. Of the 200+ recipes, the ones that I thought gave me the most bang for my buck are those contained in Chapters 11 (Creating Animation), 7 (Working With Test, Documents, and Printing), 4 (Creating Use and Custom Controls) and 5 (Data Binding), either because they covered materials not found many where else, or they clarified some concepts for me. For example, the Animation Recipes discussed concepts not even covered in the very well-received "Practical WPF Graphics Programming" book by Jack Xu. The recipes in Chapters 6 (Working With Styles, Templates, Skins and Themes), 8 (Multithreading), and 10 are good, and the remaining recipes in Chapters 1 (Building and Debugging WPF Applications), 2 (Working With Windows, Forms, and Layout Management), 3 (Using Standard Controls), 9 (Working With 2D Graphics), 12 (Dealing With Multimedia and User Input) and 13 (Migrating and Windows Forms Interoperability) cover materials easily found in other books. Another positive, however, is that some chapters contain bonus nuggets of information on things you can do to make your code play nicer with designer tools like Expression Blend. Overall, I think the authors did a great job!



2. This book has what is very hard to find with such new material as WPF... good working examples. I truely believe the the chapter on user and owner controls more than pays for the book, although the book offers much more.
   Apress rates this book Beginner-Intermediate. For me, I don't think I could have understood this book 6 months ago, but after working with WPF for about a year now I find it extremely easy to read and very informative.
   
   I found direct answers to problems that I have had over my last 6 week project, and know that if this book was out last month I could have cut 2 weeks out of that project with ease.
   
   Back to user controls (again, this is not the only good about the book... it just what I'm focusing on right now). The chapter offers not only good examples, but insight from the authors on how to make your new control work well with others that would want to restyle it. Another section shows you how to know if your in delevopment mode so as to change it's look when in Blend if required. All in all a pretty thourgh coverage.
   
   One thing I'd like to say, as I think this might bug some people. There is a fair amount of duplicate code in the book, as there are times that the same code really does express more than one idea, and can be reused in other sections (or even the same section at times.)
   
   I actually agree with the author's desision to duplicate the code instead of referencing me to other sections in the book. I can keep my train of thought where it should be, and don't have to keep flipping back a few chapters as in some other books. Even with the dupicate code, there are other functions added if appropriate.
   
   Of the examples I have read, I find them to be concise, and to accurately portray the idea the authors are describing. They do not attempt to be more than they need to be, but are strong enough to cover more than the bare minimium.
   
   Congratulations on a job well done.

5 comments about Beginning ASP.NET 3.5 in VB 2008: From Novice to Professional, Second Edition (Beginning from Novice to Professional).

1. THIS BOOK IS A COMPLETE SCAM! It should have been called Beginning ASP.NET 2.0 with VB 2005 (NOT ASP.NET 3.5 with VB 2008). Why? because there is no 3.5/2008 specific content in this book what-so-ever! I could not believe this while i was reading.
   
   He spends a chapter discussing the VB language and syntax, non of which contain the new language features or changes in the VB language, all examples will work in VB 2005 without issue. In fact, there is not even a mention of LINQ, which is the most important part of the new VB 2008 (VB9) language. In fact, he goes further by giving us chapters and chapters on accessing data using outdated data access methods and SQL statements, non of which is necesssary anymore thanks to LINQ (WHICH HE MENTIONS NOTHING ABOUT).
   
   It talks about the old, outdated controls of ASP.NET 2.0 which are no longer used or necessary due to the newer and much better controls available in asp.net 3.5 (in which he mentions NOTHING about).
   
   I still can't believe apress would allow something like this to go through. This really is a book about ASP.NET 2.0 and VB 2005 ONLY. There really is nothing (NOTHING, not even one bit) of anything related to exclusive ASP.NET 3.5 or VB 2008 features and content!!!!
   
   What a damn disappointment, when you are reading a book and realize you've practically read the exact same book 3 years ago and there is nothing new in it!
   
   Thankfully I didn't buy it and downloaded a copy off the internet to review it before buying it.
   
   THIS IS A COMPLETE SCAM, DO NOT BUY IT.



2. I have to say this is one of the first technical books that I actually enjoyed reading. It provides a more solid understanding of what ASP.NET is and what it encompasses for someone who has learned it on the job but never really took a class on it.
   
   It's well written and I learned some cool stuff. The sections that stuck out to me were the first chapter on what exactly the .NET Framework is, the section detailing the page life cycle and the chapter on ASP.NET AJAX. Great job Matthew.



3. I'm a database developer that dabbles in application development. I've worked with every version of Visual Basic released by Microsoft, every version of "Classic" ASP, and ASP.NET 1.0/1.1 (Sorry, no .NET 2.0).
   
   I needed a book that would give me the basics of ASP.NET 3.5 using VB so that I could get up to speed for a new project. This book was perfect!
   
   Too many other books have either completely abandoned VB and are now strictly for C# developers, or, give lip service to Visual Basic and "offer" to let you download VB examples from their website. Not much help to those of us that aren't C# gurus. (Ever try converting C pointer reference syntax to something comparable in VB? Not so much...)
   
   This book starts with a short history of .NET, gives you a couple chapters of VB.NET basics (syntax/control structures/classes/objects/etc.), and then jumps into building web pages. I used (FREE) Visual Web EXPRESS 2008 as my platform and never missed an example in the book.
   
   I spent about an hour or two a day mulling over the different chapters and within a week or so was pumping out web pages filled with bound and unbound data from a MS SQL 2005 database.
   
   While this isn't a monkey-see-monkey-do (step-by-step) book, it is full of code snippets and detailed explanations of how things work. If you need, you can always download the full source code for all the examples and then step through the code using the debug feature of VW 2008 Express.
   
   Considering the very limited number of Visual Basic books on ASP.NET 3.5, this book is a MUST HAVE for anyone/everyone looking to move up from previous versions of .NET (And a good starting point for .NET newbies). It is a fixture in my cube for use as a quick reference to answer the too often question of "How did I do that before..."
   
   The only reason I didn't give it fives stars was because it's coverage of Ajax was so sparse (one quick/short chapter). But, considering that Ajax is a language/architecture in itself, it really wouldn't be fair to expect too much coverage in a "Beginner's" book.



4. Very thorough and easy to understand presentation of ASP.NET 3.5. I would recommend this book to beginners as well as those who already use ASP.NET and would like information about some of the differences between versions.



5. Overall I found this book well written and easy to follow and understand. My main complaint is that it doesn't go into enough detail in some areas, especially the gridview and formview controls. What I would like to see is more content on customizing these controls. The book covers the built- in properties pretty well, but could spend more time explaining how to work with the templates. It also lacks detailed information on modifying these controls dynamically with code and relies mostly on setting the properties available in the designer. I still rate this book highly because it gives a good explaination on ADO.net, caching, application state, and security.