5 comments about OpenGL(R) Shading Language (2nd Edition) (OpenGL).

1. The OpenGL Shading Language is without doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. As one of the primary contributors to the development of the language, Rost provides a clear and well-written explanation of the language and how to use it.
   
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders.
   
   The book ends with a handy comparison of GLSL with other shading languages, such as Cg and HLSL, and a couple of appendices providing a language grammar and API reference.
   
   If you're doing shader development with OpenGL, you'll definitely want this book on your desk. My only complaint about it is that it was written before GLSL was officially promoted to the core. When that happened, a number of important things were changed that aren't reflected in the book. However, determining the differences isn't difficult, so don't let that deter you from picking this up.



2. Twenty years ago, I used to program graphics on an Evans and Sutherland PS340. It was then one of the top of the line graphics computers (costing $100k). It could labouriously do shading, but only Phong and Gouraud. Nowadays, many PCs have this ability, and much faster. But a problem still persists, where often the shading methods are restricted to what is implemented on the graphics chips.
   
   In contrast, you have the approach in this definitive book on OpenGL Shading Language. This lets you implement in your code, shading routines of your own devising. To be sure, given the same shading method, one done in this language, and one in the hardware, then the latter will have better performance. But it turns out that today's computers are fast enough, and have enough RAM, that the difference in response might not be appreciable.
   
   The book describes an extensive set of built-in convenience functions that come with the language. And the language's API is explained in detail. The author rightly recommends that you come at it with some experience in the standard OpenGL.
   
   Since the language is still quite new, you are more or less on your own, when looking at development tools. This dearth is expected to be remedied in a few years. But right now, you'll have to rely on your wits. Along with a chapter that gives general principles of how you should develop your own shader. What may be even more use, however, is the second half of the book. Devoted to case studies of many shaders. Understanding these may be more beneficial than any IDE.
   
   Oh, as you might expect from a graphics book, there is a lovely set of colour plates in the middle of the book, showing what custom shaders can do. Treat it as inspiration if you wish.



3. The recent trend in graphics hardware has been to replace fixed functionality with programmability in areas that have grown exceedingly complex (e.g., vertex processing and fragment processing). The OpenGL Shading Language has been designed to allow application programmers to express the processing that occurs at those programmable points of the OpenGL pipeline. Independently compilable units that are written in this language are called shaders. A program is a set of shaders that are compiled and linked together. The OpenGL Shading Language is based on ANSI C and many of the features have been retained except when they conflict with performance or ease of implementation. This shading language is without a doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. The author was one of the primary contributors to the development of the language, and he provides a well-written and insightful explanation of the language and its use.
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders. The book ends with a handy comparison of OpenGL Shading Language with other shading languages, such as Cg, HLSL, and Renderman and a couple of appendices providing a language grammar and API reference.
   I particularly liked chapters 6 through 8, which take you from a simple shading example -"brick"- through the specific steps of shader development that you would need to master regardless of the API you are using. Also the chapters on procedural textures and noise and the accompanying code examples helped clear up some matters that were murky when I read "Texturing & Modeling: A Procedural Approach" by Ebert et al. In summary, I highly recommend this book to anyone interested in implementing software shading, both from the standpoint of OpenGL and from the standpoint of the design process itself. I notice that Amazon does not show the table of contents for the second edition, so I do that here:
   Chapter 1. REVIEW OF OPENGL BASICS
   OpenGL History; OpenGL Evolution; Execution Mode; The Frame Buffer; State; Processing Pipeline; Drawing Geometry; Drawing Images; Coordinate Transforms; Texturing;
   
   Chapter 2. BASICS
   Introduction to the OpenGL Shading Language; Why Write Shaders?; OpenGL Programmable Processors; Language Overview; System Overview; Key Benefits;
   
   Chapter 3. LANGUAGE DEFINITION
   Example Shader Pair; Data Types; Initializers and Constructors; Type Conversions; Qualifiers and Interface to a Shader; Flow Control; Operations; Preprocessor; Preprocessor Expressions; Error Handling;
   
   Chapter 4. THE OPENGL PROGRAMMABLE PIPELINE
   The Vertex Processor; The Fragment Processor; Built-in Uniform Variables; Built-in Constants; Interaction with OpenGL Fixed Functionality;
   
   Chapter 5. BUILT-IN FUNCTIONS
   Angle and Trigonometry Functions; Exponential Functions; Common Functions; Geometric Functions; Matrix Functions; Vector Relational Functions; Texture Access Functions; Fragment Processing Functions; Noise Functions;
   
   Chapter 6. SIMPLE SHADING EXAMPLE
   Brick Shader Overview; Vertex Shader; Fragment Shader; Observations;
   
   Chapter 7 OPENGL SHADING LANGUAGE API
   Obtaining Version Information; Creating Shader Objects; Compiling Shader Objects; Linking and Using Shaders; Cleaning Up; Query Functions; Specifying Vertex Attributes; Specifying Uniform Variables; Samplers; Multiple Render Targets; Development Aids; Implementation-Dependent API Values; Application Code for Brick Shaders;
   
   Chapter 8. SHADER DEVELOPMENT
   General Principles; Performance Considerations; Shader Debugging; Shader Development Tools; Scene Graphs;
   
   Chapter 9. EMULATING OPENGL FIXED FUNCTIONALITY
   Transformation; Light Sources; Material Properties and Lighting; Two-Sided Lighting; No Lighting; Fog; Texture Coordinate Generation; User Clipping; Texture Application;
   
   Chapter 10. STORED TEXTURE SHADERS
   Access to Texture Maps from a Shader; Simple Texturing Example; Multitexturing Example; Cube Mapping Example; Another Environment Mapping Example; Glyph Bombing;
   
   Chapter 11. PROCEDURAL TEXTURE SHADERS
   Regular Patterns; Toy Ball; Lattice; Bump Mapping;
   
   Chapter 12. LIGHTING
   Hemisphere Lighting; Image-Based Lighting; Lighting with Spherical Harmonics; The *erLight Shader;
   
   Chapter 13. SHADOWS
   Ambient Occlusion; Shadow Maps; Deferred Shading for Volume Shadows;
   
   Chapter 14. SURFACE CHARACTERISTICS
   Refraction; Diffraction; BRDF Models; Polynomial Texture Mapping with BRDF Data;
   
   Chapter 15. NOISE
   Noise Defined; Noise Textures; Trade-offs; A Simple Noise Shader; Turbulence; Granite; Wood;
   
   Chapter 16. ANIMATION
   On/Off; Threshold; Translation; Morphing; Other Blending Effects; Vertex Noise; Particle Systems; Wobble;
   
   Chapter 17. ANTIALIASING PROCEDURAL TEXTURES
   Sources of Aliasing; Avoiding Aliasing; Increasing Resolution; Antialiased Stripe Example; Frequency Clamping;
   
   Chapter 18. NON-PHOTOREALISTIC SHADERS
   Hatching Example; Technical Illustration Example; Mandelbrot Example;
   
   Chapter 19. SHADERS FOR IMAGING
   Geometric Image Transforms; Mathematical Mappings; Lookup Table Operations; Color Space Conversions; Image Interpolation and Extrapolation; Blend Modes;
   
   Chapter 20. REALWORLDZ
   Features; RealWorldz Internals; Implementation; Atmospheric Effects; Ocean; Clouds;
   
   Chapter 21. LANGUAGE COMPARISON
   Chronology of Shading Languages; RenderMan; OpenGL Shader (ISL); HLSL; Cg;
   Appendix A. Language Grammar
   Appendix B. API Function Reference



