4 comments about Flash and PHP Bible.

1. This is a solid book, with great examples of PHP and Flash together; however, this isn't ideal for PHP novices .
   
   I've waited for this book for a while, and I put off sharpening my PHP skills until I received it. I wish instead I had more experience building MySQL databases with PHP first. It's odd, there is some introduction to PHP and MySQL, but it doesn't really prep you enough if you're a newbie...
   
   The title "Bible" is misleading; rather, it's more a cookbook. There is a lot of great info in here- lots of code and explanation of it, but the scope of the explanation is only how it pertains to the example given. For example, while explaining an example to output dynamic XML from a database, the author only focuses on the PHP script to retrieve the data, then parsing it into XML. I would have liked to have seen the XML as a file and how the MySQL database was structured. It would be repetitive, but that's what makes a good teaching book- or at least a "Bible" book.
   
   The other drawback for Mac PHP newbs will be: the author does a good job of explaining installation of Apache and PHP on Windows and Unix, but NOT Mac. I contacted the author as he promptly replied:
   
   "The reason for no OS X install notes was due to OS X shipping with a version of PHP which would cause issues without a large amount of editing and modifying.. which I felt was beyond the scope of the book."
   
   He did tho, create a forum on his website for readers to post questions. He quickly replies. On this forum I posted a walkthrough (with pictures) on how to quickly get PHP and MySQL running on your mac.
   
   On the whole, it's full of excellent code and various examples, but the scope is narrow and explanation is right to the point. Experienced users will welcome it, others may feel discouraged and have to look to other sources to fill in the gaps.



2. Like the other review, i also was waiting for this book to come out, but found it to be pretty disappointing when it did. The topics covered are useful for real world projects but its the way the book is laid out that had me confused.
   
   For example, in the section for installation of PHP the author describes what to do for Windows, then Linux then on the same page of installation for Linux it says about configuring PHP, does this mean for Linux or Windows or both? There are quite a few cases like this that spoil the book.
   
   The books just seems a bit garbled and not put together as well as it could have been.



3. I am sorry to say this, but this has been one of the worst books I have ever read on Flash and/or other type programs.
   
   I made it to Chapter 5, and was hoping it will get better, but no such luck..it was getting worse.
   
   Particularly, whether you are an advanced or a novice programmer, if you try using the book's examples with the available downloads, it will be a nightmare.



4. This book is not for beginners, but full of real world examples if you understand the basics of PHP, MySQL, and Actionscript already. I liked the fact that the book doesn't treat you like an amateur and gets down to the working examples right at the start (after a short part about creating a server). Its full of code that's usable right out of the book, like a shopping cart and a user login service and many more advanced topics.

5 comments about Collaboration Explained: Facilitation Skills for Software Project Leaders (Agile Software Development Series).

1. Jean Tabaka has done a great service to Software Development. The highest cost meetings where everyone is attendance can be at least twice as valuable when well run and Jean gives us some great guides to make these fruitful. This is especially true with Agile methods that recommends frequent time-boxed meetings to evaluate plans, inspect them and adapt to the changing conditions our fast-paced environments introduce. I have adopted many ideas and have found them very useful. Finally, this kind of skill is what many technically trained people need most for creating a truly collaborative environment.



2. Jean Tabaka's COLLABORATION EXPLAINED: FACILITATION SKILLS FOR SOFTWARE PROJECT LEADERS tells how to build an agile project which fosters techniques for ensuring effective collaboration. Jean Tabaka has been studying and using agile environments since its early days: her guidelines and templates for project events cover all areas and aspects of methodology and application, applying concepts to business practices and special circumstances project managers face with their development teams. A recommended, real-world project pick.



3. I found Jean's book to provide a good introduction into team dynamics and fostering collaborative, self-empowered teams. She touches on topics like DISC and other personality studies. She offers some discussion on team evoloution (from formation to real high-performance).
   
   The 2nd half of the book has a lot of perscriptive meeting formats and agendas. It's helpful for individuals who are starting out with managing a team (or experienced team members who want to refresh on the subject).
   
   The only reason I didn't give this book a 5 star is because while it's generally informative and easy to read - I felt that it didn't offer as much value for it's price. A good majority of the book is templated agendas and meeting formats, there's a few sections on strategies within meetings (like how to handle someone not paying attention gracefully). I would of liked to of seen more in way of that for the price of the book.



4. I've been lucky enough to meet Jean Tabaka before I'd read her book. She's a very humble and knowledgeable lady, and you can see both of those attributes in her book about effective collaboration. It's probably heavy reading for some people. For the right kind of people, I imagine it's very easy to digest. If you're working on projects in a team, especially as a team leader or a project manager, it's a great book that equips you with lots of practices and tools that come in handy every single day. Even if you're not working in any of aforementioned roles, as a member of any team, it offers lots of gems worth digging for.
   
   Don't be daunted by the book's thickness - Tabaka's laid the four hundred or so pages well with a decent index and table of contents, making it easy to jump around to topics that interest you. I fortunately had a few hours in the airport and the plane to give me a good chance of reading the detail of the sections that interested me.
   
   A lot of the topics that Takaba covers are very relevant to any environment in which you're working and even more so in agile development teams where collaboration is key. I definitely relate to many of the stories that she talks about, littering the book and giving real examples of the tools in practice. It's well written and many of the models are useful straight away.
   
   There's a little bit of repetition - some of it probably because it's written in a way that allows you to digest chapters on their own, and maybe so that it really lets the lessons sink in. It also talks about a number of topics that aren't directly related to facilitation though are still useful in their own way for setting a better context such as leadership and specific agile methodologies. In a way, a lot of the practices draw from many other disciplines and although not necessarily completely new, are presented in a very easy to digest manner.
   
   I'd definitely add this to my recommended reading list, especially for people who want to improve the effectiveness of their teams.



5. 
   Having had the pleasure of seeing Jean in action at a CSM class years ago and having read her book I can tell you that she is passionate about helping teams succeed. I was given a copy of the book when it was first published and it was easy to see Jean's passion play out in the book. I have used this book over the past couple of years to help me better coach teams and traditional PMs make the transition to an Agile execution model. In my mind this book should be part of every Lean/Agile consultant's/coach's toolbox.

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!