5 comments about Designing Virtual Worlds (New Riders Games).

1. To begin with, this book is not a programming book. There is no code, no discussion of VRML, MPEG-4, or X3D. Instead, this book stands back and takes a "big picture" look at the design of a virtual world from the viewpoint of systems engineering, social engineering, philosophy, history, and psychology. Ethical considerations are even tossed in for good measure.
   The book starts out with chapters on the history of virtual worlds and the cultural influences that affected their characteristics. Next, there is a fly-over view of the "production line" of building a virtual world. Bartle then turns his attention to the players - who they are, what they want, and how a virtual world can meet their needs. World design is examined from the standpoint of virtual geography, virtual world citizens, and finally the physics required to implement your world. Chapter 5 is about the specific sociology and physiology of the virtual world - skill levels, individual characteristics, how virtual inhabitants divide themselves into groups, combat, and even the meaning of death in the virtual world. The final three chapters are very philisophical in nature. Chapter 6 is basically a liberal arts syllabus through the prism of virtual world design. The last chapter, on ethical considerations, talks about censorship, and also looks at the player as a person and how game playing in virtual worlds can hurt more than help some kinds of people, particularly those prone to addiction.
   Bartle's social commentaries may be a bit long-winded for some people, although I found them interesting. Some readers may also be somewhat frustrated by the fact that the book talks more about what can go wrong in the design of a virtual world - overly complex and static story arcs, characters that players do not get invested in, characters in which players get too invested, etc - than what can go right. I really enjoyed the book, mainly because it moves the focus of the potential virtual world designer from the artistic and technical viewpoint to the player's viewpoint - why they plays games, and why a player would pick your game versus someone else's game.



2. You're getting it straight from the horse's mouth since this book is written by the grandfather of the modern MMORPG.
   Rest assured - if you are a game designer, developer, or just love reading about game theory, this book is worth every penny.
   
   I have read many other books on the subject and not one of them are packed with as much depth, knowledge, and wisdom. Bartle covers every avenue that a designer needs to consider in order to be successful. This book will help you and your team create an active, emergent virtual world.
   
   As a game developer, I learned many valuable lessons on what made other games lose subscribers, or worse -- catastrophically fail.
   
   
   Richard Bartle's writing style is very creative and detailed, and like his games, it gives you the 'just one more page' syndrome. For example, in this book it mentions how often a player must be rewarded in order to retain interest. He uses this same technique for writing by giving you something insightful to read atleast every 10 pages.
   
   
   Bartle has covered all the bases. Designing Virtual Worlds is a great book, very entertaining. I give it 5 out of 5 stars - a must read.
   
   More than 700 well-written pages packed with valuable insights, and it still leaves you begging for more.



3. Covers all the aspects of virtual worlds from a psycological perspective; the intentions, the types of virtual worlds.
   Doesn't include indepth technology and the development issues related to designing virtual worlds
   Good primer on virtual worlds.



4. This book taught me the theory behind Virtual worlds and I beleive nearly everything I read in this book.
   
   I didn't simply believe everything because it was a published book, I beleived it because Richard used examples from real games. With all the experiance Richard has you would expect him to have learnt everything the hard way, he has but he's also smart enough to realise that sometimes you can learn from others mistakes instead of making them yourself.
   
   The book is aimed at the 'Dungeons and Dragons' (and most of his examples are) type of game but there is no reason the information cannot be used in other genres.
   
   The most amusing part is how right he can be.
   Richard states that 'you cannot allow players to carry items over from the Beta testing to the online game, even though your players will try to convince you otherwise'; something I didn't really think and didn't really agree with.
   My family and I were all about to join 'Pirates of the Caribbean' when it started; when the announcement was made that players form the Beta test would be allowed to keep items my daughters asked what a Beta test was, I explained and now they don't want to play as they consider that to be cheating. We have all decided not to play.
   
   Learn from others (like Richard) or pay the price.
   
   James



5. Mr. Bartle's writing is precise and his facts carefully researched, even the ones he experienced himself. This is a huge, superbly constructed history of the tools and philosophies developed over the years in experimental and commercial development of online virtual worlds. Because of Mr. Bartle's personal knowledge as a long-time designer and his sharp memory for the significance of trends and details, this book will raise anyone's appreciation of whatever virtual worlds one comes across on line or on disk, whether they be famous commercial ones or those developed by enthusiasts for their own pleasure. I would think it would be a must read for gaming students. What a grand, satisfying, fascinating book! And when one considers that this exciting history is only the beginning of VW development... Wow!

4 comments about Principles of Web Design, Third Edition (Web Warrior Series).

1. This was one of the better web design books that I have read. It ranks even above HTML Goodies web design books. From an experienced web designer I recommend this book greatly.



2. I'm a full-time web development instructor with both high-school and returning adult students. I am using this book in my web design class. I liked the introductory chapter and the chapter on tables. However my students and I have run into a number of code errors (especially in the frames chapter) that are unacceptable. So I will continue looking for an excellent instructional book on web design. This book doesn't fit that criteria and I will not force it upon future students.