4. I'm not a fan of the 'group of papers' style of book. But this book pulls it off nicely. The text is consistenly good throughout. And the illustrations and formulas are high quality and presented nicely.
   
   I would have liked full color throughout, but I accept that it would have been cost prohibitive on a book of this heft. Speaking of heft, yeah, this is a doorstop of a book. I think some of the text could have been edited down and the formatting tightened up to reduce bulk.



5. I definitely recommend this book for anyone working with OpenGL's new Shading Language. I would, however, say that probably the most difficult part of working with GLSL is getting it working in the first place. Especially on Linux, this is somewhat confusing - some cards support GL 2.0, some don't, but still support the GLSL if using the ARB function calls. I would also make sure to point out to new users that GLEW is close to essential when working with the GLSL - you can download it from sourceforge. It might be worth mentioning in future versions of the book, along with ARB functions which are the same as the GLSL standard functions shown in the book.

5 comments about Test-Driven Development in Microsoft .NET (Microsoft Professional).

1. Many people think that Test-Driven Development (TDD) is all about testing software. In fact, test-driven development's main goal is not testing software, but aiding the programmer and customer during the development process with unambiguous requirements. The requirements are in the form of tests that the software must pass along the development process.
   
   This procedure helps to insure that problems are found early and corrected while they are still small.
   
   This book first discusses TDD from a conceptual point of view then gives a TDD example using a realistic application.



2. This is a great book for experienced developers. It covers a wide range of realistic uses in .NET and has plenty of detailed examples. It gets you into the mindset of Test-Driven Development (TDD) in good increments. The NUnit discussed is a free download and is very easy to start using with your own software quickly, so you can come up to speed right away and begin using it on your projects. One of the better TDD books that I have read, possibly the best. It will certainly remain on my bookshelf for some time.



