5 comments about Expert One-on-One Visual Basic 2005 Database Programming (Expert One-On-One).

1. I bought this book even though I am a C# coder. Roger has such great concepts on how to do design and coding that I almost shouted for joy after searching and reading other books (e.g S. Malik which is of little or no value). This book goes beyond my production code needs and is invaluable in doing it right the first time. Thanks Roger for the section on concurrency exceptions which we all have in the real world. Most folks sweep this under the rug because it takes a real pro to fully and accurately address it.



2. This book does a better job of explaining what happens behind the vs2005 data object wizzards then many of the other books that just show you how to use them.



3. Having this book a month ago would have saved me at least $1000. Which is about how much I had to pay someone to write code that this book clearly points out was already written and available by Microsoft.
   
   That's the bottom line. This book is a time and money saver for anyone writing VB 2005 code that uses a database.



4. Excelente libro, le agregaria algun truquito mas, pero esta todo, sirve como para arrancar y profundizar en los temas. Muy buena guia.



5. I snatched this book up as soon as I saw it. I have three other of Roger Jennings' database books and they are great.
   
   This one was a little disappointing. It has good information in it and it is informative. But, percentage-wise at least, it seems to contain a lot more filler, like unneeded code. The style of writing seems so different from his other books that I wonder how much of the actual writing Mr. Jennings did himself.
   
   It's definitely not a bad book. Overall it was worth the money. Maybe the second edition will add more substance. I would actually rate it at 3 1/2 stars, but that's not an available option.

5 comments about Concepts in Programming Languages.

1. While I cannot speak to the quality of Mitchell's course, having only read his book, the earlier criticisms of his use of ML in the book are missing the point of a programming languages class. It's not meant to teach you a random sampling of the 2500+ computer languages that are out there. The idea is to learn about the fundamental paradigms of programming, with a focus on the functional and logical approaches since students are generally already familiar with imperative and object-oriented programming.
   
   ML is one of several good choices for illustrating functional programming, and is actually one of the more popular functional languages (especially the OCaML dialect.) There are many well written books and tutorials on the ML family of languages freely available on the web if you need more examples or detail than he provides in this text. However, the point isn't to learn ML, but rather that once you understand functional programming in any language, you can take advantage of its power, not only in languages like perl and python which offer some limited but nice functional features like map and anonymous functions, but also in imperative languages like C via function pointers and callback techniques.



2. As a grdauate student, I feel compelled to write honestly about this book in the hopes that what I'm writing might influence some teacher's decision in the future. Granted, the topic area this book is covering isn't trivial, but in the light of its complex nature it is even more paramount that someone attempting to explain it to those who don't understand it be well-versed in, frankly, English. This book is quite possibly the worst textbook I have ever encountered. The writing is atrocious, the "flow" is like mud, and the explanations make even things that could be simple, dreadfully complex. Avoid it like the plague, there are a lot better options.



3. The excessive reliance on ML and poor language skills exhibited are well covered in the other reviews. I'd just like to add that Mitchell has a terrible habit of explaining things out of order (for instance, activation records are explained on page 165, but you are expected to know them on page 148), and his "This is beyond the scope of this book." handwaving makes many of the explanations completely incoherent.
   
   I have never sold back a textbook before, but I'm taking this back to the bookstore right after my final, and then I'll get a real Comparative Programming Languages textbook.



4. It's a good review book if you know your material and just need a quick refresh or need the same concept explained differently. However, this book will intimidate you if you're new to computer science. An example would be in Chapter 1, the words "stack memory management and recursive functions or procedures" were thrown at the readers without any explanation.



