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 Don't Make Me Think! A Common Sense Approach to Web Usability (Circle.Com Library).

1. Absolutely brilliant book. You can find heavier books on the subject, but this one is a must have. Practical advice, to the point, explained so anyone can understand and remember it. Clear and beautyful design. Just about every spread has got illustrations. And you can read it all in one day. Everyone that has anything to do with web usability (or RIAs) should get this. Its also entertaining, I truly enjoyed reading this book!



2. As the subtitle says, it is mostly common sense. But to have it reinforced like this turns judging web site designs into a much simpler task. I found myself feeling like I had confirmation for many thoughts I have on the subject, but it raised my awareness of different user view points to a higher level. One item that was quite new to me though was the subject of usability testing. He explains his approach quite well and makes it sound quite easy and very useful. If nothing else, it gives you a sense of empathy for various user experiences on the web. Which can only help you improve your design's ability to meet their needs.
   
   I highly recommend anyone who is involved with web development in any way to check out this very quick and easy read.



3. Bought because it was on Joel on Software's reading list. Clear and simple, easy to understand. If picked up in a shop, I would not have bought it.
   
   - not much content, lots of whitespace, large fonts, lots of images
   - common sense (ie, most of it you probably already know)
   
   Read a few pages, then sent it to a friend who is building her first website.



