5 comments about Jakarta Struts Pocket Reference.

1. Review
   I recently worked my way through a Struts tutorial and really liked the approach for building web applications. However, the Struts architecture has a lot of configuration files and standard components that are interrelated when building an application. It's difficult to keep all the pieces in the right place in your mind as you're first coding with Struts. This is where the Jakarta Struts Pocket Guide comes into play.

   The authors use a straightforward, documentation style of writing to give you just the core information on all the pieces that make up the Struts architecture. There's no conversational instruction on how to use or how to learn Struts. It is assumed you have the basic knowledge and need to understand the details of each piece. The format usually shows a piece of Java or XML code, explains what that piece does, and then documents each parameter that comes into play. So instead of wading through 50 pages of a book to figure out the web.xml file, you can find the core information here in six pages. You may need additional resources if you want to learn more about a particular feature, but this book will quickly show you that the feature exists and what it is meant to do.

   If you're looking to learn Struts for the first time, hold off on this book until you've gone through a learning guide of some sort (like Programming Jakarta Struts by Chuck Cavaness). You'll need that level of instruction to get up to speed on the architecture. Once you have that down, you'll be able to use the pocket guide to find answers to your day-to-day questions on how the different parts work.

   Conclusion
   If you have already worked your way through a Struts book or if you use Struts on a daily basis, you'll find this a valuable little guide to give you focused answers on a timely basis.




2. I am new to struts and was very happy with how easy this book is to find information quickly in.



3. I have at least four separate struts books, and this is the one I keep turning to whenever I have a question about syntax or properties. It lists them all, starting each tag libraries section with a description of common attributes. It then goes into the separate tags in each library and their specific attributes, with example usage. The tag references I've seen in other books were no where near as complete as what is inside this one.

   This book also includes notes on the usage of different action types, action forms, etc. All in all, an excellent reference.




4. Covers all of the bare bones and some of the guts of the topic in 125 pages. Not for complete beginners, but if youve read the limited docs on the web then this is the next step. Covers web and config xml in just enough detail, explains, form beans, beans in general, actions validation. The tag reference is 70/125 pages which makes sense as this so important to a struts app. Does justice to the html and logic tags. Great size for the desk or train. More books should be in this cut down format - it stops the authors rambling and gets to the point. for USD-10 you cant go wrong. Well edited - no mistakes. I got this with another (not as good but bigger) struts book and the two complement quite well. Go for it.



5. If the reader is not completely new to Struts, this book with the examples zipped with the Struts framework might be enough to develop a Struts based application.
   
   The book has two main parts:
   
   Intro to the usage of Struts and its most important components. (35 pages)
   This part is quite good in relation to its size. The Validator framework could get more space.
   
   Tag Reference. (85 pages)
   Includes many short examples. Tiles are also included.

5 comments about Beyond Java.

1. Great overview of where the industry is headed from a language standpoint. I've always said that Java is Complex but something like Ruby on Rails is ADVANCED! Would have like to seen CFML (i.e. ColdFusion) included as one fo the alternatives.



2. This books doesn't say Java is dead. It points the problem that the platform and (mostly) tha language has and try to show alternatives.
   
   Although totally relevant, this shouldn't be a book. It should be presented like a series of articles in some website or something like this, this book is totally temporal.
   
   Anyway, if you follow the JCP and the path Java 5,6 and 7 are following you see thar Tate is not far from the truth.