5. I can't speak to John Mitchell's skill as a lecturer, but some of the complaints here seem to betray a misunderstanding of the purpose of the book: to serve as an introduction to programming language theory, such as can be found in Mitchell's other book *Foundations for Programming Languages*. Mitchell is taking you *out of* the marketable skills zone and into abstract computer science, and he's being pretty nice about it -- the book contains friendly precises of topics like lambda calculus and denotational semantics, which make up the formal core of programming languages. What you will learn has applications in all popular programming languages, even if it's not spelled out in the text.
   
   ML was a good choice as an example language, because it includes many of the features a programming language might have (being both imperative and functional), and furthermore is a serious research language on account of its well-understood semantics and type system. Focusing on it to explain core concepts was not a mistake. Mitchell knows how to do it the other way, too: explanations of the basic elements of object-orientation are parceled out over several notable OO languages, providing a way to compare and contrast how the major OO concepts can be implemented. (I didn't find the final chapter, Apt's summary of Prolog, as helpful: the declarative paradigm is too far removed from what was developed in the rest of the book.)
   
   On account of its relatively gentle explanations and the importance of its concepts for all aspects of CS, this would be a good book for a relative beginner in CS to pick up (provided they can comprehend more than just code). But if you find it too repellent, you're probably not going to be much happier with more advanced treatments: its character just reflects the nature of the field.

5 comments about Effective XML: 50 Specific Ways to Improve Your XML (Effective Software Development Series).

1. Effective XML is a collection of about 50 tips for working with XML. Although XML seems is simple and easy to use, it's also easy to get wrong. I've often scratched your head and wondered why things like XML Schema, for example, just doesn't feel right. But it wasn't until I read Effective XML that I understood what was really awkward with it.
   
   Because the book is so diverse (an amazing feat considering the small page count), it is hard to single out any specific part as being a reason to read the book. The book doesn't just talk about schemas, the infoset, etc..., it digs down and really explains what is good and bad about the technologies and what the best ways to apply them are. All I can say is that I use XML day in and day out and have learned everything I know by trial an error. I've made many mistakes along the way. I've tried my best to learn from them, but Effective XML was the book that made everything click for me. The best part is that the book went well beyond just helping me see my errors. I've already applied some of the ideas to new work I've done recently and have been able to head off some of the problems I would have encountered.
   
   
   Effective XML is by far the best XML book I've ever read, and quite possibly the best tech book I've read all year. I might even have to add it to my favorite tech books list. If you work with XML to any significant degree, I can't recommend this book highly enough.



2. The flexibility of XML can often mean that there's a gap between using XML and using XML effectively. Elliotte Rusty Harold's book Effective XML - 50 Specific Ways to Improve Your XML (Addison Wesley) is an excellent way to move towards the latter condition.
   
   Chapter List: Syntax; Structure; Semantics; Implementation; Recommended Reading; Index
   
   There are obviously a large number of books that will teach you the semantics of writing and using XML. But just because you can create an XML file doesn't mean that you've done it well or effectively. Harold's book provides a bridge to being able to create XML files that will be usable in nearly all situations. The book starts out in the introduction with explanations of terms that are often confused (element vs. tag, text vs. character data vs. markup, etc.). Then there are four parts of the book that include a total of 50 tips that will improve the quality of your XML usage. Some tips are pretty basic, like "Include an XML Declaration". Others are more complex like "Verify Documents with XML Digital Signatures". But every one is practical and useful for making sure that your XML is widely useable by all potential applications.
   
   Excellent bridge book to read after you've learned the basics of XML. This is a book that, when taken to heart and used, will cause your coworkers to thank you.



3. This is not a book explaining XML. This is not a book that goes into any depth on XML APIs. It is not a book explaining any one XML format like XSLT, RSS, or XSD.
   
   Instead it is a book on how to work with XML. How to design an XML application to take full advantage of the facilties of XML: schemas, processing instructions, XSL transforms, namespaces. It is all structured to slowly introduce you into the complexities, and deserves to sit up on the bookshelf with Effective C++, Java and Enterprise Java.
   
   If you already know the basics of XML, it is actually quite a good way to learn about some of the more esoteric concepts -from the pragmatic perspective. Too many XML books rant about how wonderful some feature like XML schema's extension stuff is, why XML is the most universal format ever, SOAP and WS-* the best protocol for distributed systems ever, and XQuery everything you need for an XML database.
   
   This book bursts the bubble of hype with rational analysis of what makes sense, and what doesn't. Item 28: Use only what you need, is my favourite: A review of the main XML specs and analysis of what really matters, which comes down to #35, navigate with XPath.
   
   If you are designing an XML schema/system/application, you need this book. If you have to put up with architects telling you about WS-MetadataExchange, WS-Transfer and RDF, you need a copy to roll up and hit them over the head. And, if like me, you are involved in standards bodies that produce XML related things, you need to buy a copy for all the other participants, so that what you produce will actually work.
   
   Remember that XML is a language designed for use by people and machines. The machines have the upper hand. But with this book, and some thinking, you can design XML applications that people can use.