4. This book is fabulous. It is very clear and easy to read, it points out how far you can get by just using common sense (and how you can develop it if you haven't got it), includes basic design principles and human psychology as well as some pretty strong examples. It shows you how a usability test can be performed and talks about what you should focus on. I very much like the approach that there is no average user and not just one correct way to design a site. This book is of great value, a true classic and I highly recommend it to anyone who is interested in the topic. It is so well layouted and designed that I don't need a marker to highlight anything!



5. If you are looking for a book with the main principles about web usability do not hesitate and buy this book. It might be a little bit outdated but 90% of the book is still totally true. Don't miss it!!

5 comments about Managing Projects with GNU Make (Nutshell Handbooks).

1. This book is a good place to start for learning how to manage large projects with GNU Make. It covers the basics and then moves on to specialized topics including writing portable makefiles, increasing makefile performance, and debugging makefiles. I've been using GNU Make for years and still found the book worth reading.



2. I've just begun reading the book and it's a nice book on GNU's make. As already mentioned, it is not a handbook but rather more like a discussion of how to best use make in your builds. That said, I'd like to point out that the text is available on the net for free. If you look at the associated O'Reilly web-page for this book, you can find the link entitled "Online Book" - click on that to see the index of the free, online book.



3. Make has been an icon in the GNU / Linux world for over thirty years now, and continues to be one of the most used utilities to ever be released on the platform. A good number of other projects have risen to take its place as an automated-build utility, but as of yet, none have been able to unseat Make. Some see Make as being too arcane and finicky to survive in the once it is confronted with an advanced, user-friendly, utility of the same purpose. However, as it stands now, Make is still the standard in the `industry', and Makefiles are distributed with almost every major software package on the GNU / Linux platforms (as well as some others!).
   
   Any avid Linux or UNIX power user, as well as most system administrators, will need to have some knowledge of Make to do what they need. Programmers, on the other hand, need to have an intimate knowledge of Make, Makefiles, and what the abilities of Make are. This book is more for the latter group, and goes into detail that the former group probably doesn't need to know too much about. For the former group, I would suggest a more concise, simplified version of this book. For the programmers, this book is a must-have.
   
   As I mentioned before, Make can be a little finicky at some points. This, some may say, is an understatement. There are a number of "gotcha's" in the language, as well as a lot of `hackish' features (when I say `hackish', think Perl `hackish'). Perhaps, more importantly, however, there are a lot of fairly advanced features that Make can handle, and few people seem to use these. This is where the book really shines - it goes over the rarely-seen, but perhaps some of the most advanced features, of the Make utility.
   
   This might seem obvious to most, but the novel assumes that the reader has previous programming experience, and throws C++ code blocks at the reader on the third page of the first chapter. If you don't have any programming experience, you probably shouldn't be reading this book anyways - but I thought it worth mentioning.
   
   The primary content of the book is split into two sections - basic topics, and then the more advanced topics. The author does an excellent job of starting out with the absolute basics, and slowly progressing into the more advanced topics at an easy-to-follow pace. I never felt like the pace was too fast, and the author does an excellent job of giving examples for each of the topics that require one. Each example is explained in detail, with an added bonus of a few "what-ifs" at some points.
   
   In fact, this leads into one of my few complaints with the book. There is so much code, and so much text, and... well... nothing else. There are maybe a dozen and a half pages in the book that aren't just one big solid block of text. After a while, it becomes hard to take. It doesn't help that each page looks almost exactly the same, so after a while, things start to kind of bleed together. In the next edition, it would be nice to maybe see some page styling, new layouts, some more images / tables where possible, maybe some funny side anecdotes or something - *anything* to give the text some life.
   
   Once you accept the pedantry of the text, you will find that it is extremely well written, and easy to understand. There were very few instances in which I had to re-read something multiple times to get an understanding of what was being communicated, and the author's ability to describe even complex topics in simple terms is really impressive at some points.
   
   The advanced sections of the book delve into some topics that I didn't expect to see, and was honestly pleasantly surprised that they made their way into the text. Included in the list of `surprise topics' are alternatives to Make, benchmarking Make, parallel Make, distributed Make, third-party programs that work with Make to add new functionality, and even sections on Cygwin and Make.
   
   Also in the advanced partition of the book were two other sections that I found to be extremely helpful, if not essential: Debugging Makefiles, and Example Makefiles. The Example Makefiles chapter includes both excellent Makefile examples as well as discussion of what is happening in them. The Debugging Makefiles chapter goes over a lot of the "gotcha's" in the language, how to find a problem, and then possible fixes for it. These were both nice touches to the book, and are examples of the dedication the author shows to covering the more difficult parts of the language.
   
   For the purposes of an in-depth, complete tutorial in Make, this book succeeds wonderfully. The author, although a little pedantic in the design and layout, does an excellent job of communicating each lesson. I recommend this book to any professional or hobbies programmer looking to get a little extra control over the build process.



4. Mr. Mecklernburg is definitely an expert in GNU Make and the book shows it. The information it contains is well organized and the author doesn't spend precious time on non-essentials.
   
   The downsize of the book consists in the total lack of fun it produces. The reader has no joy while learning about make and he may quickly find himself yawning at pages and pages of explanations with little or no examples that smooth out the learning curve.
   
   The book seems as if the author tried to show off his knowledge with the best eficiency per page and in the smallest number of pages. He succeeded, at least with me: I am convinced that Mr. Mecklenburg is an excellent engineer but a terrible teacher.
   
   Besides the content not being enjoyable, it is so much biased towards *nix that the Windows programmer righfully asks himself "what about me"? The solution offered by Mr. Mecklenburg for Windows consists in the... Cygwin environment. I'll abstain from commenting on this suggested choice.
   
   Despite its drawbacks, the programmer may find enough material to learn from it and get the job done. But make no mistake: this is not a feat and you'll need quite some determination to finish this book and extract something useful out of it.



5. I've used make and makefiles for many years. In my current product development there was suddenly a need for a little more than the standard make knowledge. For most Open Source tools there is a good O'reilly book, so I grabbed this one from the store.
   
   This book exactly fitted to my need. It does what it should do, it explain make, and nothing more. Already after part 1 I got useful new bits of information. Nothing major, just small "ah-ha, that's how the do it"'s.
   
   The book is structured ok (I felt it could be structured better, but have no suggestion how). It consists of basic and advanced parts. The basic part will cover rules, variables, functions and commands. The advanced will talk about large project, C++, Java, examples and some debugging.
   
   All the basic concepts chapters were pretty good. Somehow I didn't enjoy the advanced chapters too much. I didn't feel I was learning much new things there. The Java chapter was a little odd. I've not met any Java developer who currently uses make, most have switched to ant quite some time ago (book was 2004, so might be changed in the fourth edition). The example makefile of the book was somehow not interesting. The second example makefile was the linux kernel. This was more interesting, but it didn't go into too much details.
   
   All in all, I found it a good book. It gave me exactly what I needed. Somehow the writing style was a little dry. I couldn't really point my finger on what made it so.
   
   I'll give it 3 stars. Not because it's not good, but exactly because it's a good book. However, it didn't give me something extra, which I always hope a book gives me.
   
   Recommended when needing to know more about Make :)