3. There is a lot to like in this book, and a lot not to like. I'll talk about the negatives first and then discuss the positives.
   
   The style of the book is extremely annoying. The author is a kayaker and a mountain biker, and he introduces each chapter with a kayaking/mountain biking story meant to serve as some kind of analogy to the programming topics he'll cover in the chapter. I found this unnecessary and distracting (I don't need sugar coating on my technical reading), and it felt like the real purpose of the stories was for the author to demonstrate how cool he is. In addition, the author uses the phrase "a perfect storm" over and over and over to describe the factors that led to Java's position of dominance in the programming world. I hated that expression even before I read the book; it has to be the most abused expression of the last few years.
   
   Despite the fact that the book is ostensibly about programming languages, the author is by no means an expert on the subject. To his credit, he admits this freely, but he also makes numerous small and not-so-small mistakes when describing programming language features which may lead more knowledgeable readers to wonder if he's really qualified to write this book. For instance, in several places he describes the advantages of static typing as being mainly for early error detection, without also pointing out another big advantage of static typing: faster code (there are other advantages as well). In another place he makes the blatantly false statement that "Smalltalk is where all the continuation research is happening", ignoring the fact that Scheme (a Lisp dialect) has had continuations since 1986, and that there has been and continues to be active research on continuations in Scheme ever since. Then he says that "In Lisp, everything is a list." Wrong again. He also seems to assume that statically-typed programs will always be verbose, indicating that he is unfamiliar with statically-typed languages like Objective Caml which have type inference. The bottom line is that he often doesn't know what he's talking about when he compares the features of different programming languages.
   
   The author's programming expertise appears to be primarily in the domain of small to medium-sized web applications. This is an important domain, but it's far from the only programming domain. So the book's subtitle "A Glimpse At the Future of Programming Languages" should really be "A Glimpse At the Future of Programming Languages for People Who Exclusively Write Small to Medium-Sized Web Applications and Nothing Else". If you want a broader picture, or are primarily interested in another domain, look elsewhere.
   
   The author is clearly aiming the book at programmers who primarily program for money. Not that there's anything wrong with that, but given the author's expressed fondness for open source software (which I share) it might have been nice to acknowledge that some people also write programs for the joy of it in addition to (or in lieu of) the financial rewards.
   
   Now that I've covered the bad, let's look at the good. The author seems to know his domain well, and he makes a good case that Java frameworks for writing web applications have gotten so baroque and tedious that they are simply miserable to use and lead to very slow development cycles. This might be just the fault of the frameworks and not the language, but the author makes a good case that specific language features (or the lack thereof) are what make Java so clumsy for writing web applications. He contrasts Java primarily with the Ruby language, and specifically with the Ruby on Rails web framework, and shows that several features of Ruby make for a much more productive programmer experience. For instance, Ruby's ability to express configuration information inside the language obviates the need for much of the XML that clutters up Java web applications. The author spends a lot of time discussing Ruby's metaprogramming capabilities and how they make it possible to write much more concise code with much less repetition. An example is a class which reads from a database and populates itself on-the-fly with methods to access specific database fields. (Small gripe: the term "metaprogramming" has a variety of semi-related meanings, all coming down to the notion of code being automatically generated instead of being written by hand, but the way that e.g. Lisp or Scheme macros or C++ templates represent metaprogramming is very different from Ruby's metaprogramming, and the author doesn't discuss that.)
   
   The most interesting chapter by far is the chapter on continuation servers. The author gives a clear (though short) description of continuations, which is no mean feat given that they are one of the most difficult-to-explain concepts in the entire universe of programming languages. More importantly, he discusses how they turn out to be extremely useful in web servers, allowing web-based programs to be written in a much more natural and concise style than is possible without them. He uses the Smalltalk language as an example, because there is a continuation server written in Smalltalk. (Another gripe: while I'm happy to see him acknowledge that Smalltalk is a good language, I might have liked it better if he also mentioned that the Scheme dialect of Lisp also has continuations (as I mentioned above), and that there is also a web server in PLT Scheme that is also continuation-based).
   
   The take-home message of the book is that writing small to medium-sized web apps in Java is rapidly becoming more trouble than it's worth, that more dynamic languages like Ruby have features that make it much easier, and that therefore there is a good chance that these languages will take over much of the programmer mindshare. I agree with all of these points, and think that today's Java web programmers are well advised to look at other programming languages. However, I also feel on general principles that all programmers would do well to learn another programming language every year or two, so for me this book just reinforces my pre-existing view.
   
   On the other hand, the author mentions, but doesn't emphasize the fact that the JVM has many capabilities which far outstrip those available in Ruby or Python or indeed most other languages. He does point out that many advanced features of Java frameworks are only useful for very large scale web
   applications (the domain that J2EE targets explicitly), and are unnecessary for the majority of (smaller scale) web applications. He leaves open the extremely important question of whether frameworks like Ruby on Rails will scale well to larger applications, or to smaller applications when they need to grow larger, though he seems to believe that they will (if not now, then later when the language and its implementation or implementations mature).
   
   In summary, I think this book is a decent read with a lot of food for thought, if you can handle the irritating style, the mistakes and the omissions. This book is far from the last word on this subject (the reader should be aware that there are lots of interesting computer languages that are not even mentioned in this book, with Objective Caml and E being two obvious candidates), but it's interesting nonetheless.



4. No doubt about it, Java is king of the hill right now, as of this review, I'm trying to hire 3 Senior Java/J2EE people in Atlanta and I'm not having much luck. Well if that's true then why am I reading a book about what's next after Java?? Bruce spells it out pretty clearly in this book, Java made developers much more productive than C++ developers for about 10 years now, but if you look at accomplishing some simple tasks like sticking a Web UI in front of a database it requires a lot of plumbing and knowledge.
   
   Does it have to be that hard? Not really, he really keys in on Ruby and Ruby on Rails to meet the needs of middle tier, those just trying to get a database driven application in the web. One thing he did not present, but is a big issue driving PHP and Ruby on Rails is how hard putting a Java App is on a shared hosting platform; in fact I gave up and went with Ruby on Rails.
   
   So where does that leave the hard-core Java/J2EE programmers? Well right now that leaves us at the enterprise level, where Java is still king talking to all the legacy systems. This is not a bad place to be though, since large companies are the ones with the big development budgets but you still need to look out for what's next.



5. This book was a quick and enjoyable read. I think the premise is right on: Java is too complex and has become a hindrance to productivity.
   
   I liked the conversational style of the book. The author makes some good arguments against Java, and provides alternatives. He attempts to make a strong case for Ruby. After reading the book, I will definitely give Ruby a look.
   
   I have several problems with the book:
   
   #1 It is highly repetitive. This is more noticeable because the book and its chapters are very short, so it can be read in one sitting. It doesn't feel like any research went into the book (aside from personal interviews) so the scope is only what the author is most familiar with (ie. he mentions Hibernate/Spring/Tapestry over and over again. He brings up static typing impeding productivity many times over the course of the book...obviously a personal gripe of his.)
   
   #2 It is not an objective analysis. After reading the book, I believe the author to be a Ruby evangelist. In particular, I didn't appreciate a section where the author shows an example of how Ruby outperforms Java. He clarifies by saying the evidence is unscientific (the Java implementation was not tuned for performance.) Well if that is the case, then it doesn't belong in a technical book (from O'Reilly no less.)
   
   The author suggests the possibility of fixing Java, but it strikes me as an obligatory mention. Beyond Java is this author's (well informed) opinion, no more no less. It did not convince me to throw out the Java baby with the bathwater. Nonetheless, it provided some interesting food for thought.

5 comments about Black Art of Java Game Programming.

1. What a great way to learn java! I read several boring java books and made little progress until I picked this one up. Games give you a visual way to understand OOP and learn java without falling asleep. I'm not done with the book yet but so far I've had no problems compiling or running with jdk1.3. And because this book concentrates on applets its a great book for web developers like myself. You won't find many new books on applets anyway which is ashame. Yes, 1996 is an old book but many of the lesson's learned are timeless. Lots of good examples if you are a visual learner like me.



2. this book is pretty old, but if your a beginner to both game programming and java then there is no other better book than this...it will teach you about classes, interfaces, inheritance...and all the while making it fun and iteresting... you'll develope little games along the way and learn about some simple AI too...so old and outdated...true...but worth every penny!!!



3. This book was generally very good. It suffers in that it is very old for a programming book and uses a lot of deprecated Java API. It also barely touches on some essential topics such as MediaTracker (for example, how do you implement a load bar for your game?) which is important for most games which will be played over the Internet. But it does have some very useful sections and will hand-hold you through building a 2D game. It also discusses how to build multi-player Java game applets, a topic I haven't seen discussed anywhere else. If you are new to game programming or game programming in Java, this book is an excellent source of information.



4. The Java world has passed this book by. Black Art is based on
   a completely outdated version of Java. It amazes me that this
   book is even still on the shelves. I am a professional Java
   developer and I simply cannot recommend a book that relies on
   obsolete technology like this.



5. I was given this book by a friend, who received it from a friend, who received it from a friend. Now I'm going to give it away too, because it's useless. We are all professional programmers and two of the friends who have owned this book are now professional game programmers (using C++). We were hoping that this book would prove java to be a great way to code games for other platforms, but it doesnt even come close. If anything it's proved that java is not a game programming option.

   The book itself is a good intro to java programming, but the game examples are just too basic...so basic that you dont even want to look at them. I have a stack of commodore 64 game programming books with arcade games written in line basic that would put this book to shame... with only 32k of memory. Dont even get me started on the speed. The best game in the book is "javaroids" but it's choppy on my p3-500 with 512mb of ram. It doesnt matter though because it would be a challenge to want to play it for more than 10 seconds,especially in a 200x300 window, and I *love* asteroids and classic arcade games. How sad.

   Whats java good for? Moving data around between servers... but not games. If this book is offered to you for free, think hard about it but then decline.

5 comments about Designing Web Services with the J2EE(TM) 1.4 Platform: JAX-RPC, SOAP, and XML Technologies (Java Series).

1. This book provides a very good, well ordered, high-level overview of architectural decisions in a Web Services application. If you have knowledge of J2EE technologies, and want an intro to the Web Services paradigm, this is a good book.
   
   This is not a programmer's reference nor an introduction to J2EE technology.
   
   The book is disciplined in maintaining a high-level overview; most code snippets are purposely contracted to show only the relevant features being discussed. This keeps the code snippets focused, but means that if you are looking for a sample SOAP document that does X, you'll need to look elsewhere.
   
   I liked the organization of the book. Rather than organizing the book around an annotated sample application, the authors
   take a more didactic approach; Chapter 1 gives an intro to Web Services, Chapter 2 reviews the alphabet soup of J2EE development and shows how various components either use the technologies or are connected by them.
   
   The next five chapters each take one component of the Web Services domain and review in detail the architectural
   decisions to be made in designing that component. In the chapter on Service Endpoint Design, for example, the authors review
   two approaches to designing a service interface definition; should you first design a Web Services Definition Language or
   should you first design the Java Interfaces? The Chapter on XML reviews the pros and cons of various XML parsers and the use of XML transformations for services which must interact with numerous systems. There are similar chapters reviewing Client design, Integration with the J2EE platform, and Security.
   
   In the last chapter, the authors review their reference application and walk through their decisions.
   
   Throughout, the authors give good advice on the judicious use of various technologies, use of Design Patterns, and designs that will give good, reusable code. The authors several times discuss patterns that will make the application simpler to understand and build upon.
   
   All in all, this is a well written treatment that I highly recommend.



2. As the title of my review says this book is intended for all the people who want to architect and develop web services in a proper way. The technology around Web Services is very splitted. I mean from a lot of separate web associations. When you want to master web services technology you have to know in detail XML, XML Schema, SOAP, UDDI and its support in J2EE.
   This book gives architectual overview how these technologies depend on each other, I mean the relationships.
   The book is not intended for getting detail information about source code implementation. Anyway, it is from the SUN Blueprint program team. So everybody developing and architecturing web services with J2EE technology should read this book. It is a very dry book. Very talkative. I am glad I have already read it.



3. his book is primarily geared towards reader familiar withthe J2EE architecture. Code samples are few and far between, and the illustrations are primarily UML. That's cool. For a book from Sun J2EE team, I would like to see a little more code examples (thus the four stars instead of five.)
   
   The book starts with XML basics, then spends the largest portion of the book on SOAP and JAX-RPC, then finishes off with an excellent chapter on security issues. There is some mention of mobile, but detailed enough.
   
   I do suggest this book as a good reading for budding Java architects who want to learn more about this topic.



4. This book is well written. It would be helpful if there were questions and the end of the chapter.



5. This is a well written book that covers the basics of Java Web Services according to Sun (i.e. from a Java perspective). However - things have moved on since the publication of this book 4 years ago. Will still be a good book to use for the Sun Certified Web Services Developer exam until the exam is updated. May want to look at more recent books.

5 comments about Murach's Beginning Java 2.

1. As a mainframe software engineer with over twenty years in the business, I have for several years now seen the need and have endeavored to learn some Object-Oriented Programming (OOP) language such as C++ or Java. Until recently, though, all I have had to show for my efforts is a stack of highly-rated but little-read books on the subject. The reason they are little-read is I would get about 4 chapters in to the book, only to get utterly lost and give up, and toss the C++ or Java book onto a stack of similar books in the corner of my home office, fighting the despair that I would ever learn any of this stuff.
   
   Eventually, I got hold of Beginning Java2 (JDK 5) by Lowe, Murach, and Steelman; published by Murach and Associates. As a result of working through this book, I am glad to report that I am finally successfully writing programs using weird and bizarre (to us mainframers) things such as Classes, Objects, Constructors, Methods, Inheritance, and Polymorphism; and I am actually understanding what is going on. Even more shocking, it is fun!
   
   I think the problem with all those other books was that they assumed the reader either knew something about Object Oriented programming, or knew nothing about any kind of programming. However, I think for some of us, when approaching OOP, knowing mainframe programming is worse than knowing nothing. This Java book clearly explains things in ways that we mainframe people can easily latch onto.
   
   If you want to finally, successfully make the jump from legacy work to Object Oriented, this is your book.



2. it helps you understand Java a little bit more than a class does



3. I am taking my Begining Java Class now and we use this textbook. Overall book is good although with some errors in text and some of the code is hard to understand without whole program code. My instructor studied on previous edition and said that previous edition was better structured.



4. When I began studying Java, a friend of mine recommended me this book and it was perfect because I could learned the essential Java skills, object-oriented programming, Swing and so on. Besides, I could understand how to work with float values in my business application by using the class Big Decimal in order not to lose precision and digits.
   
   Therefore, I can confidently say that this book is an excellent choice for learning Java and developing high quality software.



5. simple step by step instructions. very easy to follow

1 comments about Inside Web Dynpro for Java -- 2nd Edition.

1. A must for all web dynpro developers!!!
   
   SUPERB!!

5 comments about Building Parsers With Java(TM).

1. I own arround 80 books about compiler/language design, and this is what I have to say about this book.
   
   It's a FIVE star, if you are looking for a easy cookbook to deal with simple free text input in your application (e.g. a command line to enter commands in your application, or write your own scripting language).
   
   However it's a ONE star, if you want to learn or write your own compiler or want to deal with very complex free format text input (e.g. a real programming language). This book doesn't really cover the theory behind parsing and scanning although there are some chapters about Logic programming.
   
   Everyone can read this book. It doesn't rely on 'higher math'. It is not a dry text. With this book everyone can write a descent text processor.
   
   The problem with this book (which is a advantage for novice people, and a disadvantage for people who want to learn something about compiling), is that this book rely on a parsing/scanning/interpreter framework/library of the author. This framework is not described in this book. You only learn how to use this framework. This is nice for people who only want to build a parser based on this framework, but a disadvantage for people who want to learn something about the theory or the algorithms (used in this framework or in parsers/scanners in general).



2. One of the best programming related books I have found. It certainly is one of the most original and most enjoyable reading materials I have found. And having read a lot, that says something :)
   
   Steven provides the reader a strong Java framework for building your own language parsers, and contrary to some reviews I've found, he's right to do so, since he introduces a very complex issue simplifying it to the point that in just a couple of days you can write your own parsers.
   
   This book is a member of a very few select of books that should be considered "Must Have". It's one of those purchases you will not regret.



