1 comments about Java Software Structures for AP Computer Science (for the AB Exam).

1. As a Java programmer, I was interested to see from Lewis' text that Java is now in the syllabus for Advanced Placement Computer Science. Bespeaks a good future for the language.
   
   The book is not strictly confined to explaining Java. It starts with a chapter on the general methodologies of software engineering. Giving the spiral model for software development, for instance. And also briefly introducing UML, which is now a standard for describing software functionality.
   
   On Java itself, Lewis jumps immediately into the key object oriented concepts. Like polymorphism and inheritance. Explaining that Java, unlike C++, does not allow multiple inheritance. You should be aware that Lewis does not (much) go over the basic syntax of Java, unlike full texts on Java. The emphasis here is given in the book's title - software structures. So you need some prior acquaintance with elementary Java.
   
   Most of the chapters then flesh out what Java provides for you in various useful classes that are part of the default package for the language. Collections are an important part of this. Crucial concepts like what is an iterator, and how to use this to step through the members of a collection. Plus the idea of interfaces. A very nice and powerful attribute of Java. Interfaces are vital in building complex programs, where you can cleanly separate implementation from a class's API.
   
   Other chapters delve into useful tools (for that is what these are) like HashMap and Hashtable. And you can see how common computing ideas like queues, stacks and trees are implemented in Java. Hopefully, you will appreciate how much you get for free in this language. These classes have been thoroughly debugged and are so useful to the professional programmer that you might become.
   
   In a way, it is too limited to think of the book as being restricted to studying for the AP computer science exam. The scope is broader. The book is useful to anyone who wants or needs to study these aspects of Java.

No comments about Java Programmer Certification Mock Exam.

5 comments about Java XML and Web Services Bible.

1. I bought this book for its sections on XML-RPC, SOAP and such. It had no in-depth coverage of these topics, but the overview wasn't too bad. However, the editing is bad, so you have contradictory sentences, even on the same page. Also the examples have lots of problems. If you want to use this book to get some overview, it's ok, but don't rely on it as the final word.



2. Making a claim to be the Java, XML, and Web Services Bible is a big one, and one that this book fails to deliver on. While the author clearly knows the subject matter, his coverage of the basics is sometimes terse and confusing. I have some familiarity with xml, but the author takes just over 200 pages covering xml, xsl with Xalan, and xslt. Considering the scope of the subject, the author would have been better served to split this book into 3 or 4 volumes and cover the material more in depth in each volume. As it stands, the book lightly covers the basics then moves into more advanced examples, giving a feeling of being rushed through the material.
   However rushed the book may feel, it is organized in a logical manner from start to finish. Although there is a slight detour in the middle of the book to cover the fairly new SVG, each section of the book builds upon the preceding sections. But I found that at the end of sections that I wasn't familiar with already, I felt lost because I hadn't been adequately prepared.
   I was dissappointed with the sample code also. The code was written using software from the Apache Project, which was fine, but like most software books, the code was outdated before it was published. While the code was written using older versions of Xalan, Cocoon, and others, I also found that many of the samples didn't work. The sourcecode is downloadable from the publisher's site (no cd), but there are no compiled versions of the samples. There is supposedly an updated version of the sample code in a zip file, but that turned out to be fairly buggy as well.
   If any of these technologies is new to you, I suggest you spend more money on other books because this one will only confuse you. If you are familiar with most of what's in here already and need an all-in-one reference or refresher without spending a lot of money, this would be the book for you.



3. This book is full of good information about XML and Java, and almost any developer using XML for the first time would find it useful. However, I think it is a little out of date. A lot of the "extension" packages it talks about have actually been encorportated into the Java platform in one way or another, and there are a few new XML-Java initiatives that it does not cover. Also, some of the examples in the book are a bit contrived, and not very practical for real world applications. But on the whole, I think this is a very good introduction to the subject.



4. The book isn't really for beginners. I don't think Java beginners can make sense of the Reflection or servlet code. The XML/XSLT part is hard to follow even after you've already read other books on the subject. The site [url] doesn't seem to exist (I tried on Oct 12 and Oct 13, 2002), so there's no source code available to download. If you're serious about Web Services I recommend you look at Jesse Liberty's books on C# and .Net instead.



5. I bought this book based on the 4.5 stars that the original reviews had given it. It must have the author's friends. None of the examples work and could never work no matter what platform. It is obvious that the author never actually worked through these issues although it looks good enough that it faked me out. Examples: he uses virtual base classes as if they were implementation classes (DOMImplementation class), he uses methods that dont exist (System.out.null()), he fails to declare or instantiate items that he uses in the examples, ..., ..., ... It took me a month to work my own way through the 2nd chapter. Not worth the time, not worth the money.

