5 comments about Pro JSF and Ajax: Building Rich Internet Components (Pro).

1. The authors begin "This book is not, and we would like to emphasize this, not an introductory level book..." That's for certain. Except for quick review material in the first chapter, the authors move quickly into a project that assumes a good amount of experience.
   
   The book effectively follows a pattern that you have seen before. Build a simple component, integrate it, then progressively build in functionality and complexity while dealing with usability and maintainability issues.
   
   One factor that makes this book stand out is the great number of flow diagrams. This book has the expected code printouts and screenshots but the extra emphasis on logic diagrams is exceptional. Also not seen in other JSF books are two chapters on providing Mozilla XUL and Microsoft .htc renderers. Yes, the last is a bit of a surprise!



2. If you already have a background in JavaServer Faces (JSF) and you want to start exploring the integration of that with some of the Web 2.0 technologies, Jonas Jacobi and John R. Fallows have a book that might interest you... Pro JSF and Ajax - Building Rich Internet Components.
   
   Contents:
   Part 1 - Developing Smarter with JavaServer Faces: The Foundation of JSF - Components; Defining the Date Field Component; Defining the Deck Component
   Part 2 - Designing Rich Internet Components: Using Rich Internet Technologies; Loading Resources with Weblets; Ajax Enabling the Deck Component; Ajax Enabling the Date Field Component; Providing Mozilla XUL Renderers; Providing Microsoft HTC Renderers; Switching RenderKits Dynamically
   Index
   
   To be honest, this book was beyond my current technology level. While there is a brief overview of JSF technology, you'll get the most out of the book if you already have a relatively solid grounding in it. They use two components, the Date Field and the Deck components, to show how JSF can be used to build internet application components that are able to be reused in other applications. The real value comes in Part 2, where they take those two components and start mixing them up with technologies that allow for rich internet functionality, such as Ajax and XUL. Using the examples provided, you start to see how a JSF application mixed with something like Ajax allows you to start building internet applications that behave more like desktop client apps... no round-trips to the server... no constant screen refreshes to get new content... Pretty cool stuff. I'd also recommend that you be pretty conversant with the rich internet technology already. Like with JSF, there's an assumption that you already understand the basics, so don't think that your first exposure to Ajax could be with this book. You'll be in pain if you try that route...
   
   If you've had the exposure and you're now looking for some really cool project on which to apply your JSF skills, this could easily be the book that helps you make that transition from "Hello World" to "ooooohhh..."



3. I tried reading the first chapter, got through half and realized that the overview was simply hitting the architecture big picture with no code (this is after reading the complete reference cover to cover) -- skipped to the second chapter cause I had no clue where the author was at on chapter 1. Chapter 2, trying to describe component extensions -- the code examples had a bunch of css. CSS? And no mention that css was a part or not a part of jsf. To someone without a design background this would be very confusing. Huh? Why? To take up space that's why.
   
   This is a worthless book that obfuscates. My opinion, they put this thing together to capitalize on the hype surrounding jsf and ajax with no clue as to how to actually teach how to integrate the two. Finally the most annoying thing is about half of the copy starts out "in this chapter you will ... " then some worthless unrelated code and then another section with "in this chapter you will ..." Waste of my precious time and mental space to read this book. They should take a hint from NIKE and just do it rather than talk about it. CODE... examples and more code -- I don't want to read or waste time reading "in this chapter you will"...



4. Even for an advanced developer/architect this book does not make sense. There are too many typos, wrong references to Figures and Tables, and confusing diagrams. On the top of all these things, it is poorly written. For example (Verbatim from chapter 2):
   
   Figure -1 shows the five classes you'11 create in this chapter, they are HtmlInputDateRenderer,ProInputData,UIComponentTagSupport,and ProInputDateTag, as well as two you'11 be extending Renderer and UIInput.
   
   As you can tell from the above the author is quite confusing.



5. I bought this book looking for examples on how to create custom JSF components and AJAX or extend existing components. The book is very light on this. It starts with a general overview of the JSF life cycle. Chapter 2 shows you how to create a date component and chapter 3 a deck component. Unfortunately the information is scattered and does not flow very well. Part 2 of the book has very little to do with JSF. Explains what Rich internet technologies then it give other examples of Rich Technologies which don't help you in developing JSF components It even goes into Microsoft technologies
   This book would be better with more JSF/AJAX examples and less fluff. They try to bring you from entry level knowledge to expert knowledge. If I wish to create JSF components I have been using JSF and the components available to me are limit so when I buy a book like this I do not want to start at the beginning and I am not interested in other technologies that are similar to JSF like XUL, Weblets and Microsoft HTC I have choose my technology when I come to a book like this. If you want a general high level overview this book covering technologies besides JSF this book is ok. If you want and indebt book about creating JSF components with AJAX this is not it.

