5 comments about Teach Y ourself Java.

1. A few months ago I decided to teach myself Java. I purchased a few books, and I am happy with my purchase of this book, "Teach Yourself Java".

   After reading more heavy, definition type programmer to programmer java books, this book has been very helpful to return to for a less 'wham to the head' over-view and tie-together.

   On the other hand, this book certainly won't cover it all. To learn java, you are going to need to simultaneusly read multiple books.

   For someone looking to learn java, with little java experience, this book is not a bad purchase.




2. First of all, this book is very well written. The examples are short and very concise. I personally learn by typing the examples and I like them to be short and to the point! This book is also very good from the aspect of not holding you back. It covers very basic control structures through sockets! I also like the fact that there are 394 examples you can download from the web easily. This is definately more ecological. Now some bad ... 1) The 394 examples that can be downloaded are not categorized! BUMMER. You must sift through all of them to figure out which ones apply to your current chapter, although some titles do make this easier. 2) If you are like me and constantly use the index to search for stuff ... you probably won't like this one. 3) Out of 707 pages, 170 of them are dedicated to answering end of chapter questions. That is 24% of the book! I don't consider this a plus. I would have preferred to download answers instead of downloading examples! SUMMERY: This book teaches programming in JAVA without getting bogged down in all the available pre-written web stuff ... although it does cover some web applications. It doesn't hold you back and doesn't assume that you already know a programming language. If you do know C++, you can navigate this book rather quickly and be up and running fast! I'm very happy with this book overall.



3. Mister O'Neil has chosen very effective strategy. Every chapter composed of a short theoretical introduction and working examples demonstrating the theory in practice. Definitely my level of Java programming has been considerably improved after reading this book. I would recommend this book for those readers who want to step up from beginning to intermediate level of Java programming.



4. I was having a hard time understanding Java Exceptions/throw/throws. I read the chapter on Exceptions in this book. The chapter was full of short code examples that makes it easy to understand. I also loved the pre/post quiz and exercises. The writing appears to be very good.
   
   The best Java book for beginners has to be Kathy Sierra's Head First Java. Although, Some think that that should be used as a supplement book. The second best beginner's book is Herb Schildt's beginning java. I would place this book 3rd. I would not purchase Ivor Horton's book or the Java in 24hours. However, Murach's Java 2 is an excellent combination of reference & learning material.



5. This can't be the best book to choose for teaching yourself Java. It's intended to be a learning guide, but it's presented more like a reference. Recognize that part of my frustration is due to my unfamiliarity with object oriented languages. I'm just learning about OOL's, following a long dormant programming history from the 80's, the pre-OOL era. OO programing is significantly different than what I used to do. I'm fascinated with it, but it's going to take some time.
   
   The other major part of my frustration is that much of the explanation text in this book just ain't plain english. It sounds more theoretical. If you're already familiar with OOL's, it probably wouldn't be such a burden. But it's like jumping right into the deep end for me.
   
   I agree with the prior comment that pointed out that the fun stuff (GUI) is at the end. I know you gotta crawl before you can walk, but I think it would keep people's interest better to do something practical and fun along the way.

4 comments about Oracle XSQL.

1. The author has done a excellent job. It describes about the important pieces in a dedicated chapter - XSQL architecture. After that he delves into SQL, PLSQL, XSQL , XSLT. The best part is chapter 14 on Building XSQL web applications. This explains how all the above pieces are put into a working model. The material is written keeping oracle 9i in mind. As a whole, I felt very comfortable reading the whole book.

   Especially for database developers who come from sql, plsql background and are trying to get into web development world ( without the hassle of learning Java Servlets, Jsp etc ... ), I would definitely recommend it.




2. This book describes a new and interesting approach to some well-known web development problems. Though not all of the technologies described are mature (yet), they are largely standards-based and likely to grow in popularity in the coming years. The author does a good job of showing how several different technologies (SQL, XML, XSLT, HTML and others) can be focused into a coherent whole. Probably not for beginners, but anyone with web development experience should be able to learn a lot from this book.



3. Mike has done an outstanding job with a complicated topic, a remarkable achievment from a Carolina fellow!



4. There are few books out that deal with Oracle Text and XSQL. Applying the methodologies, practices, etc. I found no need to search for another reference.

5 comments about J2ME Game Programming (Game Development).

1. It's a great book! I recommend this book for people who want really to learn j2me.
   Congratulations Martin



