4 comments about Programming Microsoft® Robotics Studio.

1. This book is a good start but I can't wait for the next edition (if there is one). The author attempted too much coverage for the limited number of pages (a little over 200). I have completed all of the Microsoft Tutorials for MSRS and this book is a refreshing change. The author begins with coverage of SERVICES and does not include any illustrations. Microsoft Tutorials and Powerpoint presentations have several great illustrations on SERVICES. Also, the coverage of SERVICES is completed in an orderly manner but not in the same order used in the coding chapters (chapters 5 and later). There are the expected typos, as you expect in a new book. A couple can cause frustration until you figure out what happened.
   
   I will say that MSRS books are very much needed. While MSRS is not a huge software product, it contains several new concepts for many programmers. I have a background in C, C++, C#, and VB. MSRS is best when using C#.
   
   In summary:
   1. I would have liked to have had a thicker book (like the one coming out in June from other authors.
   2. The author of this book made the decision to only do superficial coverage of MSRS subjects such as Simulation and VPL which I believe will be used quite a bit in academic enviorments and more everywhere in the future. The VPL feature of C# code generation is important and deserved move attention.
   3. The author's style of writing is great and very readable. I wish her well and look forward to a 2nd edition.



2. I bought the book because I thought the MSRS tutorials weren't descriptive enough. I was looking for a organized and detailed guide to start using MSRS. This book turned to be useless, it's continuously referencing the tutorials and it does not provide any addiditional information. It uses profusely links to explain things... the author did not realize the the book was going to be printed on paper, so readers could not open those links and would not go to their PCs to hardcode the links in the browser...
   
   There is lack of illustrations and diagrams.
   
   Sometimes I thought that the writer had never used MSRS... and simply,she cut and pasted sentences from the internet to come up with a book...



3. This book is not very helpful for someone trying to learn MRDS. You would be better off sticking to the tutorials on the MS website. There is very little detail about how to actually get started writing robotics software. The best I can say about it is it references other interesting projects. I wonder if this author is actually a MRDS developer because if she was she would have gone into much more detail about the nuts and bolts of MRDS.



4. This book, much like Professional Microsoft Robotics Developer Studio (Wrox Programmer to Programmer), gives good examples, but only for what is explained. If you are interested in doing something like converting hardware robotics applications to simulations, then this is NOT the book for you. Also, to do the examples, you would require to have the robots, and each chapter makes use of a different robot.
   
   If you are only interested in the hardware and not the simulation, then this book is excellent. However simulations (one of the KEY features in MSRS-MRDS) is sorely missed. Especially in conversion between hardware and simulation projects.

5 comments about Schaum's Outline of Software Engineering.

1. Learning a subject from a Schaum's outline is generally a difficult endeavor. With the emphasis on solved problems and very little explanatory text, there is not a great deal of depth to the coverage. I have used many of them over the years as a source of problems. Sometimes these problems were a supplement to self-study using other more detailed works and other times I have used them as inspiration for classroom examples and test questions.
   I used this outline as a source of ideas for topics to cover in my software engineering class in the Spring semester of 2004. What I found most helpful about the problems is that they are concise. By examining a solved problem, I can see at a glance what the problem needs to cover and possible ways to organize the presentation. I did not take problems directly from the book, if the topic is to be covered as an example in class, then it is necessary to include more explanation. For example, I spent some time on Metrics for Object-Oriented Design (MOOD) in the class and the section in this book was very helpful. However, understanding the elements of MOOD requires detailed knowledge of object-oriented concepts such as encapsulation, inheritance and polymorphism.
   While necessarily brief, the coverage in the book is thorough. Nearly all of the areas considered core to the study of software engineering are mentioned. With plenty of charts and graphs to illustrate them, this book is a solid, albeit limited educational tool.



2. This is a good basic outline of Software Engineering. It accurately covers many areas, but not in depth. This is what I expected from this outline and it delivered. It will get you started in the right direction.



3. I purchased this as a required book for a graduate course I took (CS 5704 at Virginia Tech). It is an excellent roadmap for a broad scope of software engineering topics. But you should expect to treat it as a directory of topics from which you must branch out for more in-depth treatment and experience of the topics.
   
   The book is generally well written. Is is very readable and clear, though I do have some complaints. Many topics presuppose other knowledge referenced nowhere else in the book. For example, Chapter 5 on Software Metrics includes a short section on Statistics, which refer to Spearman correlations and Pearson correlations, with no clue as to what they are.
   
   One area in particular, Software Project Management, is 16 pages in its entirety. I have been a software development manager since 1988 and it is almost criminal to lead anyone to believe that what they need to know about this topic in 16 pages. The material there is quite good, and I learned something new myself, but the brevity could be quite misleading to a naive student.
   
   Many chapters in this book are deserving of having one (or more) college courses dedicated to the subject. Software Design alone, a single chapter here, takes years to master the concepts described.
   
   However, this book is marketed as an outline, and a very good outline it is.



4. Acostumbrado a otros libros de textos, llenos de ejemplos de cómo no funcionan las cosas, o al contrario de ejemplos que confirman las bondades de las teorías expuestas, éste se reduce a la esencia mínima.
   
   Se describe el concepto y se ponen ejemplos (sencillos en la mayor parte de los casos), nada más y nada menos. Cierto que muchas veces el tópico es ciertamente complicado de entender o la literatura es muy amplia, pero si en lo único que estás interesado es en conocer la idea básica tras el concepto, este libro es el adecuado. Mayoritariamente, con aplicar básicamente lo que aquí se describe uno tiene más que sifuciente para abordar la mayoría de los proyectos de seguimiento de software. Todavía no he visto ninguna organización (y ya he estado en varias y con proyectos de gran envergadura) que incluya métricas de seguimiento, como las básicas que aquí se describen (control estadístico) o incluso un simple análisis PostMortem del proyecto.
   
   Quedan para otros libros más detallados, pero también menos asequibles, el entender el "por qué" de lo que en este se cuenta.
   
   Carlos Ortega
   2006-01-30



5. This Schaum's outline does a great job of outlining the vast majority of topics you must study in order to call yourself a software engineer versus a programmer. As other reviewers have pointed out, it is not a comprehensive textbook on the subject but makes a great "big picture" supplement. This is particularly valuable to students since college software engineering classes are often poorly structured and taught. When I took software engineering at Virginia Tech the professor actually believed that learning software engineering involved memorizing every UNIX command and all of its options. Thus guidance in this discipline is at a premium.
   
   This book's format is to mention all of the major subtopics of software engineering, provide a paragraph or two in description, and then provide some examples as well as exercises for the student. No particular programming language is used since this is not a book about programming, rather it is about the tools and metrics used to organize, manage, measure, and test programming projects. Everything from project management to metrics to object-oriented design techniques is at least mentioned.
   
   Although there is no formal bibliography given, throughout the book there are references to the work of authors and experts in the field who have written more extensive works on particular aspects of software engineering such as Glenford Myers who authored the classic "The Art of Software Testing", Watts Humphrey author of "Introduction to the Personal Software Process", and Tom DeMarco who penned "Controlling Software Projects". I highly recommend this outline to students of software engineering and also to professionals who might need a quick reference for certain aspects of the field that they may have forgotten.

No comments about Applied Software Measurement.

5 comments about Oracle Developer Advanced Forms and Reports.

1. Thought this book does not explain any of the subjects in detail but it touches almost all the advanced topics of Oracle Forms and Reports. If a lead can get you going and you can get the details yourself... this is the book for you.



2. This book is a great tool for creating Visual Basic Applications



3. This is a solid reference book for those doing primarily Forms development, but it lacks quite a little in the Reports department. If you're buying it for Reports development, as I did, you'll be disappointed. I have yet to find a very good Reports reference. That said, this is probably the best one out there. The book contains something like 70% - 30% Forms info to Reports info (and that may be a little generous). It does have a few good examples and is an easy read.



4. very poorly laid out and confusing presaentation of both forms and reports. some fairly good detailed examples (if you can find them) but the overall presentation is chaotic.
   
   really not worth the bucks



5. The seller is excellent. speedy delivery. I will buy books from him again.

5 comments about Practical Apache Struts 2 Web 2.0 Projects (Practical Projects).

1. Its not for beginners
   
   This book is not good for beginners. Its very hard to follow this book with so many assumptions.



2. Like others said its not for beginners. However, that doesn't make it a bad book. If you are looking for guide for going to struts 1 to 2, this book is not it. With that said, if you are a webwork developer or already have a handle on the Struts 2 basics this book does provide some nice samples. It provides a nice sampling of how to integrate with some of the plugins that have been added over the last year. (zero config, wild cards in configuration, gwt, hibernate, spring, security). You may already be an accomplished struts 2 development however, their may be some things to take away from this to add to one's cookbook.



3. I was extremely disappointed in the authors other struts 2 book; and was planning to avoid this one, but all the other stuts 2 books kept slipping their date, so I picked this one up on a whim.
   
   I'm rather surprised by the negative reviews people are giving it, as I found it a very useful book. Yes the title is a little hokey and the content only pays lip-service to Web 2.0 aspects. I have been working on my own personal projects in Struts 2 for a few months so I wasn't a complete novice coming into the book, and I lurk on both the users and developer mailing lists. I felt the material was well laid out and followed a natural progression. The book doesn't really cover MVC theory nor how it applies to any of the "Action" frameworks, so its not really a book for people with no prior experience in those areas.
   
   The other limitation I found was the book just ends. There was no real wrap up or conclusion. Basically he finishes developing the last use case of this sample application and on the facing page is the index. To me this was the only place that felt rushed.
   
   The book doesn't cover a fair bit of the annotation based configuration opposed to XML and a few of the more established plugins however that are a few places where it might not be "future-proof" given the works that's going on now merging/combining several of the convention-over-configuration plugins into a single unified one for struts 2.1



4. "Practical Apache Struts2 Web 2.0 Projects" walks you through developing an app in Struts2. It includes use cases, iterations, a build process and some unit tests.
   
   A number of other reviews correctly point out this book is not for beginners. You should be familiar with MVC before starting out. This was ok as I wasn't expecting an "intro to struts 2" book based on the title. The author includes a section on Hibernate bare essentials to get readers with different experience on the same page.
   
   I found there to be a good balance between how Struts 2.0 works and implementing common things you might actually want to do in practice. While the book does cover Web 2.0 a bit, this is more of an extra buzzword in the title. The last two chapters are really the Web 2.0 part - RSS and AJAX.
   
   The end left me a little off balance. There was a whole chapter of introduction. The end was the AJAX chapter and the immediately dumped you in the index. A bit of conclusion, or at least a blank page, would have been nice.
   
   Overall, the book was fine. It is good for a "recipes of common tasks" type book once you have read a bit about Struts 2.0.



5. The samples in the book learn you very useful information about the Struts 2. You can download the sample codes. Futhermore you are immediately able to use them in your applications. Then you feel as you are at very good point to go forward into the details of the Struts 2.

5 comments about Oracle Applications DBA Field Guide (Expert's Voice in Oracle).

1. This is the type of book I was looking for when I entered the Oracle Apps DBA field 2 years ago. Anyone who has used MetaLink to find this information knows that, at times, it can be difficult to find all the information you need. Often, you have to read through multiple notes and combine pieces of information from each of them to find your answer. Phelps and Jackson have done an excellent job of bringing together much of the essential information an Apps DBA needs to perform his/her duties.
   
   The chapters on monitoring and tuning were especially helpful. These chapters stress the importance of proactive monitoring to head off potential issues, and give examples of what to monitor as well as scripts that can be used to perform the monitoring.
   And, as the above reviewer stated, I have turned to this book multiple times as a quick "How does that work/Where is that file" resource.
   
   I strongly recommend this book for anyone who is new to this field; had this book been out 2 years ago, my learning curve would have been much shallower. I also believe that those with years of experience in this field will benefit from the depth and conciseness of the information in the Orale Applications DBA Field Guide.
   
   Phelps and Jackson are both well respected in their field, and this book shows why.



2. A lot of folks, when they talk about tech books, start right in with details, correctness, and comments on depth and so on. I'd like to tell you that this book is an enjoyable read. Phelps and Jackson are good writers, and they breakdown concepts and details into an easy to use handbook or "field guide".
   
   As I move into more Applications implementations, I have found this book to be indispensible for day-to-day answers.
   
   What do I like? The book is organized well, with nice coverage of a diverse suite of software. It offers suggestions like clearing the JAR cache, purging concurrent requests, and workflow history, and so on. What I also really like is it has an excellent chapter on both what to monitor, and complete scripts to do it with. In the database, those include listener, logfiles, db up/down, idle sessions, long running sessions, high active sessions, blocking sessions, tablespace usage, extent issues & profile changes. Also scripts to monitor apache, jvm, forms, concurrent manager, OS cpu & load average are included.
   
   I have a couple of small caveats as well. If you're a real newbie to Oracle Apps + Oracle in general, this is probably not the book for you. Also although there is some coverage of Unix in chapter 6 toolkit, I'd say if you're not strong with Unix already, this chapter won't help much. Also chapter 7 resources, was a bit of a letdown. They mention IOUG, OAUG as organizations, and related conferences, and Oracle's own site and a couple of others, but there are tons of blogs out there, and I would have liked to be pointed to the ones the authors recommend or favor most. Also the book list recommendations are decent, but mostly in the Oracle Database arena, and since I'm already an accomplished DBA, I have all those books! Also the Performance chapter mentions hitratios, which is almost considered taboo in the Oracle world these days, and didn't get into more depth with the Wait Interface and so on.
   
   In summary I really enjoy this book for it's great writing style, quick coverage, best practices, and troubleshooting recommendations. The only thing I'd say as a reservation is, when it comes to more in depth performance tuning of the db, there are other books that can give you a more detail and specifics.
   
   Enjoy!



3. I liked this book but it is more of a quick refresher to jog memory when I am working in an Oracle 11i Apps environment as an Oracle Apps DBA. I would only recommend it to experienced 11i Apps people because it assumes at least a basic knowledge of how Oracle 11i works. For that much said, I recommend the other two excellent Oracle 11i App DBA books for new Apps DBAs.



4. I am just getting into Oracle Applications. Traditionally, I always read the Oracle Documentation . . . (RTFM). I bought this book for the purpose of getting a high level view before getting into the Oracle Docs. This book is well laid and reads very easily. The author also points to various Metalink articles which is a nice touch.



5. I was looking for more indepth information about Oracle apps. This book covers basic information.

5 comments about Game Physics (Interactive 3d Technology Series).

1. Undoubtedly this is a must-have for people who are serious about developing real-time computer graphics simulations with physically based modeling.

   This book can be compared with Coutinho's "Dynamic Simulations of Multibody Systems". I believe the latter covers more materials, but Eberly's is easier to read. The book would be almost sufficient if you also have his previous book "3D Game Engine Design".

   I am not sure why the author wrote chapter 4 and 6. I suppose these can be left out. It would have been more compact.




2. My interest is physics and physics simulations, not gaming per se...so my observations should be viewed in that light.
   
   The main problem with this book is the treatment is incomplete, superficial, or just wrong (from a physics/math point of view), and the typical programmer/computer scientist is not likely to know it. I am reminded of the great fluid dynamicist von Karmen's definition of an engineer as that person who perpetuates the mistakes made by the previous generation. The REASON a game programmer can get away with this is that he is not testing his results by real experiment...his world is a computer generated simulation with arbitrary approximations to physical laws that the programmer deems to impose.
   
   The other problem is that there are usually a multitude of techniques that one can pick to solve a given mechanics problem...and what would have been really valuable is if the author had shown why a particular method is better (for example, Newton's Laws vs. Lagrange's Equations) when the time comes to code the algorithm. We are not looking for Eberly primarily to teach us physics (but if he makes the attempt, it should be correct!)-that is always going to be the job of physics courses. Instead, he needs to tell us which method is useful for coding and why-this, sadly, he has not done.
   
   As an illustration of what I mean...look at how Petzold in `Programming Windows with C#' discuss the elementary process of using GDI+ to draw a curve. There are two approaches, using rectangular coordinates, or using parametric equations (polar coordinates). Petzold explains WHY the parametric approach is superior from a programming point of view.
   
   Any advanced sophomore or junior physics student will know most of the physics presented here (classical mechanics)...but in addition, they will also know the CORRECT statement of conservation of angular momentum (the author got it wrong) ...AND they will have a deeper understanding, because they will have likely studied something like Marion's Classical Dynamics which is rigorous and physical. Especially egregious is Eberly's twice incorrectly defining an inertial reference frame. In classical mechanics, an inertial reference frame is one in which Newton's laws are valid.
   
   Same comment for the math...The math is maybe sophomore/junior level (except for the Quaternions)...but it is not rigorous nor is it motivated, and sometimes it is wrong. Compare Eberly's terse treatment of the delta function with Marion's motivated and physical discussion. Also, we see things like interchange of limits and integration, without explaining when this is mathematically legal. Then there is the unmotivated vector spaces treatment. Eberly goes to the effort to define a field, but then restricts his definition of a vector space to having real coefficients...Then why bother defining fields if you are not going to use them. We are given the mathematician's definition of the determinant (i.e., the unique, alternating, n-linear function with identity) but this is completely useless from a computational view! If Eberly wants to present some advanced linear algebra, then some tensor analysis would have served the game programmer better, as it is often used in continuum mechanics and fluids, neither of which are discussed by the author. He had a perfect opportunity in the Affine Algebra chapter when he stumbles upon the Levi-Civita tensor, which he then dismisses as unimportant! The Affine Algebra chapter is really bad from both a physics and a geometry view. First, a physicist does not think of a vector as something with direction and magnitude, and a geometer is more inclined to think of them as a derivation. Second, affine spaces are too weak a tool to use to distinuish points from vectors, though we do mod out the origin..this really needs a manifold with vector fields and parallel translation. Third, linear algebra is the study of vector spaces and isomorphism.
   
   There is a chapter on numerical methods, but again incomplete! We should have at least got Numerov's method and some Monte Carlo techniques.
   
   The chapter on shading is ridiculous from a physics point of view. Essentially we have Snell's law, and a cursory reference to Fresnel and that's it...Evidently, the author was not up to discussing some real physics ala Maxwell. Why spend so much time on classical mechanics, and then almost totally dismiss optics with a non-physical discussion? We don't even get Huygens principal. But we do get a wrong definition of polarization of light.Thankfully, he did not try to define helicity.

   In summary, this book has two uses:
   1) It presents a list of physics and some numerical methods which the game programmer will find useful, and which he will then go ELSEWHERE to actually learn. (I can recommend Landau (of OSU, not Russia) "Computational Physics" and also the CUPS Physics Simulations books for excellent starters.)
   2) There is the happy possibility that a budding game programmer, in his pursuit of the knowledge to build a better computer game, will discover the much more interesting game called Physics.




3. I always love it when scientists and engineers, and mathematicians come along and review a game programming book. They go "oh! This is just ALL WRONG!!! AHHH!!!"
   
   Please keep in mind this book is for physics simulations for video games. We can't yet simulate the universe on an atomic scale in a PC game and expect a frame rate of more than 1 frame per millenium at this point in time.
   
   I own all all of Dr. Eberly's books and I find them all my most useful books. The only other graphics book I use alot is my Graphics programming by James Foley. The nice thing about Dr. Eberly's book is that the code for most of this is on his website, so if you get stuck on how to implement something looking at the source code can help you further understand the maths and equations. I recommend to buy this if you are willing to put in the effort to understand the maths, but if you have a phd already you might not need it than.



4. This is a great book on physics simulation, covering most of the mathematical methods and tricks. Some people would complain that's very mathematically intensive, but I don't see another way to do it without being superficial. This book, however, goes very deep in almost every aspect of rigid body simulation, and covers some aspects of non-rigid body simulation as well, which is an emerging trend.
   
   I would suggest only one change to it: there's a chapter on shaders which is pretty much useless - it's very superficial as it doesn't teach shader writing, and doesn't teach hwo to use shaders for physics - I'd suggest that it be changed to include GPGPU methods for physics instead.
   
   Other than that, the book is great, and the only one I've seen that actually covers heavy-duty, real-world simulation and not just silly approximations for special cases.



5. This book has much good information if you know exactly what you are looking for. However, its tone is very dry and academic and lacks a big picture perspective. It glosses over essential information on mechanics and in just 200 pages covers Newtonian and Lagrangian concepts. There are lots of equations, but the examples all use variables, thus making the examples no clearer than the equations they are supposed to be illustrating. There are no numerical examples at all.
   
   Chapter 5, on physics engines, which the author himself says is the heart of the book, is woefully inadequate. He talks about the equations and features he wants to implement, and shows code snippets for the features, but there is one essential component that is missing - block diagrams and accompanying discussions that illustrate how all of these pieces fit together. A crate full of clearly labeled mechanical parts does not an automobile make.
   
   Next we come to one of my areas of interest and one of the main reasons I bought this book in the first place - Chapter 6, "Physics and Shader Programs". The author certainly hits some fascinating topics - ocean waves, skin and bones animation, etc. However, once again the author skips what is between the basic physics equations that comprise these effects and the implementation of these equations and effects in code. The code that he does show is in NVidia's Cg language. So if you don't know Cg, the code is undecipherable. I would have preferred algorithmic pseudocode. Then I could implement the effects in the language of my choice.
   
   The last four chapters of the book take an uptick in quality. These chapters are strictly on numerical methods, and I can't believe they are written by the same author that wrote the first six chapters. There are fairly good discussions and examples on the subjects of linear and mathematical programming, ordinary differential equations, numerical methods, and quaternions, and also how these mathematical methods fit into solving problems in physics. They are not self-contained tutorials, but they are a good summary and review for the physics student who has already had some exposure.
   
   I really can't recommend this book as anything but a reference. Its merits are mainly the tying of mathematical methods to physics and good basic discussions on some topics. But where the rubber meets the road - answering the questions of "How does one go about building a physics engine?" and "How do I implement physics within the confines of a computer game?" I think that this book is a failure. I give it three stars only because the author obviously put a lot of effort into the work, and what he does write is not incorrect.
   
   If you are interested in game physics I recommend "Physics for Game Programmers" by Grant Palmer. It takes an engineer's viewpoint of the subject and features plenty of examples in Java of how to simulate explosions, lasers, and the motion of various classes of vehicles. There is no discussion of game engines, though. A good reference on college level physics can be found in the most recent edition of Schaum's Outline of College Physics.

5 comments about Crystal Reports(R) 9: The Complete Reference.

1. Right now we're working on web based reporting and Window apps. So Part II and Part III are very helpful. Instead of hacking around and wasting time, just open this book and find what you need.



2. Has provided little more than the basics despite substantial girth. Especially disappointing are the few pages devoted to VB. Contains no mention whatsoever of .ttx files. The index is also poor for a volume that masquerades a reference tool.



3. As a developer you better check the knowledge base of Business Objects, post in their news groups and/or if you are a registered user ask/email their consultants.
   Perhaps some "missing" information is covered somewhere in the book but if so the index must be very poor.
   The book should be titled the "Totally Incomplete CR9 Reference".



4. I was fairly new to Crystal when I bought this book and I found it to have some good material for the intermediate user of Crystal, but the index is the most incomplete I have ever seen in a reference book. Every time I try to look up something that I KNOW I have previously read in the darn thing, it inevitably is not listed in the index and I have to go thumbing through the book to try to locate it. Sometimes I succeed, sometimes the help screens are much much better.



5. Being new to Crystal Reports and finding the company's website and software tutorials very inadequate, I put forth the money to get this book with the aspirations that it would help my ability to utilize this software better. Unfortunately, that was not accomplished. I found the book to be difficult to follow, screen shots were haphazardly inserted onto the pages, and, as another reviewer pointed out, the index was a complete disappointment. The book does a pretty good job describing parts and pieces of Crystal Reports 9 but did very little to actually "teach" me how to use them. I was able to get through parts but re-reading and repeated trouble-shooting mostly taught me what I needed to know. Unfortunately, because this was my first "Complete Reference" books that I've purchased I doubt that I will purchase another. The bad news is that when I purchased this book, there were not many books on CRv9 that were available so I had little choice. Thankfully my company reimbursed me for the cost of the book.

5 comments about Game Design Workshop: Designing, Prototyping, and Playtesting Games (Gama Network Series) (Gama Network Series).

1. Few people realize just how big a business digital gaming has become. Think of it this way: It's bigger than the domestic box office of the film industry. The amount of time spent playing games by young people now exceeds everything but television in time spent on entertainment. The main factor driving the development of the new extremely powerful computers is gaming, slower machines are capable of handling almost all office tasks.
   
   The authors of this book have a great deal of experience in both designing games and teaching how to design games. This has given them an understanding of how beginning designers grasp the structured elements of games, common traps they fall into, and certain developmental exercises that help the student learn to make better games.
   
   Note that this is not a programming manual, nor is it a graphics design manual. It is on game design. What are the characteristics that make a game, how can you prototype and play test the game without a horrendous programming expense, and finally some input on the game industry and how to decide on how you might like to be employeed in that industry.



2. This might be a good book for teachers looking for material in their classes gamedesign or gamedevelopment. It may also be a good book for selfstudy, if you have the discipline to do the exercises. You need to have played a lot of the classic videogames though, otherwise you might not be able to do the exercises, which are mostly about thinking about gamedesigns and making little designs or design alterations on existing games.



3. I consider this an excellent book on game design. As an amatuer board game and basic computer game designer, I found a lot of the material extremely useful in the *process* of coming up with a game from start to finish.
   
   The chapter on prototyping did a great job in showing how to go ahead and create a prototype from a game idea, while keeping it simple and concentrating on the "core gameplay mechanism."
   
   The chapter on "Playtesting" and "Functionality, Completeness, and Balance" builds on the prototype chapter by emphasizing the iterative nature of design where one go aheads and evaluates, tries new things, identify problems and keep evolving.
   
   The next chapter following is maybe the most important chapter that discusses whether you game is fun, goes in to some theory of what makes a game fun, and relates various techniques of improving player's choices so as to make the game fun.
   
   This is a great book that gives you the necessary tools to go ahead and be able to at the very least create a viable prototype of a game that is possibly fun and playable.



4. Although I personally disagree with some parts of what this book teaches, it this game design book is one of the most comprehensive I've seen. Well-recommended.



5. I like this book so much, I've purchased it 3 times! (My first copy was "borrowed" by one of my designer/producers, my second copy was left at Ubisoft SF, and this is my 3rd copy for myself.)
   
   Great mixture of theories, old-school practices, and new-school techniques.

3 comments about Measuring the Software Process: Statistical Process Control for Software Process Improvement (The SEI Series in Software Engineering).

1. This book gives a practical guidance on software process measurement: what should be measured, how to measure, the measurement process/procedure, the data analysis of measurement, and the application of analysed results. It's easy to read and understand. It would be better to include more "case study" information.



2. This book is a self-contained statistical process control (SPC) foundation in the context of software process improvement. Authors Florac and Carleton apply early industrial wisdom and some previous work at the SEI to a modern software development environment. The emphasis of the book is primarily on the use of analytical studies (predicting future outcomes) using the control chart as the primary instrument. There is only brief treatment of the use of enumerative studies (evaluating current situations) in this problem domain. Time-honored tools such as the Pareto chart, cause and effect diagram, and histogram, however, are given much less attention. The first half of the book directs attention to critical topics such as planning, managing and measuring. The authors adequately cover the material as it applies to software development, but the reader is cautioned that many statistical fundamentals are omitted from this work. In order to put these ideas into practice one should seek further instruction or consult a statistician for best results. A few annoying typographical and redundancy errors are present as well. Most bothersome about the book is that the authors do not seem to be 100% convinced that SPC for software process improvement actually works! This is somewhat alarming, given the long successful history of SPC in other industries. All in all, however, this book desperately needs to be read by anyone wishing to improve a software development process.



3. This book contains the keys to meeting core CMM level 5 requirements, which defines key processes for optimizing and continuous improvement, and for achieving 6-sigma processes. However, you need not be striving for either (or both) of these goals to use the techniques and approach in this book to full advantage.

   Implementing and employing statistical process controls are the basis of this book. The authors lead you through the steps and techniques necessary to implement and use SPC, starting with background information on processes and a process measurement framework, and moving through topics such as planning your measurement strategy, data collection and analysis, and developing and interpreting process behavior charts using common SPC chart types. The most common controls are x-bar (mean) and r (range) charts. Be aware that any SPC approach requires two conditions to be met: (a) defined processes, and (b) the processes are in statistical control (meaning that the data points being measured have settled into a normal distribution that are randomly clustered around a mean and have defined upper and lower control limits). New processes, or processes that are not managed well enough to have these characteristics are not candidates for SPC.

   This book requires knowledge and skills in basic statistical analysis. If you require a refresher I recommend reading "Visual Statistics" by Jack R. Fraenkel before tackling this book. I also recommend "Applied Statistics for Software Managers" by Katrina Maxwell, which not only teaches the basics, but also approaches measurement from the perspective of multi-variable analysis, regression analysis and other basic measurement techniques, which nicely complements the SPC material in this book and gives a broader picture of metrics.