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 JUnit in Action.

1. This book is a great intro to JUnit and quickly advances to intermediate level stuff (Cactus etc.). Lots of best practices are littered throughout the book and there's a good balance of code and discussion. A combination of this book with "Junit Recipes" by Rainsberger and "Java Development with Ant" by Hatcher will take you from newbie to JUnit guru in no time. Written in 2004 it's begun to get a little dated with JUnit 4.0 released (using annotations is quite a change) - however I'm sticking with JUnit 3.8 which this book is great for.



2. Before reading this book I seldom wrote unit tests and when I just did it to make the project manager happy. I didn't really grasp what unit test is all about. I suppose many programmers in the industry know that unit testing is important. But they don't write any unit tests as it is boring and the next deadline is very close any way.
   
   I started reading this book because a customer made me frustrated. He complained that stuff which worked in the last release doesn't work any more in the current release. This is of course a very unsatisfying situation. This stems from the fact that every software modification may lead to side effects. E.g. something which was OK before is now broken. Worst of all programmers don't know that something is not working any more. Programmers concentrate on what they are paid for and that is writing code. Most programmers are too optimistic as they assume that everything is working properly. And therefore they rarely test the same features again. How nice would it be to have "something" which tells the programmer that a feature is not working any more !
   
   Well this "something" is called "Unit Testing". This book makes a good introduction to unit testing. It explains why you need less time to fullfill your tasks when you write unit tests and why there are fewer bugs. It is shown how stub and mock classes are used to break dependencies to other classes and other systems. It is pointed out how unit tests simplifies refactoring and how this leads to better design.
   
   This refactoring approach is what me made enthusiatic about unit testing. Let's assume your task is to extend a poorly designed, undocumented application. The programmer who created this application left the company. So you have nothing else than undocumented code. What you do about it ? Well you can start writing unit tests to figure what the application does and how it works. Once you have a unit test suite you start refactoring and documenting the application. Thanks to your unit test suit you can perform the refactoring without fearing to break something which worked before.
   
   Even though all examples are written in java the concepts and ideas layed out can be applied to other object oriented programming languages such as C++, VB.NET and C#.
   
   However, this book fails to mention that unit testing is not a replacement for proper requirements engineering. Even with unit testing you still need to find an agreement with your customer on the features he wants to order.
   
   Besides that, this book provides a good reading on a topic which will become even more important in the future. Let's hope that more programmers will read this book as this will improve software quality in this industry.



3. I read this book pretty much from cover to cover. I found it to be a nice introduction to the unit testing strategy now widely employed in software development projects. This book does put the testing procedures in perspective and it touches upon different types/levels of testing that need to performed to ensure that the code is as bug-free as possible. I really got interested in writing unit tests after writing this book. The concept of Test Driven Development made a lot of sense and I will certainly try to incorporate this strategy into future projects. Most of the time explanations are consice, clear and to the point. Several open source frameworks such as EasyMock and DynaMock are introduced briefly - although the level of detail is not as good as I would like it to be, it is nevertheless good to know where to look for frameworks (that someone already developed) you might need for your projects.
   
   The only downside to this book is that it is out of date. The JUNIT used in this book (3.8) is not the latest version available. I tested all of the code after downloading it from the web and I found that some of the samples did not work. In some cases, the software is dated. For example, in some chapters, the author uses Maven 1.0 instead of ANT as the build tool. However, for Maven to work, it needs to download several jar files from remote repository to the local repository on your machine. The very first time you run Maven, it is supposed to do this automatically for you before building your project; however, Maven 2.0 is out and the remote repository links with Maven 1.0 is broken which means that you need to download several jar files from google manually and put them in relevant folders - since there are several of them, I eventually gave up after doing a partial configuration. Note that the build files that use Maven 1.0 will not work with Maven 2.0 - you will need to do significant configuration changes in order to get this to work. I am new to Maven (although I am very experienced with ANT), so I did not bother with trying to get these code samples to work. The other thing I noticed is that some of the Cactus examples are not working in this book. In some cases, I had to do configuration changes and in others such as the chapter on unit testing the EJB, I was not yet able to figure out what went wrong. In any case, you can't simply expect to run the code and expect it to work especially in the later chapters!!! Be prepared to spend time to figure out what went wrong and how to fix it.
   
   All in all, it is a nice book on introduction to unit testing and I will certainly recommend it to newcomers to this arena. Also, note that the level of detail and treatment provided in this book is not sufficient for real world projects. I am planning on getting a more advanced book (JUnit Recipies) to complete the picture.