3. This book does not assume that you understand compilers or programming language theory. However, the beauty and eloquence of what the book is trying to teach you will be far clearer if you do understand these disciplines. This book teaches you how to build nondeterministic recursive-descent parsers. If you are interested in other kinds of parsers, then you need to consult another source. The classic source on these other kinds of parsers is "Compilers: Principles, Techniques, and Tools" by Aho, also known as "The Dragon Book".
   
   This book explains how to write parsers for new computer languages that you create. Each chapter focuses on either background, techniques, or applications. A chart at the beginning of chapter one shows you which chapter focuses on each topic. Each chapter builds on the material presented in preceding chapters, so you should probably proceed through this book linearly. I review this book in the context of the table of contents:
   
   1. Introduction - Just performs an overview of the book.
   2. The Elements of a Parser - Explains what a parser is, introduces the building blocks of applied parsers, and shows how to compose new parsers from existing ones.
   3. Building a Parser - Explains the steps in designing and coding a parser.
   4. Testing a Parser - How to test a new language's features and also how to use random testing to detect ambiguity and other problems.
   5. Parsing Data Languages - Shows how to create a parser that reads the elements of a data language. A data language is a set of strings that describe objects following a local convention.
   6. Transforming a Grammar - How to ensure the correct behavior of operators in a language and how to avoid looping in a parser, which can follow from loops in a grammar.
   7. Parsing Arithmetic - This chapter develops an arithmetic parser. Arithmetic usually appears as part of a larger language.
   8. Parsing Regular Expressions - develops a regular expression parser. A regular expression is a string that uses symbols to describe a pattern of characters.
   9. Advanced Tokenizing - Describes the tokenizers that are part of the Java programming language as well as the customizable tokenizer of this particular book. Tokenizing a string means breaking the string into logical nuggets so that you can define your parser in terms of these nuggets rather than individual characters.
   10. Matching Mechanics - Explains how the fundamental types of parsers in this book match text.
   11. Extending the Parser Toolkit - How to extend a parser toolkit which includes introducing new types of terminals or completely different parser types.
   12. Engines - Introduces a logic engine, which is a piece of software that is able to return objects and groups of objects in response to a logical query.
   13. Logic Programming - Shows how to program with facts and rules.
   14. Parsing a Logic Language - How to construct a parser for a logic language. It shows how to build a parser for the Logikus programming language that was introduced in the previous chapter.
   15. Parsing a Query Language - Constructs a parser for a query language. A query language parser translates textual queries into calls to an engine. The engine proves the query against a source of rules and data and returns successful proofs as the result of the query.
   16. Parsing an Imperative Language - Shows how to create a parser for imperative languages. An imperative language parser translates a textual script into a composition of commands that direct a sequence of actions.
   17. Directions - Points out areas for further reading and programming.
   
   I used this book to create a parser for a visual language, and I found the instructions in this book very complete and helpful. I would recommend the following books if you are interested in getting deeper into the theory behind this book - "Programming Language Pragmatics" and also "Introduction to the Theory of Computation" by Sipser.