3. I'm a full-time web development instructor with both high-school and returning adult students. I am using this book in my web design class. I liked the introductory chapter and the chapter on tables. However my students and I have run into a number of code errors (especially in the frames chapter) that are unacceptable. So I will continue looking for an excellent instructional book on web design. This book doesn't fit that criteria and I will not force it upon future students.



4. Clearly written/explained for the beginner or for an easy-to- follow review of HTML. Pages are well laid out and easy to read. It's important to me to be able to read the text while sitting in front of the monitor, therefore a book should be legible at "lap height". My only complaint is that "figure" examples should printed on the same page as the text explaining them.

5 comments about An Introduction to Bioinformatics Algorithms (Computational Molecular Biology).

1. Bioinformatics is probably the fastest growing field in both biology and computer science. The problems have come from the computer science department and the biology department having such fundamentally different goals. The computer scientists see the computer as an end in itself with no real thought on trying to do something useful with it. The biologists see the computer as just another tool in their laboratory. And the biological problems are huge, massive computers like the new Cray's and large Linux clusters are being devoted to biological applications.
   
   This book is intended to fit into the chasm between biology and computer science. It discusses computer the algorithmic principles in terms of practical techniques that make sense to the undergraduate biologist. The book is well suited for a first class for the budding bioinformaticist.
   
   Each main chapter in the book first introduces an algorithm, then it discusses the biologically relevant problems that this algorithm addresses, it includes a detailed problem and one or more solutions. Finally the chapter concludes with brief biographical sketches of leading figures in the field.
   
   This is the first book of its type, and it's likely to remain a classic in the field through many editions and many years.



2. This book gives a broad overview of algorithmic methods used in bioinformatics. It is well writen and the mathematics needed to understand is undergraduate level. Reading this book makes appetite to apply these methods to problems or to dig deeper in the corresponding method.
   
   Overall, a very good book, and due to its introductory level, one can recommend to all people interested in bioinformatics from all disciplines.



3. I knew most of the stuff before I opened the first page. It's basically teaching data structures 101 using a few watered down bioinformatic problems for motivation. The lack of applied problems involving real data was most disappointing. It does have a lot of the type questions that some nerd (me one day :P) might ask you on a job interview. The questions are also a good way to kill time if you have nothing better to do. I give the book credit for stressing dynamic programming. I believe that this is one of the most important concepts in problem solving.
   
   3 stars because I think it is a fairly good introduction for fledgling computer scientists BUT not a good reference for comptuer scientists trying to apply their skills to solve bioinformatic problems.



4. This is the first book that I've read regarding bioinformatics, so Im updating this as my class moves along. You better have a grasp of basic data structures prior to beginning this book and background with a programming language as there is very little hand-holding in this text. A bio background makes it all more interesting but certainly is not critical. There are no sample code or sources printed with the book nor is there an included CD nor answers to exercises. There is an associated web site where some ideas may be had and errata found/reported, but its not very active that I have seen. The pseudo code in the book is very python-like so easy to make use of. I personally transfer the book's concepts to C/C++ (habit) without much problem, except sometimes my results differ from the book. Apparently these are book bugs, so be sure to check the web site out if unexpected things pop up.
   Presently my class is in chapter 8 (of 12) and looking back I would like to caution that some data processing algorithms will drive a computer's CPU quite hard so be aware of battery-munching & heat. My only bones with this book so far are the alphabet soup of variables and lack of answers to exercises. It would be nice if variable definitions were refreshed at the beginning of pseudo code samples.
   I like this book as an algorithms text over traditional texts because the applications are much more fascinating. Imagine searching for something and you don't know where that something is. On top of that add not even knowing exactly what it is you are looking for. And when you do find it, its not even in the data searched! This may sound unlikely or even impossible, but it is neither. Rather, its very cool.
   4-stars



5. Este livro é excelente por várias razões. Entre elas posso citar o fato de estar totalmente voltado ao aprendizado por exemplos, sempre de forma a relacionar um problema computacional com um problema em bioinformática. É um livro muito abrangente, cobre muito bem os tópicos relacionados a alinhamentos e comparações de sequências. Seu capítulo sobre Algoritmos com Grafos é o meu preferido. O autor consegue passar as noções fundamentais com muita simplicidade, de forma que qualquer pessoa possa aprender num ritmo bem rápido.

5 comments about Podcast Solutions: The Complete Guide to Podcasting (Solutions).

