5 comments about Party of One: Arnold Schwarzenegger and the Rise of the Independent Voter.

1. Considering the subject matter, Dan Weintraub was able to capture my attention long enough to get through the book. I liked Arnold more as a paid actor saving the world than a paid politician using the State of California to perfect the art of "bait and switch". Where or where are public servants who serve the public or has public servant become an oxymoron. Kudos to Weintraub for his research and coherent presentation of a plate of "green eggs and ham" dressed up as a thought out road map to move California forward.



2. Recently, Daniel Weintraub argued that correctional officers should not receive raises. He also suggested that officers should make LESS, since there are so many applicants for the job. His logic is not only twisted, but also a reflection of the "scrooge mentality" afflicting many bosses.
   
   In Weintraub's world, men and women would be paid the least amount possible, and unions would be banned. This means that the teacher's union would not be allowed to ask for better wages, and that the Hollywood writers (without their union) should be paid as little as possible. Because, after all, there are thousands waiting in the wings to be teachers and writers, which, by Weintraub's logic, means writers and teachers are paid too much! This flies in the face of the obvious: labor creates value (John Locke).
   
   Also, in America, if a job is dangerous, requires skills, or involves education or training, we pay more for that career-- which is why NFL players, despite "only having a high school education", are paid more than Bee writers! Why don't we don't hear Weintraub and his cronies attacking the 49ers? After all, football players make way more money than correctional officers.
   
   The fact is, officers are required to attend hundreds of hours of training (they attend an arduous academy) both on and off the job. They are educated (many have BA's and MA's) and their job is dangerous (if you don't believe this, ask the family of Manny Gonzalez, an officer recently murdered by an inmate). Officers work long hours, and yes, get paid overtime for those long hours-- would Weintraub expect them to work for free? And officers do a thankless job that neither Daniel nor his cohorts would be willing to do, for any amount of money.
   
   As for the officers' union: membership in a union is a legal right, guaranteed by U.S. law. An officer can choose to not join the union (membership is voluntary), but he still receives union protection. Officers organized a union, because prior to the union, in 1970, a "prison guard" only earned $600/ month. At that time, guards had no training, no education, no protective equipment, no baton, and no alarm (just a whistle)-- They had just their wits to protect them. Before the union, a guard's retirement (if he lived that long) was $240/ month. So, that is where officers came from, and they don't want to go back.
   
   Also, folks join unions for protection-- to receive decent pay and decent benefits-- which is why McClatchy and all the other newspapers destroyed the newspaper unions, over 30 years ago. Newspapers hate unions, because unions give the workers rights-- the right to speak out against abuse, the right to pick one's job assignment, the right to expose corrupt bosses, and the right to sue for better work conditions. The union, in spite of Weintraub's complaints, is less influential than the rich business lobbies, and certainly less powerful than the writer's union (assuming Daniel is a member; certainly not possible).
   
   Contrary to Daniel Weintraub, Officer's salaries are not a major cost to the state: 41% of California's budget goes to schools and 25.3% to Health and Human Services (welfare). Corrections is only 7.3% of the budget; officers salaries actually account for less than 3% of the total state budget. With gas rising to $4/gallon, and inflation at over 5%, no pay raise means pay cut-- for a job which is dangerous, dirty and difficult.
   
   There is a certain irony about Daniel, a wealthy man, lecturing working stiffs about making too much money. Perhaps Weintraub could take a pay cut from his cushy six-figure editorial job? Because, as Weintraub argues, a job which has more applicants than openings is paying too much. And many new journalism grads want Daniel's job! But then, ignoring or manipulating the facts is common for reporters and editorial writers at the Bee. When you have an agenda, then fair and balanced reporting goes out the window.
   
   
   In ending this letter, I realize I have wasted my time: the Sacramento Bee (Daniel's boss) will never print this letter, or give equal time to dissenting viewpoints. Or, if I am "lucky", the editors will pretend to be "fair" by allowing me a hundred words or so to respond, thus crippling my comments, and making my letter impotent. After all, as all working folks know, only rich men who own newspapers have freedom of speech. The rest of us go online and read blogs.
   
   
   #####



3. This is a terrific book. It takes a very complicated and important subject -- how California is governed -- and explains it in a way that is clear, accurate and fun to read. The book is particularly valuable for explaining a much misunderstood and timely subject: Schwarzenegger's health care plan, which passed the Assembly but failed to get out a committee in the state Senate. Although this book is important and should show up on a few college syllabi, it doesn't feel like homework. Some of the writing is more than clear -- it's beautiful.



4. Schwarzenegger remains the tool of big business while pretending to be the "Peoples Governor". However, when
   you ask the question: Which people? The answer is those who contribute to his campaign, aka, big business.
   He has decimated benefits for workers injured in California and his staff illegally implemented the permanent
   disability rating schedule, like the V.A. did with Iraq and Afghanistan war veterans. However, a California Work-
   ers' Compensation Judge has refused to use the schedule and filed a case reporting how the Schwarzenegger administration is cheating injured workers by lying to the legislature. Most importantly, like G.W. Bush, he refuses to correct the problem and has twice vetoed bills passed by the legislature to fix the deceit. We are awaiting a decision on the Boughner case to correct the problem. Please don't be fooled by his act that he is not a typical Republican. He is, and always will be, a big business Republican.



5. "Party of One," by veteran California newspaper columnist Daniel Weintraub, details the amazing life of America's second most important chief executive, California Governor Arnold Schwarzenegger.
   
   Weintraub begins with a brief overview of Schwarzenegger's early life in a small town in Austria, as a bodybuilder who, "...left his native country as a young man to pursue his vision of the American Dream. He believed with the passion of the converted that anyone who worked hard and focused on his goals could make it in America. Not just make it - but make it big. Fame. Wealth. Adulation. A beautiful family."
   
   The author, befitting his profession as a political journalist, quickly fast forwards to 2003, the year of California's fateful recall of Gov. Gray Davis. During that election, Schwarzenegger promised to "tear up" the state's credit cards as California groaned under a huge deficit caused by a complete lack of spending restraint coupled with the tech bubble bursting that served to end a spike in capital gains tax earnings. It was this political promise that would serve as the central criticism in Weintraub's story; the greatest failing; the biggest lost opportunity. Weintraub writes, "Schwarzenegger's failure to deal with the long-term, structural problem in the budget - the fact that spending was programmed by law to grow faster than tax revenues - allowed state spending to rise from $78 billion when he took office to $102 billion as he ran for reelection three years later, an increase of more than 30 percent... By the time he was reelected in November 2006, the state was spending more per capita and more as a percentage of the economy than it ever had before... His goal of bringing the state's books back into the black - the defining issue in his first campaign for the governor's office - would continue to depend on little more than a gamble, a hope that the economy would perform better than his own experts expected. It might have been a good formula for political success. But as fiscal policy, it would never get the job done." Schwarzenegger's fiscal failings became increasingly obvious in 2008 as California's deficit came back with a vengeance at $17 billion.
   
   Weintraub adequately retells the phases of Schwarzenegger's public career, his first foray into politics with his after school program initiative, his initial year in office, his failed "year of reform," his retooling by coming out with a proposal to massively borrow to build infrastructure, and his push to capture the environmental issue. All of this is set into the context of examining how Schwarzenegger, while nominally a Republican, governs with no discernable set of principles - a "liberaltarian," as Brink Lindsey coined.
   
   Weintraub wraps up by breezing through Schwarzenegger's convincing reelection in 2006 and his efforts in 2007 to increase government involvement in healthcare, reform the prison system (something I had a supporting role in), and reform the political process.
   
   All in all, Weintraub tells the story of a remarkable man trying to govern a remarkable state, doing some things well, but failing in other, more basic tests of leadership. Weintraub leaves the impression that Schwarzenegger could have done more and could be doing more, but somehow is falling short of his initial high promise.
   
   Reviewer: Chuck DeVore is a California State Assemblyman, he served as a Special Assistant for Foreign Affairs in the Department of Defense from 1986 to 1988, retired from the Army National Guard as a lieutenant colonel, and is the co-author of "China Attacks."

5 comments about The J2EE Architect's Handbook.

1. This book covers many topics, unfortunately it does not go into great detail on any of them. I don't know what the author was trying to do with this book, but I do know that this is not the new J2EE bible as some of the other reviewers have stated. Some of the topics covered have nothing to do with J2EE, they are project management topics.
   
   If you are looking for a real J2EE book look elsewhere.



2. I'm a Junior J2EE Technical Architect and I just finish reading your book. It's really interesting and instructive. It helps me a lot on my project planning.



3. I develop applications using J2EE and .NET. I found that most concepts found in this book are equally applicable to the .NET arena as well. Good work.



4. This book has outstanding breadth of information for system architecture. Some details are quite basic, while others are quite indepth. Overall though, what's most important is that the book is very well written and serves its purpose well. It has many excellent strategies, along with a comprehensive feature list of most J2EE projects.
   
   Definately a 5 star.



5. I received the book when expected and in perfect conditions. Very interesting book for a very reasonable price.

5 comments about Data Structures and Abstractions with Java (2nd Edition) (GOAL Series).

1. Too complicated to use as a tutorial, and too simple to use as a reference. This book tries to be both and does a poor job of it. Buy this book if you absolutely have to (like I did, for a class at the U of MN); otherwise I'm sure there are other books out there that can do a better job.

   P.S. - I found at least one typo in chapter 1. Can you find it? :-)




2. We have been using this book at CSUCI as a textbook for a CS2 class with a heavy hands-on component. The book is very good in that role, and the lab manual - in spite of numerous errors in the first edition - is a very good companion.
   
   It is neither a tutorial nor a reference; it is a textbook for a university-level course. It teaches students how to embed numerous data structures and algorithms in Abstract Data Types (ADTs), how to use them from clients, and how to utilize the existing equivalents from the Java libraries (mainly Java Collection Framework).
   
   I highly recommend this book along with the lab manual to CS2 instructors.



3. This is one of the most useless Java books. I am a professor teaching JAVA in a state university. From my teaching experience and the feedbacks from students, I do not think this work is even worth reading. This book intends to introduce data structure through JAVA programming, but it does not achieve either goal. First, it is not a JAVA introductory book. If you are new to Java, the Just JAVA 2 (by van der Linden) is the best choice. If you want to know more about java, Core Java 2 is the good choice and can also be used as reference. If you want to learn data structure, there are many better books available on pure data structure or data structure with C++.
   
   This book is too expensive for students, and it does not deliver the content that is worth 1/10th of the book price. The only reason I use this for my class is that it is required by University and I cannot change that :(
   
   
   P.S. if you just want to learn more about Java, Think in JAVA is a great book and is free. The author (Bruce Eckel) did a great job in writing a great book and sharing it free on the internet [...].



4. Book was in new condition and shipped within a week. Would do business with again.



5. If you are planning on learning Data Structures and Algorithms, this is definitely the book to avoid!
   
   Concepts are so horribly explained that I've ended up creating an aversion towards them. This book makes easy topics appear to be the most difficult things that you can ever learn.
   
   Mr Carrano may be a top notch Computer Science person, but writing books is definitely not his forte. That is my opinion, after having to deal with this book for about two semesters.
   
   I love books and have read good amount of books on computer science. I usually hate to sell them or give them away , but this book is definitely going to be off my shelf as soon as I am done with my course. In the future, I would for sure avoid any course that requires reading this book.
   No other book bothered (read it as irritated) me as this one did.

5 comments about Java Reflection in Action (In Action series).

1. This book presents an unusual but surprisingly important Java API, the one that underlies component technologies, dynamic loading, and more. Reflection isn't just for ubergeeks writing debuggers and similarly gutsy applications, it can help with everyday tasks of many kinds. The Formans show how, using many examples and a friendly but technically dense style.
   
   The book covers all the basics. It starts with the whole idea of metaprogramming, writing programs about programs. Maybe it sounds involuted, but the first two chapters show how it works for handling the basic features of an application, the methods and fields. The next topics cover object creation: first, objects of classes that already exist, then classes created on the fly using Java's Proxy mechanism. A little later, they cover class loaders and custom loaders in the clearest, best-motivated discussion I've seen anywhere. The chapter on Design Patterns is, as in so many books, somewhat perfunctory. I've used reflection to analyze DPs in running programs, so I found that chapter disappointing. The last chapter begs to be rewritten. This book was in production when Java 5 was on the horizon, but issued after Java 5 hit the streets. Java 5 introduced many new features such as annotation, and new reflective APIs to support them. That last chapter looks forward to features that have since become real - not a fault of the authors', but enough reason for a second edition.
   
   There are some real problems in this book, though. A minor one is that the reflection API isn't actually laid out entire anywhere in the discussion, but JavaDoc will take care of that for you. More importantly, serialization is a crucial part of the component technologies that reflection supports. This book largely disregards the standard APIs and SPIs in favor of an ad hoc, roll-your-own approach. Trust me, that's a bad idea. See Halloway's aging 'Component Development' book or old editions of 'Java in a Nutshell' for much more complete treatment of real serialization. Part of the problem in this treatment of serialization is its weak discussion of the inheritance hierarchy: when serializing a subclass, you have access to only half of an object. The superclass[es] is[are] the other half, and may have private data that the subclass can't serialize on its own. This weakness recurs in an otherwise interesting discussion on checking of invariants. The approach in this book seems to forget that the subclass invariants are only half of the object invariants, and the superclass is not handled. Also, as Szyperski notes, invariants interact subtly with callbacks, a discussion conspicuous by its absence.
   
   This is an advanced book that Java newbies might not benefit from, and I don't mean that as a criticism. It's for experienced programmers with big, complex problems. It's for dynamic, extensible systems, the kind that we all want to work on. Even though it's Java-based, it's for anyone programming in any reflective language, at least until your language gets its own version of this book. Despite some significant problems, I recommend this book highly.
   
   //wiredweird



2. If, for any reason I had to keep only 10 Java books, this one would have made this list. It's consise, up to the point and covers not only Java reflection, but many other important subjects such as class loaders, design patterns, design with interfaces, proxies, et al.
   
   I'm a technical writer myself and follow the simple rule: "the book/article is ready when you can't remove anything from it". The authors have managed to cover complicated topics in a 250-page book that has nothing to remove.



3. Java Reflection is an extremely powerful API that most modern frameworks like Spring, Hibernate, XFire, JUnit etc., use as its core enabling technology. We all use these frameworks for our applications, but never really bothered to see how the framework achieves certain things that it does.
   
   This might be because we think reflection
   1. is complex --> maybe it is, but do you think that it should stop you when it can cater more elegant/flexible/reusable code.
   2. is an advanced topic --> maybe it is, that is why we are learning this after learning the basics first.
   3. performs poorly --> Latest versions of java has considerably improved reflection API's performance. Also, there is an entire chapter dedicated to performance in this book.
   4. for framework programmers only --> Not any more
   5. is not necessary --> It is not necessary until you learn it. Once you learn it, you will wonder how you even lived without it.
   
   Today, Reflection is being used even for application requirements such as
   1. Flexible and re-usable code
   2. Implementing cross-cutting concerns
   3. Validation
   4. Dynamic addition/modification of functionality... and much more...
   
   In this book, the Foremans do an excellent job of preaching the advantages of using reflection. They are pragmatic in that, they keep you adviced that reflection is a magic-bullet only when used for the right purposes. The chapters are well organized and starts with the basics and goes all the way to the most advanced concepts.
   
   The authors start with a simple scenario where reflection could be useful. Using this scenario they teach the basics of Class and Method objects, how to find the class of an object at runtime, how to invoke a method on that object etc. The next couple of chapters takes "Serialization of Java objects to XML" as the use-case and explains the concepts of accessing fields reflectively, dynamic class loading, dynamic object construction etc. Moving onto the advanced concepts, the author takes you through a tour of dynamic proxies, custom classloaders, call stack introspection, performance metrics etc.
   
   At this point, the authors stop to point out the shortcomings of the java reflection API and show you how to use Code-Generation technique to work around those limitations.
   
   Finally, the authors give a sneak-peek at java 5 and how it is going to change the reflection API.
   
   I have a couple of suggestions for this book though
   1. This book needs a java 5 update
   2. Java beans API could have been discussed at a shallow level atleast. Though java beans does not belong to the reflection api, it is <<-- well -->> indirectly related.
   
   Overall, I found this book easy to read, rich in content, pragmatic in advice and i highly recommend it to any "moderate to experienced" java developer who wants to construct code that speaks for itself.



4. This book starts great, brilliant and clear, and then crushes and burns to a cold, dark, inglorious end. The first six chapters are very well written and informative. Thanks to them some pieces that were still missing from my java puzzle clicked into place nicely. Any reasonably experienced java programmer will find interesting material on the basics of reflection, manipulating fields and methods, dynamic object construction, stack trace reflection and the uses of a dynamic proxy.
   I liked the choice of introducing new material with a very simple and self contained example before attempting a more complex "put it all together" example. Also, yes, the examples are quite contrieved, but that can be justified because while it's true that little bits and pieces of the reflection API can be useful in most programs, it's definitely hard to come up with an example program that gains real advantage by using ALL of the reflection API.
   Starting with chapter 7 on code generation, this book takes the very sorry road of an overly academical, obscure style that is only about introducing unnecessary complications. My bet is the real reason for introducing these last chapters was to fatten up a book that even like that is quite slim. In fact it's certainly not easy to produce a 200+ pages book on reflection alone, but still the author's would have been better off introducing more examples, or even treating another subject besides reflection, than introducing these bogus chapters. Still a worthy buy though, for a java programmer that has digested the basics and is curious to find out what is possible with the apparently arcane features of reflection.



5. I first ran across the concept of reflection in Java in Cornell's Core Java book back when I was first learning the Java programming language in 1998. However, that book just treated reflection as a set of cute pet tricks of which Java is capable. Interested in a particular aspect of a class? Use this or that method and inquire. Only thing was, as a developer of code and not of tools, I found this aspect of Java interesting but not particularly useful. This book gave me a whole new respect for the tool of reflection. In a large multimedia application, my main program was going through a long series of if statements and looking for matching strings and then calling the matching sub-application. It worked, but it was large, clunky, and not very maintainable. I read this book and got the idea for a much more elegant solution. Rather than enumerate each class, I build the class name of the object I need from my list of options to construct and instantiate using reflection at runtime. Mind you, I didn't read or buy this book with that solution in mind, the author was just so clear in talking about the usefulness of reflection that the idea came to me. That's just one of the uses I've found for reflection in reading this book. Trust me, you don't have to be a software tool developer to get good mileage from it. I highly recommend it. I list the table of contents just because the product description does not have it listed:
   
   1 A few basics 1
   2 Accessing fields reflectively 27
   3 Dynamic loading and reflective construction 49
   4 Using Java's dynamic proxy 73
   5 Call stack introspection 107
   6 Using the class loader 121
   7 Reflective code generation 143
   8 Design patterns 179
   9 Evaluating performance 207
   10 Reflecting on the future 225
   appendix A Reflection and metaobject protocols 241
   appendix B Handling compilation errors in the "Hello world!" program 253
   appendix C UML 256
   
   I subtract one star because this book was written before Java 1.5 came out, and new features have been added. However, it is still a good place to start when you want to see just what reflection in Java can do for you.

5 comments about Java Security (2nd Edition).

1. The term "security" means many different things. This book deals with the built-in security features of Java, which most programmers access through the Security Manager and Access Controller. Overall, I liked this book and found it a really good introduction to secutiry. However, for the price of this book, I expected a lot more infomation. For example, I would have liked it if the author explored the cryptographic package in depth and gave more real world examples of using ciphers and encryption. ALthough this is not technically what the book is about, most people think of cryptogrophy in terms of security.



2. One thing for sure that this book is well structured, chapters are properly segregated and closely linked to each other. It makes introduction to java security seems easy.
   
   I used to find java security a bit complicated, got pieces of information from articles that I read, but I ended up having more questions.
   
   Some of the APIs shown in the examples are deprecated for JDK 1.4, but you can easily replace them with the new classes.



3. A good introduction and explanation of the Java language security (sandbox, security manager, access controller and class loaders). The same for criptography, it is clearer than Java criptography. It includes great chapters for SSL and JAAS. God job Scott (Oaks). I really recommend this book both for introduction and guide.



4. JDK 1.5 has many updates to platform security as well as APIs. I bought this book recently and it does not have updates after jdk 1.4.



5. The content of this book is dated now and this book needs a revision. The book does not cover Java security from JDK 1.4 and above. I suggest to use Core Security Patterns by Steel, Nagappan, Lay, which covers Java and J2EE security todate.

5 comments about Eclipse AspectJ: Aspect-Oriented Programming with AspectJ and the Eclipse AspectJ Development Tools (Eclipse Series).

1. In Part 1, "Introducing Eclipse, AspectJ and AJDT", we are led through the building of a prototype insurance application (SimpleInsurance). Along the way, we are introduced to Eclipse, the AspectJ language and the AspectJ Development Tools (AJDT). The aspects are not presented as pre-built, but we get to see how they are selected, written, refactored and, even debugged. I found the discussion interesting, and saw new ways to use the tooling to prevent problems, but it did mean that even simple features went through a lot of hoops which were not always clear at the time. Thrown into the mix were a number of side-bars which explained the development philosophy and architecture behind AspectJ to a depth that I have only glimpsed in some of the mailing list discussions. I am using AspectJ and some of these sidebars took me several minutes to digest. I don't like to think about how a genuine newcomer would react. Thrown into the mix were screen captures of simple wizards and instructions on how to save files, making for some unintentionally funny contrasts.
   
   In Part 2, "The AspectJ Language", things calm down as we go back to the beginning and cover the AspectJ language in full detail. As one would expect, they have produced the clearest and most comprehensive overview of the language I have seen. Everything is explained, generally using code snippets and object-interaction diagrams to reinforce their points. For complex issues, there are a number of sidebars which delve into the design of AspectJ. I learned many new things, not only about AspectJ but about the Java language itself.
   
   Finally, in Part 3, "Putting it All Together", we are able to get into the "meat" of AOP and discuss how to develop our own AO application. We get to see how to adopt AspectJ, how to develop with aspects, and how to design applications with AO. Armed with a richer understanding of AspectJ, we take a look back at the insurance application that we worked on in Part 1 and see what benefits we've achieved. We briefly revisit the discussion about integrating AspectJ with Hibernate, and get to see how we would use Spring to improve our solution even further. There is great stuff here, but my only problem with this section is that there is just too much material to cover in the 100 pages it gets. As they say, a whole book could be written on this topic (any takers?).
   
   
   I couldn't help comparing this book to "AspectJ In Action", though the two are quite different in many ways. "Eclipse AspectJ" definitely contains the most in-depth information about AspectJ and the AJDT. Using the same example (the SimpleInsurance application) throughout meant that we can see AspectJ being used in many different parts of development. There are many aspects in "Eclipse AspectJ" which I am keen to use in my applications. The problem is that I'm still debating with colleagues at work if I *should*. Where "AspectJ In Action" spent some time explaining different patterns and showing where different aspects should be used and where they should not, "Eclipse AspectJ" presents the tools but leaves the rest up to us. To my mind, that is the most important difference between the two. While "Eclipse AspectJ" cannot be matched for sheer depth, it does not always provide enough context to be used by new AspectJ developers. It is a good resource for existing AspectJ developers and will give you a complete understanding of the language and the tooling, but will be standing beside "AspectJ In Action" on my bookshelf.



2. Sub-Title: Aspect-Oriented Programming with AspectJ and the Eclipse AspectJ Development Tools
   
   If nothing else, the Java community is absolutely wonderful in coming up with new variations, add-ons, even concepts. All of these get new names and a collection of devotees. AspectJ is one of the newest.
   
   I still haven't decided if I am going to actually do anything in AspectJ, but it seems to be gathering more attention. Merging it into Eclipse is certainly a big step along the way indicating both increasing support and the availability of tools that will help with a project.
   
   This book is written from a very practical sense. It starts out with getting Eclipse and the AspectJ Development Tools (AJDT). It then leads you through a tutorial to get a program running. This is, as the book says a good way to begin learning a language. You begin to see how the whole thing hangs together and hopefully a few things begin to cause you to say to yourself, 'yup, this feature would have been a help on that last project.'
   
   After that there is a more descriptive section on the fundamentals of the language itself. This is the biggest part of the book, and in good Java fashion introduces a bunch of new words to describe aspects of the language that create its uniqueness.
   
   Finally in the last part of the book, called appropriately 'Putting It All Together' the book discusses the actual process to go through to begin adopting the language. This is an often overlooked part of beginning to use a new language. This is especially true for moving the language into a project of any size, and the book does a good job of helping you define a path to adopting the language.
   
   This is not a book for beginning programmers. It assumes that you are a Java programmer, not necessarily an expert, but with some experience. On the other hand, in a fairly short while you can grasp the AspectJ language and begin thinking about it's usefulness for your project.



3. Since my last attempt to get a book to learn about AspectJ wasn't very productive, I decided to try again with Eclipse AspectJ: Aspect-Oriented Programming with AspectJ and the Eclipse AspectJ Development Tools by Adrian Colyer, Andy Clement, George Harley, and Matthew Webster. *Much*, much better...
   
   Content:
   Part 1 - Introducing Eclipse, AspectJ, and AJDT: Getting Started; First Steps in AJDT; Extending The Application; More AJDT
   Part 2 - The AspectJ Language: An Overview Of AspectJ; Straight To The Point; Take My Advice; Inter-Type Declarations; Aspects; Using The AspectJ API
   Part 3 - Putting It All Together: Adopting AspectJ; Advanced AJDT; Aspect-Oriented Design; Command-Line AspectJ; AspectJ Language Quick Reference; Next Steps; AJDT Icons Reference; Index
   
   To give you an idea of how much better I liked this book... I learned more in the preface than I knew after going through the other book I reviewed. :-)
   
   There's a lot to like about how this book is done. Part 2 - the coverage of the actual language - is more than adequate to give you the reference material you need in order to learn the language. With each concept like pointcuts and advice, you get a tutorial of the feature, examples of how it actually works, as well as reference material for the methods and properties it uses. There's probably enough here to get you quite far down the learning path. But coupled with parts 1 & 3, it's more than enough to get you fully competent in the language. Part 1 gives you plenty of knowledge and grounding in how to use Eclipse to start coding an AspectJ application. They have a nice example of an insurance application that helps bring the theory into practice. Part 3 was a nice touch, too. Since AspectJ is designed to work *with* your object-oriented applications, this section helps you plan out how you can actually start applying the new skills in your environment. Since aspect-oriented programming (AOP) hasn't yet achieved any critical mass, there's little chance you'll be able to apply it in an all-out fashion. But using the material in part 3, you'll be able to plan out some pilots and situations where you can get your feet wet. Very cool...
   
   Even as a way to get a high-level understanding of AOP, this book works very well. To take the next step from high-level understanding to competency, you'll have everything you need right here. I'd definitely recommend this book for anyone wanting to delve into this area...



4. I found the concepts of AspectJ cool but the book seems choppy and too complex to follow. The Eclipse AspectJ tools seem very complicated and busy on the screen. The book could have had a better flow and a lighter introduction. Possibly starting out as a "language" book versus a tool book.



5. Still waiting for book that will tell me what Aspect Programming is good for. This one doesn't

No comments about Stripes: ...and Java web development is fun again.

5 comments about Agile Java(TM): Crafting Code with Test-Driven Development (Robert C. Martin Series).

1. I'm not a beginning programmer, or even an absolute Java novice, so maybe this book isn't really aimed at me. My biggest gripe is that the code snippets continue on and on making the book very poor for anything other than cover-to-cover reading.



2. I've gotten about 6 chapters into this book and I love it. I've been developing Java for almost 7 years and am currently teaching myself Agile principles and this book comes as a great help.



3. This book is primarily for new programmers who want to learn Java as their first programming language. The book can also be helpful for programmers familiar with test driven development (TDD) but new to Java, or vice versa. I am an experienced Java developer, and I found that going through Agile Java presented me with a new and better way of approaching Java code development. This book covers Java 2 Standard Edition (J2SE) version 5.0, but covers only a few of the additional APIs at an introductory level. Technologies that are used pervasively in the majority of enterprise applications, such as logging, JDBC, and Swing, are presented in Agile Java. Some of the information, such as that on logging, will teach you all you need to know for most purposes. Other lessons, such as those on Swing and JDBC, will give you a basic understanding of the technology and will tell you where to go when seeking further information.
   
   The core of Agile Java is fifteen lessons of about 30 pages each. It starts with baby steps in Java, TDD, and OO. The book finishes with a strong foundation for professional Java development. The core lessons should be read sequentially since each lesson builds upon the previous ones. Once you have completed the core lessons, you should have a solid understanding of how to build robust Java code. If you haven't completed the fifteen core lessons, you should not assume you know how to write good Java code. Each of the fifteen core lessons in Agile Java has you build bits and pieces of a student information system for a university. This single common theme helps demonstrate how you can incrementally build upon and extend existing code. Each lesson also finishes with a series of exercises. Instead of the student information system, the bulk of the exercises have you build bits and pieces of a chess application. Some of the exercises are involved and quite challenging, but they are where learning the methodology really begins.
   
   There are three additional lessons to cover a few more Java topics. Two of the lessons present an introduction to Swing. These two lessons will provide you with enough information to begin building robust user interface applications in Java. But the bigger intent is to give you some ideas for how to build them using TDD. The third additional lesson presents an overview for a number of Java topics that most Java developers will want to know such as JARs, regular expressions, cloning, JDBC, and internationalization.
   
   I really liked how the author integrated the three concepts of Java programming, TDD, and object-oriented design without confusing matters. The book is very clear with good illustrations. I highly recommend it. The following is the table of contents:
   
   Lesson 1. Getting Started
   Lesson 2. Java Basics
   Lesson 3. Strings and Packages
   Lesson 4. Class Methods and Fields
   Lesson 5. Interfaces and Polymorphism
   Lesson 6. Inheritance
   Lesson 7. Legacy Elements
   Lesson 8. Exceptions and Logging
   Lesson 9. Maps and Equality
   Lesson 10. Mathematics
   Lesson 11. IO
   Lesson 12. Reflection and Other Advanced Topics
   Lesson 13. Multithreading
   Lesson 14. Generics
   Lesson 15. Assertions and Annotations
   Additional Lesson - Swing, Part 1
   Additional Lesson II. Swing, Part 2
   Additional Lesson III. Java Miscellany
   Appendix A: An Agile Java Glossary
   Appendix B: Java Operator Precedence Rules
   Appendix C: Getting Started with IDEA
   Agile Java References



4. This is my new favorite-book-to-give-to-anyone-who-is-learning-or-using-Java.
   
   The title is misleading in that this book is about much more than just the Agile Programming stuff. While it does a great job talking about Agile techniques and always starts by creating a unit test, the book really is about all aspects of Java (specifically Java 5) programming. Anyone who takes the time to work through the examples will become a much better Java programmer.
   
   OO patterns, collections, type safety and more are covered and explained in the context of a rich, in-depth example. And because the author has you construct a high-quality test suite around the example, you are free to experiment with different ways to implement each new feature - thus proving to yourself the benefits of Agile design.
   
   Just like it says in one of the quotes on the cover, this book is now required reading for the Java programmers at our company.



5. I had originally bought this book for son who was going to spend the summer working for my development team writing unit test for our database POJOs. I was so impressed way in which concepts were incrementally introduced I read the book cover to cover. It is now the only book I recommend to beginners and I introduce it as a 'must' read for all my new hires.

5 comments about Beginning Java 5 Game Programming.

1. I first bought Jon's book Game Programming all in one. Creating games in Allegro was fun and put me on a track that has not stopped. When I found out (per his website) that he had a game book on Java coming out I was excited because I am hoping to getting a job Java programming very soon. He does not teach you how to program in Java but instead shows you how to create games you would love to play in a simple, entertaining and productive way. I was able to breeze through the book and start playing around with vector graphics and sprites to test out how Java would implement them. The side effect is that you will be learning the language while creating something you can show.
   
   If you don't have some knowledge you feel you will need to use this book, I would recommend buying another Java book to keep by your side to answer any questions that the book may not answer for you.



2. This book is true to its name, since it is truly beginning Java game programming. However, I really coudn't find anything that was unique to Java 5 in the contents. Part one is actually a tutorial on the Java programming language from the perspective of what you need to know to write your own 2D game. It really is too shallow and too focused on just those parts of Java that are required to write games to be helpful to a complete Java novice. If you are a beginner to Java, you should consult "Core Java" or "Learning Java" to learn the actual Java language basics first.
   
   Part two is particularly good for beginning game programmers who already know Java, as the chapters boil down what is necessary for programming a simple 2D game in Java complete with sound effects. The author does a good job of explaining Java2D, threads, and the concept of a game loop. I particularly liked his succinct treatment of creating a framework for Java games. He does a better job of explaining what a software framework is than many books I've read that are dedicated to the subject. He tops off part two by writing a complete 2D game in Java named "Galactic War", which you can actually play in applet form if you go to the author's website.
   
   In summary, I would recommend this book if you already understand the basics of the Java language, need more instruction on its basic multimedia capabilities, and would like to learn those capabilities through the fun activity of building a 2D game. If you would like a more advanced book on Java game programming after you finish this one, try the excellent "Killer Game Programming in Java" by Davison. I notice Amazon does not show the table of contents, so I do that next:
   
   Part I: Java for Beginners
   Chapter 1 Getting Started with Java 5
   Chapter 2 Java Programming Essentials
   Chapter 3 Keyboard and Mouse Input
   Chapter 4 Sound Effects and Music
   Chapter 5 Creating Your First Java Game
   
   Part II: Java 2-D Game Programming
   Chapter 6 Java 2-D--Vector Graphics and Bitmaps
   Chapter 7 The Game Loop, Timing, and Threads
   Chapter 8 Basic 2-D Actors--the Infamous "Sprite"
   Chapter 9 Advanced Sprite Programming--Animation
   Chapter 10 Creating a Java Game Framework
   Chapter 11 Enhancing and Polishing Galactic War
   Chapter 12 Deploying Java Games on the Web
   
   Part III: Appendices
   Appendix A Chapter Quiz Answers
   Appendix B Recommended Books and Web Sites



3. I spent a half hour looking through this and it's definitely on the basic side, but even then is fairly thin coverage, and it really doesn't cover the new Java 5 features (over Java 1.4.2) very well at all. I saw several things in the code that I generally see other experienced Java programmers recommend against, but they're not horrible errors or even in the poor programming category. This is probably because, based on the author's own bio, it appears that he's not a regular Java programmer. A little more experience and research on Java 5 might have helped make the code and technical details better. He does appear to know game programming, though, and spends the whole book working on a 2D arcade game (asteroids clone I believe), which is ok I suppose, but it's only one topic in 2D.
   
   Anyway, this book is for beginners to game programming AND Java, and seems to do an alright job of it. It's not a bad book, but it's not great either. My personal feeling is still that a good Java programming book will NOT focus on teaching Java, but game programming IN Java. Teach the io, sound, and graphics APIs, but not the core language at all. This is just another "intro to Java programming using a game as an example" book, of which there are already several. Saying it's Java 5 doesn't make it any different.
   
   Book publishers -- I will hearily endorse a game programming in Java book (or books, 2 volumes might be required) that presents more than one game type and covers all the relevant topics: io, sound (2D and 3D), graphics (2D and 3D), ai (2D and 3D), multi-user (MMOG and small client/server), art assets (2D and 3D), tools, and libraries. I probably forgot a topic or two there. But I *purposely* left out 'how to get a job in the game business' or 'how to sell your game'. Make the book(s) technical. This book would be a starting point for something like that, but I honestly can't give this one a 5 or even a 4 as it's only an average book and isn't special enough to stand out from the crowd.



4. I think I'm probably right in the target audience for this book, and I think it did a great job at what it sets out to do. There's a bit of a Java review at the beginning, but this so-called "intro to Java" is focused on game making from the very first pages. Don't think that there's enough Java teaching here to get by if you've never done Java before. He covers a couple of topics essential to gaming that many might not have covered in a previous class, like getting keyboard and mouse input, but if you don't know your applet from a hole in the ground, you'd better start somewhere else.
   
   Harbour is great at explaining difficult concepts in an accessible way. If you work through the code in the book, you'll pick up a whole lot of valuable info. I did, reading through the book twice along the way, and I got a whole lot out of the experience.
   
   If I had to give a couple of criticisms, I'd say that I would have liked this book to be a few hundred pages longer. Harbour touches on so many important topics and gives you the basics, but I'd love to have more from him on all these topics. Maybe a sequel with more depth/advanced topics? If I could have those extra pages, I'd also like it if they were devoted to a different type of game. This book takes you in detail through one game project, beginning to end, but it would have been helpful to get some strategies for dealing with other game types. Don't get me wrong--it's a great idea to work through a project to finish it in such detail. And of course, a lot of the topics can be applied to other games.
   
   I'd definitely recommend this one to anyone like me, with a Java foundation looking for a way to apply it to more interesting programming topics beyond the "toy" projects they assign in most programming classes. Read this book, and then go on to _Killer Game Programming in Java_ by Andrew Davison. That one's a lot tougher than this one and covers more advanced topics without much of any Java review, and I think they make good companion volumes. Now if I could just find the right J2ME games book . . .



5. I've been working through the book, and there are some interesting and educational concepts. The book assumes you have some strength with Java, and doesn't take the time to hold your hand through some of the more difficult concepts (I found that some areas from time to time could use clarification, so you'll need to do a little outside research.)
   The examples, and the game itself, is fun and simplistic. Jonatahn Harbour seems to have a zeal for the material that is evident in the writing.

5 comments about Beginning Java EE 5: From Novice to Professional (Beginning: from Novice to Professional).

1. The book is very good until you reach chapter 9, i think the authors made this book with a no ready version of ejb 3.0 spec's.
   When i tried to run the examples i couldn?t. I prefered to start the jboss ejb 3.0 tutorial and i think im going to give just a glimpse to the
   next chapters to see if something works.
   
   It was good... until chapter 9



2. This book was published too early. By that I mean, Java EE 5 was not finalized so the code examples starting in chapter 9 don't work. Another example is chapter 10 titled EJB Entity Beans. According to the Sun tutorial, Entity Beans have been replaced by the Java Persistence API.



3. I bought this book to learn the newer concepts introduced as part of Java EE 5. This book did'nt meet my expectations, the example code described in the book has already been deprecated and just don't work on Glassfish. The code on the book may be tested to use beta version of Java EE5 reference implementation ! I could'nt figure it out.



4. Not happy with this book. The author does not provide enough details on environment configuration, unless you use JBoss. I would stick to Core Servlets by Marty Hall.



5. This book was a plethora of useful knowledge. However, it wasn't a jump in and get dirty type of title. When starting the path towards EJB/J2EE coding, one needs to do less messing around with devshed pre-coded examples, and learn by doing.
   This text references proprietary JAR packages from the authors. It is my feeling that APress let down the beginning J2EE/EJB programmer here. This book is not for the beginner java programmer -
   Repetition goes far when learning a new area of any language.
   
   Bottom Line:
   If you want to get up and go and are good at installing all the pre-defined jargon (or are highly skilled with guesswork) and just want some great examples, this book is great for You. If you prefer the repetition route, look elsewhere.
   - Hope this helps.