4. Before reading the book I was unsure of where to start. We had a large language, similar to Java which we wanted to parse, and we wanted to do it without using a compiler-compiler. By changing the author's design slightly so that the parsers were singletons and only a single assembly was ever created, we were able to parse large and complex files very quickly. More importantly, the design is such that making changes to your language is a snap. This was a must for us since our language is still in flux. If you have any kind of language you need to parse, Java is your implementation language, and for whatever reason you cannot use a compiler-compiler, then this is the book for you. The author's code included with the book will get you on your feet and running quickly. If Java is not your implementation language then keep in mind that the patterns taught in this book will work in any Object-Oriented language. Thanks to this book we now have an a new programming language which we have open sourced. Five-stars, thanks so much for the great book!



5. this review is intended to help potential customers better decide for themselves ; i was nearly dissuaded from purchasing a copy due to the reviews by inexperienced ( and apparently lazy ) programmers
   
   the provided code, and related concepts, are examined fully in the text. the code is so OOP-trivial ( this is a good Java design rather than rehashed procedural code clumsily ported to the OO-Language du-jour ) that anyone familiar with the basics of Java, C++ or C# should be able to compose their own library in a short period of time. in the preface the author suggests the reader be familiar with Design Patterns and UML, but he has included sections which address the minimal use he makes of UML. most 'somewhat experienced' programmers will be able to see through the scant UML diagrams to the underlying concepts they address, but he explains the notation anyway. as for Patterns, they are mentioned in passing but are not examined in any way which might hinder the uninitiated
   
   one reviewer laments that ''... the author's explanation of his code library is virtually non-existent -- you're going to have to figure out what he's talking about all on your own'' - this was not the same book i read. in addition to including comprehensive javadoc ( Java documentation in HTML format is provided on the CD as well as his web site, if you're buying a used copy ) to help guide readers interested in ''digging into his code'', the author walks the reader through the concepts presented in this book in an incremental and rather intuitive way. starting from ''the ground-up'' is not always a good idea, and i'm glad this author followed his instincts rather than the herd
   
   the code supplied is working code ( a feat almost unheard of today ), the examination of which helps to illustrate function better than any equivalent volume of text could. in fact the code is so well decomposed in terms of OOP that the text cannot fail to assist even entry-level programmers in the creation of their own parsers using the concepts presented. as for the difficulty of making oneself independent of 'his toolkit', i can only say that more than 95% of the class methods are under ten lines of code ( most are under six ), so it seems that anyone willing to apply themselves should be able to succeed in doing so ; especially considering the fact that his included code covers far more ground than a more sharply focused ( 'real world' ) implementation would ( meaning that, in terms of volume, you would only need to write or implement a tiny fraction of what is included with the book to satisfy any specific implementation )
   
   some reviewers have unambiguously reported putting the concepts presented in this book to work - and quickly - which says a great deal given the perceived complexity of the subject. indeed, creating a parser for a macro assembler for a particular embedded processor was so trivial ( thanks to the concepts in this book ) that i am confident modifying it for other targets will be trivial, as it was modeled after the author's OOP examples. having said that, the OOP perspective this author has provided seems the principal way in which this book is differentiated, making space for itself in an already crowded marketplace
   
   ignorance of the subject matter can be blamed for many of these negative reviews ; some reviewers are so unfamiliar with the subject matter as to call all compiler related concepts 'black-box'. each of the compiler books on my shelf examines a recursive descent parser, but in a far less practical way, and typically in pseudo-code ( including a prominent example claiming to use Java, but instead presenting what i consider to be nothing more than procedural C pseudo-code fragments ). BPWJ follows a preferable route, and anyone who has inordinate difficulty might better fail with a more abstract text on the subject before blaming this author for their own inadequacies
   
   one reviewer complains about the onus of being expected to participate in order to gain comprehension by stating ''To compound it, that code can be a bit perplexing when 95% of his variables have one-letter names -- it just isn't very readable if you're not already familiar with his ideas and approach'', which mystifies me, given that well over 95% of the class methods are under ten lines of code ( most are under six ) ... what kind of neurological damage would account for an inability to retain the type of an identifier within the span of six lines ?
   
   for example :
   
   Token t = new Token();
   Assembly a = new Assembly();
   String s = "some string given the highly problematic identifier s''
   
   should the time a programmer saves by using OOP be squandered on thinking up unnecessary, lengthy names whose lifespan is less than ten lines ? especially considering that peripheral vision will nearly always encompass the code in question, a scant few lines above ? now ... what was 't' again ???
   
   to round-out his list of disappointments, this same reviewer states ''The good news is that you'll be up and running and writing simple grammars and parsers in very little time. The bad news is that if you're working on anything [...] find yourself forced to peer into the black box to figure what the heck [his code] actually IS doing'', with which i agree - the code included is not geared to any specific project you may have in mind ; rather it is nearly exhaustive so that a working example for you to study is always at hand. warning : you will need to participate if you wish to make use of what you can learn by studying this book. if you are willing to do that, success can be yours ... passively being granted mastery in any area of programming ? i'll take the Vegas odds on that !
   
   another reviewer makes several complaints ... in order : ''(1) ... everything is so dependent on the included framework makes it difficult to learn from. (2) I think the best programming books teach you how to build step-by-step from the ground up. (3) Instead, this book expects you to immerse yourself in the code first''
   
   (1) the code, and related concepts, are examined fully in the text. the code is well designed OOP, rather than a ham-fisted port of procedural code, meaning that anyone with minimal experience in any OO language should be able to write their own, rapidly turning his ''fascinating ideas'' into a coded reality all their own
   
   (2) as for ''learning from the ground up'', the text progresses slowly, beginning with a general overview ( to help readers get their bearings within the overarching conceptual framework being presented ) and moving into actual, albeit initially trivial, examples ( as any good programming book should ) and progresses from that point with chapters focusing on discrete aspects of the subject, as well as considering various implementation domains
   
   (3) good code ( especially *working* code ) helps to illustrate function better than any equivalent volume of text could. having said that, the author forces no one to immerse themselves in code. naturally code is presented - this is a programming book after all, and not a purely theoretical one. the presented code is so well decomposed ( into OO Java ) that the text cannot fail to guide a programmer in the creation of his own parsers using the concepts presented ... so making oneself independent of his 'framework' seems trivial enough, given, again, a minimal competency in nearly any relatively modern OO language. as already indicated, the code is slowly examined initially, and given the brevity of procedures ( mentioned above ) it seems reasonable that anyone willing to apply themselves should be able to master the concepts presented in this book
   
   i cannot abide an above average programming text being trashed by the inexperienced, who might have anticipated possessing ''mad 3l33t haxor skilz'' after flipping through the pages - reviewers reporting having used the material presented in this book tell us more than any failure ever could
   
   warning : anyone who considers studying clear Java code difficult, or is unwilling to expend the effort needed to succeed in learning a new task, should avoid this book and every other book on the subject. perhaps IDG should be made aware of the sales they could expect for a new 'Dummies' title. then these unhappy campers could enjoy cartoons ( ''to spice things up'' ) and be given strained examples, twisted for the sole purpose of setting-up some moronic joke
   
   one note about the code : it was written under an early version of Java ( the book was published in 2001, remember ) and to bring it up to current standards will require hitting the files over the head with a compiler. NetBeans quickly directed me to add annotations, mostly @pragma, which took a few minutes. not a big deal, but now you know
   
   OK, now it's up to you to choose