1. I started out knowing diddly squat about podcasting. I read "Podcast Solutions" by Michael Geoghegan (what's up with that name?) and Dan Klass and now I know everything. But much more important than my over-generous opinion of myself I got my podcast up swiftly, easily and on time thanks to this incredible book.
   
   They answer questions with the insight of someone who really knows all the angles, who really knows what they are talking about, who has actually done it. The book will take you through the entire process and get you up and running. And isn't that what it's really all about?
   
   I especially enjoyed Chapter 10 "Getting Heard" which offers rich detail and many astonishing ideas about how to get people to actually listen to your podcast. And isn't that what it's really all about?
   
   Finally, the price on this book is right. Just right. Enough to make you realize you're getting something valuable (which you are) and low enough that it's well within reach of anyone who's ever splurged on a cup of Starbuck's coffee. And isn't that what it's really all about?
   
   Buy the book. Do it now! Buy a brand new book all for yourself. Don't chintz out and get a used one from Amazon. There's a CD inside that you need and it will probably be missing from any used copy.



2. Yes, it's true. I'm contemplating adding a podcast to my blog. So, I bought "Podcast Solutions" on Amazon and read it, front to back. This is a very useful book, and it comes with a CD of demo software you can use for podcasting.
   
   Anyone who is thinking about podcasting should read this book BEFORE they start purchasing any equipment. One of the most valuable things I found in this book was information about the equipment you will need to get start. A large portion of this book is devoted to getting good quality recordings from your recording sessions so that it doesn't turn potential listeners off with popping, clicking, hissing, etc.
   
   One of the other great things I found in this book is podsafe music. Never heard of it? Podsafe music is music from independent artists that is licensed for you to use it free of charge in your podcasts. Check out these sites: GarageBand and PodShow. The music is really good. I'm digging it.



3. Until someone writes something really comprehensive, this is the best there is in podcasting.



4. Michael Geoghegan and Dan Klass have done a great job in this 240 page book on podcasting. A great book for any podcaster. They do a good job of taking you through all of the steps necessary to learning podcasting. The book runs the gamut of the steps you'll need to preparing your podcast, to recording and subsequently publishing your podcast on the web.The book is easy to follow and has lots of links to websites for additional reference. Overall the best book on the market for podcasting.



5. What is podcasting?
   
   If you don't know by now - what's wrong, have you been living under a rock? ;)
   
   A little over a year ago, I had no clue. I actually thought it was using an iPod to broadcast mp3s over FM waves to a radio (which is actually done quite often, but has nothing to do with podcasting). In fact, podcasting has little to do with iPods at all. If I had had a copy of this book a year ago, I would have know that - and a whole lot more!
   
   "Podcast Solutions: The Complete Guide to Podcasting" is just that - a complete guide. Have no idea what podcasting is? This will tell you. Know what it is, but not how to listen to them? This book will tell you. Would you like to know how podcasting started? Look no further. Ever wondered what the relationship between podcasting and blogging is? You can find out. Want to start your own podcast? Then this is the book for you! It even comes with a CD with all the software you'll need to start podcasting right away, and it doesn't matter if you use Windows, Mac OS X, or even Linux - the CD has software for all three platforms. The book even tells you how to start making money with podcasts!
   
   From recording the audio to publishing the XML to getting your podcast heard - it's all in the book. You should really pick this book up if you have any interest at all in podcasting. Highly recommended!

5 comments about Art of Computer Programming, Volume 1: Fundamental Algorithms (3rd Edition) (Art of Computer Programming Volume 1).

1. All three volumes of The Art of Computer Programming (TAOCP), are classic. Each is a book that every CS student should try to study diligently reimplementing example after example. Not many will succeed to finish even a half of one volume, but if you do please buy all three of them and think about post-graduate studies :-).
   
   I think the most important is to study the Vol 1. It gives enough exposition to the Donald Knuth style and brilliant thinking. While the content is definitely important it is the level of thinking of the author that represents the main value of the book: you instantly understand the book was written by a great scientist and it does not matter much that now the contents of most chapters can be significantly improved using more modern sources. After all Vol 1 is more then a 30 years old book (it is older then Unix) and as such it should be outdated (we all believe in progress, don't we)... And it is not surprising that parts of Vol 1 on of TAOCP today look completely out of touch with reality especially MIX, the CPU instruction set that is used in all volumes.
   
   Actually MIX instruction set (and thus assembler) was outdated even when the book was first published and more reflects unique Knuth's background with IBM 650. It was far from the state of hardware development even in late 60th when the first volume was published, the period when IBM/360 was the king of the hill.
   
   Now IBM 650, a 1,966 lb machine that consumed almost 30 Kw of electricity looks more like a primitive calculator than a real computer: typical installation has the memory of just 10,000 decimal digits ( 1,000 words; 10 digit per word).
   
   It's really sad that Knuth did not adopt System 360 architecture and PL/360 assembler (Wirth's structured assembler for S/360) for his books but we can do nothing about it. Still this is a book about timeless truths, not the book about the resent CS fashion like Java or you name it :-). It actually can serve as a perfect antidote against any current CS fashion.
   
   And Knuth does provide pseudocode with his natural language algorithm description. And natural language pseudocode has an important advantage over 'structured pseudocode. The problem with a "structured pseudocode" is that the set of control structures is fixed and may not reflect the needs of a particular algorithms (branching out of loop is a common problem that is not addressed by structured programming well). Moreover it can cripple the algorithm by enforcing unnatural control structures, the structures that are absent in it but might be present in more modern languages. For example Perl has an interesting set of control structures that is superior to C. But even "Perl control structures set" can be improved further.
   That's why assembler language is preferable: it never obscures "natural" control structures for each algorithms, structures that one day can be mapped into some new elegant language construct. Also as one review noted "sometimes high level languages with all their abstractions make things look more complex than they need be."
   
   I would like to stress it again that each volume is very difficult to read; you really need to work on each chapter by reimplementing the examples that Knuth gives in your favorite language (assembler might help but is not essential).
   
   Mathematical considerations as for average and worst running time of a particular algorithm can be largely ignored during the first couple of years of study of this book. Actually most mathematics in Vol. 1 can (and probably should) be initially completely ignored. See Softpanorama Classic Computer Books for more information.
   
   On the negative side this is an overpriced book, if we are talking about students budget. To save money you can buy one of the first editions: there is not that much difference in content to justify the differences in price. The differences do not interfere with the study of the book. Knuth did an excellent work the first time he published each volume and for a significant improvement we probably need another century and another person.