3 comments about Student Study Pack (Your Student Study Pack).

1. After going back into this book more and more I can only revise my opinion upward. Sullivan covers almost every topic before calculus and does it in a very straightforward manner. The text has rigor proving many important statements but this is never used in sacrifice of understanding. The student solution manual is also great and highly recomended. A great text and reference book.



2. Came in a good condition and very timely shipping



3. I teach high school math and reviewed many textbooks before I chose this title. The examples are diverse and the problem sets complete. Students will appreciate the excellent review at the end of each chapter. Completing this book will leave one in good stead to take calculus and linear algebra.

5 comments about Java 2 by Example (2nd Edition) (By Example).

1. Hello, I am the author of Java 2 By Example, Second Edition -- and I have a problem with the 10 positive/negative reviews on this page. The problem is: all of those reviews apply to the book's predecessor and NOT to this book. Therefore, a potential reader that reads those reviews is at a disadvantage -- the reader thinks those reviews reflect the Second Edition of this book, when they do not. I would appreciate your removal of all ten reviews (if possible). Thanks in advance for your help.

   Jeff Friesen




2. I came to this book with an above basic level in Java 2. I have to admit I bought it because it was on special! Nevertheless, I found it a logical, well constructed book. It presented coded examples of major concepts and offered relevant detail, not attemped to overwhelm you with minutae.

   Of course, everybody comes to a learning experience in different ways and what works for some doesn't work for others. However I found the combination of examples and explanations to be well suited to be learning style: read, try, modify, expand, intergrate.

   Big plus: The inclusion of a chapter on Java 2 and mathematics! Finally! Authors seemd to have forgotten that computer meanes a device for computation and some of actually do need to write mathematical programs.

   This book is the underlying language. It doesn't explore Swing or the AWT. Which, is fine, I think because it's better to get a book with a good, solid coverage of the fundementals then a book that glosses over everything so as to include everything (superficial). I recommend this book and progress on to Peter Van Der Linden's Just Java 2 for higher level topics. It has questions and programming exercises, with answers too so you can test yourself and check your progress.

   Altogether a good book for the beginner to get a handle on the Java language without having to absorb too many other distractions like GUI's and such. Let's face it, you have to learn to walk before you can run. And better to learn to walk properly than try to run with a limp.

   Also of note: As far as I can tell this book also covers (properly) virtually all the SCJP exam objectives! Not bad. There are not full blown mock SCJP exams in this book however. Because it's focus isn't the SCJP exclusively, rather a broader, more encompassing overview of beginning of the language, you might consider this book as a strong supplement to one of the certifcation books around (Sierra/Bates). A good book! And also a useful one!