2. I bought this book because I'm looking to get into J2ME game development. There are VERY few books on the subject, and this book (although written for MIDP 1.0 and not the newer MIDP 2.0) seems to be the one that everybody recommends.
   
   I've worked up through the examples in Chapter 5 and so far, the content is great. If I were just grading on content then I'd definately give it 5 stars. What I'm finding I'm having a huge problem with about this book is the staggering amount of errors in the code. I simply can't believe that a book could be released to the public (and have the publisher expect consumers to pay money for it) with so many typos. So far EVERY SINGLE example I've entered and ran has had errors. Not syntactical errors (so you can't chalk it up to "I just didn't type the code in right"), I'm talking LOGIC errors that either cause the sample applications to run incorrectly or completeley different than how they are described in the text (in the case of the first example in chapter 5. Its practically an entirely different application than what the text says its supposed to be).
   
   Whoever proofread this book at Thomson publishing must not have been a technical person who just glossed over the code and focused on the content of the text. But most of the blame has to fall on the author's shoulders for writing and releasing code that doesn't work right in the first place...
   
   Either way, I really can't say that I can encourage or endorse this book so far.
   
   I hope that when I get into the main focus (after the first 200 pages of the book which rehash the same old J2ME techniques that you can read online or get from a J2ME book) that the 2 example games you write in the book from start to finish do not have so many errors.



3. Some months ago I did an exhaustive research on books about J2ME + MIDP1.0.
   (Although MIDP2.0 or Symbian is what you need to know to develop for the latest handsets, the big market out there is MIDP1.0)
   Comparing reviews from this site and citations in expert forums like Nokia Forum, it was soon clear that this book was a winner.
   
   This book is a heavy one. You will dedicate a complete month to master it. And a second month to develop your own game engine based on the one proposed in this book.
   What I liked most about this book is exactly that. There are no open-source or cheap game engines for J2ME+MIDP1.0 around. You have to assemble your own! And Wells does a very good job explaining you every decision he made while developing the framework for the game presented in the book.
   More precisely, the book presents two games. The first one is a Frogger clone, done in a pretty simple way...after the first chapters learning J2ME he shows you how to code a prototype of a game. But developing a real game is a much more involved task. That's he spends the next 300 pages explaining you how to develop your game in a professional way. Perfect!
   The book also has chapters on marketing your game and sales aspects. It also has a brilliant chapter on isometric games and a -let's say- experimental chapter on a 3d technique known has raycasting (you probably wont use it but its very interesting to read anyway). It also has an introduction chapter to MIDP2, explaining you how some of the decisions he made in the development of the game where influenced by the migration path logic to MIDP2.
   A word of warning: you will find some typographical mistakes in the book. There is even an example code at the beginning which is misplaced.
   But you probably won't type anything from the book, everything you need to try the examples is located in the CD.
   The book is in a way outdated. It explains how to code in a IDE like Eclipse and compile versions for the various handsets using Ants. Today we use Netbeans which does that transparently. Anyway, its good to know how is it done in the inside.
   I finished reading this book 2 month ago and I still use it as reference while I'm developing games.
   
   If you just want to know about mobile game programming, don't buy this book, it's too hard and long for you. But if you want to develop games professionally, this is the right book for you.



4. This book will show you how to code games using J2ME, with a clear focus on creating games for mobile phones. The chapters in this book are intended to be read sequentially, so if you're already familiar with the content covered in a particular section, you should skim over it rather than skipping it entirely. The author assumes you're already familiar with Java, or at least another object-oriented programming language. You don't need to be an expert, but you do need to know the basics. The book requires an understanding of rudimentary mathematics; however, the toughest level you get to is simple trigonometry, and even then the explanations are fairly detailed. It is also assumed that you're familiar with basic PC operations and can take care of environmental details such as downloading and installing software. Sometimes the language of the book is just a little too cute ala Andre LaMothe, but the information is all there.
   
   Part I is an introduction to J2ME, including its origins and current position in the marketplace. This section also takes a look at a range of typical J2ME devices and mentions the sort of gear for which you'll be developing.
   
   In Part II you'll grab all the tools you need and set up your environment for development. Then there is a review the APIs provided as part of Sun's J2ME SDK, along with the added features available with device-specific libraries. At the end of this part, all these tools are put into action with the creation of a small action game called "RoadRun" that presents the player with the challenge of helping a little wombat across a busy highway. The game is very simple and small, but it does illustrate some key points of J2ME game coding. I thought it was a good beginning example.
   
   Part III covers real project development. There's a discussion of how to refine game ideas into project plans before embarking on the development of a full-scale action game called Star Assault. Then, through nine chapters the book covers all aspects of developing a commercial-quality game, including graphics, physics, environments, front ends, device-specific customization, and finally localization. This is the real meat of the book for people interested in game development, but even here there is nothing particularly difficult going on.
   
   Part IV moves into the world of marketing and publishing games. This section looks at how to create marketing material to promote your game, as well as how and where you can earn revenue. This material is all pretty subjective.
   
   Part V takes J2ME game development further by covering the features available in MIDP 2. The author shows how to create different types of games by developing both an isometric and 3D ray-casting engine. Finally, the book explores networking with MIDP and how it can be utilized to create multiplayer games.
   
   All in all, this is a pretty good introduction to J2ME and to writing games using it. Just don't expect anything advanced in the arena of mathematics or physics, and get used to sitting through the author's "surfer dude" narrative style. Plus, although it is mentioned, there is a lack of sufficient information on MIDP 2.0 due to the date of publication.



5. I purchased this book when I was doing my final year project on J2ME. Although I was even new to J2SE I started coding in J2ME since I had to finish the project, using the internet sources and some introductory books to J2ME. After lots of disappointment in understanding J2ME I found this book and in a very short time I built up my knowledge of J2ME to write a 4000 line,object-oriented,well designed J2ME application. The book was not a game book to me, it was a complete source of J2ME.

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 The Java(TM) Developers Almanac 1.4, Volume 1: Examples and Quick Reference (4th Edition) (Java Series).

1. This book condenses the vastness of Java 1.4 GUI classes into a hefty 1000+ pages. It's divided into 4 sections. Part 1 contains examples of usage of the different classes, with a focus on how to accomplish something specific, from creating a JLabel component to playing MIDI audio. Part 2 contains detailed information about the classes themselves, and contains references to code examples from Part 1 to see how the class is used in code. This is essentially the documentation that SUN's website provides, but in my view, it's more condensed and the references to code are a bonus.

   Part 3 contains topics on the transition of Java from 1.0 to its current incarnation, detailing deprecated classes, new classes, etc. Part 4 is the cross-reference section, where if you know the name of the method, but not the class that contains that method, you can simply look it up. There's much more than just methods, though; subclasses, descendants, fields, and "extended by"'s are also some of the details here.

   This book is quite an impressive achievement, and I hope to get my hands on Volume 1 sometime soon.




2. I picked this book up a couple months ago and can't imagine how I got along without it before. The first section includes simple examples of common uses of the java packages. I find this extremely useful. There are realms in Java where the intricacies often slip my mind, particularly in java.io, and the small examples of these packages shown in section 1 serve as a perfect reminder of how exactly to accomplish my task.

   Section 2 is the meat of the book and includes a reference to the classes and their members. This is similar to the online API, but lacking the descriptions for the methods / classes. This is strictly a quick reference of the methods, their arguments, return types and modifiers, and the variables belonging to a class. For a description of every method, use the online API. Personally though, I find this reference quicker to use than the online API when searching for a particular class. It probably comes down to personal preference, though.

   Sections 3 and 4 I honestly haven't found a need for. The first two sections alone are worth the (relatively) [inexpensive] price of the book.

   For reference, my qualifications include Sun Java Programmer Certification 1.4 (Passed with an 86%), Graduated Magna Cum Laude from UMass Dartmouth with a Computer Science degree.




3. It's a very useful book, specially when you need to do some code but you don't have time to spend over the web. It's very complete.



4. I use the online version of this book very often. The print edition is a very great asset on any Java pro's desk, gives quick reference and correct usage examples of Java APIs, which are too numerous to remember for any one.



5. A fantastic resource for java programmers. Easy access to class and interface usage. A must have

1 comments about Object-Oriented Design with UML and Java.

1. Great book, however we're using EclipseUML which seems to be more widely used now. It would be nice to be written with that program in mind. Also would be nice if it was converted to American English. Some analagies are hard to understand if you're not familiar with Brittish colloquialisms. Also, author uses Textio class to do outputs. Why not just use the System classes? Seems unnecessary to me and an extra level of confusion for beginners.

5 comments about Professional Java Security (Programmer to Programmer).

1. The cover of this book has photos of the authors, who have the boyish good looks of candidates for a 1990's boy band. The contents of the book belie the apparent youth of the authors. They both know the topic well and how to explain it. The not only know about how Java security works now, they also know about the quirks and peculiarities of the history of Java security. They don't seem to mention it anywhere in the book, but the authors created a nicely modified version of the GPL version of the Terraterm ssh client. Having read some of the Terraterm code I admire them for even making sense of it.

   Unlike many of the Wrox technical books this is not a million page, multi author, multi topic tome but 520 pages that keep strictly to the title topic. There is plenty of information on the net about Java security but it is often hard to find and not explained well. This book goes right from the basics of explaining algorithms to giving substantial code examples for creating secure tunnels to manage database connections. I have read about public and private key algorithms several times in the past but the analogies used in this book really re-inforced my understanding. They explain the ideas behind some of the different encryption algorithms by using analogies with the characters in Hamlet the Shakespearean play. They go through the various permutations of how Hamlet could send a message to the king of England using a box locked with various key combinations. The analogies get longer and more involved with each algorithm, but they worked well for me.

   Chapter 10 has a long example and explanation on how to create an SSL tunnel server, whereby they JDBC calls are redirected between a client machine. The idea is that you configure your client system to refer to a database on a local machine but the SSL tunnel server intercepts these calls and transmits them over the secure connection to the machine running the database. A matching program on the remote machine then redirects the calls to the actual database. This is a very similar concept to using an ssh tunnel, but you can run both portions on any machine that has a java system. This is a little like having a Java based VPN.

   In one of my jobs we used the example code as the basis for a system for synchronizing files and directories between two different machines. This was an alternative to using rsync over ssh, as it it gave us operating system portability "out of the box". If we had not had the code from this book for the key ideas it would have either taken much longer, or we probably would not have started it at all.

   One thing that would be good in a revised version of this book would be a step by step guide to installing SSL in Tomcat. It is not hard, and you can find how to do it easily on the net, but many people who buy this book will want to do it.

   If you are thinking of putting Java applications on the web you will want them to be secure. Knowledge is the key to security and this is the shortest best informed route that knowledge. You probably need this book.




2. I've never worked with security before, and found this book to be a GREAT introduction. Only under-average chapter is the one on JAAS. Furthermore a description of every term in the back of the book would have been great (believe me there's a lot of new terms in security for new newbie).