5 comments about The Art of Java (One Off).

1. I enjoyed tinkering around with the code examples in the book. Lots of neat ideas and the book filled in the gaps where I was curious about how some things work.



2. I've buyed the book today ( in spanish ), and, even not being a skilled Java programmer, I've enjoyed the first chapters. It resembles me the excelent work that Herbert Schildt does in Dr. Dobbs Magazine, a lot of years ago ( sorry, Herb ), and when I saw the getToken() method into the code, this inmediatelly remembers me the "Build your own C interpreter" article, which I've loved it. After five years of "boring" network's administration, I've make the decission of to get more involved into Java developement, and take the Herbert and James's book was the right choice to me. By the way, this is not a beginner's book, but with a little effort, and a middle knowledge of Java and OOP, you are on the way. The best money I've spended.



3. I have nothing to say except thanks.With the help of this book,my skill of java problem had been improved to a higher level.I will recommend it to my friends who are studying java and also are meeting the problems that I met.



4. What I liked about this book was the fact that the author not only implemented the back end code, but showed how easy it is to put a quick Swing UI on it. The ability to write a complete, good looking application is often missing in most books. I think this should encourage more people to write quick UIs for the various utilities they code in Java. It encouraged me to go back to some old command line programs I use and throw a quick UI on them. Of course, that's not the point of the book. His intention was to show how Java can solve traditional computer science and IT problems. He succeeds at that.
   
   My only complaints are:
   
   1. the book hasn't been updated to Java SE 5 yet.
   2. the use of Swing by the author is incorrect in my opinion. I think there's a few times the author doesn't handle the event dispatch thread correctly. This could send people off in the wrong direction with Swing.
   3. the coding style doesn't exactly match the Java Style Guide published by Sun. Some people might like this, but I think it's a problem with many books.
   4. The code in the book is not syntax highlighted. Most editors do this quite effectively and I think more books should start doing it.