2. "The Art of Computer Programming" (TAoCP) is about machines and mechanical methods.
   
   TAoCP is "about timeless truths" as the author writes. It's about CPU registers and memory cells. It's about counting the number of machine cycles a program will take. It's about precision. It's not about creating fancy Excel macros or adding pop-up windows to your web page.
   
   Volume one contains two chapters. Chapter One first defines algorithms, gives basic math concepts for computer science starting with Mathematical Induction, continuing with a section on how to analyse algorithm, plus a couple of sections for people familiar with mathematical analysis (i.e. the math behind calculus). It ends with a complete description of MIX, a fictional computer, and of the machine language for programming MIX. (Note: MIX will soon be upgraded to the equally fictional MMIX). I won't repeat the author's rationale for sticking to machine language, and a fictional one at that! Suffice it to say that he has his reasons.
   
   Chapter Two is about lists and trees, the most fundamental of data structures. Stacks, queues, and deques are lists with one or two entry and exit points. Linked lists have as many entry and exit points as there are elements, but careful! you need to worry about linking elements to one another, and ending with correct linking when adding or removing an element. And then there are trees, and the many ways to visit all nodes in a tree exactly once. Leftmost node first? Last? Middle node first?
   
   Who should read this then? Patient people! Knuth published the first volume in 1966 and plans to finish the final edition of the fifth volume in 2015. This is not a For Dummies book, so don't expect to speed read through it. I skimmed the whole thing cover to cover, skipping the exercises and occasionally working hard at achieving perfect understanding of two or three pages (several hours!). I'm now going through it again more slowly, part by part, doing some of the problems. If I want, I can have fun with this book for the rest of my life.
   
   Apart from that, well obviously computer science academics will enjoy TAoCP and find inspiration here for classes and tutorials. This is a monograph, so it is complete and mostly self-contained. It is also accessible to anyone willing to put in the hours to read it, and very little beyond a little programming experience is required.
   
   Most of all, TAoCP is for people who enjoy thinking for its own sake, people who enjoy puzzling out and finding tricky solutions to what might seem like a straightforward problem. Some people enjoy tinkering with cars, others like building model ships. Like these activites, going through the exercises in TAoCP gives us what Fred Brooks calls the sheer joy of creating things.
   
   By the way, it's worth learning MIX. I do the exercises in Perl (egad! I can only handle some of the problems...) but since the solutions are in MIX, it pays to know it well enough to read through Knuth's examples.
   
   Vincent Poirier, Tokyo



3. This book has saved my bacon several times through the decades. Once I needed to actually build a database package from scratch instead of using a commercial package.
   
   I almost did not buy it when all I saw in it was mostly math. But I was desperate and it paid off. Turns out you could not explain it any other way. I use it primarily for balanced trees. I may try some thing more exotic later.
   
   The set also looks impressive in the library.



