1 comments about Sun ONE Services.

1. all of those, who wants to understand what is Web Services technically, must have this book. many books related to Web Services tend to be unnecessarily in more critical or descriptive side but, this book is not the case.

5 comments about Software Architecture Design Patterns in Java.

1. I purchased this book hoping to brush up on my design pattern skills for a new job I had just accepted. I purchased this book on the recommendations of other Amazon.com readers, but I have to say that I am pretty disappointed in the text. The book covers the 23 GoF patterns plus an additional 19 patterns.
   
   I struggled with this text on a couple of different levels. First, some of the patterns presented aren't really patterns at all. There is a "pattern" called Accessor Methods, but this isn't anything more than good coding practices. The same could be said of Constant Data Manager (btw - I disagree with the author's solution of mashing together unrelated constants into a single location).
   
   But my real problem with this book is the presentation of the patterns themselves. GoF presents patterns in a canonical form that is widely embraced by the pattern community. This book chooses not to present the pattern in much of a form. Instead, each pattern is given a short introduction (1 page most of the time) followed by one or more examples (8, 9 or 10 pages). There is no high-level goal (motivation) of the pattern stated. The benefits of the pattern are never identified. Nor are the drawbacks (consequences). The structure of the pattern is never clearly identified.
   
   This book relies on the examples explaining the patterns, but I don't think that the intent behind each pattern is explained any where near well enough. This book would be good for a person that wants to see decent (but not great) implementations design patterns. I don't think this book is good for learning the concepts behind the different design patterns and gaining the understanding knowing when to use one pattern over another.
   
   If you want to see some implementations of patterns then maybe consider this book. If you want to learn/study about patterns this isn't the right book.
   
   For me it is back to GoF. I have heard good things about the Head Start Design Pattern book. Maybe I will check this out. But I severely doubt I will be referencing (or keeping) this book much in the future.



2. My background: I am software developer with 8 years of experience. I bought this book because I hoped that it will be easier to read and understand than GoF book. Not so.
   This book is written in extremely boring style, with no explanation of what problems those patterns are trying to solve, bad vague descriptions, longish and unclear examples. If you need a "bed time" book that should put you to sleep it 5 minutes, this may be a right book for you.
   
   Otherwise, do yourself a favor, stick to GoF and Allan Holub's books. I have both and love them.
   I heard good things about "Head First" book on patterns, it should be most appropriate book for beginners.
   
   From my perspective, GoF is the best catalog of patterns, and Allan Holub's book contains a lot of "thinking" about patterns, problems they solve, good practical examples and opinions.



3. I enjoyed this book when I read it cover to cover, and it is becoming my standard reference book for the basic patterns. The introduction to UML is very useful, and I highly recommend this book if you are using Java (actually, it's good for all programmers, but then so is Java :)).



4. I have recently learned that one should not give his comments on books until he reads the book to the last page and until he reads some other books he can buy. Previously I gave the excellent rating the Head First Design Patterns because I found it very original and helpful about some patterns. But when reading that book further, and when reading the other book Software Architecture Design Patterns in Java by Partha Kuchana, I realized how one should be careful when judging a book on his first impressions. Now I read the Kuchana's book completely.
   
   Simply said, right now I would recommend Software Architecture Design Patterns in Java as a good start in patterns. The book includes all patterns from GoF (Head First did not) and adding some of its own. The style is very practical and speaks about a pattern in direct, practical and programmer style. The book does not convey the spirit of exaggerated ultimate excitation that you can feel in some other books ( "oh, this pattern is so gorgeous, so delightful"). This book simply says what a pattern is about and how to use it, all in simple terms, like a programmer to a programmer. Highly practical and down to earth, which I like.
   
   When a Java beginner reads this book he will have some occasional problems however when jumping to the examples that use Java graphical interface, but there are other examples so you can probably find out your way without AWT or Swing examples anyway, because the explanations are excellent by themselves.
   
   So, 5 stars.



5. This is a great book. It covers a wider range of patterns than the GoF book. There is no getting away from the GoF book but this uses Java and so would be fine for Java and C# people.
   
   I keep coming back to this book and for me this it the sign of a good book.
   
   I notice another reviewer recommending "Holub on Patterns" instead of this book. While I would agree that the Holub book is worth reading, it is tough going and unfortunately it has a number of code errors which, although relatively straightforward to correct, nevertheless do add to the burden of coming to grips with the patterns.

2 comments about Black Hat Physical Device Security: Exploiting Hardware and Software.

1. There are many misconceptions about security and the quality of products in the world. This book offers a larger perspective on the details of why those misconceptions exist. We must often dig deep to find these flaws and sometimes review explicitly technical processes. At the same time, surrounding these technical details are demonstrated concepts of trust and assumption that have plagued products in the past, present, and surely in the future. Some texts may demonstrate a problem and a precise solution to that problem. This book offers the understanding of how and also why. It takes the reader from looking at any product, software or hardware, and integrates perspectives specific to trust and reliance upon technologies, which, by design, were never intended to supply a secure infrastructure. You will also see the reasons why these technologies fail; trust and assumption.
   
   Recent intrusions into network and wireless infrastructures are just mere examples of products; however functional they may be, that, in general, lack any quality assurance specific to the types of attacks that are reviewed within this book.



2. As an author, I understand the difficulty of writing a good book and the sting of a poor review. I'm reluctant to do so, but here I feel I have no choice. This book is simply very poorly done.
   
   I don't know quite what the author was hoping to achieve, but I think it's somewhere along the lines of the philosophy behind security. Drew fails to deliver, instead we get rambling text, bad anecdotes, poor writing, and no focus. When we finally do get to some technical material, it's poorly presented (eg the crypto code in Chapter 3).
   
   Errors are also rife throughout the text. For example, in chapter 3 the author attempts to describe connection attributes to enforce for a connection. One of these is the MAC address of a host 2 hops away. Anyone with any understanding of TCP/IP networking would know that if a host is 2 hops away, then the MAC address belongs to your router. The attack Drew describes isn't going to see the router change out from under the system.
   
   While there's a lot of terms thrown around, there aren't any useful concepts really taught or well presented. I don't think anyone will learn much of anything from this book. The title of the book suggests that we'll be hitting hardware, too, but it's not until the last third of the book that this is introduced, and just as poorly as key concepts in software security (defense, attacks, etc), and only for one chapter.
   
   I just don't have anything positive to say about this book, and for that I truly apologize to the author (and as a fellow author). This isn't personal (I don't know Drew, I believe, nor do I harbor any malice towards him or anyone he knows), it's just not a very good product. If you're looking for a comprehensive overview of infosec, look at something like Bishop's tome "Introduction to Computer Security".

2 comments about Agile Software Construction.

1. The book takes far too favourable a view of Extreme Programming [XP]. It ignores increasing results from industry about the brittleness of XP. You would benefit more by looking up "Extreme Programming Refactored: The Case Against XP" by Stephens and Rosenberg. It goes into gory details about actual XP attempts, including the famous initial one at Chrysler.
   
   Which is not to say that Hunt's book is entirely wrong. Parts of it, like the need for unit testing, are not bad at all. It should be adopted in many projects. And the waterfall approach does have severe problems. But you can buy into agile programming without necessarily going to the extreme of XP.



2. This book ostensibly focuses on "emerging methods and approaches that are loosely described as Agile and shows how to apply them effectively...." Topics covered include Agile Modeling, Extreme Programming, Feature Driven Development, Agile Methods with RUP and PRINCE2. The author's a Brit (hence the reference to PRINCE2, pretty much unknown outside the UK). There's an overwhelming emphasis on Agile Modeling and XP and, although the books introduction states that it "....brings together a range of the most popular Agile Methods," Scrum, probably the second most popular Agile approach along with XP, receives only around one page and half a dozen cursory references.
   
   While the author emphasizes XP heavily, there is very little attempt to examine the limitations of XP. The coverage of Agile Modeling is pretty lightweight and it's not really a "how to effectiely use Agile" book either. Overall, my assessment is this is pretty lightweight, not especially usefuland there's better books out there that focus on how to introduce and use Agile effectively. There's also better "overview" books out there with a more inclusive coverage of Agile Processes and Approaches for those who want an introduction. And for non-UK reader, the PRINCE2 coverage is pretty much irrelevant.
   
   Not worth your time. Wasn't worth mine either but I'd already spent it so I thought the least I could do is spare others the pain. Sorry John. Better luck with the next one.

2 comments about Objects and Systems: Principled Design with Implementations in C++ and Java (Undergraduate Texts in Computer Science).

1. It is a very nice book to read.The subjects being explained very lucidely with lots of examples,and abstractions. In my own view every Java and C++ programmer should go through this book ,it will help them immensely and give them a clear understanding. thanks santosh



2. This book takes a rather different approach to programming and software design. For example, the Association of C and C++ users says: "Not the usual programming/design book! Well worth considering for a second level software-engineering module ... which could then be followed by a third level module on formal methods." After being buried in the successive avalanches of C++, JAVA and UML technologies, this book has found a niche by offering a more generic and principled approach that is intellectually valid for university education and at the same time more user friendly than the usual formal methods texts. Used by several university courses as main text and by many others as recommended reading, the book is gaining more and more currency in academia. It is highly recommended for its stimulating concepts that bring the right degree of formal discipline to undergraduate software education. If used as a main text, it should be aimed at honors level students. For non-honors courses, it is excellent as a source of problems and state-based solution methods for any form of object-oriented programming or software development.

5 comments about Web Services Patterns: Java Edition.

1. Some of the fonts chosen remember me of some books I read 15 years ago. There are bad recommendations like promoting a distributed architecture in the "Physical Tiers Pattern". The chapter describe how you can communicate between two processes with RMI or CORBA.
   
   The only two patterns that were not obvious for me were the "Faux Implementation" and "Partial Population", but few strategies are presented for implementing them.
   
   In overall, the author seems naïve and not very experimented.



2. I've been architecting Web Services since before they were called Web Services, so I was really hoping to come away with some new insights based on the other book reviews here. Unfortunately, this book fell short in several ways. Pros: I liked the idea of WS patterns - it's a good idea and he did an ok job, I also liked how he tied the example application to the text. Cons: the writing style was a little dry and repetitive, very few of the patterns actually applied to how clients interact with services (something most of us that implement services are interested in), all of the examples used rpc/encoded SOAP messages which is pretty much an obsolete practice, and the author seemed to have much less Web Service experience than pattern experience. For example, in the Partial Population Pattern he recommends that clients use "keys" to identify parts of the message that they want returned. A more XML-friendly approach would be to use a limited form of XPath rather than keys, thus allowing for more flexibility. The pattern also assumes that the response schema allows variations in the message to be returned, something that I don't believe he discussed.



3. Perhaps Monday is attempting what Martin Fowler did some ten years ago, when Fowler wrote a now classic book on refactoring. Here, Monday identifies several useful patterns in WS usage. We're talking about a collective, distributed computation here. That is (or can be) usually asynchronous. Another book ("Remoting Patterns" Wiley 0470-856629) discussed patterns for a general distributed case.
   
   But Monday focuses on what might emerge as useful within the strictures of WS. Especially if we use Web Services Description Language or Business Process Execution Language. In terms of example code, he chooses Java to express this. But the text makes clear that the patterns are of course independent of any given coding language. (The WSDL and BPEL and other WS variants are declarative languages.)
   
   You may find the book useful if you are new to WS. It gives a higher level view of what might be done. Whereas other WS books could be concentrating more on the WS syntax. Also, you may find out whether BPEL is sufficiently expressive for your needs. BPEL was conceived in large part because WSDL ran into limitations. But BPEL itself needs a practical workout by developers.



4. I enjoyed reading this book because it discusses middle-tier issues well. Many Chapters (ex. "SOA Pattern" and "Service Directory Pattern") are good descriptions of WS, but are not Patterns.There is not enough technical info to implement a WS. There are issues with WS not discussed in this book. Therefore it is not a good summary of WS nor of their Patterns.



5. If you have done a lot of work with OO design, and are designing SOA based systems, this book is for you. It does a brilliant job of explaining how SOA encourages a component Architecture style, rather than a Object Oriented design methodology. Some consequences of that include, 1) passing simple data structures and expecting simple Collections from Services, such as Arrays. 2) Using composition much more, rather than inheritance. 3) Separating the Business Logic (and process) from the Business Data, so that the business process can be exposed at a higher level of abstraction, and shared across multiple Activities that can fulfill the business logic.
   
   This book is still very relevant, and a great read for Architects, developers and Managers.