4. With the new Junit4, the book needs a new version.



5. This is one of the best Junit books that I have read. Definitely a keeper in your bookshelf

5 comments about Java Servlet Programming (Java Series).

1. I wouldn't say this is an excellent book, but it's not bad. The book covers good fundamentals in its first 8 chapters for those beginning Servlets. The book also covers some useful information on JDBC and Java Server Pages. There's also some additional coverage on Applet-Servlet communication, Internationalization and Tea & WebMacro application frameworks. However some topics like JavaBeans, SSL, Filters, deployment descriptors and XML were too brief and should have been given some depth. Another dissappointment is that all examples are based on API 2.2 but not 2.3!!. The Appendix just touches on new features of API 2.3 with also a separate listing of API 2.3.
   It's been 8 mths since I purchased this book. I'd suggest that starters either wait for the next edition or get something that is based on Servlet API 2.3.



2. I found this book to be semi helpful. It would have been nice if it was more tutorial like. The examples also were not the most straightforward. The book does cover alot though.



3. This book's examples in later chapters may be a bit much for the beginner, but it does a good job of covering thing very well. Good coverage of various protocols, etc.



4. I completely agree with the 5-star positive reviews listed here. I saw a couple of new ones that were not so positive, so I wanted to voice my opinion.
   
   This book is very well written - well structured, with in depth explanations, humor, good code examples. It can be used both as a tutorial and as a reference.
   
   Even though it may be showing its age now in a couple of places (e.g. Tapestry is not mentioned, uses JDK 1.0 and 1.1 for the examples), it is still very good. It paints a complete picture, so one ends up with understanding of the principles and architecture - which is what matters - for the updated APIs there is always JavaDOC.
   
   I don't know how suitable it is for beginners, but for an experienced programmer it is a thoroughly enjoyable read - once I started it I couldn't stop until I finished (I didn't actually type the examples - that isn't necessary for understanding the material) .



5. If you do not understand servlets and program in Java this book is for you. I found it very easy to read and comprehend right off the bat. The examples are excellent and you will get off writing servlets very quickly. It is somewhat shallow in complex examples but then again how complex are servlets. Some best practices and commercial examples could have helped a lot.

1 comments about Modern Software Development Using Java, Second Edition.

1. The authors make a good choice of java, as the teaching language of this book. It conveys to students the main aspects of being a professional programmer. These days, that usually involves object oriented programming. And java was explicitly designed from scratch to be fully OO, unlike C++.
   
   Also, much current programming involves making a GUI. Well in java, this is quite simple, as shown by various chapters. The reader quickly gets up to speed in coding simple graphics, with numerous types of widgets. Also, the use of widgets and graphics coding is inherently OO. So this reinforces the book's teachings about OO. To a new student [new to any programming], OO principles can seem rather abstract. Coding widgets helps solidify the principles.

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 SCJA Sun Certified Java Associate Exam Questions Guide by Cameron McKenzie Passing Exam CX-310-019.

1. I used this book and the SCJA guide SCJA Sun Certified Java Associate Study Guide for Test CX-310-019, 2nd Edition - Incredible Update to the former ExamScam Book from the same publisher. To pass, the study guide will get you there, but if you want a really high score on the exam, I suggest you pick up this book as well. It's got over 350 exam questions - like writing the SCJA exam 7 times before you actually take the test. You can't get much more prepared than that.



2. The practise tests are thorough and the author explains the answers in detail. Its good to have if you already know java programming and you want to prepare for the SCJA test.



3. The book seems larger on the web, don't let the photos trick you into thinking you are getting a huge book for the price. Although, the book seems to cover all the material and at close to 400 pages is probably a good deal. After all, there isn't much out there on this subject available on public sites...(check with the school bookstores, but i dont think many people have spent much time writing textbooks on this subject)maybe thats why the publisher charges so much for a book thats only 8.5 x 5.5 inches!