4. This is a classic book on algorithm analysis and also in programming techniques. The first one for which author create a hypothetical computing machine (he call it MIX), his own style to describe algorithms, a machine operation instruction and data representation, an assembly language (he call it MIXAL) for map algorithms and data structures into reality.
   
   In another sense: it's a self-contained book.
   
   Each chapter includes a historical review of concepts and methods.
   
   
   Important topics
   ----------------
   * Section 1.2. Mathematical basement for algorithm performance analysis. Includes a review of Numbers, Powers, Logarithms, binomial coefficients, and also an example of algorithm analysis using "Kirchhoff's first law" for inputs/outputs (flow to/from each step).
   
   * Section 1.3. Description of the hypothetic computing machine (MIX): memory word, registers, comparison and overflow indicators, input/output device names, machine instruction format, machine instructions.
   
   * Section 1.3.2. Description of the assembly language (MIXAL). Includes an interesting figure on relation between machine instruction codes and assembly language representation.
   
   * Section 1.4.1. Introduce concepts of subroutine and co routine. Co routine is described as a team of sub-programs ideal for multi-pass algorithms (the kind used for processing a stream input).
   
   * Section 1.4.3. Introduce in the field of interpretive routines and simulators. The author tells you how good programmers are at the same time good machine designers (as is the same today with virtual machines and little languages as Java). It includes a simulator program for the hypothetical MIX computing machine. You will learn how a state machine or sequential machine is implemented using a so called Control Routine (complement this reading with section 5.1 of "Computer Organization & Design" by Patterson and Hennessy - see my review for that book).
   
   * Section 2.2.5. Describes the use of doubly linked list data structure by using a discrete simulation example (author use previously reviewed concepts like coroutine and control routine). You learn how the idea of coroutine is a base for discrete simulations. Also, author use what he call a "pseudo parallel procedure": a WAITLIST. This kind of procedure was used during 1960s and 1970s as a multi-task procedure.
   
   * Section 2.3.2. Describe binary trees. The highlight of this section is a "Differentiation" algorithm. The author uses an algorithm to traverse a tree in post-order with each node representing a symbol. He then implements the algorithm using a control routine like the one implemented in Sections 1.4.5 and 2.2.5. The control routine includes a "Jump Table" for processing each node.
   
   In resume, the book describes important topics for past and present programmers. I recommend you to read "Computer Organization & Design" by Patterson and Hennessy as an intro. Then read this one. Also you can complement this read with "Fascicle 1." by Donald E. Knuth, which describes an advanced MIX computing machine called MMIX (a 32 bit hypothetical RISC machine similar to DLX machine used on "Computer Architecture: A Quantitative Approach - 2d edition" by Patterson and Hennessy. Also, "The Art of Computer Programming, Volume 3" will very useful (Balanced Trees algorithm for example, as a "self-reshaping" structure).



5. Yes, I know, we devs should all pay homage to the great Knuth. I don't dispute it. But I also don't want to read a textbook. That's what this is. And unless you're writing low level algorithm libraries, you have no business reading this book. 'Cause if you can't grasp the basics already, this book will do more to scare the crap out of you than anything else.
   
   For the hardcore only!

5 comments about JavaScript for Dummies.

1. I bought this book with a basic knowledge of HTML but very little knowledge of Javascript. Being a fan of other "Dummies" books, I thought this would be a great place to start learning Javascript. Do I feel ripped off! In the Introduction, the author states the book is for those with little or no knowledge of Javascript, which I don't think at all to be the case. She claims to use "real-world examples", most of which I find to be fairly abstract and very poorly explained. She also claims that all the sample codes are contained on the CD-ROM, which is a flat out lie, the applications are similar but the coding is very different from the book, which combined with the author's hard-to-follow explanations leaves the reader very confused and frustrated. On top of all that there are several typos, one of which refering to Microsoft Windows as a word processing program, and poorly written HTML, missing several tags. The author definately knows Javascript, but how good she is as an author is questionable.



2. I have several complaints about this book. Firstly, the author assumes you don't even know how to turn on a computer. Who would be bothering to learn about JavaScript if they don't even know how to power up a PC? Come on! The author should spend less time detailing the basic boot up process on the PC and how to open your text editor, and more time explaining the way JavaScript works, and how it depends on the browser that the person visiting your website is using to work correctly. Also, a lot of the examples given in this book don't work. (Unfortunately, I've found that is common with JavaScript books.) Also, the book seems to waste a lot of time going on and on about useless nonsense. I know it's a "dummies" book, but this book expects its readers to truly be morons.

   I'm only thankful I purchased the book at a discount bookstore for only $3.99.




3. I've been learning and using JavaScript for quite some time, and of all of the books I've used, this one has by far been the worst. The examples that the author uses are not very helpful, and often concepts are poorly explained. A lot of the code you will need to write will require you to creatively use the skills you've acquired to solve a problem; this book, however, likely won't equip you with the tools you need to be able to do this. If you're looking for a good place to start, I'd start with JavaScript: The Definitive Guide by David Flanagan. It does have flaws of its own, but it is a good place to start.



4. This book is good for a quick introduction to JavaScript. There's lots of general tricks and techniques, plenty of ideas, and code snippets to reuse (on the CD). However, the descriptions of HOW the code worked I found lacking. There were various details about exactly WHAT the Js interpreter was doing to parse the code. The book left me feeling that I had lots of great ideas, but that when I sat down to apply them and make something original--there'd be lots of bugs based on details that I wasn't told about. Good starter, good reference--definitely not "text-book" quality--but it was fun to play with.



5. Javascript for dummies, by Emily Van der Veer, is not up to the reputation of clarity, simplicity and usefulness of the books in the "For Dummies" collection. The explanations of the basic concepts of the language (primary datatypes, objects, arrays, functions, properties, methods, etc.) are garbled and confusing. The examples are badly selected, they don't go step by step, they mix trite and complex elements, and do not really explain things. This book will delay by several years, as it did for me, your understanding of Javascript. I finally understood and began to be able to use the language after having read "Javascript, the definitive guide" by David Flanagan.