5 comments about Sams Teach Yourself Perl in 21 Days (2nd Edition) (Sams Teach Yourself).

1. This book is not helpful for the newbies. Not only do some of the scripts not work, but the way Perl is explained in this book, it just doesn't make enough sense. I learned more from online tutorials that were perhaps 3 pages long than I learned in 15 pages of one chapter of this book. I usually pick things up quite easily, so it must be the book that is confusing.

   At least two of the script examples given in Chapters 1-8 had typos in them, and not enough explanation for someone that doesn't know much to figure out what. I am unfortunately going to have to give up on this book to learn Perl and turn to the internet... too bad I spent $35 for the book. I don't recommend this book to anyone except perhaps someone that already knows Perl.




2. If you want to start programming Perl in the shortest time possible, and have some programming background, you will benefit from reading Sam's Teach Yourself Perl in 24 Hours, which packs a lot of practical materials and emphasizes get-your-hands-dirty-immediately as well as uses a lot of code snippets to teach.
   
   This "in 21 days" book, on the other hand, is better if you have more time to learn Perl. Each lesson takes 1-2 hours, if you already have some programming background, and longer if you don't. This book treats Perl more systematically and in more details than the "24 hours" book. It explains a lot of concepts, including hashes and modules, more clearly than the "24 hours" book. I recommend you do 2 or 3 lessons each day, because Perl is such a compact yet complicated language, that it's best to force yourself to learn it quickly, rather than slowly, because slow learning will make you forget things. Be sure to study the examples in the book until you understand every line of code.



3. Teach Yourself Perl in 21 Days by Laura Lemay is sufficient for the beginner wanting to learn Perl, be it on Windows or a UNIX-based operating system. If Perl is your first programming language, then this book is a fairly good book to choose as a starting point. It teaches the basics of programming in Perl and moves quickly from that point onward.
   
   However, while this approach introduced me to the language I found my ability to pace through the book as I normally would with other programming languages hindered by the author's organization. Unexplained code is used in almost all of the examples before you get to its respective chapter. While this approach may work for some and give cause for thinking, it gave me an unnecessary headache.
   
   Don't get me wrong, it did teach me a good bit about Perl, it inspired me to install Debian Linux on my programming workstation, and left me to pursue Perl. Despite this, I turned to Learning Perl. I found Lemay's writing to be too verbose and the organization of the book a bit of a twister.
   
   Overall, it can be summed up by the following pros/cons:
   
   ~ Pros
   - Good introduction to Perl
   - Independent of Operating System (Great for Windows users ready to Learn Perl and perhaps Migrate to Linux for programming purposes)
   - Solid examples and references
   - Covers more advanced topics later on
   
   ~ Cons
   - Verbose
   - Awkward structure. Things such as loops are constantly used in beginning examples without much of an explanation. If you don't' have any experience with programming, it will give you a headache. The sections on these devices come much later, and have a strange introduction as well.
   - Frustrating at times when it shouldn't be (IE, having you use functions that you haven't learned, or haven't been mentioned, in an example for a particular chapter)
   
   Additionally, I'd recommend picking up Learning Perl or using it instead. I picked up Teach Yourself Perl in 21 Days, learned what I could, and then fell in love with Learning Perl's concise, straight to the point chapters and examples (albeit with a fair amount of humor). If you're a Linux/UNIX user, you'll probably find Learning Perl a better catch, but for me, Teach Yourself Perl in 21 Days was the stepping stone to Linux and Learning Perl. Overall, I'm satisfied with my purchase.



4. I bought this book after trying to learn Perl through another book (Perl for Bioinformatics). This book is definitely a better introduction to Perl than any other book I've seen. It is clear and concise enough and although it might be hard to finish it in 21 days, you can start coding your own scripts much before the end of the book. I am still on chapter 11 and I can program most of what I need with it (i.e parsers and simple bioinformatics applications). I recognize that there are a few typos on the book but if even Knuth's Art of Computer Programming have them why shouldn't Lemay's Teach Yourself Perl in 21 Days do the same?
   
   Given what I said above, I must warn begginer programmers (like me) that Perl is not the best language for you to learn as your first one. It is a dirty scripting language which does the job and is most suitable for parsing files and formatting data but it has a lot of things which make it quite confusing initially (its context dependency for instance). If you want to learn something that will give a solid programming base you should start with something else (i.e. Java, Pascal, Ruby etc) which will probably be a little bit harder but will payoff later.