5 comments about ASP.NET 3.5 For Dummies (For Dummies (Computer/Tech)).

1. I am an experienced developer so I only expected to skim over the book to get familiar with any of the new asp.net 3.5 features. I found myself reading every word of every page because the book was actually "entertaining". The writing is very smooth and easy to understand. You feel as if a really good teacher who knows how to relate to people is talking to you.
   
   I was also surprised how deep the book was able to go into each subject. For example Linq is a very complicated subject yet the book does contain enough examples for you to use it in the real world.



2. I almost didn't by the ASP.NET 3.5 for Dummies. Then I noticed that it was a different author than ASP.NET 2.0 for Dummies and I thought I would give it a look. Bill Hatfield wrote the 'Dummies' book on the previous version and while I found him to be very knowledgeable, I got frustrated because I was trying to learn how to use Visual Studio with ASP.NET and his book didn't provide much help. Ken Cox however "gets it". He wrote the book for use with Visual Studio and by the end of Chapter 4 you're already using AJAX with no difficulty! By chapter 7 you're delving into LINQ! Ken's approach is intelligent and his style works both for the beginner as well as those more seasoned in ASP.NET. Excellent book!



3. This book uses VB only. The web site reference is non existant. The overview should stipulate the strict usage of VB not C#. If you want to use C# do not but this book.



4. This is not the first ASP.Net book I've read. This is the first one I've enjoyed!-)
   
   Because of this book I'll reconsider my attitude towards the whole series. Suddenly it seems a great idea - get the basics with no pain.
   
   I liked the humor. I liked the fact the author's making it so easy. I like the stress on using the tools and not writing the code by hand.
   
   I key in the samples. Then I look at the code generated by the tools. Then I look at the code sent to the browser.
   
   A great way to learn. And have fun.



5. This book is great. In just one week I was able to create, with only a few lines of code, a brillant dinamic website.
   Well done Ken Cox.
   NOTE: This books contain VB coding and not C#

5 comments about Service-Oriented Modeling (SOA): Service Analysis, Design, and Architecture.

1. This is an excellent service life-cycle, strategy, design and architecture book that should:
   
   - Adopted as a model for service design and development in companies
   - Studied in business schools
   - Studied in technology institutions
   - Expanded beyond its initial scope to include missing elements, such as data architecture
   - Provide a meta model strategy to service oriented virtualization
   - Become the leading training material for SOA and service development
   
   I am still reading the book. I am in chapter 13 and it is becoming very apparent to me that it contains serious material that can help us getting out of the current mess that we are stuck in



2. I typically don't write book reviews, and when I write them, I do so for books that I love and appreciate. However, the amount of undeserved praise this book got is ridiculous. Someone has to say the emperor is naked. I am an enterprise architect, and I am knee deep in my company SOA implementation. The good positive comments this book got, made me buy it in a heartbeat, and I was looking forward its arrival in order to help me understand and solve some of the problems any enterprise architect have when building an SOA system. Unfortunately as Gerturd Stein once said about Oakland, California: "there is no there there". As an enterprise architect I could have learned the same amount of information I learned reading this book by spending the same amount of time watching the cartoon network. Honest. There is nothing here really. The emperor is naked. Don't waste your money. I would get SOA in Practice: The Art of Distributed System Design by Nicolai M. Josuttis - although it doesn't explicitly address modeling it is still good enough to get you an overall view of SOA. Or get Enterprise SOA by Dirk Krafzig and others to have a more in depth SOA book. This is not my opinion alone, my other colleague who is much more seasoned architect than myself has the same opinion. You have been warned. Browse it first before buying it. And if you are going to give me a negative vote on was this review helpful, then please write a comment to show why I am wrong, and what are the tangible things you learned from this book.