4. If you want a high score on the exam, start going through this book about a week before your exam date. When you write, make sure you can answer all the questions correctly and you know why certain answers are right, and why certain answers are wrong. The book provides all of thet information so it help you learn all of the really important things that might trip you up on the exam.



5. This book is packed with over 350 questions and thorough answers.
   
   Each exam objective gets hit with about 10-15 different questions, tackling the objective from every angle that is possible.
   
   It's hard to believe that anyone could go through this book, do all the questions, and not come out of the SCJA exam with an incredibly high score.

5 comments about Modern Compiler Implementation in Java.

1. I've read through several compiler texts over the past few months as I work away on a compilers project for school. I would have to say that this text, the required textbook for my class, is not in the least bit useful. Most of the material in the book is not covered in any real depth. If you are looking for a useful book on compilers, I would recomend "Compilers" by Aho, Sethi and Ulman (the Dragon Book), or "Crafting a Compiler" by Fisher and LeBlanc. Both books are much more thorough. The Fisher's book is also quite easy to read and understand. Appel's books only saving grace is the occasional modern view of things.



2. Andrew Appel's textbook (Modern Compiler implementation in Java) has been prescribed as a Course Textbook. Given a choice, I strongly recommend to take it from the library or any place where you can get it for free for one semester/quarter. This book is not worth the money and is an absolute waste. Not only does it not teach you anything about compilers, but if you already know something, then it serves to confuse you.
   
   The author has tried to explain things using an example and "steps" through the process of writing a compiler. So in that sense, if you are just looking to write a compiler and be done with it whether you understand it or not, then this book might be considered OK, though not good in any sense.
   
   No theory about compilers is explained and the author seems to be talking to himself throughout the text.



3. This book is not as bad as some reviewers say. But if you expect to get a cookbook how to write your own compiler in Java (what the title could suggest), you would be a bit disappointed.
   
   The advantage is that this book covers also advanced topics such as register allocation, frame layouting and flow analysis. There are a lot of books which covers simple parsing and codegeneration only, but this book goes futher.
   
   The disadvantage is that Java code snippets of the compiler which are printed in the book is not of great quality (e.g. public member variables, instead of getter/setters and private vars). Maybe the code of quality is compromised to reduce the size of the code in the book.
   
   If you're looking for only a theoretical book, buy 'Engeering a compiler (Cooper et al)'. If you're looking for a pure practical book buy 'Progamming Language Processors in Java: compilers and interpreters' (David Watt).
   
   This book is just between these 2 books: theoretical plus some practical sauce.



4. It's been quite some time since I read this book, and my tastes in languages have changed quite a bit since then, so it's possible that if I read this book today, I would have a different impression. However, I am doubtful that that would be the case, and as it stands, my memories of this book leave a bitter taste in my mouth.
   
   The joke goes that "some programmers can write C/Fortran code in any language," and that is exactly the problem with this book. The compiler implemented within may compile correctly under javac, but it isn't implemented in a modular, object oriented way like one might expect when using such a language. Rather, the author seems to often use classes as little more than C structs, and methods as merely convenient ways of grouping together functions. I see now that the author also has a book on C compilers, and it wouldn't surprise me if the code herein was a direct port to Java, with as little redesign as possible.
   
   I am certainly not an expert on compilers, and as I said, it's been quite some time since I read this book. The general information on compiling in this book might be useful, and I'll leave it to other people to make comments on that. However, if you are looking for a book that gives advice on what patterns work well when developing compilers, or what advantages an object oriented language might bring to the table in that arena, this is not the book you're looking for. This might teach you how to write a compiler that is, syntactically, Java, but it won't give you any insight on why you'd want to use Java over any other language.