3. Test-Driven Development in Microsoft.NET rises head and shoulders above the other books on the subject. While I know that is a very strong statement to make, the authors have made the focus of the book a very practical one. Don't get me wrong, there are several other great books on this subject, but they all seem to fall down when it comes to real-world situations.
   
   The book is split into two parts; Part I is an overview of Test-Driven Development, and Part II covers using TDD to develop an example application.
   
   Chapter 1 frames the entire discussion with an overview of Test-Driven Development concepts, including some straightforward guidelines for design. I thought it was laid out in very logical fashion.
   
   Chapter 2 throws you right into the process it's a classic stack example, found in many other TDD books. What I liked most about it though, was that the chapter began with discussing HOW you start figuring out WHAT tests to write as you develop an application.
   
   Chapter 3 covers another critical concept of TDD Refactoring. (What's Refactoring? You askread chapter 3 ;) ). Again, the authors walk you through a short yet concise primer using the Sieve of Eratosthenes implemented in C#. They introduce the algorithm and then discuss it in light of code refactoring techniques as implemented originally in Martin Fowler's Refactoring: Improving the Design of Existing Code.
   
   Chapter 4 is the introduction of the example application that will be the focus of the remainder of the book. It lays out the scenario, project features and constraints of the fictitious project.
   
   Chapter 5 covers an area that I've found generates a ton of interest when developers start thinking about TDD, namely data access. I really appreciated the practical approach that the authors took when writing the implementation chapters for the example application. I found the tests surrounding entities and relationships and the resulting explanations to be very good.
   
   Chapter 6 covers how you create tests when implementing Web Services. In the process, the service interface pattern is discussed along with refactoring Web Services. The authors attempt to lead you through a "thought framework" for creating tests through each of the implementation chapters.
   
   Chapters 7, 8, and 9 make a shift from programmer testing to customer testing and cover differing aspects of customer or acceptance testing. This group of chapters starts with an overview of acceptance testing and techniques. The middle chapter deals with driving development up through the implemented layers from a user or customer perspective. Chapter 9 rounds out the discussion by focusing on handling faults and how acceptance testing allows you to tighten things up.
   
   Chapter 10 leads us back to the programmer testing side by dealing with transactions. Following this, Chapter 11 introduces the reader to Service-level refactoring, leading you through the thought process behind different techniques. The story winds down in Chapter 12 with applying the process of TDD to implementing a web client.
   
   All in all, while I'd have like to have seen a both a simpler example and always more "real world" tips and tricks, I can tell you from my own experience that finding that balance is extremely difficult. I believe the authors have made a significant attempt at striking the "real world" / simplicity balance and that the resulting outcome is an excellent resource for learning TDD. When that is combined with the level of effort the authors are putting in to maintaining the code and forums at their GotDotNet workspace, this makes Test-Driven Development in Microsoft .NET an excellent choice for your library.



4. I attended a workshop on test driven development presented by James Newkirk. I was so intrigued with the concept that I had to go out and get his book to find out more. As a result our project now uses NUnit, TestDriven.net for test driven development and find that this has really boosted confidence in the developers and their code. The concept of test-driven development is a very useful agile method of writing code to the requirements based on tests (Red/Green/Refactor). This has certainly changed my perspective towards development and want to thank James Newkirk for purveying this concept.



5. For .NET developers new to test-driven-development who want a recipe for the process, an invaluable book. This is not a concept book, but rather a concrete example that gets a little loose towards the end. Those who have also adopted Model-View-Controller for their ASP.NET applications will be able to logically extend the first half of the book to test their web interfaces, something that is admittedly difficult using the "stock" ASP.NET design philosophy.
   
   I would supplement this book with Pragmatic Unit Testing with nUnit and C#, which gives you a much higher-level view of how to utilize TDD on a daily basis.

5 comments about Murach's ASP.NET 2.0 Web Programming with VB 2005.

1. When I received the book I had a hard time putting it down. It hit the nail right on the head, as to what I was looking for. Detailed information is great, and can be used as a reference also. You don't have to waste time sifting through page after page trying to find what you need. One page has the details and the other is reference!



2. It seems to be just what I was looking for in a training and reference book.



3. I've spent hours and hours on Amazon, on messageboards, sitting on the floor at Borders reading thru every ASP.NET book available, and it seemed none came close to this book for real-world, comprehensive teaching and practice. I have not been dissapointed, as I am almost finished and the book has helped me get up to speed after a long layoff (I last programmed Classic ASP years ago). Each example builds on the previous one to build a completed application. Awesome.



4. I thought it was a good reference book - not one you could read cover to cover. It seemed to jump around a bit more than I liked. It covered most of the need-to-know topics.
   
   I tend to work in the source code window more than the design window, and this book tends to do the latter. It's not a bad thing, it's just different.
   
   All in all, it's a good book, but some of the topics/concepts seem forced into the application you are creating throughout the book.



5. I don't where the other reviews about this book being good for beginners is coming from.
   
   I have solid programming experience in C and Visual Basic 6 and two semesters of Java. I have also 10 years experience with regular HTML.
   I have even worked through all the exercises in Build Your Own ASP.NET 2.0 Web Site Using C# & VB by Cristian Darie and Zak Ruvalcaba.
   
   Thank goodness I had that going for me, because I would have been lost otherwise in chapters 2 and 3.
   
   The example in Chapter 2 should have been about the Order.aspx page which is used in the remaining chapters of the book. Instead the authors go off on a tangent using as an example a different webpage which isn't ever used again later on in the book.
   
   The first 2 or 3 chapters are critical, and I strongly believe that the authors need to SHOW how to go about creating the Design views of Orders.aspx and Cart.aspx pages that they discuss extensively in Chapter 3. They basically just throw the screen captures up thinking that the discussion in Chapter 2 would be useful and helpful. Not!
   They also put up the code for both Product.vb and CartItem.vb without specifically telling the reader which should go where. A no-no for beginners.
   
   I also agree with a previous review which said that the dual-page approach is a great waste of paper because much of the text was redundant.
   
   I am not saying it's a bad book, but it is not as good as it could be.
   It is for people who have some programming and HTML experience.

5 comments about Scaling Software Agility: Best Practices for Large Enterprises (Agile Software Development Series).

1. Having read a lot of material on Agile, and employed it in practice for quite a number of years, it is refreshing to see a book take a very pragmatic approach to deploying Agile techniques in large-scale organisations.
   Many other books on the subject fail to go beyond the team-context, whereas that is the precise aim of this book. The book can be used as a thorough guideline for deploying Agile methods into an established organisation, pointing out which methods are the foundation of Agile, and which can be used to build on top.
   The author has a profound insight in organisational structures and how to employ the Agile methods in conjunction with external processes, such as roadmapping, in a constructive rather than conflicting manner.
   On top of all of this, the author has actually practiced what he preaches and proven that his methods work by deploying this to BMC Software and other software manufacturers.



2. Although somewhat naive ( optimistic ) and simplistic in its understanding of corporations, it is a great starting point for managing agility within a large enterprise environment, even though it espouses an agile coup of the organization.
   I will definitely use it as my standard reference for managing teams and projects.



3. If you are looking into insights to scaling Agile projects you will be dissapointed.
   
   The auther largly discribes the outlines of different development methodologies in the book, Xp, Scrum, DSDM, RUP. It takes to page 87 before the actual content of the book (scaling) even begins.
   
   But when push comes to shove, the authors silently reverts to the basic monotholic arcitecture message "agile is good in small teams, but shall not be trusted in large environments". That is saying "I have no new insights into managing the impediments of large organisation".
   
   What I was expecting was some new insights into of breaking down communication and cultural barriers that are in the way of scaling Agile projects, lean software techologies in the large etc.
   
   At is best, the book provides a good compilation of development methologies, at it's worst, it mixes up the cards so bad that you will end up even more confused than before you started.
   
   If you are looking into scaling agile, "The Enterprices and scrum" and any of Jeff Sutherlands scrum-of-scrum papers are a better bet.



4. I found this book to be an excellent recap of agile concepts, and an encouraging introduction to how to put agile into practice in the enterprise. I particularly appreciate the recommendations for measurement at both the team and enterprise level.
   
   I will use the recommendations of the book to make my distributed teams and development processes more agile, but there are still a few things that seem to be missing in the large system arena. For example: dealing with production issues in the middle of a sprint, getting the infrastructure groups (DBAs, messaging experts, integration tool jockeys, etc.) into the mix. I'd love to see more case studies involving big distributed systems with complex integration challenges.



5. Before reading this book, I had become interested in agile since I had used agile practices in successful small teams in the 90's. In early 2007, I was working on a 150 person project. And every book I saw before this one just did some hand waving about what agile means for teams larger than 10.
   
   This book was a big help to me in understanding how to begin transforming a large development organization to agility.
   
   Part 1 "Overview of Software Agility" provides an overview of several agile methods.
   
   Part 2 "Seven Agile Team Practices that Scales" distills the learnings from Part 1 into a set of key themes that are inherent to any agile approach - or really - any good development approach.
   
   Part 3 "Creating the Agile Enterprise" then gives several examples of applying the scaling practices to the enterprise.

5 comments about Pro .NET 2.0 Windows Forms and Custom Controls in C#.

1. Since the moment when I took this book in my hands and was able to make practice with the examples on this book, I was able to feel recognized the simplicity in the complexity of the controls.
   
   The examples are clear and very well done, impeccables and flawless a good thing for the newbie and the old programmer.
   
   I am enjoying the controls that allow me to click on them and assign my own properties.



2. I've read quite a few books on Windows Forms applications which include creating custom controls. There are some that are average and there are some that are very good. Usually the average books tend to touch on the simpler aspects of windows forms and forms controls and not go into much detail, which is OK for the novice programmer dabbling in .NET for the first time. However, the more experienced programmers among us want much more. In this respect the very good books tend to be a little over the top for the average user.
   
   This book falls somewhere in the middle for novice and experienced programmers alike, whilst still being rather good. It offers a good discussion on what makes up the underlying architecture of Windows Forms applications which many books lack. The .NET IDE attempts to hide a lot of the nuts and bolts behind the outer layers and generally you shouldn't touch what's under the covers. But occasionally you need to, especially when using visual inheritance because that's when the IDE starts the go a little haywire. By understanding a little about what's happening underneath goes a long way in helping you get out of the mess when the IDE does screw up.
   
   The book covers most of the interesting forms controls .NET 2.0 has to offer and describes them in better detail than what can be found in the relatively useless MSDN on-line help. The code examples given are excellent, concentrating on real-world scenarios. A good portion of the book illustrates how to extend these controls further using custom controls and GDI+ owner drawing to modify the look and feel of these controls.
   
   The book also concentrates on developing 3-tier applications isolating the presentation layer from the business logic and data layers, which is a highly recommended practice for developing scalable applications.
   
   The book doesn't include a CD but all the code examples can be downloaded from the publisher's web site.
   
   Overall I give it 4 out of 5.



3. I checked this book out online and only read chapter 20(multithreading). In this chapter the author does an excelent job progressively building your knowledge about .net Threading. I would highly recommend reading this book to anyone wanting to learn about Threading.
   
   The only downfall about this chapter is that it does not talk about some of the more advanced Threading classes such as Monitor and ReaderWriterLock. I would love for this author to do a standalone book just about threading.



4. I needed this book for a training course on Windows development in .Net. It helped a great deal to have a good reference that was not the same as the book used in the course. Sometimes I found the examples a little hard to follow because of the distraction of the scenarios shown, but when I boiled them down to what they were meant to present, they were very helpful.



5. This book has already paid for itself in just a couple of weeks -- due to the time saved in trying to find the information I need. Every time I have a question regarding an issue in Windows Forms or with Custom & User Controls, I can find it here. Additionally, the content is written in a manner that can be understood by mere mortals, with some good tips and tricks thrown in too.
   
   Highly recommended.
   
   On the merits of this text, I've already purchased Matthew MacDonald's WPF book (the 3.0 one, since I haven't *quite* moved to VS 2008 yet...).

5 comments about Algorithms.

1. Algorithms is a complex topic in computing that needs tentative learning. The authors of this book really succeeded in making learning algorithms more enjoying, interesting, and easy yet comprehensive and advanced. This is a difficult equation, but this book really achieves it. It takes you from the early foundation with the Fibonacci algorithm till the complex graph algorithms while explaining each milestone all over the way. The was they present this subject is in a story manner or a casual discussion between two computing professionals which makes the book interactive, easy to access, and comprehensive. I recommend this book for both beginner and advanced readers in the field of computing.



2. As a CS undergrad at UC San Diego, the author used rough drafts of this book to teach the algorithms course I took as a student. Although we also used the Cormen("The Bible") Algorithms book for casual reference, this text is by far better to explain the concepts behind the algorithms. I must say that the author presents the course with this text far clearer and superior than the usual dry mathematicians and the contents of the material reflects his expertise in lecturing and writing. The lucid writing makes it a joy to actually read an algorithms book, and the exercises are definitely worth investigating. This book simply makes algorithms fun!



3. I occasionally teach algorithms at CU Boulder to our undergraduates. This book accomplishes what it set out to do: provide a comprehensible (but not comprehensive) treatment of a core piece of Computer Science at an affordable cost.
   
   That we get one of the greatest researchers in the area (Papadimitriou) alongside two other distinguished authors is just icing on the cake.
   
   The first printing had numerous errors, though the online version of the book had already corrected many of them. I haven't used the book since then, but will in the Fall, and I'd expect with the vigor already invested by the authors, the book will be in even better shape.
   
   I'm glad they wrote this thing.. it was long overdue.



4. The top choice for an algorithms text is generally considered to be Cormen, et al. However, Cormen is not unassailable, and an author that is able to provide an alternate and useful approach into the subject can find his audience. Skiena's Algorithm Design Manual comes to mind in this regard, and some even consider it superior to Cormen. Dasgupta, Papadimitriou and Vazirani "Algorithms" provide yet a third approach.
   While less comprehensive than either Cormen or Skiena, the tone is more conversational and relaxed. At only 320 pages, it cannot be expected to be comprehensive. Certain standard topics are barely covered (such as binary search trees and red black trees) if at all. Because of this, it can only be a used as an introductory text, or maybe used as a supplement to Cormen or Skiena
   
   
   And now for the bad... "Algorithms" does not have answers to any of the end of chapter problems. There really is no justification for this. Yes Cormen and Skiena also do not provide answers...but as I mentioned earlier, if they want to compete with Cormen and Skiena, they have to provide something new, and giving students the answers to some of the problems would have been the easist way to accomplish this.
   The authors exhibit enough inaccuracies when discussing non-computer science topics (ie, linear algebra, cryptography, and quantum mechanics) that at times, you have to wonder about their command of the main topic -- algorithms.
   
   So, consider, for example, when discussing the simplex algorithm on page 213, they incorrectly define what is meant by a hyperplane. The standard definition can be found in Hoffman and Kunze (i.e., in a vector space of dimension n, a subspace of dimension n-1 is a hyperspace or hyperplane). Their definition is simply wrong. Moving on to cryptography, they discuss the one time pad, the AES, and the RSA cryptosystems. They dismiss the one-time pad as a toy scheme, and suggest that at the other end of the spectrum is the AES scheme. The fact is just the opposite -- the one-time pad has been proven to be a completely secure and unbreakable cryptosystem, and the AES has not been proven so. Also, comparing the one time pad to the RSA, one should note the RSAs security relies on the non-proven difficulty of factoring large numbers...and if quantum computers ever became a reality, the fact is the RSA would be broken. The reason the one time pad is not used is not because it is a toy. It is not used because in the one-time pad, the symmetric key can only be used once, and so a new problem -- key distribution -- is introduced, which in fact makes the one time pad impractical for most applications. Moving on to algebra, on pg. 33 we see the statement "The mapping x|-> x^e mod N is a bijection on {0,1,2,...,N-1}". A mathematician would properly state this as onto, not on, {0,1,2,...,N-1}, since the map is a bijection.
   
   
   Finally, the last chapter is on quantum algorithms (big marks for bravery), which neither Cormen and Skiena do (Skiena has a new edition of his book on the way, so we will have to wait and see if his latest covers it). From a physics point of view, the chapter falls way short. They attempt to introduce qubits by discussing a single electron atom. The problem is they do not seem to realize you cannot use an atom for both a qubits and a classical bits discussion. An atom is 100% quantum mechanical. (By comparison, when Feynman discussed the double slit experiment, he used electrons to illustrate the quantum effects, and bullets for the classical case.) Therefore, the author's statement on page 298 "These are the two possible states of the electron in classical physics" is just nonsense. In classical physics, the electron does not have a first excited state, it has a continuum of possible states -granted, the states are not stable and the electron will promptly spiral into the nucleus, but that is a separate issue. The authors also give a quote by Feynman: "I think I can safely say that no one understands quantum physics". Yes, at the time Feynman said that, that was probably true. But quantum theory has not stood still, and Feynman perhaps did not know the theory of decoherence, or perhaps he considered it speculative. But, as decoherence has now been observed in the laboratory, there is in fact a school of thought, championed by Roland Omnes, which claims that quantum mechanics is now, with the addition of decoherence, finally in some sense understood. ...Also, they introduce a two particle system as a tensor product state. It is true this is the correct description, but it is not correct to do so without any motivation of why (why not a direct sum of vector spaces, for example? Why must it be a tensor product of vector spaces?) and without bothering to give a definition of a tensor product. I encourage the interested reader to consult "Quantum Mechanics - a modern development" by Ballentine and also the outstanding "The Quantum Mechanics Solver" by Basdeveant and Dalibard if they truly wish to understand the modern Quantum Theory topics which the authors have so poorly treated.
   
   Still, despite the above issues, as long as one is using this book as a supplement, and not the main text, I think it can serve as valuable resource for the algorithms student.



5. One of the most appealing characteristics of this book is the small size. Textbooks in algorithms are similar to those of other fields in that they have continued to increase in girth over the years. At 320 pages, this book is a relative midget.
   However, that does not in any way mean that it is weak in content, there is plenty of material for a one-semester course in algorithms. The chapters are:
   
   *) Prologue - a bit of history and the big-O notation
   *) Algorithms with numbers - basic and modular arithmetic, primality testing and cryptography
   *) Divide-and-conquer algorithms - multiplication, recurrence relations, mergesort, matrix multiplication and the Fast Fourier Transform (FFT).
   *) Decomposition of graphs - the fundamental definition of directed and undirected graphs and performing depth-first searches.
   *) Paths in graphs- basic algorithms used in graph searches
   *) Greedy algorithms - some fundamental greedy algorithms and their basic level of performance
   *) Dynamic programming - shortest paths, knapsack optimization and independent sets in trees
   *) Linear programming and reductions - the definition of linear programming and some of the standard problems that it can be used to solve
   *) NP-complete problems - definition of NP-complete, some examples and reduction strategies used to show NP equivalence
   *) Coping with NP-completeness - intelligent search, approximation and random algorithms
   *) Quantum algorithms - a brief foray into a possible revolution in computing. Explanations of how data may be stored and processed at the quantum level.
   
   The explanations are brief yet thorough enough for advanced computer science students, the algorithms are presented in a generic pseudocode. A large set of exercises are included at the end of the chapters, the expectation is that the solutions will be expressed in pseudocode.
   Despite the compactness of the presentation, this book is a worthy choice for the textbook in an algorithms course for upper level computer science majors.