4. Elliotte Rusty Harold states in the introduction of Effective XML that the book is neither an introductory book nor an XML tutorial. Rather, it is a distillation of the author's experience using and teaching XML and how to use it effectively. The book does a great job of explaining how to use XML and its related technologies.
   
   The book is divided into four major sections: Syntax, Structure, Semantics, and Implementation. Each of the fifty Items packs a lot of information into a few pages. The Items span topics such as why you should Include an XML Declaration (Item 1), Make Structure Explicit through Markup (Item 11), Program to Standard APIs (Item 31), and Write in Unicode (Item 38). Even the Introduction is valuable because it sets the definitions for XML-related terms used in the rest of the book that the author has found to be used interchangeably or inconsistently.
   
   Item 24, Choose the Right Schema Language for the Job, provides a typical example of the great information contained in Effective XML. This Item discusses the strengths and weaknesses of four schema languages: W3C XML Schema Language, DTDs, RELAX NG, and Schematron. The use of programming languages to handle situations that the schema languages can't handle is also discussed. The Item ends with a set of questions to think about when selecting the schema language to use.
   
   I found the book very readable and like that the information is presented in digestible chunks. Effective XML isn't meant to hype XML but to identify what the actual capabilities of XML and its related technologies are and how best to use them. The book does an outstanding job at this task.
   
   Full disclosure: I received a complimentary copy of the book for review.



5. I bought this book quite a while ago and I absolutely the format. It's a great resource to just pick up and get great ideas, verify that you are on/off the right track and generally learn how to get to the next level with XML. Highly recommended

3 comments about Visual Design for the Modern Web.

1. Normally I wouldn't put too much effort to be negative about a book (there's too much negativity in the world and it's damn hard to write a good book) but I had to post some remarks on this title. For a brand new publication this book is filled with horrifically out-dated information, some of if completely wrong. I expect a *lot* more from New Riders.
   
   A few examples:
   
   - In many places the technique discussed and coding examples are completely ignorant of current standards and best practices. In one section the author describes using tables for layout and describes how to use sliced images to create pixel-perfect layouts. Inline CSS is everywhere, because "external files make for unwieldy examples".
   
   How many out-dated techniques can you find in the following sentence?
   
   "In order to accomplish multiple discrete rollovers on what starts out as a single image, we break the image apart into slice (rectangular pieces) that are seemlessly reassembled into an HTML table."
   
   - There are lots of plainly wrong information scattered throughout the book. Just one example:
   
   "PNG ... is a newer graphic format intended eventually to replace GIF for everything but GIF animation (because PNG doesn't support animation). PNG won't replace the JPG format, because PNG is not ideal for continuous-tone images such as photos." (what about 24-bit PNGs?)
   
   "In general, designers who are artists first, web developers second, often prefer sketching the comp in an image-editing program rather than creating a skeletal HTML page." Oh really?
   
   New Riders books tend to be of a higher quality than the average technology book, but this one falls way short. A book that supposed to deal with "the modern web" should present modern approaches and ideas. This book reads like it was written in 1999.



2. As the author of Visual Design for the Modern Web, my goal in writing was to teach design principles, not CSS. While it's true that I didn't always follow the latest in the rather complicated Web standards, that was a conscious choice in order to keep the code simple and the focus on the elements of design. After all, a single book can't teach every aspect of web design. I also firmly believe there is a place for table-based layouts as long as designers respect the needs of screen readers, and that PNGs aren't ideal for photos because of their size. Of course, opinions may vary.
   
   If you're looking for a title on CSS and Web standards, I recommend Jeffrey Zeldman's Designing with Web Standards (2nd Edition); however, if your objective is to learn how using traditional design principles can help you create better Web sites, than I believe that you will find a great deal of useful information in my book.