3. This is a very good book to get you started on issues such as encryption, public/private keys, message digests, certificates etc. The authors do know what they are talking about and I enjoyed going through it.

   At the same time, I sometimes found repetitive text and code examples that are too elaborate. I find that most books these days try to cover too many topics and are unable to do justice to all of them. It almost seems like an obsession to achieve a certain number of pages or the buyer won't notice the book on the shelf. I'd probably blame the publishers and editors for that trend.

   I would have preferred if the authors had added more depth than breadth to the book. For instance, I would have preferred if they had stuck to cryptography and skipped other aspects of java security. They possibly could have gone into further depth (behind the scenes) on the Java classes and their usage patterns. Also they could have dedicated a whole chapter or appendix to JCA and JCE, compared to the few pages they did.

   But do not get me wrong, this is an excellent book which could have been made better by shortening some sections and elaborating some others.




4. I have one last class to finish a graduate degree in Computer Science and a substantial paper is one of the requirements. Since I have taken several classes in security and a passing interest in Java, I decided to look into Java security constructs. I picked up several books for this and I have to say that, despite all of the other reference materials at my disposal, I kept coming back to this book! First, it is well written. IMO, anything that is going to be published should be proofread and grammatically correct. Second, I expect the examples to work given a similar environment. This book does both. I have ran 4-5 examples and they have worked as advertised. The writing is clear and concise. Professionally, I work with databases and I appreciated the coverage of database and JDBC security.
   The only other book worth considering is the Inside Java Platform2 Security book by Li Gong. An excellent read. Pick them both up!