5. I've never quite been able to figure out why this excellent little book never caught on. Over the years, Herbert Schildt has been one of the most excellent writers on computer science and programming that I have found, and this book is no exception. Both the narrative and the code are excellent.
   
   The only thing that I can figure is that because this book does not target a particular audience - say those interested in enterprise applications for example - that it never really sold well. It is true, Mr. Schildt is all over the map in his applications - with such varied subjects as a recursive descent parser and also a language interpreter from programming language theory, from the world of web applications a download manager and also a web crawler, and from the world of artificial intelligence a problem solver. To me, though, that is part of this book's appeal. However, if you did not have an academic computer science background I can see how you might not be interested in the programming language and AI parts of the book.
   
   I highly recommend this book for anyone who wants to become a better Java programmer and does not mind spending some time looking at applications that might not be of immediate need to them. Especially if you have an academic computer science background and already know something about programming language theory and artificial intelligence, this book should be very interesting and very helpful.

5 comments about Practical mod_perl.

1. Practical mod_perl is a doorstop sized volume that provides more information on using mod_perl than you ever thought you needed.

   The almost 900 pages are divided into five parts and a bunch of appendices. Part I, "mod_perl Administration" covers building, configuring and installing mod_perl, followed by some Apache details and an 80-page guide to coding with mod_perl in mind. Part II, `mod_perl Performance' deals with ways of getting the best out of Apache and mod_perl, with a little about security. Part III deals with databases, including persistent connections and data sharing. Part IV is a great guide to debugging and troubleshooting. Part V is a brief look at Apache 2 and mod_perl 2.

   The appendices are useful. The first is a short section of around a dozen small `recipes' for performing various tasks using mod_perl. I found these a good base for more complex tasks, particularly when combined with examples from elsewhere in the book. The second is a list of Perl modules that extend Apache and mod_perl with a brief description of each. The third gives some strategies for providers wanting to host Apache with mod_perl. The fourth and fifth give good overviews of the Template Toolkit and AxKit, an XML application server built on mod_perl.

   The book is readable, tending towards heavy writing and certainly dense, but I didn't feel this was a problem in a book meant for a fairly advanced audience. I think you'd want to be a fairly good Perl programmer and well versed in Apache before needing this volume and shouldn't expect to be spoon fed. I thought it well written.

   In a book of this size you expect to find a lot of example code, and you won't be disappointed. The book is peppered with short Perl examples and example command lines and configurations, all well explained. The one shortcoming is that there aren't many examples of full-blown applications where you can see everything discussed and have it explained all in one place. I would have appreciated some more of this, the examples tend to be on the short side.

   This book sits well in the marketplace. It provides more details on running, installing and configuring mod_perl and Apache than mod_perl Developer's Cookbook (and also delves more into the reasons for doing something one particular way and much more help on debugging), though the Developer's Cookbookbecomes a good companion to this volume as it provides a lot more in the way of examples. For those that want to get deep into the high end of mod_perl there is Writing Apache Modules in Perl and C, which is at core a good book on high end mod_perl programming.

   O'Reilly have their usual website with Table of Contents, an example chapter, and errata. The authors have their own website with some of the same information and all the code examples from the book as both individual files and one 40k tarball.

   I would recommend this book to anyone who administers and writes for mod_perl, it fills the missing pieces in mod_perl Developers Cookbook and is a good companion volume to it.




