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 ASP.NET 2.0 Cookbook (Cookbooks (O'Reilly)).

1. Michael Kittel and Geoffrey LeBlond's ASP.NET 2.0 Cookbook appears in its updated 2nd edition to include all new tips for version 2.0. Here are over a hundred solutions in C# and Visual Basic aimed to web developers who want an edition completely revised for 2.0. Recipes run from the very simple coding solution to entire development strategies and use O'Reilly's problem-and-solution oriented approach. This format lends to at-a-glance reference consultation - or to use as a classroom text. Either way, the authors' some thirty years experience working with ASP.NET lends to an authoritative text of solutions to common problems.



2. Much of the content was clearly taken from earlier 1.x versions of the book without being re-written to take advantage of 2.0. Yes, the samples may compile and work, but they are often not 2.0 best practices.
   
   While there are several 2.0-specific sections, much 2.0 function is ignored. You'll learn more from other books.



3. Are you journeyman programmer who knows the basics of ASP.NET? If you are, then this book is for you! Authors Geoffrey T Leblond and Michael A Kittel, have done an outstanding job of writing a second edition of a book that is a collection of ASP.NET 2.0 recipes that aims to help you quickly and efficiently solve many of the day-to-day problems you face when developing web applications with the .NET platform.
   
   Leblond and Kittel, begin by showing you how to make the most out of the master pages. Then, the authors show you how to make well-informed decisions about which control to use. Next, they provide recipes that perform a number of data validation tasks. The authors then provide you with series of nonobvious solutions for working with forms. They continue by showing you how to use time- and work-savers. Then, the authors show you how to use custom controls to build your own user interface. Next, they show you how to maintain the state of the application. The authors then cover error handling at different levels of detail. They continue by providing recipes that delve into some of the most common solutions. They also cover a host of new ASP.NET 2.0 profile features. Then the authors show you how to use web parts in your applications. Next, they show you how to configure your applications. The authors show you ways on how to ensure that your applications work as anticipated in their first release, through the effective use of testing and debugging. Then, they will show you how to create and consume XML web services. Next, the authors will show you how to deal with a design that uses images for buttons, but the button labels need to be dynamic. The authors then will help you sort through the issues of caching the output of pages or portions of pages in memory to reduce latency and make your applications more responsive. They continue by showing you the basics of how to internationalize your applications. Then, the authors show you how to download files from and upload files to the web server. Next, they discuss how to measure performance. The authors then show you how to create your own custom HTTP handler. Finally, they help you with recipes that do not fit conveniently into the other chapters of the book.
   
   This most excellent book contains dozens of code examples, ranging from relatively simple 10-liners to comprehensive, multipage solutions. More importantly, this book focuses directly on problems you face today or are likely to face in the future.



4. This is the perfect book for those who know ASP 1.x and need a find a way to solve a problem QUICKLY in ASP 2.0. It covers the vast majority of new features in ASP 2.0 as well as new ways acomplish tasks that were more difficult in ASP 1.0. A must have in for ASP 2.0 Programmers!



5. For those transitioning from ASP.NET 1.x this is a fantastic introduction to learning how things should be done with 2.0. The book is well-written, concise, and easy to absorb the concepts it presents.
   
   I've always loved the "Cookbook" format, which is to present a list of tasks 100 or so tasks that you might want to accomplish, and then give detailed instructions on how to accomplish each one. The one thing I would like to have seen, and the reason it didn't receive 5 stars, is that the book focuses on introductory tasks. Since I've been working with 2.0 for several months I already knew how to do most of the items they discussed.
   
   Overall, this book will serve as a great reference.

5 comments about PostgreSQL (2nd Edition) (Developer's Library).

1. This book lives up to it's claims for "the comprehensive guide to building, programming and administering postgresql databases". I'm a MySQL guy, but may have to do a little pgsql to support a third party app, so I was looking for a book that would bring me up to speed.
   
   The quick review is this... I give this book 3 stars, because it's so huge and covers so much territory that, in my opinion, it does a middling job of it. I would have preferred a more focussed book. I think, given it's goal of being so comprehensive, it is about as good as it could be and if you really need to know everything - from sql, to developing extensions, to embedding this in your c/c++ programs and administering things AND want a single book that covers it this is probably the book for you. If you don't need quite that much, or are willing to go to more than one book to get it, I think you would be better served to look elsewhere.
   
   The longer review...
   
   Honestly, I don't know why books on databases almost invariably are terribly dry reads, but this book, following the odds, falls into that category. It's a hefty tome weighing in at about 1000 pages divided into 3 sections.
   
   The first category, about a quarter of the book, is an introduction to sql and postgresql in particular. It does quite a nice job of introducing your standard sql commands, datatypes and basic administrative commands (like creating tables and the like). This part goes from basic to fairly advanced, covering topics like outer joins and creating new datatypes. I suspect it'll be review for those familiar with sql but reasonably usable for those delving into sql, even if they don't immediately understand all of the more advanced concepts.
   
   The section ends with a chapter on performance, something I was particularly interested in given postgresql's reputation. Here the authors talk about standard performancy things like indexes, using various tools to figure out what a particular query is actually doing, all worthwhile. But they never go into any detail about the performance implications of using some of the more advanced postgresql features like composite types and table inheritance. I was quite disappointed to find not even a whisper of this type of information in the book.
   
   The second section, about half the book covers programming with postgresql. This is a very broad chapter - covering many aspects of what it means to program this database. From server side programming using PL/pgSQL to extending the database with custom functions and types. They discuss creating clients in c, c++, java, perl, php, tcl, python and .net. Each one of these languages gets a chapter about 30-50 pages long where they go over the basics of how that language typically connects to the database and then goes through a process of creating a basic client and refining over the course of 4 or 5 iterations to become more and more robust and full featured. This is the bulk of the book and because it's so wide spread, I think most people will only be interested in one or two of these chapters - the rest of which will probably be uninteresting.
   
   The last section is the final quarter of the book where they go over the administrative requirements of the database. They admirably try to direct people to download and compile their own binaries, but cover installation from binary on unix and windows. They have an excellent reference on the things you can tweak to configure the runtime environment. They also cover backing up the database, replication, internationalization and security. Although they mention performance optimization in the intro to the section, they don't actually discuss it anywhere in the section.
   
   So, to sum up. If you really need to know about all aspects of pgsql and are looking for a one stop shop, this book is - I think - as good as you're going to find. But if you're looking into only a particular aspect (developing, administereing, etc..) or don't mind going to more than one, I feel confident that there's other books out there that will cover those topics in better detail.



2. PostgreSQL 2nd Edition is a phenomenal book if you're a programmer, and a great book if you're a non-programming admin. As someone whose programming ability reaches only ever so slightly beyond bash scripting and WSH, the parts of this book that were really worthwhile to me were those devoted to the administration of PostgreSQL. Backing up, recovering, and performance tuning were excellent resources, especially to someone who had never set up or administered a database. Speaking of which, the very beginning of the book, covering what exactly a database is, terminology, and setting up and creating schema were invaluable. To have all the information in PostgreSQL 2nd Edition consolidated in this one book makes it a must-have for any admin's bookshelf. The only reason it didn't get 5 stars from me was because I'm not a programmer, and I couldn't take away every single ounce this great resource had to offer.



3. I'm upset that this book that I've been trusting for the past month or two has such an egregious error in its discussion of regular expressions on page 51. I wish the authors had left out any discussion of regexes if they weren't going to actually test their assumptions about a topic on which I assume they know little. :-(



4. I am a database application developer with MS SQL Server, Oracle, Sybase and many other RDBMSs experience.
   This book allowed me to start working on PostgreSQL immediately.
   Pro: comprehensive, good examples, good supplement to the documentation.
   Cons: is not deep enough for me (does not explain format of a transaction log file or WAL file, for example), but, I guess, I should read the PostgreSQL code for this.
   If you are new to databases you would need to read some other books first.



5. As a developer with many years IT experience in control systems and only a little in databases and none with Postgres, I found this book to be extremely helpful. It covered a huge amount of topics with examples and put them together in a way that made it more efficient than googling!
   
   It helped that I knew what topics I needed in looking for answers but the chapters were self explantory in the topics they covered which I believe would allow a beginner to make quick progress in learning Postgres.
   
   Cavaet: If you are after a book to learn SQL and database design (normal forms) you will be disappointed, this book is not for you.

5 comments about Data Structures and Algorithms in Java.

1. It is worth to have waited for 10 days for the book
   It covered up to date java technology and provide additional informations about the implementations of algorithms in real life.
   I got many usefull java and algorithm theories from this book and I think it fits to people who want to learn java and the other who have java knowledge.



2. I strongly recommend this book as a textbook for learning how to program Data Structures in the Java Programming Language. It has very clear examples with full code, and very nice explanations that explanation an abstract subject. I learned Data Structures in C++ and this book made learning them in Java a piece of cake.



3. This book, as many have said, is used in numerous introductory courses in computer science. It was recently dropped by my college after it was disowned by the professors who chose it---we students threw so much scorn on the book no one wanted to admit they had anything to do with it.
   
   The book has a very idiosyncratic style. It likes to use some unnecessarily specific class and method names for its examples, and fails nearly every time when it attempts to justify certain proofs about big-O and algorithm runtimes. In fact, the authors seem to think it adequate to make a broad statement and then give a simple example.
   
   All in all, you're best finding webpages written by random professors than purchasing this morass.



4. This is for the fourth edition, which from other reviews doesn't suck as bad as the first two...
   
   It's an okay text book - but I pity anybody who doesn't have either experiance working with data structures in C or C++ OR who hasn't taken a Finite Math class specifically for CS.
   
   Only get it because you need it for a course, spend as little as possible and then dump it on eBay as quick as you can. Not worth keeping as a reference.



5. This was a mediocre text that is a rewrite of the same text in C++. As is common, the book reads like it was updated by search and replace.

5 comments about Everyday Scripting with Ruby: For Teams, Testers, and You.

1. This book teaches the Ruby language by working through a series of practical scripts. These scripts accomplish everyday tasks that every tester can relate to: comparing file lists, monitoring code changes, scraping web pages, and using a notification framework. The book covers not only the Ruby language, including an excellent chapter on regular expressions, but also provides detailed advice on how to develop reusable libraries, something that Watir users are always asking for help with. If you are a serious Watir user, don't hesitate to get this book.



2. It's been 12 years since Yukihiro Matsumoto released Ruby's first version. Now that Ruby has achieved mass popularity, more and more people are getting into this new, perhaps odd, programming language. Among other functionalities, Ruby is very suitable for developing lightning fast scripts and learning how to write these is this book's main purpose.
   
   The book is written around four interesting projects that teach you from the basics of Ruby to some useful aspects of this language. Those are an uninstaller checker, a version control system, a web page information retriever and a system monitor for watching long-running programs and then forward information trough email or instant messaging.
   
   Even though the graphics in the book's back says it is for people between beginner and expert level users, I find it specially good for beginners. I'd risk saying that it is even suitable for absolute beginners due to the fact that Brian Marick explains how to set up the language, use a system shell as well as what object oriented programming is, etc...
   He does all this without appealing to other languages. This fact, although it is great for beginners, can sometimes annoy experienced developers a bit but it's nothing one cannot deal with.
   
   Brian Marick lead us through the book using a simple and direct speech sometimes with a slight sense of humor to chill things out. He doesn't only teaches how to use the language but also encourage people using it referring to eventual "bugs" and other things that may appear to be odd for beginners.
   Another good characteristics are the "Ruby Facts" chapters, it's like an intermission that briefly introduces some concepts as in chapter 10 - "Ruby Facts: Regular Expressions".
   
   The book intends that the reader goes programming along with it as it is a practical book. No deep and extensive concepts are taught here, there's not even an introduction reminding of Ruby's history. Therefore this is a straight practice oriented hands-on book with it's main target being testers that might want to automate some of their work.
   
   Concluding, despite the fact that the book's name ends with "for Teams, Testers and You", all the book seems to be written thinking about testers. I recommend the book specially for beginners who want to learn Ruby as their first programming language and for people who don't know Ruby and want to learn quickly how to write Ruby scripts. Therefore I give this book an overall classification of 4/5.
   
   Review by
   Joaquim Rocha (NEEI)



3. "Everyday Scripting With Ruby" addresses its three target audiences well:
   
   The first audience: The person who is doing repetitive or manual tasks that could be automated by scripts, but "thinks programming is too hard."
   
   For that audience, the book is a fine introduction to the Ruby language using practical scripts.
   
   The major example scripts are:
   
   * Comparing files in two different directories and reporting the differences.
   
   * An example of automated testing.
   
   * A reporting script for a version control system.
   
   * A script that visits a web site, "scrapes" data from the page, and prepares it for import into a spreadsheet.
   
   * A "watchdog" script that keeps an eye on long-running programs or tests and sends an email or instant message when they finish.
   
   These scripts will be a fine start to your own scripting library, and portions of them will be useful in writing scripts to solve your own problems.
   
   The scripts are improved iteratively, and each iteration provides compelling motivation and a context for learning the next set of Ruby language features.
   
   The second audience: "The person who gets bogged down when writing or changing larger scripts."
   
   This book teaches modern programming techniques that assist in managing complexity, such as test-driven development, "borrowing other people's work in bits in pieces, growing programs gradually, and constantly keeping them clean."
   
   The third audience: "For the person who knows the wrong languages [for scripting purposes] well." It is much easier to write scripts in Ruby than in many other languages. Ruby also compares favorably to other scripting languages such as Perl, Python, or shell scripting (like Bash.) It is easy to read and make changes to a Ruby program that you wrote six months ago.
   
   Ruby on Rails is the web framework that is driving a lot of interest in the Ruby language, and this book would serve as a good introduction to the Ruby language before tackling Rails. An understanding of the Ruby language is essential to understanding Rails.
   
   "Everyday Scripting With Ruby" is well organized and well written. It's a very easy read, and a great introduction to Ruby and scripting.



4. Unless you've been stuck programming mainframes in COBOL, experienced programmers should steer clear. I found the book to be very slow going and even condescending at times. It spent way too much time on basic concepts like how if/then/else works.
   
   Were I in the target audience, I would probably find it useful, hence the 4 star rating. But if you passed Computer Literacy in 7th grade, some of this will be a refresher.



5. Everyday script with Ruby was a bit of let down for me. I normally really enjoy books from the Pragmatic Programmers series of books, but this one didn't do much for me. This certainly could be because my expectations were not quite in line the material.
   
   I was hoping for a book that focused heavily on testing with ruby. Instead you get a VERY introductory book about programming, which happens to use ruby. It does cover a tiny bit of using subversion, and automating a few very simple tasks, but it's mostly and introduction to programming Ruby.
   
   I am not saying the book is bad, it's not. It just wasn't what I was looking for. I probably could have done a little more research and found that out ahead of time. In the meantime, I will be passing this book out to my colleagues who are interested in learning programming and/or Ruby.

5 comments about Creating a Web Site with Flash CS3 Professional: Visual QuickProject Guide.

1. I was so excited to find a book that seemed to be perfect for me. A guide to making a website in flash cs3 from beginning to end. I don't really care about anything else in flash but making websites. Unfortunately this book uses actionscript 2 instead of 3 to build the site on. This is bad very bad. Flash CS3 now has actionscript 3 which is the new version of their programming language. Why base a book on Flash CS3 but leave out one of the most important changes? Simply ridiculous! I am so heart broke luckily I bought this book locally so I am returning it right now. Also the other books that the author recommends in his book all make their projects in actionscript 3 and not 2. Why did you do this. I don't want to buy a new program to get a new book that teaches me the old way of doing things. Don't buy this book unless you are only doing this a hobby.



2. If you're looking for an introduction to the Flash CS3 program then this isn't the book for you. However, if you are starting out in Flash and web development, and want a very basic website example to get you started this book will hold your hand. But it definitely needs to be supplemented with other Flash resources. If you *have* built a website before you probably do not need this book, either.
   
   It's not difficult to follow, and it's not meant to be complex in either the text or the example. What else can I say; it is what it is, and the scope of the book is pretty clearly stated. AS2 is still widely used so I can live with it being used here...there's so little scripting in the book it doesn't matter anyhow.



3. I think the idea of a project guide is sound - walking you through the steps of creating a 'practice' site to get you familiar with the tools, but this particular instance isn't very well done. The book starts off ok, but towards the middle, around chapter 6, it starts to get really confusing, especially in relation to the timeline, one of the key aspects of Flash. The author did a poor job of displaying the workspace - cropped sections of the timeline, covered with activated menus make it hard to see what is going on. Also, the basic layout of the page could use some improvement - small snippets of text jump all over the page, when the instructions are numbered (sometimes they are, sometimes they're not. it's kind of like a game.) the numbers aren't prominent or aligned. Overall - good idea, bad execution. I would love a different book that takes me through the construction of a project, just not this one.



4. After being forced to buy this book for a web design course, about 15 classmates and I slogged through about two-thirds of this book before using it for skeet shooting. I am somewhat familiar with Flash from a 16-hour class, a full-semester course, various training videos on [...], and many web tutorials. Despite this modicum of knowledge, I found this book confusing, frustrating, and just plain wrong.
   
   As other reviewers have indicated, the illustrations are poorly conceived, steps are missing or out of order, and it uses ActionScript 2.0 although this is CS3 version of this book. It's true this is a "project" in Flash, not a systematic teaching text, but even those quite familiar with the program were having trouble following this workbook.
   
   Building an entire website in Flash can yield a very cool presentation (Starbucks and JK Rowling come to mind), but this would probably NOT be the best way to learn Flash initially. This book may have some value to exprienced designers and Flash mavens looking to begin working entirely in Flash, but for most folks, it's a waste of money.



5. I'm a Flash "newbie" who has just completed "Creating a Web Site with Flash CS3 Professional," cover to cover. In my career as a software evangelist for more than 20 years, I have written many tutorials and demonstration scripts similar to this book, which I found to be very well organized. It introduces the reader not only to techniques, but to best practices as well. And, unlike many of the online Flash tutorials in which you create a simple movie with a few animated circles or squares, in this book you create a sophisticated, good looking Web site.
   
   Yes, about a third of the way through the book the author begins to assume your knowledge of things already covered, and it becomes somewhat more difficult to follow the instructions. And a few times I had to go back and redo something I had done incorrectly at first. But in the end I had a fully functioning Web site, and I learned a lot about Flash CS3 along the way.

5 comments about Network Security: Private Communication in a Public World (2nd Edition) (The Radia Perlman Series in Computer Networking and Security).

1. Great book for learning cryptography, authentication, or about Internet Standards such as PKI and Kerberos. It is heavy on the math and theory aspects, the book actually includes an interesting chapter on Number Theory. The last chapter entitled Folklore is a refreshing way to cap off the book. The one catch is that there is little to no pseudo-code included with the examples, so you code junkies will have to start from scratch. Overall the author's attempt at a light approach to dense material helps ease the fact that it really is dense material. It covers the bases and has some nice extra material.



2. This is a very good book on network security. It is a bit too technical for leisure/work reading. I got this book because it is a required text for my graduate class.



3. I had to use this book when I was in Graduate school and this was the course book. I still have the first edition and looking to purchase the latest version. It was very interesting information I didnt get anywhere before. I remember in my company some very Sr. developers were working to understand how to implement machine authentication, and they were using it. Having used it before and with my course notes I helped them out. What a name for me :). I highly recommend it to anyone who wants to learn more about the network security. At least it is not as ridiculously expensive as Tanenbaum books. Yes it is very mathematical but remember this is a computer science book meant for actual software engineers. People with no computer science background but working in industry might find it difficult in the beginning.



4. This book is great. Hope the authors will plan to include wireless network security in the 3rd edition.



5. An elegant and detailed text on cryptography and network security. A good starting point for beginners and a fine reference for domain experts. The writing style is crisp and, at times, quite humorous making the book an interesting read.

5 comments about Purely Functional Data Structures.

1. This is the best book available on the implementation of data structures in functional programming languages (e.g. ML, Haskell). Unfortunately, much of the book covers esoteric data structures that will almost never be needed in practice. Hash tables are a major omission, likely because they don't fit well into a functional environment.



2. A correction to another review: Hash Tables are included, briefly.



3. Okasaki's slim volume is one of the best expositions on implementing data structures & algorithms in a functional language. After taking an introductory course on functional programming, this would be the book which tells you where to go next.
   
   This book doesn't just present a rehash/rewrite of imperative data structures, only written in a functional language. Instead, Okasaki makes sure to emphasize benefits which only functional programming can bring to the table. For example, many functional data structures can compactly represent not just their current state, but all of their past states as well--a feature called "Persistence". Also, functional newbie programmers might be wondering why lazy vs. strict programming is a big deal, and Okasaki shows clearly where data structures can benefit from either being lazy or being strict.
   
   For the advanced reader, Okasaki also presents several powerful techniques for analyzing the runtime of algorithms, including the so-called "Banker's Method" and the "Physicist's Method" for analyzing amortized algorithms.
   
   I hope that Okasaki comes out with a 2nd edition of this book; there is one missing piece in particular which I really wish he would have included: Although he presents an EXTREMELY lucid description of how to implement Red-Black trees in a functional language, he only presented algorithms for insertion and querying. Of course, deletion from a red-black tree is the hardest part, left here, I suppose, as an exercise to the student. If you want to supply this missing piece yourself, check out a paper by Stefan Kars, "Red-black trees with types", J. Functional Programming 11(4):425-432, July, 2001. It presents deletion routines, but you'll still want to read Okasaki's book first, for unless you're very much smarter than me you won't be able to understand Kars' paper until you read Okasaki's exposition of red black trees.
   
   Finally, this book is not just useful for programmers in functional languages; logic programmers, using prolog or a varient, will also find this book very helpful, because most of the techniques (all of the techniques, really, with the exception perhaps of the lazy programming stuff) can be directly applied in a prolog programming setting as well.
   
   After reading this book and implementing some of the data structures for yourself, you'll be amazed at how fast algorithms can run, even when written in a functional language!



4. The description of the book says it includes source code in both ML and Haskell. Unfortunately, the body of the text uses ML exclusively, and the Haskell code is banished to an appendix.
   
   I say "unfortunately", because many of the data structures used depend on lazy evaluation, which comes quite naturally to Haskell, and seems to require some sort of non-standard extension in ML.
   
   While the content is good, I wish it would have used Haskell as the primary exposition language.



5. If you are beginning to learn functional programming, this is a good book to study. It focuses much on the "no assignment" aspect of the functional style; a good place to start. And does this on one data structure after another allowing it to be easily understood by readers with a procedural background. For the more advanced reader, the algorithmic content of the book is good reading and I find myself picking this book every year or so just to entertain myself. The applicability of the data structures is limited in that most languages come with basic libraries that suffice most of the time.