5. I find myself using this book as a refernce almost every day. It is well written and easy to follow. I highly recommend it.

5 comments about Unified Modeling Language User Guide, The (2nd Edition) (Addison-Wesley Object Technology Series).

1. Start reading Chapter 1 of this book for even just the first few pages, and for various topics, it will say to go to future Chapters. If you take a look at those future chapters, there will be notes on the side telling you to go back to Chapter 1 or to other chapters. You can run into infinite loops or dead ends not really picking up anything. It is possible to maybe find what you were looking for, or find that the explanation for it is just not sufficient.
   
   If I'm trying to look for a topic to remember, this book is not an easy read with the index either. If you look up some topics in the index and go to all the pages listed, it may not list all the important pages. Sometimes, when I had to look for information on something, say a "use case" for instance, then I'd look that topic up in the index. I'd go to all the different pages listed in the index and it might not be what I was looking for. Then I'd have to look at the side of the page of usually the lowest or 2nd lowest numbered page listed by the indexed topic, and go to the Chapter(s) listed. When I went to those chapter(s) I'd still have to scour the entire chapter(s) until I might find what I was looking for. An example was when I was trying to understand what one of the diagram types was, a "state diagram" I believe it was, as compared to say an "activity diagram." Sometimes I would find out that things just weren't worded well if in there at all, and I'd have to refer to another UML book.
   
   This book may have some good use, but I haven't found that yet. It's hard to read and hard to look things up, and hard to learn from if you don't already know much or anything that is for sure.



2. I picked up this book as a way to familiarize myself with the changes to UML in UML 2.0, which are extensive, as I found the OMG specification nearly impenetrable. I had liked the first edition, though I too felt Fowler's Distilled was a much better intro to give to students and engineers learning UML for the first time. This edition, though, does not meet expectations. The typos and bad references throughout are bad enough. Join that with a complete lack of real-world design examples, poor organization, and poor design. Why a chapter on State Machines and a separate chapter on State Diagrams that repeats a lot of the earlier chapter? The blue cross references make it clear that the book is spaghetti design at its worst. Check out the table of contents, you won't know where to look for your favorite diagrams; check out the index, and you won't be able to find the definition of the concept you just can't quite remember. The glossary is useful, as the UML 2.0 spec dispensed with a glossary, making it even more impenetrable. On the other hand, the authors make no attempt to call out the new UML 2.0 features, which would have made my day. What I find most unforgivable, though, is the authors' inability to present the new UML as it really is: the book is seriously misleading in many ways for learning UML 2.0. My biggest peeve is the way they treat the new and highly useful composite structure diagrams. In the list of diagrams, they don't even mention it, calling it by the name of a different diagram, the "Component Diagram", which they feel is the same thing. They then separate the discussion of composite classes and components, making it seem as though they're totally unrelated. They fail to mention quite a few of the new UML features (the X navigation adornments that make non-navigability explicit, for example, which is critical to code generation, or the fact that you can have multiple stereotypes associated with model elements. In their defense, the UML standard isn't very clear on these diagram types, but this is a practical tutorial that should take practice into account. There are constant references to the Reference Guide for more advanced features; these are mostly the UML 2.0 features that they didn't feel were important enough to include in the comprehensive tutorial. The appendix on UML notation simply ignores many UML 2.0 notations. I can't help but feel shortchanged.



3. Book is complete waste of money. Find more prevalent information online. Not really a required book. Not used at all.



4. I don't know what people who would review this book well are thinking. These authors may be good at creating the UML, but terrible at explaining it. The sentences are packed with words they haven't explained - or uncommon uses of words that really have no meaning, unless you are already a UML expert. I can't imagine a more poorly written text.



5. When I am using tools supported UML, I often search key concept with this book. Because this book is an user guide.
   I made some sequence charts, so I use some functions of UML.
   I can not understand which architecture is good or not.
   I think there are little idea about that.

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 Java Network Programming, Third Edition.

1. If you're doing anything with Java and Network I/O programming, the topic will most likely be covered in this book. The author does a great job describing not only how Java handles network programming, but the concepts and details of network programming in general. The book takes the core java.net classes and describes each method, what it does, how to use it, what to watch for, code examples, etc - it takes the API Javadoc and expands upon it.
   
   It's a great Java Network API reference book.