5 comments about Effective C#: 50 Specific Ways to Improve Your C# (Effective Software Development Series).

1. I agree with those who say that Effective C# is not for beginners. Even experienced programmers should go elsewhere for an introduction to the language and the .NET environment. While other books might serve as a comprehensive textbook for learning the rudiments, this one offers some in-depth insights into how to build solutions that are elegant, efficient, reliable, and maintainable.
   
   I also agree with those who are disappointed in the poor editing. The book is riddled with typos, especially word spacing problems. Mostly, these are little more than a minor annoyance but they make the book a really poor example of publishing quality.
   
   "Software engineering" has been described as finding the best solution for a given problem where "programming" is merely a matter of developing something that works. That's what this book is all about. Sure, there are going to be times when you don't need to build the kind of quality into your code that the author advocates. The need to get something done quickly will often outweigh issues like whether you're really getting optimal performance, whether accepted OO principles are always being followed, or whether your employing the best of all possible solutions. But this book is about how build "industrial strength" classes that can be reused without breaking or creating undue heartburn for the poor slobs who have to rely on them.
   
   Like most programming books, lots of the information is conveyed in code examples. However, this is not the book you'll want if you're going to cut-and-paste somebody's sample program and hack it into your own working version. In fact, the code examples are so brief and simple that they often seem almost pointless at first glance. As you read the explanations, which are more punchy and to-the-point than they are eloquent, you begin to grasp the essence of the principle being explored. Personally, I feel there's room for improvement in Mr. Wagner's writing style, which can be a little too concise to be really illustrative, but he does get his message across.
   
   Possibly the book's greatest strength lies in the rationale given for the recommendations offered, as opposed to the recommendations themselves. The fifty items are more than a series of "best practices" to be blindly followed whether you understand them or not. Good programming is often a matter of choosing from a set of alternatives by weighing the value of each approach, assessing trade-offs, and making intelligent decisions. That's where this book can really help.
   
   Evidently, this book carries on a tradition of "Effective" books in that it consists of a series of relatively short articles, each of which illustrates some very focused aspect of how C# code is compiled, the nature of certain .NET Framework types, and/or how the CLR operates. I, for one, think a more conventional format, where the content is broken down into longer chapters that go into major concept areas in depth might have been a better way for Mr. Wagner to share his obviously thorough knowledge of the subject. At first glance, this book gives the impression of being a set of little hints and tricks, as opposed to the serious technical book it really is.