3. The Web is a huge topic. There's HTML, CSS, JavaScript, graphics standards, PHP, Perl, Ruby, SQL, HTTP, Apache, and the list goes on. Creating a basic consumer site these days can easily involve a dozen technologies, each of which has its own complexities. And that doesn't even touch on the business side, which is, after all, the reason for having a site in the first place. Let alone the interface.
   
   No one book can cover it all, or even attempt to do so. Instead, authors need to choose a goal, and try to do a good job with it. The goal of this book is clear enough: to give people an overview of the main tasks they need to accomplish to create a basic static Web site for a small company, a family, a nonprofit, or whatever.
   
   The book succeeds at that. The first thing you notice when you look at the table of contents is that the book is not organized around technology. There's not a chapter on HTML, another on CSS, and so on. Instead, the book is organized around the attributes of a good site. For example, the navigation chapter shows how to achieve good navigation, talking about affordances, link states, link reliability, and so on. The chapter mixes together HTML, CSS, and JavaScript, just as any real navigation system mixes together different technologies. The book keeps the focus on the thing that matters: the user's experience.
   
   To my way of thinking (such as it is), that is the way it should be. The book focuses on the ends FIRST, and then shows what means can be used to achieve those ends.
   
   A common scenario is that people read books on HTML, CSS, and JS, and then start to create sites. The problem is, although they know how to create a link, they don't know when to create one, or why to create one, or the difference between a useful link and a less useful one. They know the tools, but not how to use them well. The results are less than professional.
   
   That is what Visual Design for the Modern Web is for. Once you learn what an is and what a CSS class is, this book will show you how to use them to create a good user experience.
   
   This should not be the first book you should buy. Buy HTML for Dummies (or some such) first, and play around. When you get ready to do some real work, then buy Visual Design for the Modern Web.
   
   There are some things I don't like, but not many. The waterfallish design model in the first two chapters could be replaced with something more clearly prototype based, maybe with more examples of design documents thrown in. There could be a little more server-side stuff added as well. Otherwise, it's hard to motivate the material on forms. Perhaps a little bit of PHP. Maybe two scripts, one showing how incoming data is appended to a file, and another showing how the file data is output to a page. Just enough to show how forms can help business processes run.
   
   In summary, a good book if you've learned some basic tech, and now want to know what to do with it.

3 comments about Programming Applications for Microsoft Office Outlook 2007.

1. Anyone who develops on Outlook should buy this book -- even if you don't have Outlook 2007. The beginning chapters review best practices and underlying architecture that every Outlook developer should understand, regardless of which version of Outlook you're using. Plus, you'll see all the great new stuff in 2007 which you'll want, so you can convince your stakeholders to upgrade. Later chapters drill into the technical details with surprising depth so you can find out what you need with only minimal trips to MSDN. Code samples are generous, albeit limited to only managed code... but that's understandable given the obvious advantages to using it for rapid application development.
   
   The difference between this book and previous attempts to document the Outlook development experience is like night and day. Kudos to Randy and Ryan for understanding what we face and doing an admirable job at enlightening us.



2. This book provides a good basic understanding of the process for programming Office Outlook 2007 plug-ins. It has a good spread of information about all the underlying office/outlook types and objects, although only briefly touches on their use. Demo's of using these objects are provided, covering typical basic tasks, but more advanced functionality is not really shown, though alluded to. The book makes extensive use (for C# programming) of a Shim Wizard which provides the interlinking functionality between the managed code and the COM interfaces. Unfortunately this wizard has been extensively modified since the book was published, and some of the instructions provided are out of date, resulting in the plug-in not functioning correctly. As very little information is provided with the book (and with the Wizard) working through these issues takes some time. The book's website does not include any errata to indicate the correct use of the modified wizard, though the site does contain links to the latest version of the wizard. Other than that the book is well worth it.



