5 comments about Dreamweaver MX: PHP Web Development (Programmer to Programmer).

1. While the content of the book is potentially good, anybody who needs a little handholding might get lost quickly as the author does not give much background information and skips many steps that are second nature to proficient developers. This is where the beginner puts this book away and the intermediate user struggles with finding more information on how-to-do a particular thing. (This starts with the setup of a Apache / MySQL / PHP server and ripples thru the whole book.)

   In addition to the content, the book is slightly disorganized and not the easiest reading material. Not so much because of difficulty but because of writing style.




2. I've found this book very useful for a PHP beginner as me. I could make the whole website working with Dreamweaver MX 2004, PHP5 and MySQL 4x on my local machine and test it on a webserver using PHP4x and MySQL 3x.
   
   Hints to work with this book:
   
   ON YOUR LOCAL MACHINE:
   1. Do not create password for MySQL
   2. When creating Database Connection in Dreamweaver, type in the username as root, but do not type the password.
   3. For Admin page, if you get an error, use the error handler shown on page 300, 301 to handle it.
   
   ON A WEBSERVER:
   Go through pages and specify host, MySQL username and password (don't miss page 254).
   
   I have enjoyed the book very much.
   
   Minh Lam



3. If you already know PHP then this book will be too easy for you. If you know Dreamweaver and want to get into PHP, this book isn't large and can help you a lot.



4. You could write a book just describing the errata and missing instructions for this one. Don't waste your money!



5. The book was exactly as described. Is in great condition and saved me a bunch of money instead of buying it through my campus bookstore. Delivery was fast. Will order from them again.

5 comments about Flash MX for Interactive Simulation (Macromedia Flash).

1. FlashMX for Interactive Simulation by Jonathan Kaye and David Castillo is one of the most informative books I have read in quite a while. Don't expect this to be a light read however.

   While the book was written primarily to teach you how to program Flash Device Simulations, it touches on many other facets of Flash design that are worthy of mention such as the use of Flash for educational instruction, usability testing, component design and much much more.

   This book and the software provided on the CD ROM will allow you to add structure to your actionscript programming and will allow you to create complex applications that are predictable and easy to troubleshoot and maintain after the fact.

   This book introduces UML state machine design into the Flash programming environment allowing complex applications to be easily developed that would otherwise have been very difficult.
   
   Because the state machine provides a structured approach to your design, it is predictable and more important, maintainable. Documenting your design using state charts allows others to test your application which is great for large projects where many people are involved with the various phases of the project.

   The state machine engine is provided on the CD ROM. This alone is worth the price of the book, not to mention all of the other goodies packed on the CD.

   If you like to learn by example, the CD contains plenty of great working samples that show you how it is done. Each example is covered in detail in the book so you can either learn by doing from scratch or use the book and examples as a reference.

   This is must have book if you are going to do any serious programming in Flash...

   Larry Fortna, President
   realatour.com - a division of Flash Solutions, LLC




2. Anyone who has a complex Flash project that involves more than a few `states' will find this book very interesting.

   If you have a project that involves simulating something and you are thinking of using Macromedia Flash or even just wondering if Flash is up to the job, order this book now. It will save you days and I mean days of work on a simulation project and when the amends come in, it will again save you from ripping your hair out.

   It doesn't come for free though, you will, unless your brain is very big, have to work at this book. Unlike many other IT books it's nearly all lean meat without the fat, miss a few vital paragraphs and you could find yourself confused further on. You will also probably find you will have to do some support reading to make sure you are up to speed on some of the topics that are assumed.

   If you get stuck, don't fear, as there is an excellent support website for the book, if you post a question on the discussion board, you will most likely get an answer from the authors of the book in 24hrs.




3. Jonathan Kaye and his collaborators know simulations and simulation building, and it shows in this book. A thoughtful, very deep look at machine simulation building and the state engines which power any good machine simulation, "Flash MX for Interactive Simulation" is not a light read. Anyone designing educational simulations in Flash MX must read this book. You may not run out and start desiging all of your simulations with his state engine (because it's complex and resource intensive to integrate into your production practice), but you'll be a much better simulation developer -- or ActionScript developer, for that matter -- for having read the book.



4. This book is a real disappointment. I bought the book based on all the raved reviews given below. Even though the treatment on the subject is pretty exhaustive, the authors manage to turn an interesting and useful subject into a very dry and complicated one through their use of language and horrible code (does that remind you of college textbooks?). Speaking of code, who is the technical reviewere for this book? (maybe there isn't one, I can't find it in the book) The code is so hard to read because of the abbreviated naming in the functions and variables. Can you figure out what this function tries to do: model.irh = function(msg, val) { ... } or this: s0.entActs = function() {... }
   
   I know negative review can sometimes garner negative reactions, and I refrain from giving one as much as possible because I can imagine the hardwork one has to put into writing a book, but I also think that a fair look at this book is necessary for the authors to improve. I urge that you take the time to read this book in the bookstore before you rush out to buy it, and my best hope is that I am wrong about everything I said here.



5. This book is a real disappointment. I bought the book based on all the raved reviews given below. Even though the treatment on the subject is pretty exhaustive, the authors manage to turn an interesting and useful subject into a very dry and complicated one through their use of language and horrible code (does that remind you of college textbooks?). Speaking of code, who is the technical reviewere for this book? (maybe there isn't one, I can't find it in the book) The code is so hard to read because of the abbreviated naming in the functions and variables. Can you figure out what this function tries to do: model.irh = function(msg, val) { ... } or this: s0.entActs = function() {... }
   
   I know negative review can sometimes garner negative reactions, and I refrain from giving one as much as possible because I can imagine the hardwork one has to put into writing a book, but I also think that a fair look at this book is necessary for the authors to improve. I urge that you take the time to read this book in the bookstore before you rush out to buy it, and my best hope is that I am wrong about everything I said here.

5 comments about Illustrator CS Killer Tips.

1. I bought this book based on the wonderful customer reviews and was very disappointed. Most of the items can be easily found by anyone exploring the menu bar or palette options. In my opinion such things don't qualify as "hidden secrets," as the cover claims.
   
   I did find one tip that I use (a keyboard command to reset the horizontal scale of type to 100%). It saves me, oh, a minute a month or so. At that rate the book will pay for itself in five years!



2. I do not agree with the 5-star reviewers of this title. If you have used Adobe Illustrator for more than, oh say 15 minutes, you probably know more than this book will teach you, and anything else can be found out by using the pull-down menu system, or the Help button.
   
   Okay, maybe not fifteen minutes, but there is nothing here, no "hidden" tips and tricks. And if the creative value of this title were to be measured from 1 to 10, it would rate a minus 6.
   
   I hear Dave's doing another book for CS2; however, if it's like all the other Kelby-clone titles, it will just be a rehash of this book with a few screen shots from the new application.
   
   Save your money on this title, and treat yourself to a nice dinner.



3. I guess "photoshop Junkie" must be an incredibly experienced Illustrator user to know all the tips in this book. I've used Illustrator for around 5 years and there were lots of tips that I didn't know. Okay, I probably could have found many of them by searching around in the Help Files, but why bother when they're right there in the book?
   There were enough tips in there for me to say it was worth the money. Why not 5 stars? Some of the graphics were not the greatest (although that really didn't affect the tips I guess, so I'd give it 4.5 stars if I could)



4. Unlike a lot of Illustrator books, this doesn't describe the full range of functionality or offer lesson plans. Instead, it's a compendium of hints and shortcuts, many of which are those niggling little things that you wish you knew how to do, but can never seem to find in the bigger, more complete books.
   
   I've bookmarked a lot of these nifty items: how to align items using one item as the "keystone"; selecting an object "hidden" by another object; and how to get that @&#*!$ knife tool to cut in a straight line. And there are many timesaving techniques and shortcuts, such as averaging and joining two points in one step. Not earthshattering, but a nice way to speed things up so you can spend more time on creative work.



5. If you do not have alot of time in your day and a basic understanding of Illustrator this is perfect. Each tip is just that a tip. Half page explanation, easy way to do things.

5 comments about Java Gui Development (Sams Professional).

1. Style is subjective, and I really disliked this author's style. I think he was trying to be eloquent at times (simply loves the word "abstraction"), but it sounded muddled to me. The introductory material seemed especially burdensome - endless repetition which doesn't provide real insight.

   And really dry. 140 pages of toy code showing the endless variations of all the event models. Other reviewers are correct that this book has way too many editing errors - especially in the code listings.

   C'mon - an introduction to Swing GUI development should be downright FUN! This book is simply too oppressive to recommend.




2. The book is an easy read and places emphasis an the common architectural themes that pervade the jfc. It describes many of the important elements of swing in detail, with clear perspective.

   It is lacking in ommiting some important swing components, but the book's clarity more than makes up for this.

   It is a gui roadmap rather than a gui bible




3. I am new to Java from C++. I have done some GUI development using TrollTech QT library. This book covers basic concepts of GUI development in JAVA. It literally takes the reader by hand, one step at a time with real sample code. I like the whole presentation of the book; it is quite readable and well organized. I can't believe that I have just covered the basics of AWT and Swing in one week! Of course development with QT has helped me a lot. Anyhow, this is a good book and I recommend it to others who are just embarking on drinking Java cups and making some Java cups :-) Good thing also that the author did not distract the reader with exercises at the end of chapters! This is not a college X101 course indeed. Good.

   Merci bien




4. I liked this book. I am new to Java from C++. I have done GUI development using TrollTech QT 2.X. The author has done a very good job taking the reader by the hand, enphasizing on key concepts, and providing working sample code for nuts and bolts. I like the fact that the author did not distract the reader with exercises at the end of chapters. Always makes me feel like in some X101 class I took twenty years ago! Good book, well organized. The explanation about the 'lightweigthness" of Swing compared to AWT is a bit unclear, should have done better.
   Overall, I recommend this book to anyone who would like to learn Java fast, and Java GUI development definitely. I just can't believe that I have covered the basics (enough to be dangerous!) of AWT and Swing in just one week! Thank you Mr. Vartan



5. This book is a superficial (at best) review of the Java classes needed to build Java GUI's. It does cover some AWT concepts in the first 100 pages, and very briefly covers a few key Swing concepts.

   Most of the book is one (sometimes 2 or so) pages briefly describing each GUI control with a simplistic code example (with errors). You could get just as much information from reading the Javadocs!

   I'm an experienced Java programmer and originally purchased this book some time ago in hopes that it would cover GUI topics in depth. I was very disappointed in the depth of material. I would not even recommend this book for beginners because you can get just as much information readin the docs or from other sources.

1 comments about Building European Spatial Data Infrastructures.

1. European governments and the EU are promoting geographic information technologies to help citizens get access to location-based information, and so both computer and business libraries at the college level will find essential Building European Spatial Data Infrastructures, a guide to SDIs which include the spatial data, technology and policies needed to exchange, use and manage such data. Author Ian Masser is one of the world's SDI experts, but here he's able to provide a nontechnical guide to how GIS is used in both government and private endeavors, making his guide surprisingly accessible across genres.
   
   Diane C. Donovan
   California Bookwatch

No comments about Dreamweaver and Flash Bible.

5 comments about Flash MX 2004: Graphics, Animation & Interactivity.

1. This book is jam packed full of great stuff. The illustrations are excellent and a lot of subjects are covered in detail. It goes beyond what you get in some other beginning books. It's well written and the CD has a lot of good stuff.



2. As an instructor of Flash, I have used, since version 4, James Mohler's Flash book as a supplement to my course content. For Flash MX 2004, Mohler has kept with his consistent, user-friendly style of writing and accessible way to instruct a somewhat complicated program.



3. Being completely new to Flash and any kind of media development, Mohler's book was a great place to start for me. It provides numerous exercises throughout the book so that the reader can get hands-on experience while learning about Flash. Many of the exercises are quite useful and some of the techniques I was able to use immediately for the project I am working on. Each topic covered: 2D animation, 3D animation, video, sound, ActionScript gives enough of the information to the reader so one can continue exploration on their own. I will say that ActionScript treatment was a little too basic (that may be a software engineer in me speaking), so I bought two additional books about it. Also there are some errata, but think of them as trick questions to test your understanding. :-)
   Overall, this book is a great place for a newbie to get started with Flash.



4. I got this book to learn Flash MX 2004 and while I did find it helpful and informative, I found that missing steps in some exercises forced me to take my mind off learning the techniques involved and left me scratching my head. Some times I could examine the sample files on the CD and figure it out for myself. Other times I just got frustrated and skipped on to the next section -- hoping I'd find another source on how to do whatever it was I skipped should I need it in the future.

   The author's lack of naming of symbols and letting Flash label them (Symbol 1, Symbol 2...) made it difficult to take the samples apart to figure them out on my own. In one exercise you are told to create two symbols yet the sample file has 25 symbols. Huh?

   A keyDown events exercise has "mouseDown" trace responses? The instructions say to "Select Press from the list." for a mouse event yet the sample code and references are on "release?"

   I found the references to the way Director works a bit distracting as I've never used Director. Might be useful to some but why not sidebar it or stick that in an appendix so the rest of us and skip it? Maybe put the 3D chapter there, too, since you really need to use another app to do it

   I was hoping to find errata material on the publisher's web site to make up for the book's shortcomings as it really does have potential and I have learned from it. Nope. Sigh.

   This might be a good classroom book with an instructor supplying the missing pieces and an copy editor having gone through the text. As a learn on your own book there's a lot of room for improvement.




5. All in all, this is a great book. I am still going to give it 5 stars despite some errors.
   
   As other reviewers said, some of the instructions for the exercises in the book don't match up exactly with the files on the CD. For instance, one step told me to add a symbol to the stage from the library that wasn't in the library of the file I was supposed to be using. However, most of these mistakes are small and can be easily worked around.
   
   As a whole, the book is well-written, clear, and accessible for the Flash beginner. The layout is nice, and the indented hints are helpful. The training projects teach very useful techniques. The index is complete and makes the book especially easy to navigate. Some of the sections of the book are a little "too" extensive for the intermediate-advanced user, but non-beginners could just skim these sections.
   
   I highly recommend this book to those wanting to get a good grasp on Flash concepts and basic techniques that are useful in many applications. Other books may have more extensive sections on Flash web page development, but as far as "graphics, animation, & interactivity" go, this is an excellent book.

5 comments about Delphi Graphics and Game Programming Exposed.

1. This book really helped me. Didn't you people read HOW TO INSTALL THE HEADERS?! All the samples work for me and I'm right now writing my first game as I go along. When the back cover says "intermediate to advanced" it means intermediate programmers
   NOT intermediate GAME programmers. I do wish it covered 2D in Direct3D though, because in DirectX 8.0 and up you MUST do things this way but nothing off as at print time DirectX 6-7 were current and many people still use 7.



2. I don't know what it is about this book but I liked it a lot.
   The book has a special vibe; it is casual but it leaves no detail out in what it's aimed at.
   Unlike other technical books where you would skip sections this book keeps you reading from begin to end.
   Sure it's not sophisticated, no 3D for instance.
   But it's great for example for people who're coming from Turbo Pascal like me and want to explore Delphi and games(using DirectX). So it is a good primer presented clear and understandable. And no no not beneath beginners.
   And great 2D games can be made with this book as a background.
   2D games still have their place in the entertainment world.
   I'm not saying that you should necessarily learn how to make 2D games to be able to make 3D games but it's an asset. You people shouldn't ignore the "gamemaking thinking" that comes with 2D game manufacturing. But as the author points out in the book if you really wanna make 'em big, you hafta have artists involved in your project.

   ps: if you notice that im from Belgium: I have the same edition and in English.




3. I too thought there would be a little 3D in this book, but I can understand why there isn't. 3D Game programming is absurdly complex. You need to get the basic concepts and feel of game programming down in 2D (well, it's a good idea anyway).

   Many complain about not finding the CD Key... it's on a card that sticks out like a sore thumb in the back of the book. Look a little harder.

   This book is not a comprehensive guide to game or direct x programming (or Delphi). However, what it can do is provide you with the means to jump right in and make a game. What I'm talking about is ready-made basic 2D game engine's that can be modified to do just about anything. The book gets you the basics on graphics, sound, sprites, controls (even force feedback), special effects and a bit more.

   I was introduced to this book by taking a graphics class in my 4th year of college. We barely used the book (because we only touched a little direct x at the end), but I spent the end of that winter break and much of the following months making a Tetris style puzzle game. If you can get the example programs to compile/run, you should be able to modify them to do your bidding.




4. This book is useless and stupid also for beginners.
   Please don't buy it



5. I recently bought this book and it is, as several reviewers say, out of date (not the author's fault although it would be nice if the publisher came out with an updated version). Several reviewers also, however, comment that the book is worthless because the Delphi 4 version does not come with the key. This is a problem. However, the authorization code is available on the publisher website (www.wordware.com). Of course, Borland has come out with several versions of Delphi since then but Delphi 4 is still a good compiler and a great way to start up with Delphi (especially if you aren't wanting to get into .NET right away).
   
   I'm pleased that I bought this book and am looking forward to experimenting with the code. As author Ayres points out, he's trying to equip us to write shareware games, not become professional game developers for slave-labor game shops.

3 comments about Design Concepts with Code: An Approach for Developers.

1. An introduction to web design for those coming from the technical side of things, this book covers many aspects of graphics and UI design, but sometimes falls short in its allocation of page space and in the technical details.
   Strength: Design fundamentals as applied to websites.
   Great discussion of Line, Type, Shape, Texture, Space, Size, Value and Layout etc. Although I have been designing web sites and simple printed material for years, I found the exercises and explanations in this book refreshing and useful. Also liked the emphasis on clear communication with the client and common pitfalls. The discussion of color in chapter 8 was particularly well done with clear examples printed in full-color.
   Weaknesses: Reliance on SVG.
   Although I am an avid supporter of SVG, I found that this book's reliance on the technology and excessive printing of code to be distracting. I counted 75 pages of verbose SVG code and 25 pages of general XML/XSLT/ASP/HTML code printed in a 350 page book. Also, although well suited for bridging the technical-aesthetic gap, SVG still lacks widespread browser support, and no web developer worth his salt would actually build a professional website in SVG today, a point which the authors should have acknowledged more clearly. However, the XML/XSLT/XHTML/ASP examples used later in the book effectively illustrate how these emerging technologies can be combined into a single project.
   Summary:
   As someone with experience in web technology and design, I found several minor flaws in the technical assertions made in the book (browser compatibility), but enjoyed the non-technical design / interface portions which, to be fair, was the focus of this book.



2. One of the books I recently finished reading for review was Design Concepts With Code: An Approach For Developers by Kelly Carey and Stanko Blatnik (Apress). While this book might appeal to some niche of website design and development, I don't think I'm part of that group.
   
   The chapter breakdown: Introducing Interface Design; Introducing Design Principles; Project 1: Building an Open Source Portal; Implementing Design Elements: Line, Type, and Shape; Implementing Design Elements: Texture, Space, Size, Value, and Layout; Project 2: Building an Online Resource Center; Working with Content and Typography; Using Color; Project 3: Building a Webzine; Exploring Site Issues and Accessibility; Index
   
   This is a different book that is hard for me to describe. There are a number of abstract sketches in boxes that are about 1" x 1". The reader is asked how they would interpret the lines and they are given three choices. They are then told which answer is correct as far as the attitude and mood that is suggested by the design. Each sketch is followed by Scalable Vector Graphics (SVG) code to show how that sketch is coded. After a number of these exercises, the concepts are used to show a design of a web page or site that incorporates that type of design to create the proper sense and feeling.
   
   If you're a graphic designer of web sites, you would probably get something from this book. A developer (or at least *this* developer) would have a much harder time getting past the "here's a picture and here's the right answer as to what it should mean to you" style. Outside of that, the incessant use of showing each sketch's SVG code seems to be nothing more than a space filler. I would have much rather seen something like this be downloadable from a website and to skip the endless code listings. I guess I misread the title Design Concepts With Code. I was thinking the book would cover how your code can show design concepts, not to show design concepts with code printed for each picture.
   
   I won't say it's a bad book... It's just got a few flaws I would have done differently, and it definitely isn't a book that will appeal to everyone.



3. I don't know who the authors thought the target audience for this book is, it's defenetively not me. Why I have to read about 'dealing with clients' in a book supposedly about design concept, I don't know. And what I gain by reading broad statements like 'clients like to talk about their company' is a mystery to me, too. There are several areas in the book where the authors are simply wrong.
   It's true what they say: If you're not good at something, teach it.

2 comments about Computer Science with Mathematica.

1. This would be a good book for you if you understand computer science, but don't know anything about Mathematica. Maeder provides examples from physics, differential equations, data sorting, etc, showing how these problem can be solved quickly in mathematica. In the examples, however, Maeder does not always explicitly explain what the Mathematica commands are doing. Every example in the book is downloadable from his website, but he sometimes refers to files under the assumption that you have downloaded them. The most useful parts of the book for me were the section on OOP within mathematica and the section on preparing your programs for distribution.



2. As a symbolic programming language, and as one that can effectively emulate most programming paradigms, Mathematica is unequaled. In this book, the author makes this abundantly clear as he takes the reader through a sampling of the power of Mathematica, with the target reader being a computer scientist without a knowledge of Mathematica.

   After a very brief review of computer concepts and architectures in chapter 1, the author begins chapter 2 with an overview of the syntax of Mathematica. The most helpful points in this chapter were: 1. How to implement piecewise-defined functions. 2. Pure functions. 3. The ability of Mathematica to do functional programming via functional operations. 4. Normal expressions and atoms.

   Chapter 3 is an introduction to iteration and recursion. The author begins the chapter by showing how to use rule-based or recursive programs to construct a program to calculate the greatest common divisor of two integers. He is careful to note however that the use of recursion may be inefficient and so he shows how to convert the program to one that uses loop iteration. The contrast in inefficiency between iterative and recursive programs is illustrated again in the next section which deals with the Collatz problem. An iterative computation of the Collatz sequence is given, and the author encourages the use of loops and not recursion, to obtain efficient programs. The author shows how to use loop invariants to test program correctness for loops. The engineer/physicist reader will appreciate the application of iterative methods to the solution of ordinary differential equations.

   In chapter 4, the author shows how to build packages in Mathematica, via an example in complex variables. The role of contexts in Mathematica is made very clear, as well as how to handle options in the package.

   A discussion of abstract data types follows in chapter 5. The author defines these in the usual sense of being independent of implementation and he introduces the concept of a model. The ring of modular numbers is chosen as an example of how to design and implement data types in Mathematica, and he shows how to make the data type for this ring independent of implementation by using constructors and selectors. The discussion in this chapter is not found in the usual Mathematica books, so it is invaluable for a more in-depth view of the capabilities of Mathematica to handle abstract data types.

   Topics of a more applied nature are discussed in chapter 6, wherein the author gives Mathematica algorithms for sorting and searching. The graphics capability of Mathematica is used to illustrate the properties of these algorithms and the author shows how to design a binary search algorithm that is polymorphic, i.e. one that can be used to search collections of data of different types. Dynamic data structures are illustrated via the binary tree.

   The computational complexity of algorithms is discussed in chapter 7. The author uses the computation of the nth Fibonacci number to compare the complexity of different algorithms. A recursive algorithm is given for this computation, and shown to be of exponential complexity. This algorithm is improved upon (given a quadratic dependence in the number of steps) by using a technique from dynamic programming, wherein each computed Fibonacci number is stored as a rule. For those involved in encryption algorithms, the discussion on long-integer arithmetic and fast multiplication should be helpful. The Karatsuba method for multiplying two integers is implemented in Mathematica.

   Chapter 8 is devoted to linear algebra, wherein the author shows how to implement basic matrix multiplication and inner and outer products in Mathematica. In addition, he shows how to do vector calculus using Mathematica, and defines the divergence operator, the gradient, the Jacobian, and Laplacian. Most importantly, the author shows how to program with dynamic data structures in Mathematica, this being relatively straightforward since Mathematica does garbage collection. The heap data structure is analyzed in detail as an example.

   Chapter 9 is a more detailed overview of lists and recursion in Mathematica. Readers interested in artificial intelligence will appreciate the discussion because of the connection with the LISP programming language. Although short, the author does give a convincing treatment of how to operate on data structures via their selectors and constructors.

   The discussion in chapter 9 on rule-based programming was the most important to me, as it was helpful in bringing out the pattern matching capabilities of Mathematica. If one is attempting to implement such as inductive logic programming or stochastic logic programming in Mathematica, this chapter is a good start in that regard.

   Chapter 11 could be viewed as a discussion of how the lambda calculus from mathematical logic is implemented in Mathematica. The ability of Mathematica to emulate functional programming is one of its most powerful features, and this is illustrated nicely here.

   The topics in chapter 12 are more theoretical in nature, and those interested in this facet of computer science will find the discussion on primitive recursive functions fairly convincing. In addition, the author gives the Mathematica code for simulating a Turing machine. He shows via Mathematica, that recursive functions are Turing computable.

   The author gives an introduction to databases in chapter 13. He shows how to perform the relational algebra in relational databases using Mathematica. Although the practical value of this chapter is limited since one would probably not want to access databases using Mathematica, the treatment does allow an understanding of how databases are constructed.

   The last chapter of the book is a very interesting discussion on how to implement object oriented programming in Mathematica. The author shows how to implement containers using Mathematica and gives the class hierarchy associated with the collections. The interval, list, and set are given as implementations of collections, and the array and dictionary is given as an implementation of an indexed collection.