2. Excellent book. My only complaint -- where's the new edition for the new version(s) of the framework?



3. While C# is pretty easy to get up to speed with coming from a C/C++ background, the similarities can lead to costly blunders! .Net/C# is a "real" language and as such deserves the respect of any self-proclaimed professional. This book is a great resource for getting that first glimpse to advanced topics that every pro should strive for. It's an easy read and the format (recipe) lends itself very well to quick reading sessions that stick in your mind. Your coding style will invariably change for the best upon closing this book. Simply stated this book should be mandatory reading for anyone joining a .Net project but coming from a traditional language (C/C++).



4. This book has helped me identify and made some performance improvements to my C# software code. One thing I like about this book, is that the author cuts right to the chase in his explanations and gives excellent supporting code samples in cases where needed.



5. This book would benefit greatly from a rewrite. It is often difficult to follow the authors' logic. I get the impression that this book was rushed to print. A simple example of this is the fact that all the left-hand pages are incorrectly indented so that they run into the binding of the book. Please adjust your publishing software!

5 comments about Essential COM (DevelopMentor Series).

1. All vetran C++ programmers should learn this along side MFC, it assumes a minimal knowledge of COM so it is easy to pick up, and gets you familiar with the common elements of this widely used standard (CLSIDs, IIDs, COM Functions, etc) Shell programmers will want to read this first. See my other reviews for more good books in COM.