5. Hi,
   I'm a mid-expert in java, but did not know much about security, only by words.
   I've decided to try a book that would give me an overview of the topic but at the same time I wanted a book that would "dirty" my hands in enough code to be able to try out what I was reading.
   I consider this a perfect book to cover the topic for people that loves to "play" with java code.
   Max Pellizzaro
   http://www.maxpellizzaro.com

No comments about The Definitive Guide to Grails, Second Edition (The Definitive Guide).

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.

5 comments about Algorithms in Java, Parts 1-4 (3rd Edition) (Algorithms in Java).

1. This is an excellent book. Robert does a great job leading you through the fundamentals of algorithms and algorithm analysis. The visualizations are very well done. In particular the sort algorithm coverage is very well illustrated and described.
   
   The best parts of the book are sorting and searching. A wide variety of algorithms are explained and demonstrated in detail. The code is solid and the writing is very good.
   
   This is the set of Java algorithms books.



2. I have the dubious distinction of having taken a class that used this book as it's central text. The illustrations are great. The explanations of algorithms and general algorithm design concepts are clear. The code, however, is neigh unreadable in a lot of places.
   
   This was a huge problem for me, as I had a lot of difficulty seeing a clear mapping from the concepts explained to the code examples. Sedgwick's code examples often build on previous ones to the degree that they are not understandable on their own (this is especially true with the graph algorithms in part 5). If you try to use this book as a reference you will find yourself digging much harder than you would like in order to understand code samples that are actually quite simple. You could see how this might make a programming based course difficult.