3. I'm an enterprise architect (a former developer), working for one of the largest retail companies in the US. This book is one of the most important books in the software modeling field because it explains and provides examples of a service development lifecycle. This text demonstrates the power of service reuse via hundreds of drawings and charts and it also offers a language for modeling enterprise applications and services.
   
   My company embraced this book as our SOA modeling bible and most of our architects and developers found it valuable to their daily work. With the offered SOA language we are able to describe integration and deployment of services and middleware and we are also able to analyze our business motivation and the technical feasibility.
   
   This book is necessary to my work, and to many of IT professionals, because it discusses the core of SOA development and it proposes service development ways in the following topics:
   
   1) Service Analysis
   2) Service Design
   3) Service Architecture
   4) Service Typing and Profiling
   5) Service Conceptualization
   6) Service Integration
   7) SOA Integration
   8) Business Integration
   
   Very recommended
   
   Sandra Bernstein
   White Plains, NY



4. It would be nice if we all recognize that SOA is not WS*. The problem with almost any book that claims that it is about service oriented architecture - is actually about web services. The industry fails to recognize that web services are really a very small part of SOA. But the amazing issue is that almost any company vastly capitalizes on WS. In other words, companies typically do not invest in strategies. They construct WS, deploy and integrate WS infrastructure, and create a WS environments. But where is their SOA?
   
   This modeling book gives an opportunity, a rare chance to reconsider what actually we are spending our money on. It comes down to a rudimentary selection between the bottom-up approach, where web services are launched to satisfy tactical concerns; or a most strategic, a top-down choice, that advocates reuse, encourages efficiency, and more.
   
   Recently, the development of simpler service technologies confirms this book's assertion that a service is not only WS. Meaning, a service can be any software component that exposes interfaces to its potential consumers. REST for example, also known as Representational State Transfer, devised by Roy Fielding early in the game, enables developers to avoid the convoluted WSDL (a rigid and tight contract) and utilize a looser service contract approach. As a side note, I would volunteer: it would be astute not to bet on WSDL as a "forever technology". Developers always complain about the WSDL method because it is complex, error-prone, and time and resource consuming.
   
   But the most compiling reason why anyone would want to read this book would be the large amount of new approaches to service design and architecture. It is a serious discussion about the "why" and later it proposes the "what". It is about the "thinking" process first, then the "doing" process next. In essence, every architect and developer that follows this book's advice becomes a strategist that can see the big picture, by learning how to avoid the silo mentality that has driven many of our decisions.
   
   I would give it a four star because it is too long and very detail. Almost every book part can be expanded into a separate book.



5. Before I purchased this book I was skeptical about its promise. I'm not a big fan of big title books or publishers' promotions.
   
   But this SOA modeling book is unique. It makes sense. It is logical. It is one of the best software modeling books that I have read. I think that it is big in historical proportions.
   
   A big part of it is a software development methodology. It is kind of a step-by-step guide to developing services. This is a guide for developing software on the application/service level and on the enterprise/service level.
   
   The other sections introduce a modeling language for service oriented architecture. The two authors explain and justify service reuse, service composition, decomposing, usage of SOA intermediaries, usage of ESBs, usage of SOA Gateways, usage of Adapters, and business process modeling.
   
   The book itself includes examples and diagrams for modeling but you can find more examples on different sites on the Internet.

5 comments about Ant in Action (Manning).

1. 
   A 500+ page book about a build tool. I guess your initial reaction might be the same as mine. Why would we need so much pages to describe a build tool.
   
   Well, after reading "Ant in Action" I concluded, it doesn't need. The book just described much more than just Ant.
   
   The book consists of three parts. The first part is called "Learning Ant". This is basically the build tool part, which describes the basics of Ant and how to use it. Well actually, in part one it already goes a little further to also include unit testing and already some deployment related information.
   
   The second part is called "Applying Ant" and goes well beyond just describing Ant. Chapter 10 describes working in large projects. Chapter 11 talks about managing dependencies and introduces Ivy. Chapter 15 introduces continuous integration and introduces Luntbuild (not sure why the authors not chose to describe CruiseControl, which is absolutely the most used CI tool). Chapter 16 alone would already be a reason to get the book and it talks about automating deployment and introduces a tool called Smartfrog.
   
   The third parts is called "extending ant" and explains how you can extend ant, develop your own tasks and test them using AntUnit. It describes how ant is implemented so that you know how to extend it (and probably how to develop for it further).
   
   When I started my journey through this book, I was a simple Ant user. The authors showed me that there are so much things possible with Ant and also explored the world around Ant. After finishing the book, I felt I have learned so much and it certainly improved my build scripting abilities. An absolute must read.