3. I found this book quite helpful since I am familiar with C# yet new to Programming with Outlook. My current assignment is to use VS 2008/C# to integrate with Outlook 2003 and 2007, I could apply some of the examples to my needs. Since I need to use VS 2008, then some of the steps are different and stick with events that would work for both Outlook versions, however, I have managed to figure them out.

5 comments about Access 2002 Desktop Developer's Handbook.

1. I'm comfortable with Access but when it comes to VBA I'm a newbie. This book doesn't only tell you what to do, but explains the why behind it. I have a database that I've put double digit hours (10+) into one problem. I got the book read up on combo boxes, the problem area, and in 30 minutes debugged my code to make them do what they were suppose to do. If I get nothing else out of this book it was worth it for that one issue, but upon further reading I'm learning the why's of Access. The code is still a little foreign but now I'm much more comfortable working in VBA. They use Reddicks naming convention which is different to me, but that's easy to look past. A great book!! Thanks Sybex!



2. Without a doubt, THE best book on Microsoft Access you will find. Most Access Developers will have several books on the shelf next to their desk gathering dust while they search through Google to resolve their latest dilema. Although I'm a Googler as well, my copy of ADH is frayed and worn...but never dusty. The authors write confidently and authoritatively, yet it seems that they take precautions to avoid intimidating the novice. I've seen reviewers referring to this book as "not for beginners." I was at the beginner-intermediate level when I first thumbed through it at a bookstore. I thought the pricetag was a little too high, but after about ten minutes I had to own it. Since then, it's brought me a long way. Whatever your level, if you really want to learn this stuff you will find great value here.



3. Not only is this series the absolute best when it comes to MS Access, it is the best technical documentation I've had the pleasure to use since the early days of Vax/VMS. A perfect blend of explanation, examples, syntax, and guidance. A level of art to which all others should aspire (and regrettably too many do not).



4. As the word 'Developer' should imply, this book is not for MS Access beginners, but once you qualify yourself as 'intermediate' or better, you will feel right at home. Very little of this book is devoted to boring you with rehashes of stuff in the help file (as most other books seem to do). There is a great deal of depth and insight into areas that apply to everyday usage, complex projects, and solutions to many problems MS tends to ignore version after version.
   
   The writing is excellent and they have a web site devoted to updates, errata and such which is very helpful. Chapters 10, 14 and 15 have had an extremely positive impact on the quality and usability of my projects in MS Access as well as VBA and Visual Basic. Many of the code samples are outstanding and written so that you can just drop them in to your projects with no modifications. Many of them are done so well they seem like natural extensions to MS Access (stuff MS 'should' have included in the 1st place).
   
   Complaints? None. Well, okay, I do have 1 minor complaint. They devoted almost 30 pages to The Office Assistant. IMHO these pages and the Office Assistant itself are a complete waste.
   
   This book and its previous versions are the best money I have ever spent. They continue to save me hundreds of hours while adding reliability and capability to all my projects. Highly recommended!



5. This book is absolutely not a book for beginners, but a great desk reference. A must have for any serious Access developer.

2 comments about The Web Warrior Guide to Web Database Technologies.

1. Wonderful book, easy to read and packed with useful information. Highly recommend for users of all experience levels.



2. This book gives you an overview of the topic but does not go any deeper. The exercises are way too easy and does not help you grasp the topic. If you are a curious learner, this book is not for you. The book is also monotonous and boring but is written in plain English and is easy to understand.

No comments about Web 2.0 Patterns: What entrepreneurs and information architects need to know.

5 comments about Higher-Order Perl: Transforming Programs with Programs.

1. As you might expect from a book called Higher-Order Perl, this book is not for beginners. That said, it's a wonderful addition to an intermediate/experienced Perl programmer's library.



