Software Books

I am not an expert developer but I have a fair amount of experience building financial applications in Java and C++. I spent quite some time looking for a book that would get me started with Web technologies. It is not easy. Yes, there are many books that describe one or another technology but I wanted to find one that puts these technologies in prospective. I was very pleased when I found this book. I can always dig deeper in one direction when I need to but this book helps me to understand how to get started and where to concentrate my efforts. I like it, I think it is very useful.

I have to disagree with the reviewer who disparaged this book's emphasis on history. The background on TCP/IP protocols explained how HTTP came to be and why servers and browsers work the way they do. Discussion of how web development platforms evolved provided insight into the problems newer approaches tried to solve and the problems some of them created. The authors may have gone overboard spouting the merits of "separating content from presentation" and touting the praises of MVC approaches, but their point is a valid one you can really relate to if you've worked with page-centric platforms like ASP and JSP. The historical review of different approaches explained the authors' reasons for ultimately choosing an MVC approach with Struts and JSTL, and offered insights into how development platforms may evolve in the future. This is a book that starts with basics and builds on them, covering protocols, markup languages, and development platforms. The history helps drive the points home. Personally, I learned a lot from this book. I agree that they could have provided a CD-ROM, but it turns out their website (webappbuilders.com) is pretty good and has other good info aside from the app's source code, including some articles from the authors.

This book is an ideal text for providing intermediate-level web developers with a solid grounding in architectural principles and more advanced techniques. Before going into why I like this book I do want to offer one caveat - the authors' approach is towards the Model-View-Controller paradigm, and is based on Java Standard Tag Library, Jarkata struts and Apache. These are solid elements, but if you are working in a different environment you will not appreciate this book as much.

The historical material in this book is not fluff if you approach it with the intent to gain a fuller understanding of the major components of the Internet and web. This material is rich with details about why the core web technologies developed and evolved, including design choices the pioneers made in the face of constraints. In a subtle way this part of the book is a primer on design and architecture.

What makes this book so valuable is the non-trivial application that brings this book alive. This is a refreshing change from other books that use thinly contrived snippets of code or trivial applications. The code for this application can be downloaded from the book's supporting web site, which also contains errata (thus far there are only two entries), and articles that are valuable resources with or without this book.

Overall this is one of the better books on web application design and development, and one that dives into code and technical details.

I've been writing Windows-based mutlimedia applications since Windows 95 was released. I've been looking for a good book to help the crossover to web application development, and I found that this was just the ticket. Explanations were solid and presented in a way that made experimentation easy (both from the browser and server side). Quite simply, this book served as a great jumping off point for deeper exploration into session management, security, web services (both SOAP and Rest), etc. Definitely a great introduction for folks with a software engineering background.

I always thought Amazon search is good but I stumbled upon this book at a store. It's a useful summary, but not a reference. I particularly like the examples and the way they build up from trivial to complex. The level of detail is right. Altogether, very refreshing.

Steve Heller does it again, this time pushing the envelope. It continues where his Introduction to C++ left off in Who's Afraid of C++, and gets into more complex topics. The book provides another great stepping stone into the world of C++ programming. Its a great book, and worth the read if you are a bit more than a novice, or you have read the previous one. It not only tells you how to program in C++, but explains why you do certain things, something which other C++ books skip on because they assume you've already learned C. You don't have to learn C to program in C++, this book proves it, and if you know C++, then its a snap to do a little C programming.

1. Steve writes VERY well. 2. The interplay between Steve, and Susan is very engaging (it ought to be, ... they got married) 3. Steve uses iterative improvement to demonstrate how software really gets written. 4. He admits to his mistakes, at least some of them ;-) 5. He presents the material in a way for the reader to add new knowledge to a solid foundation.

Steve, you done good!