3. Another reviewer gave this book a one star rating citing that the book falls short on practical examples.
   
   In light of that, I'm concerned that other readers might overlook what, in my opinion, may be one of the most comprehensive and well written introductions to graph theory and graph algorithms that there is, and certainly one of the best that I have personally come across thus far.
   
   Recently I took on a project wherein I needed to solve a shortest path problem for a particular kind of graph. I am not a specialist in graph theory and needed practical information that I could utilize immediately. For me, this book fit the bill and was a godsend.
   
   It is true that I already had a practical real world application in mind before I even knew of this book but this book has exceeded both my needs and expectations.
   
   It is easy for me to understand how you may not initially see the practical value of the information being presented, if the sole reason you're studying this book is simply because it is a part of your college curriculum. I think, however, that that does not lessen the value of the book, especially for those of us who do have practical applications for the material.
   
   If you are looking for an informational resource for a real-world problem related to graph theory, you would do well to consider this book.
   
   The book does actually open by citing several practical examples of areas where these algorithms can be applied, although, perhaps the reader who assigned the one star rating may have appreciated and benefited from a case study.



4. I give this book 5 stars for everything but the Java code, and 2 stars for the Java -- 4 as a weighted average.
   
   Regarding the code, the authors flout standard Java conventions, which makes reading the Java code tedious for anybody with a lot of Java experience.
   
   Things like uppercase fields and parameter names are only minor annoyances, to be sure, but so is ReAdInG TeXt LiKe ThIs AlSo JuSt A mInOr AnNoYaNcE, and there is no reason to not write code using the conventions of the language you're writing in rather than the conventions of the language your book was first written in or your own arbitrary conventions.
   
   Having said that, I have no other gripes, and the book has much else to commend it.
   
   The prose is very clear and exact. Whenever I found some description or definition confusing, a careful re-reading and consideration of every word included always cleared up my misunderstanding. This is not one of those books with sloppy definitions that confuse you if you really try to understand why every word in a definition is included.
   
   The typesetting and typography is very well done: the pages are easy to read, with good contrast, and there are large margins for writing notes, summaries, and the like. There are many very helpful diagrams that illustrate pictorially the data structures and algorithms under discussion. Lastly, the exercises are at just about the right level for the intended audience.
   
   In summary, if the CJava code were replaced with pseudo-code or idiomatic Java, I would give this my highest recommendation, and even with the many C-isms, I still very much enjoyed and benefitted from reading it.



5. [...]I have at least half of both volumes, and it really seems to me that there are real problems here with the exposition. Let me see if I can elaborate.
   
   Here is an actual sentence from the book-
   
   We construct a symbol table that is made up of an ordered array of keys, except that we keep in that array not the key, but an index into the text string that points to the first character of the key.
   
   Consider that there are two possible conflicting meanings of the sentence fragment :
   
   ...an index into the text string that points to the first character of the key.
   
   In the first meaning, there is an index that points to the first character of a string which string has the property that it, in its turn "points to the first character of the key". (a String is engaged in pointing and so in the index.)
   
   In the second meaning, there is an index that points (into) a text string and in fact that index points into the FIRST CHARACTER of that text string, and that first character the index is pointing to, well, that is the also first character of the key. (only the index is pointing; the string pointeth not.)
   
   OK so how do you describe what's missing here? At least the disambiguating use of commas, at least. It's as though he likes to write in subordinate clauses, but thinks it's economical to leave out the punctuation (which, it is true, there are no hard and fast rules for).
   
   So it's just sentence after sentence after sentence like that. Sometimes you can understand what he's saying. Other times, really you just can't. IF each sentence has 2 (or more!) possible interpretations, and each sentence depends on your understanding the last (as is the case- he never says the same thing in two different ways), then you get this ambiguity growing at the alarming rate of x^2, an observation the author might enjoy.
   
   As the other reviewers said, the code is a C programmers attempt to write in Java. This never goes well.....
   
   
   But the fact remains it is still the most accessible and thorough coverage of some of its subjects. So what are you going to do?
   
   I don't get the impression he is deliberately bartering in obscuratism, it's just that this book suffers (and so will you) from a lack of editing, a lack of reviewing and feedback by genuine, unaided learners etc. etc.
   
   You might want to check other people's lists for alternatives. Or not. Perhaps that passage was perfectly clear to you.