2. As a build tool, Apache Ant has been in existence for quite a while now and remains the number one Java build scripting tool. A large number of books have been written on its implementation - both good and unfortunately bad - and here is a brand new one which covers Ant 1.7.
   
   This book is a retitled second edition of Java Development with Ant by the same authors but is not just a minor update - the back cover quotes 50% new content and I can well believe it. Personally, I have implemented lots of build processes using Ant and even written a book on its implementation myself. I therefore thought I knew most things about the tool - however I was pleasantly surprised that I still managed to learn some new things from this book.
   
   In general I don't really like books over 250-300 pages - and this one stretches over 560 pages. Although there is probably some content that could have been left out, there are also gems such as Managing Dependencies with Apache Ivy (although I prefer the Ant tasks for Maven), Working with XML and Automating Deployment using a tool called SmartFrog. For me these chapters made the purchase of the book worthwhile.
   
   If you are new or have limited experience of Ant then you should add an extra star to my rating. I believe this is probably the most complete book at taking you from an Ant novice to expert, in as short a time as possible.
   
   It would have been nice to see some more examples of how Ant can be integrated into automated build processes, and rather strangely the book uses Luntbuild as an example rather that the more popular CruiseControl tool. Also it would have been nice to see how Ant can work alongside commercial tools such as the Build Forge build/release framework, application servers such as Weblogic or WebSphere and deployment tools developed by the likes of Tivoli or Microsoft. On the whole however, these are relatively minor complaints.
   
   In summary, if you are new to Ant then buy this book now. If you are an experienced Ant user then well, still buy this book!



3. Boy, was this new version that covers version 1.7 needed! Manning's first version was 2003 (Own it, too), and it was really starting to show its age. This book was, and still is, the only game in town. Its therefore a good thing it is written so well!
   
   So why 4 stars? I really, really, wanted a thorough treatment of the Ant API, and didn't get it. I selfishly want to call Ant from within Java code, but the section on Embedding only had a very simplistic example using echo().
   
   I also have to give 4 stars because as the only book out there on Ant (at this level), there is nothing to compare it to.



4. Being a general novice with Ant, I needed to get up to speed to amateur/expert level for my new job. So far its been a great reference getting in depth information about lesser used tasks in Ant.
   
   Since I work on a large scale project here, Chapter 10, Working with Big Projects has really been the most useful for me. Overall, I would say this book fits my needs and doesn't require me to buy any additional Ant books at this time. I would recommend it to others in similar situations.



5. "Ant in Action" is really the second edition of "Java Development in Ant." I think the original title was more descriptive as the book focuses more on process, tools and techniques than most Ant books. For example, they introduce continuous integration and why you would want to write unit tests. Not that the Ant coverage isn't good - it's excellent - just that the book is so much more. The book assumes you know Java, but walks you through everything else.
   
   Like most Ant books the authors don't rehash the excellent online manual and API. For those new to Ant, features are clearly described with good examples and good descriptions of "what happens if ____." The flow diagrams helped visualize concepts nicely.
   
   For those who have been using Ant, there are margin notes about what was added in 1.6/1.7 along with coverage of Ivy. I also liked the Java 6/JEE 5 examples. The techniques for writing reusable/maintainable code and extending Ant provided significant value. I was a little disappointed that the JUnit examples used JUnit 3.8. The authors did explain the reasoning and I understand their reason. I still would have liked to see it though as this book will still be used when JUnit 4 is in wider use.
   
   Coverage of related tools is also useful. It's good to know what libraries to look into to increase productivity with Ant. I've been using Ant for complex builds for three years and still had a page of take away points from this book. I recommend it for the valuable information and techniques.

5 comments about Beginning Database Design: From Novice to Professional.