2. I have learned a lot with this book. I would not qualify the book an introduction book because unless you have some background knowledge and practice, you are going to find the last chapters hard to digest. What the book does is to covers the essential principles of COM with great details. This will make the first reading very interesting and it will make you come back from time to time to seek back specific detail.



3. I read Essential COM almost 10 years ago, and revisited it recently, out of curiosity. It's tough sledding, but if you *must* know this stuff, this is probably it.
   
   However, throughout the book the phrase "the source code that accompanies this book" occurs repeatedly. As far as I could ascertain after an hour or so of googling and searching, there *is* no such source. I assume it stopped working 5 years ago or something, and rather than continuing to provide it somewhere on the web with a disclaimer -- which I assume would be embarrassing to Mr. Box -- it has been silently "disappeared". I consider this mildly unethical, and certainly annoying, since many perhaps minor points are supposedly demonstrated by this non-existent source.



4. If you want to learn COM I dont think this book is a good start. It is a great book and I think every COM developer should read it, however; it is not a step-by-step into. It also doesn't have small projects which let's your get feet wet w/COM. I would recommend "Inside COM" by Dale Rogerson to start learning COM.



5. I read this book about ten years ago first time. When I have to deal with a COM problem, I still find it useful.

5 comments about Eclipse Distilled (Eclipse Series).