I've read some of the more technical language references for C++, but I'd always end up just using them to look up stuff when I got stuck. This book (and the first Who's Afraid...) both have a casual and clear tone that makes complex and abstract concepts seem to make perfect sense if you slow down and especially if you read the questions asked by the "student". About 1/2 to 2/3 of the time I had the same question. Some people won't like the fact that it's not purely a technical book, but a little story goes a long way in making a book interesting enough to read through instead of wade through.

Following the lead of the first book, "Who's Afraid of C++?," this latest volume does not skip a beat. While most books _show_ you how to write _code_, this one _teaches_ you how to be a _programmer_. The two are not synonymous. Through the object-oriented development of a realistically sized application, the reader is engrossed in the software design process. Features of the C++ language are introduced as their need arises in the program, giving the reader a great perspective on why they exist and how they are used effectively in real programming situations. You will learn how to truly utilize C++ as the tool for solving problems and designing great software. At the end of this book, you will have the tools necessary to advance in the world of C++ with great confidence. Without reservation, enthusiastically recommend the two "Who's Afraid of..." books to anyone interested in truly learning C++. I pity those who have to learn it any other way!

The genius of Steve Heller has created a masterful sequel to his original work "Who's Afraid of C++." His treatment of complex topics like encapsulation, inheritance, and polymorphism demonstrates an understanding of the difficult process of learning advanced C++ concepts. Steve's goal is to help the reader understand how to create his or her own class as opposed to simply referencing classes created by others. His writing style, which includes using a student-teacher dialogue, is unique in the world of C++ instruction. All of the topics covered follow a logical progression of thought. His in-depth treatment of memory addresses and program instructions enables the reader to see at a glance the complex workings of the execution of a C++ program. The highpoint of the book has Steve teaching a unique method for the creator of a class to hide pointers from the user of a class in order to prevent many of the common memory-allocation problems associated with C++. As he did in the original "Who's Afraid of C++", Steve encourages the reader to build a working example of the techniques covered in the book. The software included with the book has the source files used and a C++ compiler on CDROM. There is also an e-mail discussion group that allows the reader to contact other readers and Steve himself regarding issues covered in the book. In addition to all the C++ covered, Steve offers his thoughts on the Y2K problem and its consequences. If you really want to understand C++ and develop your general programming skills, you can't go wrong with this volume.

I was told about this book by a co-worker who took classes with Professor Giannini. We were discussing a new project I am starting which required some internet and database access code, which (since I have done mostly GUI programming) I wanted to brush up on quickly.

This book was very well written, and seemed to address exactly what I needed. I found the sections on CGI and COM very helpful on the Internet side (part of our project is a ColdFusion page using a COM object), and the comparison of various database approaches like ODBC vs. DAO very helpful. The sample programs comparing the different database technologies was a great idea.

My only complaints would be that the index was a bit hard to use, and there was no CD provided. But, I was able to locate the source code for download on the authors FTP site.

I recommend this book for anyone familiar with programming, that needs to get working quickly with some new specific aspect, like Internet or database.

I got this book because I was tired of diddling around with the MFC Socket classes, and none of my other books seemed to have much material outside the predefined classes (CInternetSession, CHTTPFIle, etc.). I was very glad to see the source code for the CPNSocket class, and it explained a great deal. Seeing the MFC classes just completely bypassed, seemed to prove my own frustrations.

Then, looking at the other chapters, which is rich in MFC examples, I decided I had made an excellent purchase. If you are an MFC programmer at any level, I highly recommend this book.

This book covers a lot of material on both API and MFC programming for Windows. I got it mostly for the Internet topics, since it seemed to have a pretty wide range of topics, including ISAPI extensions.

The sample programs, an FTP program, an emailer, a link lister, and others, were all very neatly written, and the source code described them in good detail. The socket class described in the book as a replacement for the MFC classes, was an amazing piece of work, and discussed each function in a clear understandable manner. I got everything I wanted out of this section, without having to purchase multiple books.

I'm glad to say that I now feel comfortable with several new technologies (to me), and have some excellent sample source code to help me understand it all. Increasing your knowledge in as many possible directions is important in this field, and this book helped me.

It's hard to say where this book fits in exactly, but it does several things nicely. One, it has a very broad range of topics. Going from basic windowing into database and internet programming, but showing the code and step-by-step instructions for each. I didn't read any of the beginning chapters, but then happened to find an interesting section on MFC subclassing with a great demo, and decided that I should probably go back and read the first part.

I especially liked the chapter on database access, and the fact that there are 3 programs that are identifical in every way except how ODBC, DAO, and ADO work with the data. That gave a great chance to compare the various methods. The introduction on database access was good for a beginner, but also had some interesting observations and hints for the more advanced.

The section on the Windows Installer, and creating installation programs is also a topic I hardly see anywhere, so having it all in one nice package was great.

If I had to nitpick, maybe there could have been more on Active Directory for Win2000. But, Win2000 was covered enough to get you started, and the PocketPC programming was covered in a bit more detail.

Summary: I liked it alot. It is right on my shelf now with the Kruglinski and Petzold books.

You can't go on a holiday to Portugal armed with only a Portuguese dictionary and grammar book and hope to converse with the local people. You will be forever turning the page here and there to construct the sentence you want to say. What you need is a phrase book: a book containing common and useful phrases such ` Where is the nearest tourist office please?' or `When is the next train to Lisbon?'.

That's what this refreshingly straightforward and intelligently laid out book, written by Keogh&Giannini, is. It is a phrase book for Windows programmers. The most common scenarios are discussed, with full code given. You won't find obscure situations such as those found in Petzold's oversized Windows Programming book like how to draw an elliptic circle in a window! What you will find in this concise book is useful code such as creating an application where the main window is a dialog box used for data entry through edit boxes. (This very common and fundamental of situations is not addressed in Petzold's book).

Each example is explained sufficiently enough for any programmer to build on or tailor to their needs. And the core explanations are embedded within the code so you won't have to laboriously cross reference with the main body of the text. How refreshingly intelligent is that?!

Whats more, for those new to the Visual C++ environment, step by step instructions on how to use it to enter the code and build it are given in list form e.g. 1) Select File/New menu choice 2) select the Win32 Application project type, and so forth. Most Windows programming books often make the assumption that you know your way around the environment.

And you will find each example written in both MFC and Windows API! Name me a book that has done that?!

The problem with so many Windows programming books on the market including Charles Petzolds and Joseph Newcomers is that they are basically dictionaries, grammar references of the Windows language. They are inaccessible. If these books were to be useful to anyone it would only be to a seasoned Windows programmer who already has a feel for the language, but definitely not for a beginner. These books are not practically organized and don't fit the needs of today's developers. For example, discussions on essential topics such as dialog boxes are left until chapter 11 in Petzold's classic; in Keogh&Giannini's book, it is discussed in chapter 3. And Petzold's book misses a number important programming issues. These are not my own criticisms by the way. These criticisms are those of Dr Dobbs Journal, arguably the most technical journal in computing, certainly more so than those that Petzold decided to quote on the back cover.

In Keogh&Giannini's book , there are bonus chapters on database programming (ODBC), internet programming, Windows CE and 2000 programming, threads, ActiveX controls and lots more.

I am giving this book 5 stars because it is head and shoulders above the rest in terms of accessibility, completeness, conciseness, modern refreshing style, and its use of novel approaches to speed up learning for the impatient novice Windows programmer.

I have shelves filled with computer "How To" type books and in the past have stayed away from the "Dummies" series thinking them to be a bit too simplified. However, recently I needed to get up to speed with Microsoft's Access, specifically in order to prepare reports. So I bought Access Forms & Reports for Dummies by Brian Underdahl. I found this book to be a refreshing diversion from the normally dry and sometimes obtuse computer books of the past. Mr. Underdahl has a colloquial writing style which is not only entertaining but highly informative. Within a very short period of time I found myself successfully creating Forms and Reports which made my work go much smoother. I highly recommend this book to anyone who needs to understand Access and quickly create Forms and Reports.

Access is, of course, a database program. Unlike many of the big database programs, it is closely integrated with a quite sophisticated front end package to enable the creation of easy to use input forms and quite good looking reports to take the data stored in the database and present it to the outside world in a clear and useful format.

A database is useless unless you have a way to put data into and take it out of the database. This book mostly covers the setting up of input forms and output reports. It obviously won't be your only Access book, because you'll need something to describe how to set up a database. So this is a specialty book, that does an excellent job of covering this important aspect.

Selecting data out of the database to then present is sometimes a problem. Most beginning books just use the Access QBE to produce the data. Often this is enough, but this book goes just a bit into SQL that allows you to do so much more. While this is not a book on SQL, this is a good start to give you enough information to know if this is a direction you need to go.

All in all, this is a very useful book to enable you to get more utility ot of an Access database.

First, it is important to realize what this book is not. It is not a complete Access reference book. It will not teach you database theory and all aspects of data normalization. It does not cover advanced techniques such as VBA programming, the ADO object model or using the Windows API.

So what do you get from this book? A fantastic introduction to developing forms, reports and queries. In the tradition of the Dummies series, the author gently guides the novice towards building expertise in this narrow but all important aspect of Microsoft Access. With a conversational style, each step in creating a report, form or query is clearly explained. Also, the reasons for creating a report or form, and the differences between the two are presented. Although the title doesn't mention queries, because they are integral to producing reports and forms, several chapters deal with queries. Finally, two chapters discuss enhancing queries with SQL and troubleshooting those queries when things go wrong.

In summary, by spending a few days with the author, via this book, a beginning Access programmer can quickly become adept at designing forms and generating reports.

I use Access daily and thought I knew it pretty well. But this book really showed me a lot of new tricks I couldn't find anywhere else. This is by far the most useful book on Access I've found!

I bought a bunch of Access books, but this one is by far the most helpful one yet. It shows me how to do a lot of things I've wanted to do, but simply couldn't figure out on my own (or from any of those other books). You really need to add this one to your collection!

'Advanced Excel for Scientific Data Analysis' is one of those niche books that is absolutely the standard in the field. Warning/fact #1 is that this books is NOT NOT NOT for the every day regular Excel user. Repeat, this book is NOT for you. Jam-packed full of mathematical equations without a high amount of screen shots, this book is for mathematicians, physicists, econometrics people, statisticians or anyone that needs to go way way past the normal 'AVG' and 'SUM' functions found in Microsoft Excel. This is not light reading and its about as pinpointed to a specific audience as can be.

If you are a power Excel user go buy this book immediately and you will learn how to release its power better than ever before!!

***** HIGHEST POSSIBLE RECOMMENDATION

Do you need a spreadsheet tool to analyze experimental data? If you do, then this book is for you! Author Robert De Levie, has written an outstanding book on advanced Excel that shows you how to conduct the numerical analysis of experimental data, such as are usually encountered in the physical sciences.

De Levie, begins by describing some of the standard mathematical methods, such as numerical integration and differentiation, and how to perform these most accurately on the spreadsheet. Then, the author examines precision--with random fluctuations and their reduction or removal. Next, he shows you how to apply the least squares methods to polynomials in the independent variable x, and to multivariable functions. The author continues by describing the nonlinear least squares method, where one compares a given data set with a model expression that depends on one or more numerical parameters.
In addition, he also deals with the application of Fourier transformation in numerical data analysis, rather than instrumentation, where it is often built in. Then, the author discusses the use of time-dependent signals. He also describes particular types of errors: The algorithmic deviations caused by replacing a differential equation by an approximation thereof. Next, the author will show you how to copy spreadsheet data into a macro, manipulate them, and return the result to the spreadsheet. He continues by looking at some common mathematical operations, often encountered in scientific data analysis, and their numerical implementations on the spreadsheet. In addition, the author shows you how to extend the set of tools available for matrix operations in Excel. Finally, he focuses on three types of spreadsheet-related errors: those that are rather easy to make on a spreadsheet, those that result from Excel's adherence to the IEEE-754 protocol, and those that are in hidden in Excel.

The author of this most excellent book has made a great effort to make it as broadly useful as possible to the reader, and to incorporate examples from different areas. More importantly, the author believes that this book offers instead, an attempt at the synthesis of different areas, thus illustrating how many numerical problems can be fitted comfortably in the convenient, user-friendly format of the spreasheet.

Every modern scientist and engineer relies upon some type of software for the analysis of data. Many software programs are available in the market today and each seems to have its own unique code and learning curve. In the PC world, perhaps no other software for data analysis is more common and easier to learn than Microsoft Excel. Many high school students are already using Excel for their homework assignments. All of these features make Excel an attractive analytical tool for scientists and engineers at university and afterwards. All such tools need reliable tutorials in order to train users to harness their full capabilities. Most available literature on Excel is introductory in nature, and therefore not appropriate for advanced applications. Robert de Levie's "Advanced Excel for scientific data analysis" helps fill in this void.

Prospective readers should be aware that this text is not appropriate for beginners. The author clearly alerts readers to this point in the preface. This is also readily apparent from browsing the Table of Contents. I was skeptical at first with some of the more advanced applications such as solving differential equations in Excel. Many scientists use higher-level programming languages such as Mathematica and Matlab to solve differential equations. While such software packages are quite powerful, they also have steep learning curves. I previously thought that Excel is not capable of solving differential equations, but Chapter 7 turned me into a believer.

The major emphasis of the examples is on least-squares and Fourier transformation. Chapter 2 does a nice job of contrasting Excel's three available routines for linear regression. The author does a very thorough job showing how Excel can be effectively used for Fourier transformation, and gives many examples. However, some other useful mathematical topics are either covered minimally or omitted entirely. For example, I was disappointed by the lack of a routine to calculate eigenvalues and eigenvectors. Excel's array structure makes it well-suited to linear algebra and the author should consider adding more on this topic in a future edition.

One of the greatest strengths of the book is its detailed coverage of Visual Basic for Applications (VBA). Advanced data analysis require the use of special user-defined functions, and VBA allows one to extend Excel capabilities to satisfy this need. Unfortunately, VBA code sometimes conflicts with Excel code. For example, the square root operation in Excel is SQRT, but in VBA is SQR. While the author certainly has no control over this, he does an excellent job alerting the reader to these pitfalls.

Chemists definitely need a reliable tool for the analysis of experimental data. de Levie's book covers most of the techniques we use in our lab. The book clearly demonstrates how Excel is not just a convenient tool for plotting data from the stock market or keeping track of students' grades, but a powerful tool for scientific data analysis. This book is highly rercommended for all students and research workers in the areas of analytical and physical chemistry.

If I had written this book I think I would have called it Scientific Excel rather than Advanced Excel. To be sure, the book is certainly for advanced Excel users, but it won't help you do an advanced business application.

You'd best have some knowledge about Excel before starting this one. There's a brief survey of Excel at the beginning that starts off comparing a spreadsheet to an accountant's ledger. That's pretty basic. Anyone with any Excel experience at all can follow the first three pages. On page four he is talking about making a thousand point plot with random numbers, normal distribution -- no longer something from Excel for Dummies. By page 5 he's calculating averages and standard deviations. By the end of this Survey chapter he's talking about the accuracy of the calculations performed by Excel.

Subsequent chapters discuss various types of mathematical manipulation that are often needed in the analysis of scientific data.

There are three chapters on Least Squares. This is the fitting of a curve to collected data so that the trends might be more easily visualized.

There is a chapter on Fourier Transformations, which is the probably the most frequently used analysis tool when working in signal processing. Geophysical seismic data, radar receivers, cell phone systems are all processed primarily using Fourier Transforms. This kind of data is of course too voluminous for Excel, but the techniques used here would be ideal for quite a number of laboratory applications.

A couple of chapters cover convolution, deconvolution, and time-frequency analysis as well as Numerical integration of ordinary differential equations.

All of these processing tasks are done using macros. These are described in the book, or can be downloaded from the author's website -- www.bowdoin.edu/~rdelevie/excellaneous/. This web site also includes some additional macros that enhance Excel's computationability when handling numbers of higher precision.

The final four chapters of the book are on writing your own or modifying existing macros, with an orientation to scientific analysis.

I consider this to be almost a mandatory book for anyone interested in using Excel to analysis scientific data.

This book does not give much info on Excel itself. I think the book is outstanding in that it opens one's eyes to using Excel for tasks like non-linear least squares fitting of data to models, signal deconvolution, etc. In retrospect, that one could use Excel for this should not be too surprising, but I have found myself resorting to MathCAD for many of these things when a solution implemented in Excel would have been easier to share with colleagues since Excel is more available. There is a bias towards biological/chemical examples, but nothing too egregious.

If you are working with Filemaker Pro files on the web, this book is essential. Although the title says, "Advanced," I think it would be perfect for beginners also.

I particularly appreciated the expository style of the book. In a way that I haven't found in many other computer manuals, the authors start with a real problem the reader has and show how to solve it, adding interesting general commentary along the way. For example, I had a problem developing an XSLT document to import variable numbers of repetitions of a field - there, on pp. 330-333 is a brief statement of the problem, specification of a solution, and clear explanation of the code. I recommend this book to any FMPro user who wants to work with FMPro and CDML, PHP or XML/XSLT. Well done! I hope these authors produce other books of the same calibre.

This is more than a book, it is really a course in web development. The authors communicate the material in a way that is easy to understand, and the book is filled with examples that you can do as you read. Although the focus is on FileMaker, the knowledge you'll glean will apply to web development efforts with other databases as well. I reviewed and skimmed the chapters out of sequence in order to get a sense of what the book had to offer. Once I had that overview, I began to read the chapters in sequence and I think that's the best approach, as material in succeeding chapters builds on the previous chapters. No stone is left unturned as XML/XSLT, Instant Web Publishing, CDML, Lasso, PHP and Web Services are covered concisely, yet in depth. Take your time with this book; after working through the material you'll be prepared to do web development using any of the aforementioned technologies.

This is one of the first books that goes beyond a mere rehash of the manual, like most FileMaker books out there. This book is a treasure trove for those who already have their feet wet in FileMaker and are looking to go to the next level.

This is a very good book, and if you're looking to web-enable your FileMaker 6 application, this is pretty much the only source for in-depth information that's available.

However, this book definitely left me wanting more. I have been building a fairly sophisticated web application in CDML using the Web Companion, the web toolkit that comes built into FileMaker 6. This topic gets less than 50 pages, and feels light. Many of my questions went unanswered. This topic could have been 100 pages, easily.

Two other toolkits, Lasso and PHP, while great options, require you to acquire and install add-on software. Each gets 60+ pages in the book. It's great that there's additional information (possibly required to cover installation), but devoting that much space to things not built into FileMaker, while not giving enough depth to the built-in component, seems like the wrong focus.

Another flaw with the book is that it doesn't really cover larger-scale applications. You get information about how to access, search, modify, and delete data, but you don't really get advice about how to structure a full-blown web application. Things like managing user sessions, authentication, etc., really are not covered at all. You'll need another book (which won't use FileMaker as an example at all) to get information about these basic web application topics.

In the end, this book gave me enough information that I could get started, and a good enough CDML reference that I've been able to figure out a lot more on my own. That makes it quite a good book, well worth the money spent. I would love to purchase an expanded 2nd edition.

I should note that it remains to be seen how well this book will hold up after FileMaker 7 Advanced Server is released. There's a lot of changes in FileMaker 7, and all of the web functionality has moved to the Advanced Server (not yet released), so many things may change...

You know C, you know pointers, you know how to program. But what you need is something to teach you more about creating firmware applications. How to actually make something work! What actually goes on inside this black-box that we call the ARM core? How do you make it do some simple DSP?

There should be a course in every college that basically teaches the information contained in this book!

Product came in faster than expected and it was in new, excellent condition.

The authors have done a wonderful job of taking something complicated and making it very simple, without dumbing it down. They explain why and how, and the material is well organized. There are useful reference tables scattered throughout. There is no attempt at humor, and I'm grateful for it.

Highlights include discussions about registers, Arm multiple load/store instructions, the Arm function calling convention, tactics for writing fast C and assembler, DSP implementation, memory management, and assembler code for things like division. The chapters on firmware and basic OS implementation each show a simple yet functional implementation.

My only complaint is that there's nothing practical in here about IO, not even JTAG. The authors have limited themselves to the ARM core only, perhaps because there are many differences between the microprocessors that use it. This makes the title a bit misleading - in my view a System Developer's Guide should have enough information so that you can at least write a "Hello World" program of some sort, even if it doesn't work on everybody's hardware.

So to do anything practical, you'll have to track down a lot more documentation for your specific microcontroller. Still, five stars for the clear, detailed information on the topics it does cover. I will certainly be using it as a reference.

This is the best book I've seen for the ARM series of processors. I have developed with many processors, on and off the Job and am now planning to develop for the ARM7 and ARM9 processors; particularly the AT91 and the AT91SAM7 series of processors by ATMEL. Base on the processors' hardware specs they are perfect for the small time developer. But, when looking the ARM's instruction set, it appears that programming them requires a steep learning curve.

This book will easily reduce my learning curve, at the very least, by more than half. It is clear, comprehensive, and to the point.

In a world that has strict requiresments on performance, power, as well as development time, a developer has to ARM himself. This book will show you how to do just that.

This book covers many aspects of programming the ARM familiy, including a surprisingly thorough discussion on fixed-point DSP computation.

Having come from another architecture, this book really got me going on ARM. It complements the documentation manufacturers usually provide for their ARM chips in that it covers the ARM core much more in-depth.

The book discusses everything from register usage to memory management units. If you want to become an expert programmer in C/Assembly on ARM systems, you must buy this book.

Also included is a nice comparison of the ARM and Gnu assembler directives, which came in handy when I converted an ARM assembly file to the Gnu syntax.

I've been designing games for more than 20 years and I've read a ton of books on the subject.
This one is unique.

Most game design books focus on teaching you how to make a good game, detailing what techniques and processes one must master to understand an audience, to design a product that will satisfy their needs and aspirations, and to work with a team to produce it. "The Art of Game Design" goes beyond that: It teaches you how to become a better designer.

Here's an excerpt from the Deck of Lenses' instructions (it's the deck of cards sold separately that illustrates the 100 design "lenses"):

How to Design a Game
Step 1: Think of an idea for a game (it's easy, it can be anything!)
Step 2: Try it out (no really - try it out - you have to play games to see if they work)
Step 3: Figure out what's wrong with it, and change it so it is better. Then go back to Step 2!

That's what game designers do, over and over again, until they're satisfied with the game or they run out of time or money. However, if there are lots of books out there that explain how to increase the quality of whichever aspect of the game you want to change, it's the first one that so directly and so thoroughly addresses the problem of "figuring out what's wrong" with a game at each iteration.
In the book, Jesse Schell presents one hundred ways of looking at your game in order to figure this out, one hundred lenses. Even if this number seems big, it really isn't, because the book covers every domain touched by design: from the nature of the playing experience itself, to understanding the player, the game mechanisms, interface, story, technology, theme, etc.
For instance, here's the sum-up of a lens taken at random:

Lens #82: The Lens of Inner Contradiction
A good game cannot contain properties that defeat the game's very purpose. To remove those contradictory qualities, ask yourself these questions:
- What is the purpose of my game?
- What is the purpose of each subsystem of my game?
- Is there anything at all in my game that contradicts these purposes?
- If so, how can I change that?

The book doesn't give answers but helps you ask the right questions. I think of this book as the Tao of Game Design, a path toward understanding, each step its own path that can be explored and perfected. The one hundred lenses are one hundred design domains in which a designer can become more proficient. Jesse Schell's knowledge, experience and talent are obvious when he clearly explains how to consider all these questions, why they are important and how they are linked together.
This book makes and helps me think. To me, that's the best things a book about design can do.

It's rare to find an instructional book on any topic that takes such a broad, holistic view of it's subject matter. Not only is it loaded with useful info on game design, but many of it's methods can easily be applied to the creative process in general. It's depth and breadth of thought set it easily above any other game design book I've come across.

The Art of Game Design is a book which provides an easy read, it has a simplistic elegance to it, yet the depth of the book is quite deep which will keep you thinking for hours upon end. For me one of the most impressive things about the book is that it pretty much covers everything that a game designer should be aware of and how their decisions will effect the real world (it even talks about the moral obligations which I have never seen covered in a book about game design!). If you really want to learn the depth of being a game designer this book is a must read.

The Art of Game Design is simple in its language yet intriguing in its concepts. Jesse's well written book is equivalent to a four year undergrad degree in the same subject. The bulkiness of the book might seem overwhelming, but once you start reading, you delve right into it without you even knowing it.

The book draws inspiration from a myriad of topics and fields and definitely provides life lessons on a deeper level. The philosophy and its understanding helps in knowing yourself better, first as a person and then as a designer.

The Art of Game Design will inculcate a positive design perspective to the way you observe everyday things and events. Even if you are not a designer, it certainly is an excellent addition to collectibles that broaden your horizon. A must-buy for those aspiring to be a designer.

good things come to those who wait - and i have been waiting for this book for years. jesse schell has managed to compose not only a game design guide through an idealized design process, but also a handy catalogue of "lenses" that will help designers to inquire whether their game is enjoyable, or not, and how to improve the design. most importantly, 'the art of game design' provides intellectual as well as practical inspiration throughout - what more can you ask from a book in this field?

Prolog remains academic but still of great educational value. But to get to that value, you need to get past using prolog like a smart procedural language. This book and especially its last few chapters achieve this goal. For this reason I recommend it as a must read for any decent computer scientist.

I am currently working as a computer hardware design engineer. I have always been looking for new software methodology to improve my hardware design flow. Prolog, and especially its presentation in this book, shows me an interesting and powerful view of how computer programming should be.

Overall, I am a true believer in Prolog and logic programming after reading this book.

This, to me, is one of the 4 best books on computer programming. Unfortunately, it is hard. Not because the book is poorly written - it is like a wonderful story, but because understanding how to think declaratively after being taught something like C or Java is like someone giving you a pair of wings when you're a mudfish.

Thinking declaratively changes how you think about problems and how you write code. It's a career changing experience. This book leads the way.

Top 4:
* Structure and Interpretation of Computer Programs (Sussman, Abelson)
* The Art of Prolog by Sterling/Shapiro
* Introduction to Algorithms by Cormen, etc.
* Concepts, Techniques, and Models of Computer Programming by Van Roy and Haridi

Admittedly, this one tends to be a bit pricey. But, the content is pure gold for any programmer. Nowhere is the Prolog paradigm better conveyed than here. And, it is of little value to you if you attempt to learn prolog with a mindset of some other language. Prolog is unique and demands a unique way of looking at computer programming in general. It is dated a bit in that it does not cover all the latest developments in Prolog/AI research but no other Prolog books provide the foundational understanding that it does. Get this one for a solid foundation and then build on it with others. See my listmania list of AI Language books for suggestions of followup titles.

This book is a must for anyone starting to program in Prolog or interested in logic programming.

A downsize of the book (if any) can be that it could have detailed more in the respect of Prolog's applications. The pleasant style of the authors would have made a wonderful introduction into these fields.

A real pleasure to read.

This is a well-organized and comprehensive introduction to Grails. The reader will come away with a lot of exposure to the Grails way of doing things, which was kind of a shock for a hack like me who is used to mixing sql queries with html and changing entire schemas at a whim. The authors do not assume you know MVC or even Groovy, so I think it would be a good book for anyone with a bit of Java coding under their belt.

The source code presents some difficulties, although some of these might be attributed to Grails and Jetty. One problem is that all the collab-todo examples are called "collab-todo", which seems innocuous enough but it causes several problems as you proceed through the book. Often Grails leaves all sorts of artifacts in GRAILS_HOME that corrupts different versions of collab-todo. I found myself having to run rm -rf ~/.grails/1.0.3/projects/* before things would work properly for the next chapter. Secondly, I found it impossible to deploy multiple demo chapters at the same time, which would have been useful to see how the author edited various files to achieve increasing customization. Even when the application.properties file was altered to give the deployments different names, the lightweight jetty app server would display a "port already in use error". If I chose a new port for new deployments, there were still deployments files that were still using the directory name "collab-todo" instead of "collab-todo4", my renamed app.name, which caused all sorts of weird runtime errors. The authors and testers really should have foreseen this problem.

Another albeit smaller problem is that the .project files used for Eclipse or IntelliJ are missing for chapters 6 and 8 and I don't think those are really finished demo freezes - I'm not sure if this was intentional or not. I suspect they were not meant to be deployed. If that is the case they should put that in the README. The unfortunate things about chap 6 is that it would have been good for a working MySQL example. There is no formal introduction into using a different backend database until chapter 12, an example so complex it threw all sorts of Hibernate errors in prod mode.

I think the collab-todo project is a decent model for the average web application. However, in some sense a lot of the quick webapps that would have previously been done in Visual Basic or FileMaker Pro can now be handled by Rails/Grails, so a migration example starting from a poorly maintained Excel spreadsheet with no normalization and no keys might have been useful.

After banging my head against JSF for a few months I was happy to see a framework that has proper respect for GET and for a developer's need to have control over any element of a web application without question. I just didn't want to bang my head to get some of these Grails demos to work. Still, this is a decent read and well worth the money.

This book is an excellent way to get started with grails development. This book provides a solid foundation and excellent coverage of the grails framework.
The book starts out with a 3 chapter overview of the groovy language. After that starts the Grails Sections, Which are very fluid working though one application (Collab-todo) from start to finish. Showing you how to use features such as plugins, ajax frameworks, security and web services. This book will really get you going with grails fast.

As a Java developer who is a true beginner with Groovy and Grails, I found Beginning Groovy and Grails an excellent starting point. The book's strength is providing a core structure for the Groovy language and the Grails framework, then building on them.

I had read other Groovy books, and still use them as a reference. But BGG kept Groovy at the right level for me to start -- showing the core features without getting bogged down in the details. I was able to work through the examples and get an excellent feel for the power and elegant simplicity of the language.

The Grails overview is an excellent start to understanding the framework. I appreciated the step by step introduction to setting up and evolving a simple web application.

In terms of writing, I found this book very readable. I wish that the copy editors had helped out a bit more in spots, and the errata pick up some glitches in code, but overall I truly appreciated the authors' efforts and have learned a great deal.

I concur with the previous reviews. I've been looking to dive deeper into Groovy and Grails for a while now. I'm hoping this is the first of many new titles to come on this subject. I would really like to see the language and the framework take off as it should. There are many people out there doing cool things with both like Graeme Rocher, Guillaume LaForge, and one of the above reviewers (Scott Davis....you gotta see this guy talk about Groovy if you can!). People who work in the Java space really should give these technologies a look. This book should really get you going. I would also suggest looking at some of the book offerings by the contributors mentioned above. Good stuff. Buy this book!

Let me start by saying "Beginning Groovy and Grails" is the book that the Grails community has been clamoring for. Two very good books kicked off the Grails revolution ("Definitive Guide to Grails" and "Getting Started with Grails"), but both predate the 1.x version of Grails by many dot-versions and many years (as of the time of this review, August 2008). BGG will certainly have worthy competition on the bookshelf before long, but right now it is the book that we all have been waiting for. Luckily, it easily lives up to the heightened expectations.

After reading BGG cover to cover, it seems to break naturally into three sections: Core Groovy, Core Grails, and Ancillary Grails. This division is mine, not the authors; the table of contents lists 13 chapters with no explicit section breaks. (Whether the three sections correspond to the three authors is an interesting question -- the tone of voice and writing style is consistent across the entire book.)

The first three chapters do an admirable job of covering the Groovy language from the basics to advanced topics. Groovy offers lots of syntactic sugar that might initially catch a Java programmer off-guard. These features, once you've seen them, dramatically reduce the lines of code you have to write. But more than that, there are some fundamentally new features in Groovy that don't have an easy match in Java. Builders, Expandos, metaprogramming, and DSLs are all discussed in these early chapters. While you don't have to use these features yourself to be successful in Grails, it certainly helps the reader understand how much of the Grails "magic" occurs under the covers.

The next three chapters (Introduction to Grails, Building the User Interface, and Building Domains and Services) hit the Core Grails features hard. These 150 pages do a great job of walking you through the basics of getting a Grails application up and running with a minimum of effort. They also make testing feel like a natural part of the development process (which it should be!). Rather than having a single chapter dedicated to testing, each new topic organically includes testing as a way to validate that the new code does what it promises to do.

The remaining chapters (Security, Ajax, REST, Reporting, Batch Processing, Deploying, and Alternative Clients) make up close to half the book. Each chapter covers the subject material as advertised, including working sample code. Not every Grails application will use every feature discussed here, but I still found a clever snippet of code here or a nice explanation of a general concept that rewarded me for reading every chapter.

Overall, "Beginning Groovy and Grails" delivers on its title -- if you are new to either (or both) technologies, you will be up and running before you know it. But don't be fooled by the title; even though it has "Beginning" in it, this book doesn't shy away from the advanced topics, either. This isn't a completist volume. Rather, it is a broad survey of the Groovy and Grails ecosystem. Christopher, Joseph, and Jim covered a lot of ground in an easy, readable way. I highly recommend it.