2. This book is certainly a good reference book for me when I need to know about network programming using Java. As you all know, Java Network Programming is a vast subject, on which a single book can make no justice of. But Elliotte has tried and he is successful with this book.
   
   I liked his treatment of Multicasting, NIO, Threads and reaped a lot of benefit reading these chapters. I particularly liked his treatment of NIOs.
   
   Elliotte is an educator and his books on XML have been fantastic. As a teacher, I am sure he knows how to write books.
   
   This book caters to beginners and intermediate programmers who want a good reference book on Java N/W programming. The expert programmers can always read the Javadocs on the Sun website and other generic network books.
   
   Anil Saldhana,
   Chicago Java Users Group.



3. I bought it to prepare my class
   
   It was a good reference to me



4. This book begins with three chapters that outline how networks and network programs work. Chapter 1 is a gentle introduction to network programming in Java and explores some of the unique programs that become feasible when networking is combined with Java. Chapters 2 and 3 explain in detail what a programmer needs to know about how the Internet and the Web work. Chapter 2 describes the protocols that underlie the Internet, such as TCP/IP and UDP/IP. Chapter 3 describes the standards that underlie the Web, such as HTTP, HTML, and REST.
   
   The next two chapters discuss two parts of Java programming that are critical to almost all network programs but are often misunderstood and misused - I/O and threading. Chapter 4 explores Java's classic I/O models which, despite the new I/O APIs, are still the preferred means of handling I/O in most client applications. Understanding how Java handles I/O in the general case is a prerequisite for understanding the special case of how Java handles network I/O. Chapter 5, explores multithreading and synchronization, with a special emphasis on how they can be used for asynchronous I/O and network servers. Chapter 6 shows how Java programs interact with the domain name system through the InetAddress class, the one class that's needed by essentially all network programs.
   
   Chapter 7 explores Java's URL class, which enables you to connect to and download files and documents from a network server without concerning yourself with the details of the server's protocol. It lets you connect to an FTP server using the same code you use to talk to an HTTP server or to read a file on the local hard disk. Chapter 8 introduces some little known classes for parsing and rendering HTML documents that make this task easy.
   
   Chapters 9 through 11 discuss Java's low-level socket classes for network access. Chapter 9 introduces the Java sockets API and the Socket class in particular. It shows how to write network clients that interact with TCP servers of all kinds including whois and HTTP. Chapter 10 shows how to use the ServerSocket class to write servers for these and other protocols in Java. Chapter 11 shows how to protect your client server communications using the Secure Sockets Layer (SSL) and the Java Secure Sockets Extension (JSSE).
   
   Chapter 12 covers the I/O APIs that were introduced in Java 1.4. These APIs were specifically designed for network servers. They enable a program to figure out whether a connection is ready before it tries to read from or write to the socket. This allows a single thread to manage many different connections simultaneously, thereby placing much less load on the virtual machine. These APIs primarily provide huge performance boosts for high volume servers. Chapter 13 introduces the User Datagram Protocol (UDP) and the associated DatagramPacket and DatagramSocket classes, and Chapter 14 shows how to use UDP to communicate with multiple hosts simultaneously.
   
   Chapters 15 through 17 look more deeply at the infrastructure supporting the URL class. These chapters introduce protocol and content handlers, concepts unique to Java that make it possible to write dynamically extensible software that automatically understands new protocols and media types. Chapter 15 describes the class that serves as the engine for the URL class of Chapter 7. It shows how to take advantage of this class through its public API. Chapter 16 also focuses on the URLConnection class, but from a different direction; it shows how to subclass this class to create handlers for new protocols and URLs. Finally, Chapter 17 explores Java's mechanism for supporting new media types.
   
   Chapter 18 introduces RMI, which enables distributed Java applications to run across multiple heterogeneous systems simultaneously, while communicating with straightforward method calls just like a nondistributed program. Chapter 19 discusses JavaMail, which is an alternative to low-level sockets for talking to SMTP, POP, IMAP, and other email servers.
   
   This book assumes you are an experienced Java programmer. Thus, you should be comfortable with basic AWT and Swing programming, since some of the code examples use these APIs. It is assumed that you know the basics of computer networking - how to use the Internet, what a URL is, how to FTP files, and write simple HTML. However, it assumes no prior experience with network programming. I found the book to be complete and in-depth. The code examples are plentiful, non-trivial, and well commented. I would recommend it not only as a tutorial in Java network programming but as a reference for someone who already knows the subject.