1. With Eclipse becoming extremely popular as an integrated development environment, there have been a number of books published to help you learn the tool. I recently received a copy of Eclipse Distilled by David Carlson, and it's a pretty good addition to the collection...
   
   Contents:
   Part 1 - Getting Started: A Java IDE and So Much More!; Hello Eclipse; Managing Your Projects; Customizing Your Workbench; Rapid Development; Java Project Configuration; Debugging Your Code
   Part 2 - Getting Agile: Characteristics of Agile Development; Updating the Eclipse IDE; Continuous Testing with JUnit; Refactoring Your Code; Continuous Integration with Ant; Team Ownership with CVS; Coding Standards; Index
   
   If you're looking for a book that covers a large number of the features of the Eclipse IDE, this book will be a good choice. In addition to covering all the technical details for installation, options, and "how to" things like refactoring, the author also covers how Eclipse works with various other common programming tools like JUnit and CVS. It's not a definitive guide on these other software packages, but you'll get a good grounding on how they integrate.
   
   What this book *isn't* is a tutorial guide to learning Eclipse. There are a number of Eclipse books that will walk you through a number of examples of how the package works and how to write code with it. This book really doesn't do that. You'll find out a lot about all the different options, but it's not like a "step 1, step 2, step 3" presentation. I really don't consider this a detriment to the book. If I wanted a tutorial, I could find one. But if I want a book that shows me all the mechanics and let's me figure out how to apply them to my needs, the "Distilled" approach works great.
   
   I like the book, but I can see how some people might not be enamored with the lack of sample code. If you're going in with your eyes open, you should be fine...