3. I came to this book with an above basic level in Java 2. I have to admit I bought it because it was on special! Nevertheless, I found it a logical, well constructed book. It presented coded examples of major concepts and offered relevant detail. I think the pedagogy may be a little tough for the complete novice (Try head first Java), but excellent with some idea of programming. Covers all the major topics: from the beginnings of the language, up to threads (excellent chapter), inner classes (this book has a VERY good chapter on inner classes-> one of the best I've seen, better than deitel, Horton, Eckel, Van der Linden, schildt, all of whom glass over this important topic) and files and streams. Also collections! AGain, a good chapter with the intention of showing you what it means, rather than fobbing them off or sidestepping them in lieu of masses of SWING (graphics) stuff, which you can get easily enough if you get the language beneath it.

   Of course, everybody comes to a learning experience in different ways and what works for some doesn't work for others. However I found the combination of examples and explanations to be well suited to be learning style: read, try, modify, expand, intergrate.

   Big plus: The inclusion of a chapter on Java 2 and mathematics! Finally! Authors seemd to have forgotten that computer meanes a device for computation and some of actually do need to write mathematical programs.

   This book is the underlying language. It doesn't explore Swing or the AWT. Which, is fine, I think because it's better to get a book with a good, solid coverage of the fundementals then a book that glosses over everything so as to include everything (superficial). I recommend this book and progress on to Peter Van Der Linden's Just Java 2 for higher level topics. It has questions and programming exercises, with answers too so you can test yourself and check your progress.

   Altogether a good book for the beginner to get a handle on the Java language without having to absorb too many other distractions like GUI's and such. Let's face it, you have to learn to walk before you can run. And better to learn to walk properly than try to run with a limp.

   Also of note: As far as I can tell this book also covers (properly) virtually all the SCJP exam objectives (except there is no mention of assertions therefore minus 1 star because it's really not Java 2 1.4 then...more java 2 1.3)! Not bad. There are not full blown mock SCJP exams in this book however. Because it's focus isn't the SCJP exclusively, rather a broader, more encompassing overview of beginning of the language, you might consider this book as a strong supplement to one of the certifcation books around (Sierra/Bates). A good book! And also a useful one!

   Jeff doesn't walk away from his obligations to give you a strong grounding in the language. He doesn't seek to dazzle you with 300 pages of simplistic graphics stuff where the ooh-ahh factor is high for the novice. If you read and digest this book, you'll be able to figure out most of that anyway and do better than most- Using method local anonymous inner class for event handing on SWing objects -> at least YOU"ll understand, not merely mimick it!

   This is a very underrated and undervalued book. Which is a real shame because it is significantly more comprehensive in a Java language sense than most of the 'huge' Java books: Deitel, Horton that convolute what you need to know. Try it and see if I am wrong! Because I'm not.




4. I first came across 'Java 2' by Jeff Friesen at Carnegie Mellon.
   
   I appreciated the initiation approach of using the complete application as an introduction to Java. The application with its solid commenting and solid outline of the primary features of java parlayed an old trick from the software design world. The craps application with it intuitively commented script set up the notion of understanding a language, abstract as it may be, by examining the whole first.
   
   From my experience, in the planning and design phases of software development the whole is the starting point. The whole decomposes into segments, comprehending the pieces and comprehending their synergy. Most experienced software engineers follow this profundity, piecing the code, modulizing the code, by working backwards from the whole. And I pose why should learning be any different? We can all remember those boring math problems in elementary school that didn't seem to have any real life application.
   
   Jeff's approach is exciting and more useful than the generic 'hello world' app. The text is clearly written and the author has enthusiasm for the subject. Let's make java fun and approachable is the bent. Java can be fun.



5. Java 2 By Example, Second Edition, is the gift of an unforgettable friend.

   I consider myself a beginner in the Java programming field in spite of having a background in C and C++ and I think that Jeff makes an excellent exhibition of the most important topics in the Java language, each topic covers a group of very important concepts in programming that will nurture the readers with that whole necessary philosophical focus for the newbie programmers. Jeff has abundant programming experiences in programming, especially in Java 2 Standard Edition and he give many good guidelines.

   One of the most powerful aspects in Java that Jeff explores is Multitreading which can be intimidante and confused for the beginners, however Jeff adds to this topic the magic of his experience to achieve an almost painless topic for those that begin.
   In chapter 7 Polymorphism, Jeff begins with a brilliant explanation about the four kind of polymorphism and subsequently it covers expressly each one of these kind with clear code examples that give a deep vision in this topic.

   I think that the existent repertoire of excellent, useful and varied exercises at the end of each chapter doesn't exist in other similar book. Those readers that solve all the exercises appeared in the book will be very prepared to face the more dissimilar tasks in Java.

   I could be writing about the excellent qualities of each chapter but it would surpass the 1000 words allowed in this review, but without a doubt it cannot lack a comment about the expressive Glossary appeared at the end of this book. Do you want a definition of some topic? Look for it in the Glossary and Bingo!

   This book will probably bring Java 2 to a whole new generation of beginning Java programmers and this book does represent a great way to get started on learning the Java language.

   If I could give 6 stars, I would give them!

   Thank you Jeff, we wait for Java 2 By Example, Third Edition!

No comments about Java: How To Program.

4 comments about J2EE Open Source Toolkit : Building an Enterprise Platform with Open Source Tools (Java Open Source Library).

1. This book is not only good conceptually and instructionally, but it's also a great reference text. Aside from reading very well, the content presentation is straightforward and concise. Using this book the reader can quickly throw together everything needed for development of this nature. The book is worth it for the chapter on developer tools (chapter 4) alone. After sitting down and going through it once, I was finally able to get a complete development environment up and running under Linux. I had made a few attempts before but couldn't set up the environment correctly nor had any good choice for an IDE. Under Linux (my preferred development platform) I had always just used the command line compilation tools and text editors (like vi). Now the IDE is set up and I can test, debug, write, and deploy code easily and I'm considerably more productive.
   The book is incredibly useful for experienced programmers and indispensable for anyone trying out Java and J2EE (particularly if you don't have access commercial development environment or testing platform... as a grad student I rely heavily on open source for development in all languages). It also explains how open source solutions can enhance production environments as well. And I've not found another reference that had everything I needed all in one place. This text is thoroughly recommended to anyone with an interest in J2EE or Open Source.



2. I would definitely recommend this book to developers or enterprises that need to build applications with limited resources.

   Having been the commercial app server developer for years (using Weblogic, JRun and Websphere), I was unaware of the capabilities of todays opensource app server. The capabilites and performance of opensource app servers like JBoss are well illusted in this book.

   This book also introduces the reader to a variety of opensource API's. Most of these API's are supported by Jakarta or Sourceforge projects.

   As it's name suggests, if you need opensource knowledge, start with this toolkit.




3. This book is perfect for anyone wanting an introduction to the capabilities of Open Source software. It is EVEN BETTER to help convince management on using Open Source. It clearly shows how to quickly setup a free, fast and reliable enterprise platform for your development team without spending thousands of dollars!

   If you want to have a professional level enterprise platform for you or your development team this book is for you! Using the book and the Companion website you can use all of the most popular open-source tools to build a single, integrated platform.




4. I tried to make myself read this book, but it didn't say much. Mainly a list of open source projects for a given topic. For example, templating engines, then proceeds to explain each one. This goes on for the entire book. Most of this information is available on the web for free. I wouldn't recommend this book.

5 comments about Java Black Book.

1. Target Audience
   Beginner/intermediate Java developers who are looking for practical examples of code while learning about a specific concept.

   Contents
   This guide to learning Java is focused more on solving problems than an exhaustive teaching of each Java concept.

   The book is divided into the following chapters: Essential Java; Variables, Arrays, and Strings; Operators, Conditionals, and Loops; Object-Oriented Programming; Inheritance, Inner Classes, and Interfaces; AWT: Applets, Applications, and Event Handling; AWT: Text Fields, Buttons, Checkboxes, Radio Buttons, and Layouts; AWT: Lists, Choices, Text Areas, Scrollbars, and Scroll Panes; AWT: Graphics, Images, Text, and Fonts; AWT: Windows, Menus, and Dialog Boxes; Working With Streams: File and I/O Handling; Working With Multiple Threads; Swing: Applets, Applications, and Pluggable Look And Feel; Swing: Text Fields, Buttons, Toggle Buttons, Checkboxes, and Radio Buttons; Swing: Viewports, Scrolling, Sliders, and Lists; Swing: Combo Boxes, Progress Bars, Tooltips, Separators, and Choosers; Swing: Layered Panes, Tabbed Panes, Split Panes, and Layouts; Swing: Menus and Toolbars; Swing: Windows, Desktop Panes, Inner Frames, and Dialog Boxes; Java And XML: Using The Document Object Model; Java And XML: Using The Simple API for XML; Collections; Creating Packages, Interfaces, JAR Files, and Java Beans; Exception Handling, Debugging, and Advanced Topics

   Review
   It's getting harder and harder to find a unique niche when it comes to Java learning guides. There are humor-based guides and academic-based guides, reference guides and basic information guides, exhaustive volumes and "For Dummies" level material. So how do you find something different? Holzner finds it in Java 2 Black Book... a guide oriented towards practical solutions.

   Each chapter has a brief explanation of the material to be covered. From there, the rest of the material is covered within the "immediate solution" sections. The first section is an outline of each class to be covered, along with the properties and methods. The rest of the immediate solutions follow a conversational tone with a series of fictional problems that need to be solved by a java programmer. In many ways, this approach makes it easier to place the new information in context. You see how someone might need to use a text box in an applet instead of just learning what a text box is.

   This particular edition of the book covers Java through version 1.3, so if you want the most up to date information, you'll need to look elsewhere. Also, by looking at the chapters, you'll see there is a lot of coverage given to AWT and Swing programming. If you're more interested in server-side Java programming, this may not be your best choice. I would think this book would appeal to someone who has already gone through one learning guide and is now starting to use Java on a regular basis.

   Conclusion
   This book is more conversational and practical in nature than many other Java guides, and will appeal to readers who appreciate a less academic approach to learning new concepts. In my opinion, this would be a good "second Java book" for someone learning the language.




2. This isn't really a tutorial; it's a reference. In fact, it seems like most computer books I pick up these days are references. That's understandable: a tutorial is much harder to write than a reference. (It's probably harder to sell, too, since a tutorial has to be pretty squarely aimed, so I don't necessarily blame the author.) Of the 1,000+ pages this book, I'd say half just list all the attributes of Java objects, and a good portion of the remaining page consist of code listings showing help-file-level examples of how to use them. In cases where things are built up incrementally, often an entire page of code is repeated to show one or two new lines.

   It'll definitely boost your ego and possibly your reputation among those who might be impressed by your "reading" of a 1,000 page book in a few hours, and it won't hurt your Java skills. But you won't see any serious Java programs in here either, or learn how to make them, or learn anything about object-oriented design--a pretty important topic if you're going to work in Java.

   This Black Book is constructed in the form of a running dialogue between yourself--apparently a master of Java already--and a gallery of irritating "characters" like the "Novice Programmer", the "Big Boss", the "Product Market Specialist", etc. Sometimes these dialogues have the right hint of smat-alec, but by page 500, a sense of deja vu sets in, and they begin to seem like a crutch.

   There are some seriously irksome things about this book, too. A third or more is dedicated to the "Advanced Windows Toolkit" (AWT) of Java. OK, no problem. Java's "Swing" system has taken over from that, but you might still use AWT, right? Except the Swing section begins with a discussion of how bug-ridden AWT was. What? How can I have read a book's worth of material on a subject and this be the first I've heard about the bugs?

   Swing is relatively glossed over, but not as badly as interfaces, threading, beans, and a bunch of other topics where reading a list of attributes does not give you a good sense of how to use them.

   I expected a lot more from a Coriolis Black Book.




3. Java 2 Black Book is an awesome reference book! The author does a good job at covering most of the details of Java programming. There are a few subjects missing from the book, but if you are using this book as a reference for Java, chances are that you aren't ready for those subjects anyways. Sometimes finding a code example is easy and they are plentiful, and other times they are not what you are looking for. It's kind of like hit and miss. I recommend this book for all beginner to intermediate Java programmers.



4. This book was hard to track down but I did manage to find one on the west coast. It was worth every penny spent on it. Great reference book to turn to when you are just needing a refresher or even better if it is a completely new subject for you to learn. 5 stars plus!!!



5. Thank you. This book rocks. it covers almost all the stuff that i need from work.

4 comments about Sams Teach Yourself Wireless Java with J2ME in 21 Days.

1. As one of many people now moving their programming to the wireless world of Java 2 Micro Edition, I found this book to be excellent.

   It contains numerous, real world examples - from getting simple text off a server, right through to reasonably complex game design and even sprite manipulation.

   In fact I'm sure many of the applications in this book will be converted into real world code by cut and paste coders!

   The book does require some limited knowledge of Java2 but I was at home very quickly.

   With plenty of exercises, and a CD of all the source and latest Sun Forte/SDK I was delighted with my purchase.

   Perfect if you're targeting Motorola cellphones or Palm development (note though doesn't cover the new Nokia J2ME SDK)




2. Bad news first: This book has a few typographical errors in the
   explanatory texts but none in the source code listings. It also
   has a few misplaced words reversing the meaning of what the
   author intended to say. But if you're a beginning Java
   programmer and understands basic code optimization, you'll find
   yourself correcting the texts with a note on the margins.
   Example: on page 273, "... it takes longer for MIDlet code to
   access local variables than ... member variables..." The "local"
   and "member" words should be interchanged.
   
   I had to re-read Chapter 17 "Creating Animated MIDlets" because
   the author uses a different Sprite / Sprite Management classes
   that I'm used to (I write my own). Chapter 19 is probably the
   most difficult chapter to read because it uses artificial
   algorithms without fully explaining them (in fairness to the
   author, he did mention the names of the original algorithm
   developers, the general term of the algorithm and one possible
   source for AI research).
   
   The author could have used this chapter to create a multiplayer
   game (as a perfect combination of his prevous game programming
   chapters and networking-I/O chapters). Example: A two-player
   first person turn-based boxing game could have been a good
   tutorial.
   
   Also, the last two chapters were not necessary. He could have
   put them in appendices. The space could have been used too for
   more complicated examples.
   
   Good news: Nevertheless, Chapters 1 to 16 were an excellent
   J2ME tutorial altogeter. The author wrote very clearly and he
   reinforces previous lessons implicitly. As this is not a game
   programming book and despite the minor issues above, this books
   served its purpose of teaching me J2ME in 5 days (not 21 sorry).



3. Very good tutorial text ... with a nice hands-on approach
   and a working example on every chapter. Strongly recommended as your first book on J2ME. Simple graphical interfaces, persistent storage, connecting to the internet, personal information management..and even a few chapters on game development, which is great since , honestly speaking, is there any of us who wants to use Java on cell phones to make boring contact managment programs?



4. I knew a little bit of Java, and I found this book very good. J2ME is explained pretty good, and the examples are easy to follow. I have developed several applications that I use after reading this book.
   If there is anything that is missing in this book, it would probably be an Appendix with a better description of the different APIs.
   It is a very good book for anyone that wants to learn J2ME, but might be a little boring if you already have J2ME experience. However, if you buy a "Teach Yourself .... in 21 days" book, you are probably not an experienced programmer in the language anyway.

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.