5. I've noticed that most reviews (both positive and negative) are a bit out-dated, referring to older editions. This review is about the latest (third) edition, which is also somewhat outdated (2004).
   
   My biggest complaint is that the book is basically a glorified API with some very boring examples. Each chapter explains the methods and constructors of a certain class then throws them together in a sample program.
   
   In my opinion, the book should have included more ideas and concepts and logic used in networking. It doesn't really discuss how networking relates to most of the things any given programmer would like to do. The book's cover and description leads you to believe otherwise, to believe it's more than a strict reference. Unfortunately, it isn't.
   
   Another complaint is that the book is a terribly dry read and almost completely devoid of illustrations. This makes things terribly confusing when discussing things that might be new to you such as sockets.
   
   It's not a bad book overall, it's just bad at some things. Admittedly, a great desk reference, and no one can deny that the API docs can be cryptic at times.
   
   Bottom Line:
   Good reference, mediocre instruction. Nice to have but might not be enough.

2 comments about Java 6 Illuminated: An Active Learning Approach (Jones and Barlett Illuminated).

1. This is the best resource for learning Java I have found. The book assumes the reader knows nothing about the language, starting with the most basic elements of the programming language and moving ahead to more complex topics that build on those elements. The code examples are in colored text so that it is very easy to read. Tips are given throughout the text for avoiding common errors that Java programmers fall into. The information is also in depth - every aspect of the language is explained in detail, and this is why the book is so thick. I don't think you could find a more thorough book. It's ideal for both beginners and experts.



2. This is our first college semester and our book budget was seriously under quota...I was really nervous about buying used books online so this was a last result. The book was in really good condition and included the cd and I got it the same week! THANK YOU for turning my big ordeal into a positive one. It was definately worthwhile experience. Thank you-Thank you-Thank you!

4 comments about Expert .NET 2.0 IL Assembler.

1. This is an excellent treatment of the MSIL topic at just the right level if you're in need of nitty gritty details for debugging, disassembling, or generating IL code. Coverage of the PE format for managed executables is the best I've seen. The text is well-written, the examples are clear and concise, and the diagrams are very helpful. The book can be used as both a tutorial and a reference: the appendices include an ILAsm grammar reference, a metadata tables reference, and an IL instruction set reference. The book is also available electronically to owners of the physical book.



2. I needed a good "go-to" reference which would aid me in quickly gaining knowledge so I could understand disassembled PE files related to a "small" project I had already invested 40 man-hours. There are references you can find on the web, however, this book will save you time looking for them. It consolidates all information you need to quickly get up to speed if you have not been doing assembler code projects for a while. The author's writing style reflects his extensive knowledge and "comfortableness" in discussing it. He includes invaluable references to tools one can use related to the subject he is discussing. The Appendixes contain excellent information that is quickly accessible simply flipping through the pages. I am not a compiler writer by trade, but I had a good laugh related to the author's comments in Chapter 19's Summary (on page 408). You'll just have to purchase the book to find out! I look forward to investing more time in reading this book in detail. If you have to spend money on a tool, this book is money well spent.



3. Wonderful experience writing an IL code generator. Project went quickly, easily, with high quality result. Thanks to Microsoft's .Net and IL ecosystem, and three books; Expert .Net IL Assembler (Serge Lidin), Common Language Infrastructure Annotated Standard (James S. Miller), ECMA-335 CLI Standard (downloadable from ECMA).



4. This book is best ever! You can learn IL, but you can undarstand MSIL, how aplications are build.

2 comments about The Practical Guide to Defect Prevention (Best Practices).

1. This is the first review I have performed and here it goes... I work in software development and have for the last 11 years. As a Quality Assurance Professional, I think "The Practical Guide to Defect Prevention" should be on everyone's book shelf. Everyone in the industry or those contemplating a start-up in the industry should read this book to get an understanding of what quality means and how to achieve it. This is a fun book filled with real world experiences and enough technical knowledge to implement the many quality systems and is most beneficial read from end to end, but is also designed to be a reference. "The Practical Guide to Defect Prevention" does a great job of giving a strong foundation for those wanting to develop quality in their processes.
   Who can really benefit from this book?
   * The executive wanting to know what it takes to have a successful software business
   * The manager wanting to know how to improve the product
   * The product designer who wants to provide enhancements to existing features and determine what features to add
   * The developer wanting to gauge the effectiveness of the implementation
   * The tester that wants to catch all of the errors
   Sure, we could talk about all the content and implementation issues, including; Root Cause Analysis, Failure Mode and Effects Analysis (FMEA), Fault Tree Analysis (FTA) or Failure Modeling, but my favorite aspect of this book is the real world examples and pitfalls described.
   Many great related quotes are included to illustrate some aspect of the material to be presented. My favorite was in chapter 12, "Adapting Processes" where there was a quote from Mark Twain "A man who carries a cat by the tail learns something he can learn in no other way". This quote illustrates the reason you need to read this book and keep it on your bookshelf.
   Arne
   The Practical Guide to Defect Prevention (Best Practices)