2. At almost 900 pages, this is certainly the biggest book on mod_perl that has been published so far. In my opinion it's also one of the most useful.

   Stas Bekman and Eric Cholet are two of the best-known and (probably more importantly) most respected names in the mod_perl community so you can be sure the the information you get in this book is going to be top quality.

   Part 1 of the book is about mod_perl administration. It starts with an overview of what mod_perl is and how it relates to CGI and the Apache web server before going into a chapter which gives a quickstart guide to installing and using mod_perl on some of the most common platforms. Chapter three then goes back over the installation process in far more detail. Chapter four explains how to configure mod_perl in various ways and chapter five cover monitoring, upgrading and maintaining your mod_perl enabled web server. Chapter 6 is full of advice about how to write Perl code that takes advantage of mod_perl's features.

   Part 2 is all about mod_perl performance and contains chapters about benchmarking and tuning your server. I found chapter twelve to be particularly useful as it discusses a number of useful strategies for splitting server load between a mod_perl server for dynmaic content and a "plain" (non-mod_perl) server for static content. Other chapters in this section cover other strategies for improving performance by tuning Apache's configuration, changing your Apache and mod_perl build options and being cleverer about the HTTP headers that you return.

   Most dynamic web sites have a database involved somewhere so part 3 covers using databases with mod_perl. Part 4 is all about debugging and troubleshooting your mod_perl server. Finally, part 5 looks at what has changed with the release of the forthcoming mod_perl 2.0.

   And this isn't just theoretical stuff. The two authors have been involved in developing mod_perl for a long time but they are also mod_perl users. You can just tell from the way they write that the problems they discuss are problems they have dealt with. This is the voice (or, rather, voices) of experience.

   A lot of the text in the book is based on the mode_perl guide which has been available on the web for some time, but all of the content has been revisited, updated and expanded. This book is not really in competition with books like The mod_perl Developers Cookbook or the older Writing Apache Modules with Perl and C as those books largely concentrate on how to write code for mod_perl whereas the emphasis in this book is on configuring and administering a mod_perl server.

   And if you are the administrator of a mod_perl server then you should really consider adding this book to your library.