1. This book delivers what it promises. It give a object oriented approach to designing databases. The basic topics and design methodology are addressed. I have become a better programer having read this book
   
   Using several examples of data modeling (plants, argiculture testing, personal management) it tracks the process from use cases and data collection to modeling the information with UML, and presenting this informaotion in a useable format. She touches on a number of common issues, such as a 'fan trap', key generation and data types that need to be addressed early in a project.
   
   The style is light and fast paced. The impact of different techniques are illustated in a concise manner with sufficent detail to be understandable and not overwhelming. I see it as a good basic introduction, and will use it as a foundation for more in depth study.



2. The more I get into database design, the more I keep coming back to this book, as well as Database Design Demysified. The two books are oriented toward small to medium databases, and that's the best way to learn the fundamentals. In my work for the government, I've only seen one or two decently designed databases. The true examples in the book of databases gone wrong are amazing and oh so common. Some much needed humor enlivens a dry subject in both books, and neither throws a lot of jargon at you. Database Modeling and Design (T Teorey) could never teach me how to design a good database! It just never gets down to the nitty gritty details of what works and what doesn't, and why. The two good books are complementary- I reccommend you get them both. Good Luck!



3. This book is excellent for someone who is trying to get into learning databases. I like using a different form of ERD than mentioned in this book, but I couldn't find any errors with this book. I found this comforting since many database books use the author's interpretations of database design, rather than generally accepted practices. Awesome educational book!



4. I am about 1/2 way through this book and all the things that I thought I would get out of it, I haven't. It is a fast read, but it is lacking in content.



5. Clare Churcher is an excellent teacher! She can explain difficult things in a clear and concise way. This is e.g. the first book who explains table joins to me without getting a hazy feel in the head. Nice to have this book as a first introduction. For digging a little bit deeper in the subject I would reccommend Beginning Database Design (Wrox Beginning Guides) wich I also bought.

4 comments about The HCS12/9S12: An Introduction to Hardware and Software Interfacing.

1. I'm an Electrical Enigineering student and do a lot of work with the Freescale MC9S12 family of 16-bit microcontrollers. After using just about every other book on the market for the HC(S)12 family, I can honestly say that this one is the best - by far. It's definitely the only one you will need on your desk if you work with these chips. The thing that makes it so useful is the wealth of code included in the text - both in assembly and C. Most books on the topic just include assembly, which is a fine place to start, but most of my work is done in C. So having the addition of the extra language is a huge selling point for me. And this book is for JUST the S12 family; it doesn't try to confuse things by adding the older HC12 family. The author includes code for everything that he goes over; and not just one or two snippets, there are many full examples for each of the topics covered. The author thoroughly discusses all of the hardware aboard the S12. It's like he takes the Freescale User Guides, interprets them into a form that's very easy to understand, and then gives you the code, both in assembly and C, to perform the task that was just explained. The author chose to use AsmIDE, MiniIDE, and GNU C for the code in the book. These software tools are freeware which makes the book more appealing to students or those without high-dollar development tools. In addition, they're included in the CD that comes with the book, and since they are freeware IDE's, they have no memory size restriction like the tools included with many other book CD's. Also, a plethora of practical applications are presented such as interfacing the S12 with stepper and DC motors, Servos, keypads, LCD's, external memory and much more. It also explains how to program the onboard Flash memory using both the resident booloader and a BDM. No other book that I have found even comes close to presenting just these two topics as well as Dr. Huang does. Before I had this book, I spent weeks trying to figure out Flash programming and Interrupts. This book makes it simple. Also, if you're just starting out and not familiar with a programming language, this book begins at the ground level introducing assembly and C. Basically, this is THE textbook on how to make the HCS12 microcontroller work. I use mine constantly and all of my other books just sit on the shelf - honestly. Come to think of it, the copy I have isn't even mine but my professor's :) To sum it up, I love this book because it's completely up-to-date, easy to use, and applicable to actual applications that one is likely use with the HCS12. You can tell that Dr. Huang actually uses the S12 and knows what he's talking about; not just a professor writing a text for an academic audience. This book is completely thorough and made to be used in the field. Money well invested! Thank-you Dr. Huang for such a great book!



