4 comments about Mastering Joomla! 1.5 Extension and Framework Development.

1. I recently read "Mastering Joomla! 1.5 Extension and Framework Development" by James Kennard, and I must say I really enjoyed it. Every time I read a book about Joomla! framework and extension development, I get all sorts of new ideas. This time was no exception. The book provides a thorough description of the topics surrounding Joomla! 1.5 extension development, and it is a great reference book. I would not recommend reading the book cover-to-cover, but I think it is a great resource to have handy when attempting to develop extensions for Joomal! 1.5. The book was written for experience PHP developers who already have a working knowledge of Joomla! For those wanting to learn Joomla! extension devleopment, I recommend starting with Joe Leblanc's book, "Learning Joomla! 1.5 Extension Development", and having "Mastering Joomla! 1.5 Extension and Framework Development" as a reference for getting more in depth with the framework.



2. The really frustrating thing about this book is the style and lack of indexing. When I buy a technical reference, the most important thing is being able to look up any relevant term or function name and immediately find the place to read about that. This book has the terms subcategorized under other terms that only make sense if you already know Joomla programming! I seriously almost never find the term I'm looking for in the index. This really drives me crazy. When I have found the area I'm looking for, however, I've been pretty happy with the quality of explanation provided. Indexing is all important.



3. If I didn't already know MVC, Joomla 1.5 and had made components before I think this book would be useless.
   
   
   If you have dabbled in developer code however and Joomla 1.5 this is a great resource.
   
   This book lacks examples of building finished components.
   
   If it combined the style of other books like learn joomla 1.5 as well as having this great resource of information it would be worth solid gold.
   
   Without it and without a good index It takes time to find what you are after. Once you find it however it always provides great, accurate information.



4. The book was a good resource for me to get to grips with the Joomla 1.5 API, having had very little experience of Joomla and PHP development in general, however having a good background in programming. I feel the book has been written with developer's like me in mind, i.e. people who have knowledge of general web application programming but little or no knowledge of Joomla. The way the book has been sectioned progresses nicely, starting with a brief intro to Joomla (for completeness' sake), a Joomla programming Getting Started chapter and then delves into the API per se. It introduces the general classes Joomla uses, and how they relate to each other. Each chapter then introduces and describes more enhanced functionality, such as accessing the database, developing components, the MVC model, and keeps on building, with each chapter building and adding to the knowledge learned in the previous chapters.
   
   Overall I think this book is a good start for anyone delving into the Joomla Development world. It introduces the concepts, explains, and with that knowledge you can go ahead and dive into your development.