3. This one of the most informative O'Relly books by absolute metrics: almost 1000 pages packed with useful information. It pretty much covers all bases: from porting existing CGI scripts to mod_perl, to architecturing busy websites for optimal performance. One of the authors, Stas Bekman, works on mod_perl full-time, so this is it's basically as authoriative as it gets.
   
   The only drawback of this book that I noticed is that it sometimes gets too heavy on basic Perl or sysadmin stuff, making the experienced developer flip pages in anxiety. Also, some parts are too similar to online mod_perl documentation (which is not surprising as it's written by the same person).
   
   Still, this is the first book with substantial mod_perl2 coverage, and probably worths buying for this reason alone. All in all, if you're coding mod_perl for living, I think you owe it to yourself to have this book in your O'Relly collection.



4. This is very practical. It starts with a lot of information on how apache works and how mod_perl and other modules intract. Then, after learning that information, it shows how you can use the knowledge to signficiantly improve the performance of your mod_perl apps.
   
   In addition, it gives valuable advice on how to troubleshoot fustrating issues with mod_perl & apache.
   
   This book should be required reading for anybody doing mod_perl work.



5. We have been using perl for our server side programming for over 6 years now. During this period, the popularity of our web based applications has grown. To deal with the growth, we have had to optimize the programs, as well as look at alternate server setup strategies. We acquired this book as it covers both the topics of our interest -- mod_perl for efficiency of perl programs and setting up servers that use mod_perl.
   
   In the course of the optimizations, we have gradually moved into the mod_perl world. It has yielded significant performance improvement, probably making our web application more than 50 times as fast. "Practical mod_perl" served as a guide while we carried out this transition, which has resulted in dramatic savings in our server costs. I have no hesitation in saying that this wonderful book is perhaps the best investment we have ever made in technology.

No comments about Internet Multimedia Communications Using SIP: A Modern Approach Including Java® Practice (The Morgan Kaufmann Series in Networking).