2. "The Practical Guide to Defect Prevention" was written for software developers and testers, but many techniques presented can be applied to improve quality in other products as well. I'm in the midst of a career change into software development after 2 decades of working with office automation hardware, and have referred to this book during a current project, as well as passed along suggestions straight from this book to former colleagues in a much different career field. When I saw the title of this book, I was afraid I'd be reading advice that wasn't much more than common sense, or a rehash of material learned in programming or intro software testing. Wrong! Realizing how naïve I was, I picked up 2 other texts in the field of defect prevention and root cause analysis. I found this book to be more readable. The clear taxonomy, the complete explanations of various methods (with multiple examples and references) and the humor (!) held my interest enough to where I learned and understood the techniques presented, as well as broadened my understanding of what quality software development really entails.
   
   As a previous reviewer pointed out, this book is useful to everyone from the tester who wants to catch errors, through the executive wanting a successful business. And, I suppose this sounds like I'm laying it on with a trowel, but I have to say it: Although I'm a voracious reader, I keep only a few dozen books on my shelves at home; this is one of them, and I suspect that I'll continue referring to it for quite some time. Thanks to the authors Ross, Marc, Bob, Dan, David, Lori, and Josh for taking the time and putting forth such a great effort!

5 comments about Pro/ENGINEER Wildfire 2.0 Tutorial & MultiMedia CD.

1. Problems, Problems and more Problems. This is the way I would describe the book. This is my view, and I am expressing it as a practicing design engineer.
   
   Errors in this book are too numerous to name and address and far from acceptable as an Engineer. Is Roger an Engineer or a very poor English major.
   
   You will require lots of patience's and time, one cannot effectively get through this book without reference to the companion CD. The quality of the CD is very poor!!
   
   I believe most new users of Pro-Engineer reliant on this tutorial is up the river with out a paddle. The author wrote this book in hopes that you understand and know Pro/E and or assumed that either the reader has previous exposure to an earlier version of Pro-Engineer. The search goes on for a good basic book on Pro/E.



2. This book is ok for starters. Just about ok.
   It omits (intentional) a whole bunch of features. Toogood barely touches drafting (pro/detail)(omits BOM tables, balloons, some important assembly features - they are available in advanced tutorial). This book leaves a lot to be desired. Only the basic - very basic proengineer tools are discussed in this book. If you really want your money's worth, go for sham tickoo's proengineer wildfire for designers. In tickoo's book, you get a fair knowledge. He discusses good number of menus and options. It is easy to refer back in case of any questions because of the organization of the book. Hope this review is useful.



3. i have both beginner books tickoo's and toogood's
   
   sure tickoo's book is more expensive than toogood's but it's worth every penny.
   Put it this way. toogood just brushes through every subject and tells you to "experiment, play, etc". sure i would experiment, but its' frustrating when you dont know your way around (beginner). i dont have time to spend hours "exploring" either.
   tickoo spoon-feeds you everything, and can be used easily as a reference guide in case you forget something. try doing that with toogood. you have to dig through his unnecesarily philosophical language. it gets even worse since the book is not arranged step-by-step like a self-teaching book should be.
   
   sure toogood might be a pro at using proe, but knowing is one thing and teaching is another. tickoo has 1/4 of a century teaching experience under his belt (or so i read)
   
   dont cheapen out on this one guys/gals.



4. Just what I was looking for. Great tutorial for any Pro/E newbie



5. Pro/ENGINEER Wildfire 2.0 Tutorial & MultiMedia CD is a great book.
   The CD takes you through a step by step tutorial that gets you up to speed very quickly.
   I wish they had books with CDs like this when I started learning ProEngineer back in 1995.
   The transition from ProE 2001 to Wildfire was drastic for many old time ProE users, but once you know it it is business as usual.

5 comments about Spidering Hacks.