No comments about Practical Java Project for Beginners (Book/CD-Rom).

1 comments about Experiments in Java: An Introductory Lab Manual.

1. This is a good book for practicing basic java programming concepts but the problem with book is that you need a lot of already written java classes from authors site. Sometimes problem of classpath arises. Secondly, some advance computer science concepts like seraching, recursion are introduced very earlier which makes it difficult to use this book for first java course. I am myself a teacher. I think labortary manual should be self sufficient not dependent on the code or material not available in manual itself. It reduces the interest of student in the subject and experiments. However, it is an execellent effort by the author. There is no such book available. It can be improved more if it is made not dependent on some code not written in the manual.

5 comments about Professional Java XML Programming with servlets and JSP.

1. I think this isn't a very good obok. First, it's not written in a very clear way, I simply didn't understand everything in the book. However, the biggest reason not to buy this book, YOU HAVE TO READ ALL/MOST OF THE CHAPTERS TO UNDERSTAND PARTS. Why is that bad? Many people, including me, like to read only relevant chapters. For example, if you already know some of the stuff, you skip directly to the right chapter and read from there. You can't really do it here, since the authors create lots of classes they constantly use in later chapters. Thus, it makes the book terribly inconvenient. Maybe this is only my impression, I didn't read all of the book, but after a few chapters that I found myself reading stuff I *DIDN'T WANT TO READ*, I just abandoned this book and moved to another one.