5 comments about PostgreSQL (2nd Edition) (Developer's Library).

1. This book lives up to it's claims for "the comprehensive guide to building, programming and administering postgresql databases". I'm a MySQL guy, but may have to do a little pgsql to support a third party app, so I was looking for a book that would bring me up to speed.
   
   The quick review is this... I give this book 3 stars, because it's so huge and covers so much territory that, in my opinion, it does a middling job of it. I would have preferred a more focussed book. I think, given it's goal of being so comprehensive, it is about as good as it could be and if you really need to know everything - from sql, to developing extensions, to embedding this in your c/c++ programs and administering things AND want a single book that covers it this is probably the book for you. If you don't need quite that much, or are willing to go to more than one book to get it, I think you would be better served to look elsewhere.
   
   The longer review...
   
   Honestly, I don't know why books on databases almost invariably are terribly dry reads, but this book, following the odds, falls into that category. It's a hefty tome weighing in at about 1000 pages divided into 3 sections.
   
   The first category, about a quarter of the book, is an introduction to sql and postgresql in particular. It does quite a nice job of introducing your standard sql commands, datatypes and basic administrative commands (like creating tables and the like). This part goes from basic to fairly advanced, covering topics like outer joins and creating new datatypes. I suspect it'll be review for those familiar with sql but reasonably usable for those delving into sql, even if they don't immediately understand all of the more advanced concepts.
   
   The section ends with a chapter on performance, something I was particularly interested in given postgresql's reputation. Here the authors talk about standard performancy things like indexes, using various tools to figure out what a particular query is actually doing, all worthwhile. But they never go into any detail about the performance implications of using some of the more advanced postgresql features like composite types and table inheritance. I was quite disappointed to find not even a whisper of this type of information in the book.
   
   The second section, about half the book covers programming with postgresql. This is a very broad chapter - covering many aspects of what it means to program this database. From server side programming using PL/pgSQL to extending the database with custom functions and types. They discuss creating clients in c, c++, java, perl, php, tcl, python and .net. Each one of these languages gets a chapter about 30-50 pages long where they go over the basics of how that language typically connects to the database and then goes through a process of creating a basic client and refining over the course of 4 or 5 iterations to become more and more robust and full featured. This is the bulk of the book and because it's so wide spread, I think most people will only be interested in one or two of these chapters - the rest of which will probably be uninteresting.
   
   The last section is the final quarter of the book where they go over the administrative requirements of the database. They admirably try to direct people to download and compile their own binaries, but cover installation from binary on unix and windows. They have an excellent reference on the things you can tweak to configure the runtime environment. They also cover backing up the database, replication, internationalization and security. Although they mention performance optimization in the intro to the section, they don't actually discuss it anywhere in the section.
   
   So, to sum up. If you really need to know about all aspects of pgsql and are looking for a one stop shop, this book is - I think - as good as you're going to find. But if you're looking into only a particular aspect (developing, administereing, etc..) or don't mind going to more than one, I feel confident that there's other books out there that will cover those topics in better detail.



2. PostgreSQL 2nd Edition is a phenomenal book if you're a programmer, and a great book if you're a non-programming admin. As someone whose programming ability reaches only ever so slightly beyond bash scripting and WSH, the parts of this book that were really worthwhile to me were those devoted to the administration of PostgreSQL. Backing up, recovering, and performance tuning were excellent resources, especially to someone who had never set up or administered a database. Speaking of which, the very beginning of the book, covering what exactly a database is, terminology, and setting up and creating schema were invaluable. To have all the information in PostgreSQL 2nd Edition consolidated in this one book makes it a must-have for any admin's bookshelf. The only reason it didn't get 5 stars from me was because I'm not a programmer, and I couldn't take away every single ounce this great resource had to offer.



3. I'm upset that this book that I've been trusting for the past month or two has such an egregious error in its discussion of regular expressions on page 51. I wish the authors had left out any discussion of regexes if they weren't going to actually test their assumptions about a topic on which I assume they know little. :-(



4. I am a database application developer with MS SQL Server, Oracle, Sybase and many other RDBMSs experience.
   This book allowed me to start working on PostgreSQL immediately.
   Pro: comprehensive, good examples, good supplement to the documentation.
   Cons: is not deep enough for me (does not explain format of a transaction log file or WAL file, for example), but, I guess, I should read the PostgreSQL code for this.
   If you are new to databases you would need to read some other books first.



5. As a developer with many years IT experience in control systems and only a little in databases and none with Postgres, I found this book to be extremely helpful. It covered a huge amount of topics with examples and put them together in a way that made it more efficient than googling!
   
   It helped that I knew what topics I needed in looking for answers but the chapters were self explantory in the topics they covered which I believe would allow a beginner to make quick progress in learning Postgres.
   
   Cavaet: If you are after a book to learn SQL and database design (normal forms) you will be disappointed, this book is not for you.

5 comments about Design Patterns in Java(TM) (Software Patterns Series).

1. Metsker, in collaboration with Wake, has released a counterpart to his earlier book, "Design Patterns in C#". Essentially, it covers the same design patterns, but now implemented in Java code. The authors readily point out that the book is directed at a new or intermediate Java programmer. Experienced Java coders probably [or should] already have written such patterns, based on their prior knowledge.
   
   The book takes you beyond the elementary syntactical issues of Java. The pedagogy also includes frequent problems interwoven into the text. These have answers! [At the back of the book.] One reason given by the authors for including the problems is simply that you can get good experience with patterning, if you tackle them. A cheaper and safer alternative than trying out patterns for the first time on actual workplace problems.
   
   None of the problems are very intricate. But they expose enough of the essence of the patterns for your understanding.
   
   Of course, aside from actual coding, patterns are now forming part of the standard vocabulary of professional programmers. If you are not a programmer, but have to interact with them, then the text can be good background.



2. If you're a Java programmer and want to approach the subject of design patterns from that perspective, this book is very well done... Design Patterns In Java by Steven John Metsker and William C. Wake.
   
   Contents: Introduction
   Part 1 - Interface Patterns: Introducing Interfaces; Adapter; Facade; Composite; Bridge
   Part 2 - Responsibility Patterns: Introducing Responsibility; Singleton; Observer; Mediator; Proxy; Chain of Responsibility; Flyweight
   Part 3 - Construction Patterns: Introducing Construction; Builder; Factory Method; Abstract Factory; Prototype; Memento
   Part 4 - Operation Patterns: Introducing Operations; Template Method; State; Strategy; Command; Interpreter
   Part 5 - Extension Patterns: Introducing Extensions; Decorator; Iterator; Visitor
   Part 6 - Appendixes: Directions; Solutions; Oozinoz Source; UML At A Glance; Glossary; Bibliography; Index
   
   Wake and Metsker use the same standard patterns that have been popularized in the Gang Of Four patterns book. But the main difference between that book and this one is in the application of the material. After you get a very clear understanding of the goals of a certain pattern set, they explore the implementation of that pattern using Java coding examples. That's the value that sticks out for me. Rather than dealing with general abstract coding philosophy, you end up with concrete examples, real business scenarios, and working code that illustrates the concept. Granted, the "real business scenarios" are most applicable to running a fireworks factory, but it's better than "dog is a object of class mammal" fluff that doesn't bridge well to where we live on a daily basis...
   
   This book can definitely stand alone when it comes to learning all about design patterns. But if you've read the classic and still don't "get it", this book will tie it all together for you... From the Java perspective, it'd be hard to go wrong here...



3. I've heard a lot about the classic "Gang of Four" Design Patterns book. However, while I've read many papers based on it, I've never actually read The Book. So, when I had a chance to read the new Design Patterns in Java(TM) (2nd Edition) it seemed like a perfect chance to load up on some must-know information as it is applied to my programming language of choice. Excellent!
   
   This book merges and updates the Design Patterns Java Workbook and Design Patterns C#. Design Patterns in Java is targeted at developers who know Java and want to improve their skills as designers. It covers the same 23 patterns discussed in the Gang of Four Design Patterns book.
   
   Patterns are powerful things. As the Metsker and Wake put it, "Patterns are distillations of accumulated wisdom that provide a standard jargon, naming the concepts that experienced practitioners apply." Exactly! They authors have a way with words. I really appreciated the one sentence descriptions of each pattern at the beginning of each chapter. These helped me to immediately grasp the intention of each pattern before digging in to the details. The periodic "challenges" throughout the text are thought provoking and worth the effort to work through.
   
   The advantage of this Java-centered book over a general patterns book is that it helps you understand how Java's unique features can be used to implement the patterns. For example, sorting can be implemented using polymorphism and the template method pattern. The original GoF book is a classic. Design Patterns in Java is, for the Java developer, the perfect combination of the GoF book's concepts with concrete Java implementations to make it all easier use. Not only are there Java examples but the book also includes information to help you refactor your existing code to use patterns. Very helpful.
   
   The appendices include solutions to the various code challenges, information to access the sample site's source code, and a crash-course in UML.
   
   I love the suggestion at the end of Appendix A: "Decide how many hours a week you want to spend on your career. Take five hours off the top and pay yourself first. Spend that time away from the office, reading books and magazines or writing software related to any topic that interests you." Great concept!
   
   If you're a Java developer looking to invest some time to improve your design skills, this would a great place to start.



4. I found the book quite useful. I especially liked that the book is Java based as that is the language i primarily use and that code examples are provided. I learn by doing and the book is excellent at giving the reader the opportunity to implement patterns. This book is more than just theory. It's practical.



5. First off, the content/material in this book is great and very helpful for starting to bridge the gap between being just a Java programmer to becoming a system designer.
   
   My biggest problem with this book is its format/structure. You cannot read it straight through (linearly). There are questions and challenges scattered throughout each chapter that force you to flip to the back of the book to see the answer because there are not enough supporting examples in-line. IMO, sometimes there is not enough information before the question/challenge to answer it (especially if you're not very familiar with Design Patterns); this forces you to check the back of the book every few pages, which can be very annoying. I was hoping for a book that I could read straight through, not a workbook.

5 comments about Lewis and Clark for Kids: Their Journey of Discovery with 21 Activities (For Kids series).

1. I would have given this book five stars if there had been just a few more activities in it.
   
   The book reads as non-fiction literature and is interspersed with good photos and interesting sidebars. There are also some useful activities for the child to do within the text to reinforce what is learned.

   This book would be useful for all grades but can be read independently in the middle school grades. The book contains a glossary, index, web site suggestions, bibliography, listings of museums and parks and other handy references.




2. The Lewis and Clark Bicentennial is here, finally! If you are still on your own undaunted journey of discovery or plan to teach children about these two courageous men and their corps, then you NEED this book. It will be invaluable to any teacher of intermediate students.



3. I found "Lewis and Clark for Kids" to be an excellent source of information and activities for both children, parents and teachers. There is an abundance of information about the actual journey plus there are great activities for children to engage in to learn more about the various indian cultures that Lewis and Clark interacted with on their journey of discovery.



4. This is a perfect book for kids to learn about Lewis and Clark. Not only is it informative but also holds their attention by giving them useful and entertaining activites. A must for those not in the standard school system in the states.



5. The book has many fun and interesting facts about Lewis and Clark. If you're using it for the classroom...the activities are creative and easy to do.

5 comments about C All-in-One Desk Reference for Dummies.

1. This book is invaluable as a reference for the C programming language. It doesn't matter if you know a little or a lot about the C programming language this book caters for all levels. This book features a lot of working program examples and allows the reader to easily interact with the book whilst putting any knowledge gained from the book's content into practice.



2. If you need to learn the C language, there is no better book than the "C All-In-One Desk Reference". The book is FUN to read, and gently (and effectively) takes you from the simplest of C concepts like variables, conditional statements and loops, through pointers, references, and arrays, to advanced topics like double-linked lists. The book is OK as a reference, but it EXCELS at presenting the C language to the new programmer. No other technical book in my personal library has helped me (and my career) as much as this one.



3. This book teaches all about C in a fun and easy to learn way. Great for someone that has some experience programming in either C, C++, Java, Perl, or Python. And also great if you read C For Dummies the first one that offers great introductory information on C and the idealogy of programming. Dan Gookin is one of the best authors of his time.



4. I have made various attempts to learn C over the last fifteen or so years, generally in the company of the C Programming Language (2nd Edition) (Prentice Hall Software) by Kernighan & Ritchie.
   
   In these attempts, I picked up enough of the language to write some REALLY simple programmes, to print ready-reckoners and the like and also to do some basic programming on microcontrollers.
   
   However, I would never have called myself a C programmer; pointers always remained a mystery to me. Is C just too hard? No - I was just using the wrong book. Whilst K&R makes a handy reference text, Dan Gookin's book actually TEACHES, and in a light-hearted style.
   
   I am only about one-third the way into the section about pointers but, so far, it is all making sense. Many of the concepts are already familiar, as I am a Perl programmer. If you know Perl and want to learn a "real" programming language (ie: one that is compiled), this may well be the book for you. Having said that, I feel that even non-programmers could get into C with the aid of this book, provided that they have the correct mind-set.



5. C All-in-One Desk Reference for Dummies is a very informative book that introduces and clarifies many topics. I, personally, fell behind on a few topics, such as hex numbers, but that won't affect all readers. It all depends on your ability to ingest the reading. That aside, the majority of the reading is completely comprehensible and useful. I'm very pleased with my purchase and hopefully I pass my 'C' programming class in the fall with an A :P.

5 comments about Ajax Security.

1. Ajax Security was the last book I read and reviewed in 2007. However, it was the best book I read all year. The book is absolutely compelling and every security professional and Web developer should read it. It's really as simple as that.
   
   I am not a Web developer. I was not very familiar with Ajax (beyond its buzzword status and a vague notion of functionality) when I started reading Ajax Security. I attended the authors' Black Hat 2007 talk and was thoroughly impressed and disturbed by the security implications they presented. I expected Ajax Security to be a good book, but one can never be sure if talented hackers and presenters can transfer their skills to the written word. Ajax Security gets the job done.
   
   Despite being a traditional network security guy who prefers inspecting traffic to analyzing JavaScript, I had no problem understanding Ajax Security. The authors do a superb job leading the reader through the issues surrounding modern Web applications. They start by introducing a technology, which is critical for someone like me who doesn't deal with Web development issues. Next they describe how it is broken. They continue with defensive recommendations and summarize their findings in the conclusion. This is a perfect technical writing style that is too often lost on other authors.
   
   Ajax Security makes very good use of case studies (both large stories like ch 2 and small ones throughout the text). The book also integrates code, diagrams, and screen shots. The text itself is very clear and the authors keep the reader's attention throughout. Histories for various technologies provide a welcome background, showing readers how we've ended up in our current Web 2.0 predicament.
   
   If you'd like a positive critique of the technical components of the book by someone who is a Web expert, I recommend reading Dre's review of Ajax Security in the TSSCI-Security blog. Otherwise, I give my highest recommendation to Ajax Security, as my Best Book Bejtlich Read in 2007 award.



2. Anyone involved in developing/testing AJAX should read "AJAX Security." It covers preventing a hacker from attaching your application. The audience includes developers, QA and penetration testers. While there are code snippets, they are explained well. While managers aren't in the target audience, I think they could benefit from understanding the concepts presented in the book.
   
   The book begins with a brief review of AJAX architecture with an emphasis on security. The writing style is quite engaging including a chapter walking you through an attack from a hacker's point of view. All the major known categories of attacks are included including resource enumeration, parameter manipulation (with SQL and XPATH injection), session hijacking, JSON hijacking, XSS, CSRF, phishing, denial of service, etc.
   
   I particularly liked the analogies to things that happen in the physical world such as resource injection into a roommate's "to do" list and hijacking another customer's paid order in the deli. These made it easy to visualize the problem even for people who don't code often.
   
   The authors were realistic and included the limitations and drawbacks of each tool/framework mentioned. I liked the chapter analyzing two major JavaScript worms including the source code. This really hit home on the importance of certain practices!
   
   All information was up to date as of printing including comments on all four major browsers (IE, Firefox, Opera and Safari.) They even mentioned the HTML 5 specification. The book is not server side language specific, which was nice.



3. Are you a web developer? Do you believe you can ensure that your client-side code will function as expected? Well, you are wrong. In Ajax Security you will find out why.
   
   Ajax changes the game in that it moves business logic to the client. In doing so it increases the attack surface of the application. The authors get curious with some real world Ajax frameworks such as Prototype, Dojo, and Microsoft Ajax. They demonstrate with these frameworks how developers might be unknowingly building vulnerabilities into their applications. If you're home brewing Ajax, the authors cover important security considerations you'll need to know so that you don't make the same mistakes the industry leaders have made.
   
   I learned a lot about JavaScript from reading this book. I learned even more about how JavaScript can be used maliciously. The authors describe techniques for function clobbering, JSON hijacking, storage attacks, and presentation layer attacks. One of my favorite parts of the book, not to mention one of the scariest, is an explanation of how to hide malicious JavaScript from signature based anti-virus software.
   
   The authors explain why the Same-Origin Policy is broken and how it can be subverted. Also covered are security considerations for offline applications. An in-depth analysis of Ajax worms is covered. If you are curious about how Ajax is changing web security you should read this book. If your are a web developer or a security professional you should read this book, even if you aren't using Ajax. If you don't believe cross-site scripting is a "big deal", I dare you to read this book and maintain the same opinion.



4. A lot of examples shows how absolutely everything could be attacked and corrupted in the chain of components used for building ajax applications, from css (yes even css) to html, from javascript to http, from browser to server ... Sometimes there's too much lines about evident things and sometimes things seems more proof of concept than real possible attacks. But these guys know what they are talking about. This is an excellent book that every serious ajax developer must have read, specially if they plan to make mashups or let their users bring and share things using their applications.



5. This is very good book. I've created so many websites using AJAX techonlogy. This book provided me to check how secure the websites are. I am glad that I fullfilled all the details without having the through knowledge of AJAX security. But this book has collected all the security check point at one place.

5 comments about Web Design: Best Portfolios (Icons).

1. I reviewed another one of these books I bought at the same time as this one and it basically is the same review. The very most of the sites featured were done in Flash, which looks real good and inspires design ideas, but is very uninteresting for a web designer like me. These books should be called "Best Flash Portfolios" it would be more realistic.



2. As an amateur photographer, some years back I'd built up a simple site to show my images. It is pretty stale so I wandered the net looking what other photographers were doing. While it is easy to just wander around, it is time consuming for this research aspect.
   
   Looking at the latest web design books at the local bookstore, this one was titled exactly what I had in mind. Fortunately Wiedemann has wandered far and wide to gather this collection. Sitting on the couch, it is easy to thumb through and mark those you may want to see. Clicking on these is like a best-of and the sites are fantastic as far as content and creativity. While not every one will match your preference, there are more than enough that will.
   
   Many of the examples play heavily on Flash programming so it may be a bit much for casual site builders. To me, this book is a nice reference for those who want a site but may not have an idea which direction to pursue. Seeing the layout, this may be beneficial when farming this aspect out. You can say..."I like this feature on this site...can we integrate something like it in ours?" So by picking-chosing various features, one can develop a pretty nice atmosphere for viewers.
   
   You'll easily spend countless hours in fruitless wandering to maybe turn up 2-3 sites in an hour that really grab you. Then try and dig through your history tab frantically hoping to recall one particular site with a feature you liked. This book for the price is a no-brainer...BUY-IT! For me, the overall value in design layout, content, Flash ideas exceeds the price paid in multiples.
   
   The book's production values are first rate too. Well worth $10.



3. I am a web developer and purchased this book with a few others to sample the current design trends and to find inspiration for new design layouts. Quite simply, this book serves both purposes much more completely than I had anticipated.
   
   I picked up the book in a hurry, expecting only to find photos of sites. I was pleasantly surprised to find a bit more: the book provides a caption noting the languages/tools/technologies used to create the site, the names of the programmers (and, by logical deduction, the number of programmers it took to create), the number of hours that were spent creating the site, and the average number of hours that are spent maintaining the site on a monthly basis.
   
   It is true that most of the designs are created primarily with Flash. If you're looking for layouts to mimic using XHTML and CSS, well, good luck.
   
   Also, as a lifelong member of the Grammar Gestapo, I had quite a few chuckles when reading the introduction (the English introduction, that is--the book is trilingual, with the introduction, titles and captions in English, French and German).
   
   Despite the poor grammar (which is, I'll grant, better than that of most native anglophones), the book delivered much more than I had expected, and I am extremely happy with my purchase. I imagine I'll be carrying this book around with me for at least the next few months, glancing through it whenever I have a free moment on the bus or out at lunch.
   
   The book comes with a durable cover and glossy pages that smell great!



4. Great book and a nice compact format. Not a lot of text but visuals are why you would buy this book.



5. As someone doing web design, I bought this book to look at other designs, and how they were built. If this is what you're looking for, this book isn't for you.
   
   This book should be a coffee-table book, but is the wrong size and format even for that. All it contains is pictures of websites, and not at a size to to be considered art. Not helpful. If you want to browse websites, only looking at a picture, you can do that on the web just fine.
   
   This book should never have been titled "Web design". It's not web design, it's a vanity site on paper.

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 Compilers: Principles, Techniques, and Tools (2nd Edition).

1. The CGI cover looks great! I only wish it stretched along the spine of the book like in the previous editions.



2. I spent some serious quality time with the first edition (the "red dragon book"), in three main episodes over the past dozen years: 1) undergraduate compilers class, 2) industry project, and 3) parser generator implementation. During all three episodes, I was disappointed in various ways, though there is no denying that the book contains a wealth of information. As an undergraduate, I found the book somewhat impenetrable. When in industry, I found the book too abstract. When implementing a parser generator, I discovered that the book excludes important research results with regard to LR parser generation. It is the last disappointment that I will focus on.
   
   The book presents parser generation in layers of increasing complexity, from SLR to LR to LALR, where LALR is presented as the penultimate algorithm, though LALR parsers can only handle a subset of the grammars that LR can handle. The justification for this is that the original Knuth LR algorithm is intractable for large grammars. However, an efficient, fully correct, approach for LR parser generation was published in 1977, and on top of that it appears easier to implement than efficient LALR parser generation! The red dragon book's original authors simply cannot have been unaware of this research result, but I suspect that they elected to warm over the "green dragon book" (published in 1977) rather than incorporate the state of the art as of 1986 into the "red dragon book". Now here we are another 20 years later, and as near as I can tell from reading through available online information, the "purple dragon book" is perpetuating this omission. The result of the red dragon book is that we have an entire generation of computer scientists who have been mislead to think that LALR is somehow superior to LR, and the purple dragon book is setting things up for yet another generation to be mislead.