5 comments about Beginning Google Maps Applications with Rails and Ajax: From Novice to Professional.

1. I was worried when I ordered this book that it would just be a reference book of the Google Maps API, but thankfully I was wrong. This book is an excellent reference to anyone wanting to build a Google Maps enabled Rails Application.
   
   The first four chapters take you through building an application, similar to the author's hotspotr application where a user can save Wifi hotspot information. For many people this may be all they are looking for, a way to create maps, save information and geocode addresses.
   
   Chapters 5-8 deal with larger datasets and the example they use is from the FCC Antenna Structure Registration, which has 120k records already geocoded for you. It then takes you through different presentation methods. If you want to see the output, go to book dot earthcode dot com chapter seven, server custom tiles. It's a very impressive result, similar to the pictures of earth at night.
   
   The rest of the book gives other advanced uses and apis, I have not read all the way through that but it looks interesting. The other thing I like about the tone of the book is the conversational style. For example in Chapter 5 where they are using the FCC dataset they talk about the advantages of using a mysql import instead of going through the ActiveRecord layer, resulting in importing the data in less than a minute compared to 1.5 hours with ActiveRecord. This is the type of information that usually only comes from time spent trying different methods, so it's nice for us to be able to leverage their hard work.
   
   In general I have been impressed with the Apress books ( no pun intended) them and Pragmatic Programmers have really started giving O'Reilly a run for their money.



2. I would highly recommend this book for anyone who is interested in using Google Maps with Ruby on Rails. My expectations were exceeded and I believe it lives up to its sub-title "From Novice to Professional".
   
   I develop Rails applications and became interested in Google Maps in conjunction with a Real Estate application I was working on. In particular, I was interested using Google Maps for visual analysis of large data sets. Knowing next to nothing about the Google Maps API, I was truly at the Novice level. The book started off at the basics and quickly built on example and technique to the point where there was a working example of a problem similar in scope to mine. Along the way, the trade offs and techniques were well presented and explained in detail. Not only did I gain the knowledge and confidence to tackle my particular problem, but I was also inspired by all the other potential applications of this exciting new technology.
   
   This book was well organized and written. I was obvious that the authors had worked through the examples and I especially appreciated many of the best practices and hints they gave. Chapter 7 "Optimizing and Scaling for Large Data Sets" was particularly interesting for me and my application. It included code and examples for several server-side and client-side techniques and as well as a clear explanation of their uses and trade offs.
   
   If you are a Rails coder and you want to master Google Maps, this is a must have book



3. A good guide if you are new to google maps. If you are an experienced google maps developer trying to integrate RJS or other cool rails techniques, this book is not very useful. I'm coding rails and google maps applications daily and I haven't picked this book up more than twice since receiving it.



4. I was a little disappointed. Although there are a few interesting tips, I did not think the book was very well edited. There are several typos. For example, one obvious mistake in chapter two, which for a novice, would make the code unusable. array.size should be array.length. Furthermore in chapter three, the authors abandon the completed code listings altogether leaving the novice totally stranded. In addition, the online code is also incomplete and quite broken. I would not recommend this book unless you are already an expert and can filter through the errors and omissions.



5. This item is an excellent start point to developers who want to learn how to use Google Maps API within Rails. Helped a lot to increase productivity with the basic skills.

3 comments about Java Pocket Guide (Pocket Guides).

1. This is a handy pocket reference/guide for the intermediate or advanced programmer. All materials are well-organized and illustrated with concise examples of code. It is "worth it's weight" and should be on every Java programmer's reference bookshelf.



2. This is a model for all reference books in my mind. Clearly written and to the point. There are sections covering all the main aspects of the language. It is well worth getting for any/all Java developers. Even though I know Java, I have been referring to it when I travel.
   
   An easy purchase.