2. After reading through this book, I was not sure if this book is focused on Java programming or XML or Servlets and JSP programming, although it claims to be about how to integrate all these technologies together. The book overall is not very well organized and it is tough sometimes to really make out what the authors are trying to convey. As for the example code, it is not difficult to make out that the authors are from academia and certainly are not developers who hack it out in the real world.



3. I am a professional programmer with a background in C++ Windows programming who started learning JAVA a year ago. I bought this book with the intention of learning how to leverage XML in JAVA apps and servlets. I made it through the first chapter just fine and then all heck broke loose. I could not get the examples to work, the text became as clear as mud and I had to put the book down in disgust because every other chapter in the book lynchpins on knowledge from the previous one. This would not be a good buy in my humble opinion.



4. I bought this book on impulse based on the title alone. Unfortunately this was the first book I bought from this particular publisher. God, I hope the others are not this badly organized.

   As a professional Java programmer who has used all of the tachnologies in this book, I find that there are some good concepts here in terms of high-level OO design. Unfortunately, the organization of the book requires you to read through a lot of superfluous verbiage to get to the meat.

   The criticisms mentioned in other reviews are valid and I won't repeat them here, except to reiterate that the author's academic roots do shine through on this book. The tone is written as if you were sitting in a lecture hall with all the time in world to discuss these concepts and the code examples are not written for performance or high volume traffic on a web site. As a Java professional who writes almost exclusively on the server-side, I found this iritating. There isn't enough time to wade through this book to get what you need when a project is due.