3. This is the classical reference book for compiler design. This is not an easy text because of its heavy use of mathematical notation and the algorithms are presented only in pseudo code but you will not find a more complete collection of compiler related algorithms than in this book.



4. The Dragon book is a core text for understand complier theory. Great technical reading for all software developers and software engineers.



5. This book is famous, and when I told people 20 years my senior that I was in compilers and I was using the dragon book, they knew the book. There are probably some changes between editions between now and then, but the fundamentals of compiler design has changed little.
   
   And when it comes to be basics, reading this book can be more like slogging. The information is there, but it isn't quiet clear. Some topics have examples that do most of the explaining, while other topics lack a nice example that would explain it.

5 comments about Building Microsoft® Access Applications (Bpg Other).

1. Easy to read first few chapters with basic design info, remainder of the book focuses on complete applications that can serve as a template/best practice for almost any other MS Access application.
   
   Viescas clearly understands/communicates an in depth knowledge of Access Applications that I have not seen anywhere else.



2. Definitely not for the newbie. This is for the seasoned access programmers. I you are new to programming (at least in access) and are looking for a book on how to program with access, this is not for you. This is a great book for those seasoned programmers who are looking to make their applications better.



3. This book is a good start toward understanding how to build Access applications. Some of the details are missing. An example would include the proper syntax for referencing fields in a form.



4. Very hard to follow, poorly organized and written. Unless you're well versed in Access already, skip this book. Definitely NOT for beginners.



5. This book is written with the intermediate to advanced programmer in mind. There is much to learn from this book on options and techniques to use when building business applications in Access. There is explanations of every sample application and it's function. I would give it five stars if it were not for the title. The title maybe a bit misleading since it talks about building applications since it kind of sways you into thinking that it is a book on the step by step process of "Building Microsoft Access Applications." If you are seasoned in Access programming it is a gem to have in your bookshelf.