3. I don't know about you, but when I'm confused about something, I'm really confused. I need an example to clear up my confusion or my memory. This book gives examples in the most superficial of terms. It is designed to be a quick guide to J2SE through the Java 6 Platform, and quick is what it is. It is not going to jump start you if you need a real jump start on an issue you have forgotten. The most useful information is at the very end of the guide where it talks about the Java Scripting API, tools, and UML. The first half of the book is oriented towards the Java programming language and the second half is about the platform components and some special topics.
   
   If you need useful examples in an accessible format I still suggest the Core Java books by Cornell. They may be somewhat unwieldy to lug around on trips, but they get the job done. Java Examples in a Nutshell is somewhat outdated, but it still can clear up some questions on parts of the language that haven't changed over the years. If you are new to Java I absolutely recommend against getting this pocket guide. You'll be lost. I include the table of contents since it is currently not listed in the product description.
   
   Chapter 1. Naming Conventions
   Section 1.1. Class Names
   Section 1.2. Interface Names
   Section 1.3. Method Names
   Section 1.4. Instance and Static Variable Names
   Section 1.5. Parameter and Local Variables Names
   Section 1.6. Generic Type Parameter Names
   Section 1.7. Constant Names
   Section 1.8. Enumeration Names
   Section 1.9. Package Names
   Section 1.10. Acronyms
   Chapter 2. Lexical Elements
   Section 2.1. Unicode and ASCII
   Section 2.2. Comments
   Section 2.3. Keywords
   Section 2.4. Identifiers
   Section 2.5. Separators
   Section 2.6. Operators
   Section 2.7. Literals
   Section 2.8. Escape Sequences
   Section 2.9. Unicode Currency Symbols
   Chapter 3. Fundamental Types
   Section 3.1. Primitive Types
   Section 3.2. Literals for Primitive Types
   Section 3.3. Floating-Point Entities
   Section 3.4. Numeric Promotion of Primitive Types
   Section 3.5. Wrapper Classes
   Section 3.6. Autoboxing and Unboxing
   Chapter 4. Reference Types
   Section 4.1. Comparing Reference Types to Primitive Types
   Section 4.2. Default Values
   Section 4.3. Conversion of Reference Types
   Section 4.4. Converting Between Primitives and Reference Types
   Section 4.5. Passing Reference Types into Methods
   Section 4.6. Comparing Reference Types
   Section 4.7. Copying Reference Types
   Section 4.8. Memory Allocation and Garbage Collection of Reference Types
   Chapter 5. Object-Oriented Programming
   Section 5.1. Classes and Objects
   Section 5.2. Variable Length Argument Lists
   Section 5.3. Abstract Classes and Abstract Methods
   Section 5.4. Static Data Members, Static Methods, and Static Constants
   Section 5.5. Interfaces
   Section 5.6. Enumerations
   Section 5.7. Annotations Types
   Chapter 6. Statements and Blocks
   Section 6.1. Expression Statements
   Section 6.2. Empty Statement
   Section 6.3. Blocks
   Section 6.4. Conditional Statements
   Section 6.5. Iteration Statements
   Section 6.6. Transfer of Control
   Section 6.7. Synchronized Statement
   Section 6.8. Assert Statement
   Section 6.9. Exception Handling Statements
   Chapter 7. Exception Handling
   Section 7.1. The Exception Hierarchy
   Section 7.2. Checked/Unchecked Exceptions and Errors
   Section 7.3. Common Checked/Unchecked Exceptions and Errors
   Section 7.4. Exception Handling Keywords
   Section 7.5. The Exception Handling Process
   Section 7.6. Defining Your Own Exception Class
   Section 7.7. Printing Information About Exceptions
   Chapter 8. Java Modifiers
   Section 8.1. Access Modifiers
   Section 8.2. Other (Non-Access) Modifiers
   Chapter 9. Java Platform, SE
   Section 9.1. Common Java SE API Libraries
   Chapter 10. Development Basics
   Section 10.1. Java Runtime Environment
   Section 10.2. Java Development Kit
   Section 10.3. Java Program Structure
   Section 10.4. Command-Line Tools
   Section 10.5. Classpath
   Chapter 11. Basic Input and Output
   Section 11.1. Standard Streams in, out, and err
   Section 11.2. Class Hierarchy for Basic Input and Output
   Section 11.3. File Reading and Writing
   Section 11.4. Socket Reading and Writing
   Section 11.5. Serialization
   Section 11.6. Zipping and Unzipping Files
   Section 11.7. File and Directory Handling
   Chapter 12. Java Collections Framework
   Section 12.1. The Collection Interface
   Section 12.2. Implementations
   Section 12.3. Collection Framework Methods
   Section 12.4. Collections Class Algorithms
   Section 12.5. Algorithm Efficiencies
   Section 12.6. Comparator Interface
   Chapter 13. Generics Framework
   Section 13.1. Generic Classes and Interfaces
   Section 13.2. Constructors with Generics
   Section 13.3. Substitution Principle
   Section 13.4. Type Parameters, Wildcards, and Bounds
   Section 13.5. The Get and Put Principle
   Section 13.6. Generic Specialization
   Section 13.7. Generic Methods in Raw Types
   Chapter 14. Concurrency
   Section 14.1. Creating Threads
   Section 14.2. Thread States
   Section 14.3. Thread Priorities
   Section 14.4. Common Methods
   Section 14.5. Synchronization
   Section 14.6. Concurrent Utilities
   Chapter 15. Memory Management
   Section 15.1. Garbage Collectors
   Section 15.2. Memory Management Tools
   Section 15.3. Command-Line Options
   Section 15.4. Resizing the JVM Heap
   Section 15.5. Interfacing with the GC
   Chapter 16. The Java Scripting API
   Section 16.1. Scripting Languages
   Section 16.2. Script Engine Implementations
   Section 16.3. Setting Up Scripting Languages and Engines
   Chapter 17. Third-Party Tools
   Section 17.1. Development Tools
   Section 17.2. Libraries
   Section 17.3. IDEs
   Section 17.4. Web Application Platforms
   Section 17.5. Scripting Languages
   Chapter 18. UML Basics
   Section 18.1. Class Diagrams
   Section 18.2. Object Diagrams
   Section 18.3. Graphical Icon Representation
   Section 18.4. Connectors
   Section 18.5. Multiplicity Indicators
   Section 18.6. Role Names
   Section 18.7. Class Relationships
   Section 18.8. Sequence Diagrams