5. I love this book but obviously it is not for novice.

5 comments about Java Programming With Corba.

1. This is a excellent book for java programmers with very little corba background like who know to use IDL object created in corba in their java classes,and want to know more about IDL language - and want to independently write in IDL large scale etc.Its give the fundas of IDL as well as goes into it.



2. Nice examples Excellent Coherence Explaining all 3 Joe, Orbix & Visibroker is much useful Very helpful in learning CORBA from Java



3. I read this book from starting, when I started trying to use the excercises by downloading from the authors recommended site it was failing beacuse all the programs author wrote was using Visibroker's ORB implementation(not with the Java1.2 ORB implementation). The language author used merely confuses you when you try to understand the program from his explaination given above each implementaion of the program. You can't even understand where the implementation of the program started or ended this is the case with his examples in 8th chapter of this book which also has lot of printing mistakes with missing underscores "_". I am tired of trying to read and then spending half an hour on understanding what he actually meant(Big waste of time). Some times you may wonder whether he is trying to explain you or confuse you. Please look for some other good book, I lost money but you can save yours.

   Thank You




4. This book is good for the expert or people who are faimiliar with the CORBA. Altough the authors are the professional programmer, they need to pratice how to teach the audiences. If you go to the Java web site, they will describe you step by step. This book is not a good programming. It is only the theoritical book.



5. This book refers to obsolete technology. It was published in 1997. Much has changed after that. Get the third edition.