2. In his forward, David Carlson writes: "This is the book I wanted to read when I started using Eclipse three years ago." Wow! And this is the book I wanted to read too!
   
   Like husbands and wives, wrenches and nuts, hands and gloves, some things were meant to fit together, while others repel like oil and water. When I learn a new programming language, IDE, API, software program, etc. I want the basics, the practical, the stuff I really need to get going. In any of these endeavors, there is simply too much to learn to sit reading detailed information on features that just never come up for me. Give me a good grounding in the basics, and I will pick up the details on the fly when I need them.
   
   Carlson's book will get you up to speed fast. Furthermore, it gives you the basics on several of the latest development methods with which Eclipse is compatible. He provides excellent basic discussions of Agile Development, JUnit testing, Ant, refactoring and the Concurrent Version System. He easily fits all this information into less than 300 pages.
   
   If this approach fits you like it fits me: Quick! Buy this book and get started.



3. I manage multiple developers spread around the globe building product relying on the Eclipse Web Standard Tools (WST) and other parts of Eclipse. Getting each team member's IDE configured and updated was sucking up time.
   
   Chapter 9, "Updating the Eclipse IDE," saved us time equivalent to purchasing boxes of the book. Now we have flexible, consistent, repeatable configurations that make upgrading to new versions of WST and other features easy.
   
   We have adjusted our team's practices based on info in other chapters too.
   
   Carlson has provided excellent information for developers who want to work more effectively in the Eclipse environment. I'm delighted with the purchase.



4. I read this book end to end but didnt find even a single startling fact about eclipse that i didnt know already.It was more like feature round up ( which you can discover going through the menu items in eclipse IDE)
   I would recommend this book for people who are absolutly new to eclipse .



5. This is an excellent book and I recommend it highly to start with Eclipse.
   It saved me an incredible amount of time by providing the right level of information on virtually all important features of Eclipse.
   This book is for people with a background in development, but new to Eclipse.

4 comments about The Definitive Guide to Terracotta: Cluster the JVM for Spring, Hibernate and POJO Scalability (The Definitive Guide).

1. A must have book to buy to understanding Terracotta Best Practices,I personally was an early adopter and has had much success, Terracotta has proven over the years to help ease the development of HA systems, that scale from the start...this book has real world examples (not just Hello Worlds! Programs) ..to build and deploy systems backed by Terracotta for your enterprise.



2. This book really presents an in-depth coverage of the power of Terracotta, backed by real world how-to examples.
   
   The only thing that could be better is the language. Sometimes the concept is explained in a very dense language upfront, so by the time you get to the example, you get a little lost and need to go back and re-read some paragraphs.
   
   Besides that, it's one of those examples where the content compensates the shape. A must have if you are looking forward to turning you application into a clustered solution.



3. This book is a must for anyone trying to understand and get real performance out of a custom terracotta deployment.
   
   There is a lot of information in this book that is either not on the terracotta wiki or is scattered across many sites.



4. This book goes into a lot of detail about how and why Terracotta was made. It goes into a lot of topics such as scaling, the jvm, synchronization, etc.
   It talks about the philosophy of terracotta and goes through in detail about the choices that you have when for example, you have to scale, and the tradeoffs of each of those choices.
   In short, this book is a good read, even if you are not going to be using terracotta just yet.