5. For reasons of local tradition I am using this book in my Compiler Course in this semester. For students (and practioners) who already know the theory behind a compiler, this book is certainly a valuable help in actually implementing a compiler.
   
   However, for readers who have little (or no) previous knowledge about compilers, this book seems rather hard to understand.
   
   This is mainly because of its poor didactics. Definitions are not given precisely in Mathematical Notation - often "things are just somehow sloppily described" in a rather colloquial language which does not really help in understanding the concepts.
   
   For example the important concept of FOLLOW-Set is only vaguely explained, and then "defined" only in terms of some cumbersome Algorithm to compute this set. Such a definition could have been presented much much clearer.
   
   Moreover, there is no nice step-by-step concept: Again and again we find confusing side remarks and forward references to later chapters, which do not help in understanding the very chapter which I am just about to grasp.
   
   For example, already in the first Introduction chapter, when the reader has not yet even learned the very basics of a compiler, one of the exercises is already: to fiddle around with some Java Code in order to make an Interpreter for an example of a little language!
   
   Of course the book offers plenty of programming and code examples to play with, however I don't really appreciate this Learning-by-Trying approach promoted in this book.
   
   Therefore I would recommend to study a more theoretical introductory textbook (like the famous "Dragon Book") first, and then, with the background knowledge from such other books, use the code examples from Appel's book to actually build a compiler.
   
   With only this one book on compiler construction, the student would probably not be sufficiently well equipped.

5 comments about Java Servlet & JSP Cookbook.

1. Target Audience
   Web developers who are looking for real-life examples of the use of servlets and JSP.

   Contents
   This is a companion-type book that goes beyond strictly reference material to the use of different servlet and JSP features, along with working examples of code to illustrate the concepts.

   The book is divided multiple chapters that each cover a different technique or function:

   Writing Servlets and JSPs; Deploying Servlets and JSPs; Naming Your Servlets; Using Apache Ant; Altering the Format of JSPs; Dynamically Including Content In Servlets and JSPs; Handling Web Form Data in Servlets and JSPs; Uploading Files; Handling Exceptions in Web Applications; Reading And Setting Cookies; Session Tracking; Integrating JavaScript with Servlets And JSPs; Sending Non-HTML Content; Logging Messages from Servlets and JSPs; Authenticating Clients; Binding, Accessing, and Removing Attributes in Web Applications; Embedding Multimedia in JSPs; Working With The Client Request; Filtering Request and Responses; Managing Email In Servlets and JSPs; Accessing Databases; Using Custom Tag Libraries; Using The JSTL; Internationalization; Using JNDI and Enterprise JavaBeans; Harvesting Web Information; Using the Google and Amazon Web APIs

   Review
   I really like the O'Reilly Cookbook series. I read a lot as part of my ongoing study, and often it's easy to understand conceptually what is going on. But making the jump to practical solutions can be difficult at times. The Cookbook series gets plenty of use on my bookshelf as I do my day to day coding. And when it comes to servlet and JSP coding as I continue to learn more about Websphere Application Server, this book will surely become dog-eared like the rest of them. Bruce Perry has done a great job.

   As with most Cookbook titles, each chapter in the Servlet And JSP Cookbook is made up of a number of Problem/Solution/Discussion groupings. This format proposes a coding problem, states the solution to solve it, and then devotes the necessary space to discuss the solution both with text and code. By using this format, you can think through a working solution and determine how to apply that technique to your own problem. Perry covers a wide range of problems that will help both the beginner and the experienced coder. For beginners, the solutions for setting cookies with servlets and JSPs may be just what you need to get started. Experienced people will find the internationalization and JNDI/Enterprise JavaBeans solutions useful. I appreciate the fact that coders of all experience levels can get something out of this book.

   The only caveat I have on this book is that it is very focused on the Tomcat and WebLogic web application servers. If that's your platform of choice, you're going to get everything this book has to offer. For me, I'm partial to the WebSphere platform. While I will benefit from a lot of this book, there are chapters that will have no appeal to me, such as using the Ant package. I will also need to pay attention to the coding examples to make sure that the techniques are coded correctly for my platform of choice. Even with that warning, I would still highly recommend this book to all coders working in this area.

   Conclusion
   This is definitely a title that will be useful to you as you learn more about servlet and JSP programming. It will give you the ideas you need to solve real business problems you'll encounter as a developer.