2. I am NOT a SW guy - I am a perl autodidact HW engineer. I have written some pretty BIG "scripts" that get the job done - but a fringe "benefit" to me from the demise of the previous company I worked for is that I DON'T HAVE to maintain those scripts - a big bowl of spaghetti :(
   I tried several times to learn the OO side of Perl but this stuff was w-a-a-a-a-y out there for my scull :(
   
   HOP just made it for me! I wish it was available 5 years ago so I wouldn't waste my time writing the aforementioned spaghetti! Study it! It will twist your brains to the point of pain but stick with it - well worthed - you won't look at scripting/programming the same old way ever again!
   
   vess



3. In a book market awash with teach-yourself-in-x-time-units, cookbooks, and API tutorials, Higher-Order Perl is ambitious. It attempts to bring functional techniques to Perl, leaning heavily on two language features: closures, and functions as first-class entities. To enjoy this book you need to be completely comfortable with Perl's syntax, there's lots of code to read and digest, and if you can't follow it, you're going to get lost very quickly, because there are lots of new concepts going to be thrown your way. There's no outlandish symbol table hacking, almost no object orientation, not even much use of modules, but it is in a very different style to most of the Perl you're used to.
   
   If, like me, most of the programming languages you're familiar with are more closely related to C than Lisp, this is going to be a challenging read. It's going to take you a long time to get through this book, and it'll probably require re-reading (more than once) to fully get it all. This is a book bursting at the seams with ideas, beginning with recursion, and then onto caching, iterators, streams and currying. The last two chapters show how to apply these techniques to parsing and declarative programming, and they feel like mini books in themselves. Applications of the code range from classics like Tower of Hanoi, Fibonacci sequences and the Newton Raphson method, to more practical material including databases, tied files, and directory walking.
   
   Part of the reason I enjoyed this book so much may be because I have no formal training in Computer Science, and of course, the likes of SICP and The Little Schemer contain similar concepts. But for someone without functional programming experience it's great to have it in Perl. Lispniks, MLers and Haskellites may well be familiar with these ideas already, but they should consider this an enticing 'gateway book' for Perl programmers. And Introduction to Functional Programming using Haskell just isn't as well-written as HOP. There's no hiding from the fact that if you want to fully appreciate the material here, you're going to have to work hard at it, but Mark Jason Dominus does a great job at stopping things from feeling like a textbook, and knows how to inject some wit into the proceedings without being distracting. Full marks to Morgan Kaufmann for the layout and overall production quality, too.
   
   I keep The Camel, Perl Cookbook and Perl Best Practices on my desk when programming Perl. HOP is not going to be joining them (yet), it's not that sort of a book. Instead it's a very different intellectual pleasure and easily one of my favourite and most important Perl books (only PBP edges it out due to the latter's everyday practicality). If you're serious about Perl, you need to read this book. If you're serious about programming, ditto. Hell, this might just be a good enough reason to learn Perl if you don't already (admittedly, the chances of such a person reading this far are small).
   
   HOP has set the bar very high. Python and Ruby authors, please step up!



4. I had originally planned to read Higher Order Perl and write my review immediately. When it became clear that I wasn't going to read HOP straight through, I figured I'd write a review when I was done. More and more, it looks like my reading of the last two chapters is being indefinitely delayed. I'm going to write what I think so far, while it's still more or less fresh in my mind.
   
   Higher Order Perl was originally going to be given some fairly bland name, like "Handbook of Advancted Perl Techniques." This would have been a spot-on (but uninteresting) title. HOP provides the reader with explanation and demonstration of techniques for problem-solving that are often overlooked. The examples are complex and detailed, but not byzantine, and they're built up slowly, piece by piece, so that each line of code's meaning and significance are made clear.
   
   The title "Higher Order Perl" refers to the book's most central technique, functional programming. While many programmers understand how to abstract a specific solution into a more general one, Dominus helps the reader learn to push the envelope, abstracing generic solutions into extremely generalized solutions that can be applied to seemingly-unrelated problems. This is frequently done by the construction of functions that build functions that build functions -- and so on, functions all the way down. Instead of solving the problem in base, earthly Perl, the programmer produces Perl elements of a higher order which, operating in harmony, become all things to all people.Well, I'm hyperbolizing, but I think it would be hard for me to over-emphasize the value of techniques like closures, iterators, and currying. They are, in part, what make Lisp so powerful, and the marriage of Lisp's power and Perl's expressivity is a happy one.As for the writing, it is good. The language is clear and the material is well-presented. One should be cautioned, though, that the book is dense. Dominus is constantly pressing onward, explaining new techniques or new ways to apply already-explained techniques. I found myself reading each page carefully and deliberately, only to turn back to it a few pages later, to be sure that I understood how the new material was relying on the old. It made the book a challenge to read, but it was a thoroughly enjoyable challenge. I never felt so frustrated by a bizarre idea that I gave up or so bored with an over-explained one that I skipped ahead.
   
   Finally, while the techniques that Dominus presents are powerful and advanced, the required knowledge of Perl is not particularly great. Because he clearly explains the key Perl concepts that he uses (especially closures and associated scoping issues), any competent programmer with a working knowledge of Perl should be able to put the ideas in Higher Order Perl to work.
   
   For serious Perl programmers, Higher Order Perl is a must-read book.



5. Functional Programming is a programming paradigm that is very useful and must be part of the tool-arsenal of any software engineer and developer along with the well known Object Oriented Programming, the procedural programming approaches and the less known Aspect Oriented programming.
   
   HOP gives an easy access to Functional Programming for Perl developers. The book is written in a personal manner and is fun to read and sometimes even funny. It is definitely not a dry factoid book.
   
   The examples in the book are useful not only as they demonstrate nicely the need and power of functional programming but also due to their practicality for seasoned programmers.
   
   I felt the influence of books such as "Structure and Interpretation of Computer Programs" by Abelson and the Sussmans" on HOP, and it was very nice and helpful to read MJD's recommendations for other good readings on the subject.
   
   I got to reading HOP cover to cover, several times. I attempted to solve myself the problems raised in the book and found the process of doing that enjoying and rewarding. Reading on the commentary and approach suggested by MJD was in many ways enlightening. You can find some very amusing footnotes in the book that makes it yet more fun to read.
   
   MJD gives a refreshing view on Perl programming, and shows that tasks that can be very complicated and hard, or computationally intense can be turned "inside out" and handled in a functional programming approach that simplifies understanding, simplifies the solution and also simplifies the implementation.
   
   MJD presents a very useful introduction to functional programming using Perl using practical problems, and the nice thing is that even theoretical problems get practical usages when explained, which makes the reading fun, and worth the while for the non-theoretical people amongst the readers.
   
   Though the book sometimes goes into detail or length too much for my taste, it does do a good job in giving the new view of the capabilities of a Perl programmer and the Perl programming language and how to use them.
   
   I can testify that a lot of code that I got to see, write and maintain got a considerable "lift" and "upgrade" since me and other colleagues of mine read this book and used some of the wisdom that it offers.
   
   There are many good and useful follow-ups to this book in the form of Perl modules on CPAN, articles and posts on the web and some book chapters. Look them up!
   
   Also, if you feel that this functional programming approach is useful to you, you might want to probe further on this by reading Haskell, Lisp, Scheme (and other functional programming languages) literature. There are several "must read!" for these programming languages that will give you a very deep understanding and good skills in this programming paradigm. Also -- you will find, especially after reading HOP, that you now have the tools to easily and practically apply the functional programming principles that you learn in Functional Programming books to Perl and use it in your Perl code.
   
   A few words on MDJ himself: I read a lot of what he wrote for Perl and used some of his modules and code that is available on the web. I had the pleasure of hosting him on the first YAPC in Israel and attend a 3 day course that he gave. He is a very smart person, a very nice person and an excellent teacher and a very good writer. If you don't already know MJD, this book is a very good way of getting access to some of the wisdom that this gut has to offer.
   
   If you don't know which Perl books to buy and/or to read, know this: HOP is one of the books that you should read!
   
   (It is funny that almost 3 years after I read this book for the first time and after reading some of the material before editing, as MJD offered in his private mailing list, I only now get to write a review on it. But still, it surely deserves a book review and a good mark too.)

3 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.