3 comments about Cocoa in a Nutshell: A Desktop Quick Reference (In a Nutshell (O'Reilly)).

1. This book may be recommended by Apple Computer as reading for programmers aspiring to be OS X Cocoa programmers, but these "In a Nutshell..." books from O'Reiley are like the dictionary. They are good references, but not good to learn from.
   
   A much better starting place to learn Cocoa programming -- the best OS X technology for new Mac-OSX only software -- is the book "Learning Cocoa with Objective-C'. This book is also on Apple's recommended reading list for programmers aspiring to master Cocoa.
   
   The ISBN number of "Learning Cocoa..." is: 0-596-00301-3.
   
   I plan to continue my study of Cocoa with "Programming in Objective-C:A Complete Introduction to the Objective-C language". I feel that I need this book even though I know C and C++. Objective-C is quite a bit different. ISBN 0-672-32586-1
   
   Then, I plan to read: "Cocoa Programming" ISBN 0-67232230-7.
   
   That brings me back to the book that I started with. "Cocoa in a Nutshell". Then, I'd be ready for a reference book, and I would also use Apple's web reference, and on-disk reference materials that are on your hard disk when you install Apple's free development tools.



2. One of the best books a Cocoa programmer can buy! It references most of the Cocoa API and Objective-C, as well as providing a few good examples. I find it indispensable.



3. This is pretty much a must have reference book if you're programming in Cocoa. The only drawback is that a lot of the new APIs like Core Animation and Core Data are not covered. The last edition dates from 2003 and could use a Leopard update. That aside, this book is virtually indispensable for Cocoa devs who've made it past the beginner hump. If the authors read this review, please put out a Leopard update and I promise to buy 2 copies to help make it worth your while!

5 comments about Computer Systems: A Programmer's Perspective.

1. What a splendid book! I wish I had gone to CMU and take this course. This book is written by CMU professors after teaching Computer Systems course for few years. This book covers broad spectrum of topics from Operating Systems, Compilers, Computer Architecture, Assembly Level Programming, Kernel internals, Linkers, etc from a programmer's perspective (as the title aptly says).
   
   I am searching for words to describe the usefulness of this book. In my experience, I have had hard time learning some of the topics where Operating systems, Processor and Compilers intersect. For example, Linkers and Loaders, program disassembly using reverse-engineering, virtual memory in Kernel etc. After all the hard work, I found the right book which grinds all the famous books in different areas and gives the right juice for the real programmers to taste and digest.
   
   Those famous books are:
   [1] Computer Organization and Design Second Edition : The Hardware/Software Interface by David A. Patterson, John L. Hennessy
   [2] UNIX Internals: The New Frontiers by Uresh Vahalia
   [3] Linux Kernel Development by Robert Love
   [4] Linkers and Loaders by John R. Levine
   [5] GNU Binutils (GAS, objdump, ar, nm etc) Documentation
   
   Excellent job. I really appreciate the work and content of this book.



2. I just completed a college course using this textbook... the course was tough, but the book was very good and useful. This is one textbook I won't be selling any time soon!
   
   The practice problems provided in the book were usually very good, and the programming problems distributed with it were fun and educational, including topics like Buffer Overflows, Memory Optimizations, and Debugging with GDB, among others.
   
   There are *some* problems with this book, but it doesn't suffer from the devastating flaws that plague most computer science textbooks. Some sections lack thorough explanations and examples, and the writting is a bit unclear at times. Some solutions to the practice problems are vague and don't really provide much insight on how to solve the problems. Luckily, these flaws only creep up in a few places.
   
   Compared to most technical textbooks, however, this one really shines. It's not quite perfect, so I think 4 stars is appropriate.



3. Even though the topics of this book are absolutely great and crucial for any CS student, I dislike the entire book !, its hard to follow the writer, i find it hard to keep with him !
   too many complicated information with either Tiny explaination or more complicated explaination ,
   its a very big book with many topics , i prefer reading seperate books with specific topics rather than this book,



4. An excellent reference, but it is an embarassment of riches, and as such it can't completely cover every area exhaustively. This would probably be extremely frustrating for a casual reader to absorb. I used this as a text book for a class with an extremely good instructor who backed up the material in the book very well. As such, the class and the book were a joy.



5. Purchased this for a computer science course since it was required. Great price at Amazon!