2. Being an O'Reilly fan it is hard for me to find fault with their no-nonsense approach to technical books, but there is one MAJOR issue I have with this book.
   
   As a developer for a major corporation I cannot use custom libraries for my work, especially when the license (http://www.servlets.com/cos/license.html) does not allow for commercial use. Where it would be helpful to see details on creating say, a multipart request class, Bruce Perry instead uses the com.oreilly.servlet.MultipartRequest class to hide much of the functionality (this is just one example).
   
   This makes little or no sense. Developers in the real world need real examples. Hiding the implementation of such under the non-commercial license pretty much ruins much of the potential application of an otherwise well written book. If you buy this book realise that only some of it will actually be useful in the real world.



3. This book is exactly what it claims to be: a general reference to hundreds of "everyday" situations Java Web developers face. Just as any cookbook, it doesn't go into the "deepest" details about every little thing, and it does give examples of ways to not reinvent the wheel. Some reviewers see this as worthy of only 1 star... This is only a 1 star book for readers who like to reinvent the wheel and waste time on unnecessary details... if you're like me and have deadlines to meet, you'll find what you need here quickly and efficiently.



4. I'm not a big reviewer. I find writing a challenge, even if it's a positive experience, as it is now. I started learning Java a few months ago and bought a number of books on the topics I needed to really create a java website.
   I stumbled on this book as one of the ten or so I purchased.
   
   I haven't touched the other's since. This book has it all, written so clearly that you know the author is very familiar with her subject and understands it thouroughly. It was written in 2003 and discusses Tomcat server as release 4.0 but that does not matter one bit. I was truly able to use this book to put together a website. Servlet, jsp, even java script is covered. I found many questions I had assembled reading the other books being answered in this one.
   Murach's books should be proud of this and I notice that they don't publish a 100 books on a subject; just have a few. I'll bet they're just as good.



5. A good book. Not for someone looking for a "tutorial" or "introduction" on the subjects covered. However, a good reference book to find examples of specific programming problems for someone who already has a good understanding of servlets and JSP. Covers a good number of different aspects of servlet/JSP programming. I also found it a good book to convey some general knowledge in areas like using attributes, DB access, etc. I enjoyed selectively reading different chapters.

5 comments about Java Concepts.

1. An excellent intro to programming from an outstanding author and programmer. It keeps reasonably upto date with the latest java version and presentation trends (pages are so full of color that reading it reminds me of a kid's birthday party.. personally I hate it, but it seems that's the current fashion..). My only problem with this book is its price and outrageous selling strategy. This book, as well as Big C++ and Big Java sell for 80 to 90 bucks in the US, where they can be imposed to college students as textbooks. Here in Italy, where this trick can't work they sell for their real value, that is from 40 to 50 bucks.
   So, exploiting the enthusiasm of the student buying his new textbooks (I know how it feels I have been there myself) or just the plain fact that it can be imposed as required reading in some classes this text is oversold at almost double its real market value. I find this disgusting. Unless you are forced to adopt this text, go for a maybe less academical and colorful book (but reasonably priced ) by the same author, Core Java.



2. I use this text for an AP Computer Science course, and find it to be one of the most confusing books on the topiic of Java and Computer Science. Being in multiple APs, I obvisouly cannot read every single word and frequently have to sort out what information is relevant in a book. In most of my textbooks, this is rather easy. Horstmann's book is, however, quite the exception. The authos literally interupts his own sentences and sections with dozens of "Random facts," "Productivity Hints," "Advanced Topics," and many more of these litte interuptions. One chapter, I forget which one, actually has three of these strung in a row, manking this book incredibly hard to read. After cutting out in the middle of a topic, it is very common to just, without warning, start back up five pages later. Avoid this book.



3. This text is a nightmare. Terms are poorly defined, if defined at all, and examples are few and far between. The illustrations are laughable. I've seen better graphics in nursery books written 30 years ago. If your professor assigns this text, and you're new to Java, be prepared to shell out more bucks for better sources or cruise the Internet to get the answers you need. This book won't provide them.



4. If you've read "The C Programming Language" and enjoyed the style of its presentation, you'll likely find this book appalling. The book is neither concise, nor lucid; you wade your way through endless explaination and come out with little understanding. I've found the examples and the presentation on Sun's website to be much easier to understand, simply because they start with a clear example, discuss it a bit, then give the details of each statement (much like Kernighan's book).
   
   Also, some of the code can't simply be typed in and compiled. In one section, they fail to mention, either in the text or in the example, that you need to import a certain class. The documentation on Sun's website is excellent, but that shouldn't make it acceptable to leave details out of the text.
   
   Finally, the price is a total rip-off. I was fortunate enough to get the book used for under $20, but I would feel cheated if I had paid more. A lot of the information can be gotten for free, and that the quality of the free information often exceeds that which is in the book. Sadly, this book seems to fit the "intro to programming" niche, and a lot of students will be forced to buy it for those classes, allowing the publisher to get away with the high price.



5. There are lots of people dissatisfied with this book, myself included. I really don't understand how anyone can find this book cohesive, and the little bit of information you get out of it you have to dissect the text for hours to get any meaning from it. This book loves to give you code to use and not tell you what in the world it does, just that you need it. So you use it for chapters then boom, in chapter 9 your finally tells something about it. That is not constructive. The learning process does not work this way. Most of the time the book hardly tells you anything. You can see that certain things must come before others, but not told why and with out being told what the code really does; its mostly just guessing why. I understand that the goal of the book is to teach programming and not a specific language, but this book does not successfully do that when it doesn't tell you what is going on. In my opinion, it confuses you to what is going on and you have to "unthink" what you've learned to actually progress with another book. I gave up completely on the book for my class and turned to outside sources to pass. Most of my classmates have been forced to do the same.

5 comments about Flexible Rails: Flex 3 on Rails 2.

1. The author goes into great detail on how to efficiently get Rails and Flex working together. The book is updated for the latest version of Rails as well as the upcoming Flex 3 release. I've found the book easy to follow along with and enjoy the author's humor spread throughout the book.
   
   As a developer I'm often tasked with making "things talk to each other". Typically if I can I'll use a tool like Flex Builder for a project and if I have a choice I'll pick Java, .NET or Ruby for the server back end - whatever is the best fit. This book only backed up my belief that Rails and Flex really do work very well together. I've learned a lot going through the code both on Rails and Flex.
   
   I also liked how the author is continually refactoring the application (called "Pomodo"), that is where your learning kicks into overdrive. He uses the Cairngorm framework and even RubyAMF. I didn't have any experience in either up until this point. Now I can say I do and it all fits together nicely.



2. I wasn't sure whether a mixed-technologies book would be adequate for both reading and reference, especially with two technologies. As both a software engineer and a moonlighting instructor this book was an easy read from the start. Mr. Armstrong explores both Flex 3 and Rails 2 with enough background information on both technologies to get a reader ready to code--and that was just Chapter...err...Iteration 1. The second iteration begins with coding (Hello World) and it doesn't stop. This is a must for your coding library and makes a great textbook for students who enrolled in courses geared toward building web and Rich Internet Applications.



3. This is a great book. Peter is the #1 expert in Flex + Rails.



4. I have used Flex for about a year and I have only dabbled in Ruby/Rails development. I have been curious how I might back a Flex front end with a simple service layer that isn't hard to create, maintain or host. So far I have only worked with Java/Spring/Hibernate backend services which can take a little while to build and integrate (Grails is MUCH faster).
   
   After about 100 pages I'm in interation 4 building an interesting RIA with a Rails backend that I can host on relatively inexpensive server if I wanted to. My only struggles thus far was getting MySQL going properly. But that was only because I forgot a step in installing it.
   
   If you have little exposure to Rails and/or Flex and you feel at home on the command line as well as you do in an IDE like Eclipse, this is a great "project" book for you. I'd say you probably want a primer in Ruby, Rails and Flex before you get going but it is pretty easy follow and has a lot of free professional advice from someone that has obviously been around the block a few times. Peter is very upfront about some things that he has done in the book that should not be considered "best practice".
   
   I am hoping to get some good insight how I might do something similar for Flex and Grails. Regardless, I am confident this is going to be a fun journey!



5. I found it best technical book till date but you should know Flex & Ruby before you can jump into this..