1. well, sometimes a generalizing lie.
   .
   IMHO, this book should have been named "(some) Spidering Hacks using Perl"
   .
   the "100" and "industrial strength" sale pitches they could have spared from the title as well
   .
   the very little python and java code that was either mentioned and/or included as code examples I think was as a way to pepper the content and apparently make it more appealing to a broader audience
   .
   ._ the book is mostly about Perl scripts (you could compile Perl to C and then use c2java, for example, but why bothering if, as I noticed right away, it was mostly toy code?) I wonder what the "industrial strength" thing was all about.
   There is also some gnu utils examples (wget and curl), from which you could get better examples online
   ._ the book has "examples" that don't make any sense (to me) and not only that but you could see as a total waste of time, why bothering scraping amazon's pages if they offer SOAP/RSS feeds? And not only that but then he goes on telling you how to scrape a site offering financial stocks info, too!?!?! I would have started by splitting the book in two, cases for which you don't really need scraping at all and those for which you do
   ._ the author in an attempt to reach the "100" mark, included cases on how to download, say MP3 with Beatles songs and PDF files from IRS sites as separate cases :-? I wonder what the difference is once you have a connection to the data feed?!?
   .
   there is, "Web Content Mining with Java" ISBN: 047084311X and as you see the publishers/authors named this book after what it is all about and if you want to read about "industrial strength" approaches I would recommend "Mining the Web" ISBN: 1558607544
   .
   usually "hacks" books are about hacks, meaning you already know your stuff and are learning some hacks. If you know the basics of spiders and how to retrieve data off the Net programmatically this book is not for you. If you, on the other had, are new to this subject and are a Perl programmer you may learn a few things from it
   .
   otf