2. Let me state that I'm a rank novice to microcontroller programming and embedded systems. This book seemed quite comprehensive, going as far as recommending demo boards and compilers to run the examples in. There were a few errors (i.e. Chapter 14, table 1 and figure 1 are the same) but the code all seemed to compile and run ok and the CD provided all of the source code for both assembly and C. All in all this book covered pretty much everything I wanted it to and would recommend it for any student looking to use the new HC9S12 family of microprocessors.



3. Fantastic reference.
   Great examples in asm and "C".
   Good explainations.
   A must have if you are using this family of MCU's.
   Covers tools as well.



4. I always seem to find the right book at the at the right price at amazon. This time was no exception. I went with amazon because of the free shipping and it arrived in a timely manner. I was not disappointed. The book arrived in described condition, and I hope to get my moneys worth out of it. Thanks Amazon.

5 comments about Data Structures and Algorithms in C++.

1. Although I have bought this book for its C++ emphasis for DSA, I have found it very good at teaching DSA itself. It has very clear explanations, well chosen examples, and depth enough coverage with along clear and easy to understand code illustrations in C++. The book teaches the topics in an incremental manner by making connections among different related DS and algorithms, which are helpful in understanding the theory.
   
   Its layout for teaching a topic consists of three parts: 1) Introducing the data structure or algorithms with an informal language. It relates it with other similar ones, and explains the differences. 2) It shows C++ implementation (it does not have C++ codes for all DS and A's; however, I think what it has is enough for such a book) and explanations, even some alternative implementations. 3) It has complexity analysis for the algorithm, and any drawbacks. Drozdek has concluded the each chapter with an case study and provides full implementation in C++.
   
   I have extensively studied Cormen's book of "Introduction to Algorithms", which I really like, however, this book is much better at teaching the fundamentals of the DSA topics and has better figures although Cormen's book is more in-depth and has more topics covered, and more academic. If you are looking at more implementation of the DSA with some in-depth theory, Drozdek's book is more useful. If you need more academic study on DSA, Cormen's book would be more helpful (in fact, I suggest both of them).
   
   Another thing I like in this book is its chapter for Memory Management. Although this is an OS topic, it covers it since many DSA requires dynamic memory allocations, and I think it is good at teaching the basics of data structures and algorithms used in memory management.
   
   In short, I strongly suggest this book to programmers who wants to understand DSA and CS students, and also the ones want to have a reference book. I think C++ codes are extra for those who are programming in C++.



2. On my bookshelf right now I have 13 books on DS&A using C++. Every time I am in need of a new type of data structure or algorithm, and quickly scan through each of them to determine which seem to have the most relevant information, and also which have useable source-code. Drozdek's book is almost always the book I end up selecting to learn a new topic.
   
   Without a doubt, Drozdek's DS&A book is the most complete and well-written of its kind. It includes a chapter of graphs, which many books surprisingly omit. Also, as of the 3rd edition, it includes a chapter on string matching. As far as I know, this is the *only* C++ DS&A book to dive into this subject.
   
   Surprisingly (because of such a broad-scoped book), the material presented in the string matching chapter is modern and incredibly useful. I found the coverage of suffix tries to be excellent. According to Professor Drozdek (via email correspondence), this chapter is actually a compressed version of what was to be an entire C++ book on string matching. Apparently no publisher would touch such a 'specialized' book. How short-sighted of them!
   
   I work in a research-intensive company focused on developing cutting-edge algorithms to solve difficult modern problems. We do the majority of our coding in C++, which is what originally attracted me to Drozdek's book. Since then, I have referred several colleagues to this book, all of which now use it regularly and are loving it.
   
   My only complaint about this book is that it doesn't discuss primality or random-number generation at all. So many algorithms rely heavily on one or both of these, so I find it strange that this book (and most others) completely ignore them.
   
   As for the reviewer who negatively commented "worst written educational book I have ever read", this person obviously bought Drozdek's book expecting to learn C++ and not DS&A. If you're looking to learn C++, I recommend "C++ Primer Plus (5th Edition)" by Stephen Prata (ISBN: 0672326973). Despite its awkward title and oft-maligned publisher, it really is an excellent book for learning C++ (and also as a reference for an experienced programmer).
   
   Depending on your needs, you might look into supplementing Drozdek's book with Robert Sedgewick's books 'Algorithms in C++'. His books do not go as deep as Drozdek does, but he provides an enormous number of fully implemented algorithms that don't exist in any other C++ DS&A book. Be sure to get the 3rd edition; it is much improved over the 2nd.
   
   Here's a complete TOC of Drozdek's book (3rd edition):
   Table of Contents
   1. Object-Oriented Programming Using C++
   2. Complexity Analysis
   3. Linked Lists
   4. Stacks and Queues
   5. Recursion
   6. Binary Trees
   7. Multiway Trees
   8. Graphs
   9. Sorting
   10. Hashing
   11. Data Compression
   12. Memory Management
   13. String Matching
   Appendices
   A: Computing BIG-O
   B: Algorithms in the Standard Template Library
   C: NP-Completeness



3. I bought this book due to the other reviews and targeting the string matching chapter. But when it arrived, I was able to directly apply tree other topics in my current work (skip list, recursion parser and expression tree). It saved me a lot of research, so I'm very happy with it.



4. I saw a different picture when i order it but got a totally different book from what I expected, but it was only $6.95 so i just kept it.



5. Mr. Drozdek must be creating false accounts and giving himself good reviews; that is the only way to explain this book's high rating. This is without a single doubt the worst text I've ever had to use. If you are a professor or someone looking for self-study, pass this one by! If you are a student taking a class with this as a required text, have a good secondary text handy. D.S. Malik has a decent C++ DS text that I used as my real 'study' text for my DS course. Again, STAY AWAY from this book at all costs!!!!!!!

5 comments about Rapid GUI Programming with Python and Qt (Prentice Hall Open Source Software Development).

1. I've been programming in python for about 2 years, and programming in PyQt for about a year. But I haven't had time to really delve into how things work, and how they relate to each other. The on-line documentation falls short in this area, so this book is a great help! I learned some new stuff about Python in the first few chapters, but the biggest help was the explanations of how PyQt works, and how to use it to the best advantage.



2. This book is perfect for someone new to the world of GUI programming. It provides a detailed walk-through of generating a useful and robust user interface. Providing a firm foundation in python and OOP and then adding both knowledge of Qt and a best practices approach to GUI programming.
   If you aren't new to programming and GUI creation than this book is still a very useful source of information if a bit hard to get through. The feature this book lacks which many love in O'Reilly books is a component by component breakdown of features with good examples. This is not really a flaw as this book is a ground up approach, however if you are looking for something akin to PyQT In a Nutshell you won't find it here. That being said, it is the best book on PyQt4 out there, and even if there were many other PyQt4 book to choose from this is still an excellent learning tool.
   
   In short this is an excellent book for people new to Python and Qt, especially those without GUI experience. Those with more experience may be bothered by the lack of a more modularized approach to learning PyQt4 as this book follows a more chronological approach of the design process. It's not quick and dirty, but it is robust and well written.



3. Finally i made possible to buy this Book, when I'm just starting to develop in PyQt (http://opencoffee.lnxteam.org) even having basic Knowledge of Python, this book results a very well material. I am professor from the Univ. and my own Linux/Free software Centre and I found this book that has the right way of teachings.
   Another important detail is, i am Spanish speaker and i could easily read, speak and translate English. But most of the times I found many programming books that has a way to explain things not thinking if that many languages speakers could read it. This one is a very exception: it is easy to understand, even when you native language is not English.
   
   So, Congrats Mark!!



4. The book contains one of the best Python introductions I've seen so far, which means it's useful even when you don't know Python, yet. After the introduction, you'll love it :)
   
   After that come 19 chapters which are packed with useful information in well digestible bits so the reader won't feel overwhelmed. When you're a professional, you won't waste time finding the information you need and when you're a beginner, you can easily follow every step as the author builds the examples from ground up.
   
   When I started with PyQt, I was a seasoned Python developer but I knew little about Qt. With the help of the book, I could write a complex application using even more complex widgets like QTextEditor (including HTML formatting) in a very short time. Developing was a very nice experience because the book always seemed to contain just the answer that I was looking for.



5. Good written book. covers all you need to know about python as programming language and QT to make you produce python GUI applications.
   
   To read this book you don't already have to know any programming language, the book will teach you; but it would make the whole thing a little easier if you already knew some other (or python) programming language.