2. A spider (also known as a web crawler or web robot) is a program which browses the World Wide Web in a methodical, automated manner. This book is about how to create programs that perform the functions of a web crawler, with most of the Hacks being written in Perl. Like the rest of the Hacks series, this book presents 100 bite-sized chunks of code or technique to tackle specific activities. In this book these range from the simple - how to download a set of image files - to the complex - cross-referring the output from one site with another to generate a third set of data. No matter what the complexity, each hack is clearly explained, with the code samples balanced with instructions, examples and notes on how to hack the hack.
   
   As already mentioned, the hacks in this book mostly use Perl, though scattered here and there you'll find some Java, Python and PHP. If you really hate Perl, then you will not like this book. On the other hand the authors assume only a rudimentary knowledge of Perl, and there is no requirement for any knowledge of network programming of any description. After the opening chapter which gives guidance of being a good spidering citizen (how to respect the sites you are taking data from), there is a second chapter which details how to create a spidering toolkit (how to find and install the site of modules that many of the hacks depend on).
   
   With a toolkit in place and a knowledge of good behavior, the book dives into the various hacks that are organized by topic: collecting media files, gleaning data from databases (with many examples for Yahoo!, Amazon, Google, Alexa and other popular information sources), maintaining your collections (more automation with "cron" or other scheduling tools) and a final chapter on giving something back (creating a web service, generating RSS feeds and so on).
   
   The bulk of the hacks are in chapter four, which looks at extracting data from databases. Aside from the obvious sources such as Amazon and Google, these including online banks, tracking FedEx packages and more. There are a range of techniques used to grab and filter the data, so even if a data source you want to use isn't listed, the chances are that one of these hacks can be refactored to do what you want.
   
   If Perl is not your thing then the very light sprinkling of non-Perl hacks probably isn't enough to make this a worthwhile purchase. If you're a Perl hacker interested in spidering there is a ton of stuff for you here without doubt. Also, if you are a student looking for a good supplement on building a web spider from scratch, this is probably not the book for you either, but the various hacks will give you some ideas on what you might want to do in your own spider if you wish to write one in a higher level language such as Java. Amazon does not show the table of contents so I do that here for completeness:
   
   Chapter 1. Walking Softly
   1. A Crash Course in Spidering and Scraping
   2. Best Practices for You and Your Spider
   3. Anatomy of an HTML Page
   4. Registering Your Spider
   5. Preempting Discovery
   6. Keeping Your Spider Out of Sticky Situations
   7. Finding the Patterns of Identifiers
   Chapter 2. Assembling a Toolbox
   Perl Modules
   Resources You May Find Helpful
   8. Installing Perl Modules
   9. Simply Fetching with LWP::Simple
   10. More Involved Requests with LWP::UserAgent
   11. Adding HTTP Headers to Your Request
   12. Posting Form Data with LWP
   13. Authentication, Cookies, and Proxies
   14. Handling Relative and Absolute URLs
   15. Secured Access and Browser Attributes
   16. Respecting Your Scrapee's Bandwidth
   17. Respecting robots.txt
   18. Adding Progress Bars to Your Scripts
   19. Scraping with HTML::TreeBuilder
   20. Parsing with HTML::TokeParser
   21. WWW::Mechanize 101
   22. Scraping with WWW::Mechanize
   23. In Praise of Regular Expressions
   24. Painless RSS with Template::Extract
   25. A Quick Introduction to XPath
   26. Downloading with curl and wget
   27. More Advanced wget Techniques
   28. Using Pipes to Chain Commands
   29. Running Multiple Utilities at Once
   30. Utilizing the Web Scraping Proxy
   31. Being Warned When Things Go Wrong
   32. Being Adaptive to Site Redesigns
   Chapter 3. Collecting Media Files
   33. Detective Case Study: Newgrounds
   34. Detective Case Study: iFilm
   35. Downloading Movies from the Library of Congress
   36. Downloading Images from Webshots
   37. Downloading Comics with dailystrips
   38. Archiving Your Favorite Webcams
   39. News Wallpaper for Your Site
   40. Saving Only POP3 Email Attachments
   41. Downloading MP3s from a Playlist
   42. Downloading from Usenet with nget
   Chapter 4. Gleaning Data from Databases
   43. Archiving Yahoo! Groups Messages with yahoo2mbox
   44. Archiving Yahoo! Groups Messages with WWW::Yahoo::Groups
   45. Gleaning Buzz from Yahoo!
   46. Spidering the Yahoo! Catalog
   47. Tracking Additions to Yahoo!
   48. Scattersearch with Yahoo! and Google
   49. Yahoo! Directory Mindshare in Google
   50. Weblog-Free Google Results
   51. Spidering, Google, and Multiple Domains
   52. Scraping Amazon.com Product Reviews
   53. Receive an Email Alert for Newly Added Amazon.com Reviews
   54. Scraping Amazon.com Customer Advice
   55. Publishing Amazon.com Associates Statistics
   56. Sorting Amazon.com Recommendations by Rating
   57. Related Amazon.com Products with Alexa
   58. Scraping Alexa's Competitive Data with Java
   59. Finding Album Information with FreeDB and Amazon.com
   60. Expanding Your Musical Tastes
   61. Saving Daily Horoscopes to Your iPod
   62. Graphing Data with RRDTOOL
   63. Stocking Up on Financial Quotes
   64. Super Author Searching
   65. Mapping O'Reilly Best Sellers to Library Popularity
   66. Using All Consuming to Get Book Lists
   67. Tracking Packages with FedEx
   68. Checking Blogs for New Comments
   69. Aggregating RSS and Posting Changes
   70. Using the Link Cosmos of Technorati
   71. Finding Related RSS Feeds
   72. Automatically Finding Blogs of Interest
   73. Scraping TV Listings
   74. What's Your Visitor's Weather Like?
   75. Trendspotting with Geotargeting
   76. Getting the Best Travel Route by Train
   77. Geographic Distance and Back Again
   78. Super Word Lookup
   79. Word Associations with Lexical Freenet
   80. Reformatting Bugtraq Reports
   81. Keeping Tabs on the Web via Email
   82. Publish IE's Favorites to Your Web Site
   83. Spidering GameStop.com Game Prices
   84. Bargain Hunting with PHP
   85. Aggregating Multiple Search Engine Results
   86. Robot Karaoke
   87. Searching the Better Business Bureau
   88. Searching for Health Inspections
   89. Filtering for Content
   Chapter 5. Maintaining Your Collections
   90. Using cron to Automate Tasks
   91. Scheduling Tasks Without cron
   92. Mirroring Web Sites with wget and rsync
   93. Accumulating Search Results Over Time
   Chapter 6. Giving Back to the World
   94. Using XML::RSS to Repurpose Data
   95. Placing RSS Headlines on Your Site
   96. Making Your Resources Scrapable with Regular Expressions
   97. Making Your Resources Scrapable with a REST Interface
   98. Making Your Resources Scrapable with XML-RPC
   99. Creating an IM Interface
   100. Going Beyond the Book



3. This book has a strong perl focus, so make sure you want to use perl. Otherwise, it's a great book with plenty of examples on integrating website data into your site.



4. I bought this book shortly after it came out, and actually still refer to it from time to time. This is just another book that shows you how powerful Perl can be when in the right hands.



5. Definitely a very useful book.
   
   If you pick one of these books up, from this series, and learn just one thing, or something that saves you some time, it is well worth it.
   
   I use a couple of things from here, or adaptations of constantly, and it helped with learning some new techniques.
   
   Definitely recommended.