Software Books

Thanks Gary & Dale for getting me up to speed in short order. Your book, Implementing and Administering MS Office Project Server 2007 is a great read and a great reference as we begin our MSPS Server 2007 implementation. I now visit the MS ProjectExperts web page regularly and look forward to more great insights and products.
Well done !

Jim Gibbons PMP
US Dept. of Labor
EITPMO SME

Gary and Dale have written many books, this is the best yet. I cannot recommend strongly enough that if you are about to embark on an EPM implementations, be you an EPM implementor or part of the organization the EPM implementation is for, you NEED this book. Given the time you will save and the added value you will provide after reading the book, the decision is a no-brainer: buy it!

Gary and Dale's book is VERY thorough, and well organized. Given that the book is an 8/12 x 11 paperback of over 800 pages, it not something to curl up with in bed! If they offered it in a loose-leaf form to put in a binder, it would be easier to handle. One annoying feature is that most illustrations are on the FOLLOWING page from the texts referencing them.

Gary and Dale, keep hitting it square on the head. This book is the best I have seen for managing project server 2007 and sharepoint 2007. I have looked at much of the Microsoft documentation, but this book gets to the heart of what is needed. It has great explanations and step-by-step procedures. I would recommend to anyone who is going to configure, manage, and monitor project server 2007. Also, it is a great book for those people who designing a project management office in their company. It will have you frame out your PMIS for your PMO.

As an EPM implementor and PMO Director at a technology company, my advice to you is this: If you are implementing MOPS 2007, buy this book! It contains outstanding practical advice and best practices about how to SUCCESSFULLY implement this tool.

My only regret is that it wasn't published before we started our implementation... it would have saved us several MONTHS of figuring out how do do it ourselves.

Note: I am in no way affiliated with MSProjectExperts, nor am I receiving any kind of compensation for this endorsement. These books have saved us tons of time and rework!

This is a very good book for every programmer to grow to next level. Book is written to address almost all issues related to software development. Need to have book for every programmer.

All .Net developers have to keep Patterns & Practices publications under thier radar screen because one of the best works come out of that group.

A great book that covers in detail any areas you need: CLR, strings management, collections, asp.net, ado.net, xml, SQL Server and much more. A practical handbook that should be on your desktop as a reference for you everyday programming.
[...]

To be honest, I hate two kilos books. Usually such a book contains not much information. But not this book.
It starts from design guidelines and 40-pages(!) length questionnaire, and covers in detail a lot of subjects, including CLR, interop, remoting, ASP, XML, Web Services, etc. performance. How to measure, how to test, how to tune.
If you have to know a lot of things about a lot of things concerned with .NET performance, this book is for you.

In a word...WOW! There is such a wealth of info in this book. Direct for the source, one of the performance architects of the CLR (among other authors). This book is a must have for any developer who writes high use web apps or web services. The book goes into so much detail, and explains why one coding method is more efficient than another. Probably not a good beginner book, you should have a good grasp on .Net development first.

Well written and concise. How about keeping it in print, I ordered another copy.

Unless you have a bent for philosophy, don't buy this book until you have seen at least part of Chapter 4! This is not "10 Quick Tips to Improve Your C++ Skills." It is a seminal text that attempts to alter the fundamental way you perceive the process of programming.

This book seeks to correlate object-oriented programming with cognitive science. To this end, an abstract Object Model is created which is language-independent. This level of power and generality invariably exacts a toll in readability. Rather than illustrating the concepts with specific examples from a programming language, the author instead conveys the essence of the concepts first and only then clarifies this abstraction with programmatic examples.

Readers familiar with Ada will recognize certain terminology and concepts. For example, "attribute" is formally defined, and we see that an Ada attribute indeed conforms to this formal definition, and that the Ada construct was aptly named. The first part of the book deals with Abstract Data Types and is extremely relevant to both Ada and C++ programmers. The second half is concerned with Object Orientation and would only be of use to Ada95 (and, of course, C++) programmers.

I had the privilege of working with Bob Meehan, a brilliant PhD in mathematics. Bob had an uncanny ability to create a mental map of a program and then translate this abstract mental map into a working program. Over the years, I have learned to achieve this using Ada, but was at a loss to transfer this facility into C++. Reading this book has given me a glimpse into the way Bob's mind worked, and I am confident that after I have read (and re-read!) this book and fully absorbed its content, any expertise that I may have acquired in Ada will be fully transferable to C++.

This book is a treasure trove, but its nuggets are not easily mined. To absorb its message, you are asked to learn a number of abstract concepts whose pertinence to programming is not at all apparent. But, as an earlier reviewer has stated, if you keep at it the light eventually dawns and you find that you have been handed the key to correct thinking--because the author has altered your cognitive processes and enabled you to perceive and function in a completely new way.

Ada actively enforced the Object-Based paradigm. Resistance was futile and the compiler ruthlessly punished infractions. C++ relies on convention and the integrity of the programmer to enforce the Object-Oriented paradigm. Other than type-checking, the C++ compiler is promiscuous. Indeed, it has to be, since it needs to be able to compile C programs. Without the broader view and greater understanding imparted by this book, strict adherence to the OO paradigm would be quite difficult. Kurt Godel pointed out that a framework can only be completely understood from a broader, more inclusive framework that encompasses the original framework. This book, if you have the tenacity, will impart that broader framework and will change the very way you perceive the world.

This book is excellent! It is what a C++ intermediate book should be. The emphasis is on teaching what the Object Model is and how to implement it using C++ language constructs "sensibly". I wish the author would bring it up to date and write an advanced version. I would also enjoy seeing the author's recommended reading list.

Thank you Dr. Papurt for this book. Please write more.

This book will delight the intermediate to experienced C++ developer. The focus is on concepts supported by the C++ language features. Short code snippets make the implementation of those concepts clear and practical. A book worth reading more than once. A book in which you can find justifications for a particular design choice. If you need to strenghthen your use of C++ on a conceptual level, if you pay attention to program in the right way, if you are a purist towards the use of C++, read this book !

This book is a sleeper. When I started to read it I thought it irrelevant. Then a light dawned, and I began to understand a new, and correct way, of thinking about OO programming while gaining a greater knowledge of modeling and C++ programming techniques. I've read it twice and refer to it frequently for clarification and reference on some fine points. A truly useful book for active C++ programmers.

A pleasure to read, both for the inspiration coming from reading about people being very successful being idealistic, and from learning about the history of the Desktop Publishing revolution.

We at the Designer's Bookshelf have just awarded this book "THE BOOK OF THE YEAR" award for 2002. These awards are given by the editors and staff at the Design Bookshelf, DT&G Magazine, and the Graphic Design network as top choices for all those involved in the design, publishing and visual arts fields.

The only real flaw in this book is I want more. Adobe's story is fascinating, and I could probably read a detailed history of each product without being bored. (And I would have loved to have found out why Adobe never made an Illustrator 5 or 6 for the PC).

I got the book in the morning and started reading right away, skipped lunch and finished. Short read you might say... not at all; the text and the images are excellent and the book reads like a novel (reason why I skipped lunch). What a story!

It answered many questions that came up in my 10+ years of experience as a graphic design professional. Why Adobe this and how Adobe that.

The great thing about the book that it made me re-live my experiences; the advent of the mac and the LaserWriter, early releases of the software (it is quite touching to see pictures of the first, say, Illustrator), the successes and the failure the company went through. Those of us (graphic designers) who have pasted photostated type on the blue outline grid by hand will relate.

The book is about what and how things happened to allow us (graphic designers) to work the way we do today; it is, however, also about how Adobe changed the publishing world and global communication altogether.

Thumbs up on this one. Thank you Pamela Pfiffner for a great piece of research and writing. Thank you Adobe for the perseverance in bringing it all together towards the age of Network Publishing.

Anyone who uses a computer to design graphics, create printed documents, edit Web graphics, make movies and animations, or just type a letter should read this book.

While most people recognize the contributions Apple and Microsoft made to computers, few realize how much Adobe was right in there with those other companies.

This book tells that story--and does so with humor, behind-the-scenes gossip, and inside information. What were the "Font wars" of 1989? What were Adobe's original plans for Photoshop? What was the original purpose for the Acrobat PDF format?

Even better the quotes from industry greats. What did Steve Jobs think the first time he saw PostScript added to a printer? How did designers such as Roger Black and Louis Fishauf feel about products such as Illustrator and Photoshop?

The book is filled with tons of candid photos of those early days. You'll gasp as you see the much-younger versions of today's famous speakers and industry giants. My favorite is the extremely young Steve Jobs (in a tie and jacket!) at the debut of the PostScript LaserWriter.

The author must have been given quite a bit of leeway with the writing because she also describes those times Adobe didn't get it exactly right. What were the mistakes Adobe made in their first Web page-creation program? What was the problem with the original distribution of Acrobat Reader? And who was the only person at Adobe who could easily use the original Illustrator Pen tool?

And in an age of trade paperbacks, this book is a physical joy--a beautifully bound embossed-hardcover book with a varnish-coated dust jacket. The inside pages are exquisitely designed, with full-color photos throughout the book.

This is the sort of book you pick up and read, then pick up again, then again, then again. There's always one more little tidbit to laugh or smile over.

This is a best book I have ever seen. It has every details about how to use the iText. It's very clear in every technical aspects. iText is also a great API for Java programmer. It's also really easy to learn. I love iText.

I love this book. I strongly recommand this book.

This is a great book for people developing or maintaining applications using iText. It covers every corner-case I've run into, typically offering various options on how to solve a problem. The writing is concise, with easily approachable chapters and examples.

In January 2006 I was assigned to build a system that would create lots of PDF reports, typically with hundreds of pages of tables, and with tables nested in other tables. I started with an an open-source tool called BIRT that is well-designed and powerful, but it didn't quite give me sufficient low-level control over some aspects of PDF creation. When I realized that BIRT wasn't going to work for me, I was behind schedule and in trouble. Then I discovered iText. (BIRT actually is built using iText jar files.) I found that iText gave me exactly what I needed: an easy-to-use yet powerful Java API for creating PDF files. The remainder of the project, using iText, went smoothly, and my boss was very happy with the results. But I sure wish that I'd had Bruno Lowagie's "iText in Action" book at the time! That would have shaved a few weeks off of the project and would have saved me from learning some things painfully, by trial and error. As the original developer of iText, Bruno Lowagie is uniquely qualified to write this book. He obviously put a huge amount of effort into it, reflecting his longstanding commitment to iText. He made every effort to explain things as clearly as possible, and to document the pitfalls as well as the attractive features. It is evidently a labor of love for him. The book is written to the high editorial standards of other Manning books, with clear organization, good typography and layout, and so on. I highly recommended iText itself, and also this book, to anyone who is using Java to work with PDF files.

This is nice book, though most of the contents can be found online (I believe it is linked from the author's website). I have created some complex PDF files using iText following the examples on the book and online tutorials. This is the book from iText creator, surely it worth a 5 starts.

I've always figured that there should be some way to create PDF files without the manual effort of any 3rd party software client. Now I find out there is a way, and it's rather exciting... iText In Action by Bruno Lowagie covers the iText open source software project. It's a very well done reference manual that can also serve as a tutorial for a decent Java developer.

Contents:
Part 1 - Introduction: iText - when and why; PDF engine jump-start; PDF - why and when
Part 2 - Basic Building Blocks: Composing text elements; Inserting images; Constructing tables; Constructing columns
Part 3 - PDF Text and Graphics: Choosing the right font; Using fonts; Constructing and painting paths; Adding color and text; Drawing to Java Graphics2D
Part 4 - Interactive PDF: Browsing a PDF document; Automating PDF creation; Creating annotations and fields; Filling and signing AcroForms; iText in web applications; Under the hood
Appendixes: Class diagrams; Creating barcodes; Open parameters; Signing a PDF with a smart card; Dealing with exceptions; Pdf/X, Pdf/A, and tagged PDF; Resources; index

Lowagie starts off with a brief background of how iText came into being, along with a scenario of where the ability to programmatically create PDF files could dramatically change the way a college would run a department. Then after a short Hello World example that involves creating a simple document, he delves into all the different features and capabilities. The book at this point starts to change from tutorial to reference manual, but it's done in such a way that you could just keep working through the material in tutorial fashion with little effort (and good results). The example code in all the chapters are extensively annotated and explained, so you're not left to your own devices to try and figure out what the logic is trying to accomplish. In fact, I would say that the code annotation and commentary is some of the best I've seen in a book of this type. Great job...

The main target audience for this book is the Java developer, as the iText project is Java-based. There are .NET ports for J# and C#, and knowing how close those languages are to Java, this book should work pretty well for those development efforts with a little bit of thought and modification. Other languages should be able to use the iText toolkit if they have some way to call Java code modules from within their programs. As a Notes/Domino developer, I should be able to utilize all of this package in any Java agents I write, and the LS2J feature of LotusScript might also work well. After reading this book, I know I have some things I need to try...

If you have any sort of need involving the creation of PDF files from within your own system, iText is a great alternative to explore. And if that seems to be the way to go, I don't know of any better book to get than this one...

In the last decade, the performance of J2EE applications has become of monumental importance in enterprise industries that use these applications. With the complexity of J2EE applications increasing every year, it is crucial that users of these applications be presented with a level of performance that is acceptable to them, this performance usually codified in the ubiquitous "response time." The authors of this book have given a good introduction of how to deal with performance issues in WebLogic applications and have discussed a freely available tool, called Grinder, which allows load-generating and data collection. The book though can be read with respect to any load-generating tool, such as Mercury LoadRunner, etc. Even though Grinder is free, it may take time for enterprise users to trust it in testing and modeling.

After a brief introduction to what the book is all about, the authors begin in chapter 1 with discussion on a testing methodology for doing performance studies of J2EE applications, which they hope will be generic enough for all readers. Their methodology boils down to first defining the performance metrics for the application, and then setting a target for the metrics. Test scripts that accurately simulate the application usage must then be obtained, and the statistical sampling method and metrics must then be defined. The authors emphasize the need for a realistic `usage profile' for the application, and they recommend strongly a fixed number of users per test run, with subsequent runs changing the number of users. They do not give quantitative reasons for not varying the number of users, but merely say that such an approach is "statistically incorrect."

They also point out the need for including "think times" between the executions of each request in a script, asserting that the think times will have a very dramatic effect on the observed response times and throughput for a given user load. They are correct in this claim, as testing and modeling studies will show, and they give examples of this in chapter 4 of the book. In addition, they remark that the attempt to simulate more users by decreasing the think time, with the assumption that the resulting data can be then extrapolated to obtain the performance at real think times. They point out, correctly, that applications do not scale linearly over different time scales, and that the application and Web servers, the database server, and the operating system do not interact the same way with different user loads. Performance testers and modelers have verified them time and time again, and so it is beneficial for a reader who might be new to the field to see the case studies illustrating this included in the book.

The authors discuss two sampling methods in the book, namely the `cycle' method, and the `snapshot' method. Defining a cycle as a complete execution of a test script by a simulated user, each user will thus execute every request in the script once. Increasing the number of cycles will result in more meaningful statistics, but the time to run a large number of cycles might be too prohibitive. The snapshot method involves capturing the data for a specified period of time.

It is rare to see in books at this level a statement that acknowledges the difficulty in the mathematical or simulation modeling of Internet traffic. The authors though are cognizant of this difficulty, and give some brief suggestions on how to simulate the Internet in a test environment.

The authors also devote a fair amount of time discussing how to assess the accuracy of the test results. The authors report that variability of up to 50% on the performance testing of applications has been observed, and so they propose a measurement of "quality" for the sample data. This is defined as the standard deviation divided by the arithmetic mean, and when close to zero indicates high quality in the sample data. A value above 0.25 for the quality they take as a sign that the tests are not reproducible, and they therefore encourage the running of more cycles of the test in order to pin down the origins of this non-reproducibility. They define a "load factor" to better quantify this, which they define in terms of an "aggregate" average response time. Plotting this quantity versus the number of cycles gives some information on a bad quality indicator.

Frequently, application development using J2EE requires that the impact of design changes or proposals on application performance must be understood. The authors address how performance can be impacted in the context of building servlet applications. The dynamic nature of servlet applications entails that special measures be taken to maximize the performance of the application. The authors discuss how to choose a session mechanism that will preserve the session in user requests, and how to manage the servlet thread pool. Other helpful hints are given on how to increase performance, such as making sure that the auto-reload feature of servlets is disabled in a production environment. In testing the servlet API, the authors choose the snapshot method of data collection, and used zero think times as a baseline, since the real think times are unknown. They use WebLogic Server 6.1 in this discussion however, which makes their presentation somewhat dated, since WebLogic is now in version 8.1. The authors also test the performance when the WebLogic performance pack is activated, for both the average response time and the transactional rate. Also studied is the cost of maintaining HTTP logs, an issue that is very important for those businesses who must keep these logs, either for advertising purposes or other reasons. By running tests, the authors conclude, as expected for those readers who have managed Web servers, that the keeping of log files can have a considerable impact on performance, for a high number of users. The effects of the size of the response generated by the test servlet is also studied, along with the effects of using HTTP 1.0 versus HTTP 1.1.

This is the best book yet about J2EE performance tuning. I hope 'Expert Press' (which looks like a Wrox imprint) continues as they have started.

The authors lay out a practical method for performance tuning of Web Applications and EJB's on BEA Weblogic, but there is no reason why the approach (and the 'Grinder' tool) cannot be used to evaluate different approaches on any other Web and Application server.

Note that this is a specialized book. It will not teach you how to do Java or EJBs. What it will do is help you evaluate how to deploy them in the real world to get the performance you need, and also to help you evaluate different approaches.

I was looking for a book to help me understand how regular performance testing is performed so that I could construct a plan to do Denial of Service security testing. I knew nothing about performance testing at all. The books really well laid out, structured, has great examples and is really methodical. It was perfect !

It was a great book! Had lots of information about Performance Testing. When coupled with the power of Panorama(TM) by Altaworks.com, it is incredible.

Thanks for making such a good book avaliable. I think the chapter on testing EJB design patterns is very well written. I would recommend this book as it is one of the best I've gotten my hands on.

One of the best books I have read in this subject. Detailed and with many practical rules and examples.

The title says it all, this book really does explore all of the issues surrounding how to do just enough requirements management on your software development projects. I'd argue that it provides the insight that you require to put together an requirements program within your organization that is right for you, one that is sufficiently agile yet still reflects your situation. It explores strategies for eliciting requirements, prioritizing/triaging requirements, specifying requirements, and finally managing requirements change. Davis managed to pull off what few writers can do - by exploring the requirements management spectrum he has presented a range of strategies which should speak to both traditionalists and agilists. For traditionalists he presents some pretty convincing arguments that the "big requirements document up front" strategy might not be all that effective, and for agilists he presents convincing arguments that we need to invest some effort in requirements documentation. Most important is a running theme throughout the book: the goal isn't to write a perfect requirements document, it's to deliver working software which meets the needs of your stakeholders in a timely and cost effective manner. Sounds like really great advice to me.

If you think that requirements are not all that necessary, this book might change your view: Before you build something, you should decide what you want to build. If you think you cannot start development until requirements are "complete," Davis will convince you that, since requirements change, requirements management is an ongoing activity. He breaks it down into three major areas:

- Requirements elicitation (i.e. determining the actual needs of the stakeholders): This includes identifying ALL the stakeholders and also knowing when and how to apply different elicitation techniques. Davis comments on the proper use of modeling notations are really noteworthy.

- Requirements triage (to balance the delivery date and the development budget against desired requirements): If you don't know what triage is, then you should probably read this book. Its importance (and the author's bias) is manifest when you realize that it has the longest chapter in this book.

- Requirements specification (i.e. documenting requirements): Davis advocates for the use of lists of discrete annotated requirements written in natural language just because natural language is the language of customers (and free text is not too manageable). Supporting models can also be sensibly used, but only for those parts of the system where the use of natural language would introduce too much risk, never to completely replace the written requirements.

"Just Enough Requirements Management" ends with a reminder of change as an unavoidable fact. It also includes an extensive annotated bibliography for those interested in learning more about requirements, just after reading this cleverly-written book...

Al Davis has done it again, with a highly practical and useable book on the ongoing process of effectively managing changing requirements.

Davis is an expert in requirements, bringing to light his vast expertise in many domains including systems engineering on real (very large) projects as well as commercial software. He is perhaps THE expert on requirements triage.

This book provides practical advise on how to do triage and provides examples and wisdom on documenting requirements that honors both the need to 'write it down' in some way with the reality of ever-changing requirements.

I was very impressed when reading Alan Davis' latest book on 'Just enough Requirements Management.'

In his past work he has worked on bringing more formalism into requirements engineering in order to make them correct. However, over time he realized that this doesn't solve the real problems, because the requirements are changing despite the fact they've been formalized in advance.

There are not many people who are confident enough to admit that they have learned over the past years which also means that they've changed their mind. Alan is competent enough doing so which makes him really authentic.

A real eye opener for most of the readers is probably his illustration of the reality of ongoing requirements activities despite using a waterfall approach.

In this fast moving world, it is essential to know how much requirements engineering is necessary in order to being able to moving on and it is even more important to know when to stop doing requirements engineering for being in-time on the market.

I really recommend reading this book in order to know what barely sufficient requirement engineering is all about.

This book is the best way for anyone who want to work with the Real Time Image Proccesing.

Thanks to the Autor ......

I first read a friend's copy of this book, it was already out of print and he had lost the CD, but the tecniques and ideas in this book are clearly written and easy to read. This is an excellent reference even if you are not working in Java (which I wasn't at the time) The Ideas are easily adaptable to C - C++ and the information and theories are fundamental to understanding 3D imaging from Movie Special Effects to Gaming. I spent 2 years trying to track down a copy with a CD and finally found it through Amazon.com, Thanks Amazon!

Don't let the age of this book fool you. It is basically all about the algorithms necessary for producing visual effects in both 2D and 3D that just happens to use Java as an implementation language.
The first chapter is titled "Easy Animation." The chapter's main focus is creating quickly loaded images, and reducing flicker.
Chapter two covers sound and is eight pages long. Two pages are sample code. Remember this book was written when Java had very primitive sound support.
Chapter three goes deep into image processing. The end result is that this chapter shows you how to code many of the special effects found in PhotoShop. Wave, ripple, and explode filters and 3D button effects among others are included here. To me this chapter is the one that stands the test of time the best due to all of the algorithms shown.
Chapter four covers two-dimensional rendering. The main topic of this chapter is creating small animations based on single pictures. The author introduces his framework class "ImageProcessor" first in this chapter.
Chapter five is entitled "Entering the Third Dimension". A really interesting star field program is included that was written, of course, before Java3D. Other programs include a bouncing ball and some take-offs of the star field. Then a 3D spiral program is introduced. The chapter dives back into the ImageProcessor class next. A program to break apart a picture and put it back together ends the chapter.
Chapter six discusses the now obsolete VRML. 3D transformations, movement in 3D, and wire and shaded objects are all covered, quickly and with no sympathy for the novice. A full page and half is dedicated to a discussion of VRML. This is a lot for this book. Most topics get explained once, very quickly and then it's off to the next topic. Several pages are dedicated to explaining a turning cube script. The Matrix3D class is covered next. Navigation is covered briefly, and wireframes are introduced. Shading is covered very lightly then a truly monster program for a so-called "basic" Model3D class is given. This is twelve pages of code. A second program follows that allows you to view Model3D. The chapter ends with a discussion on precalculating movement and passing HTML to the VRML animator, which is also included. There are interesting ideas here, but VRML is old hat and the code will require adapting to more modern needs.
Chapter seven is titled "Adding Realism." The main targets of this chapter are shading, illuminating, and textures--all, of course, very important to making that virtual world look real. The chapter walks through the creation of a cube in wire form then shows how to fill in the surfaces and begin shading. Shadows and perspective are discussed, then another little jewel is given. Listing 7.7 "Creating a 3D object from an image" and the accompanying viewer in 7.8 show how to take a title, make it 3D and shadow it. Texture is covered in great depth with lots of good code and more interesting tricks with pictures. The rest of the chapter is one long update to the Model3D class introduced earlier.
Chapter eight gets into tricks with text. This chapter is crammed with interesting scroll tricks. Late in the chapter some great 3D text scroll scripts, like a 3D spiral, are given.
Chapter nine is titled "Navigation." The keys to this chapter are frames, tracking the mouse and 3D animated menus. This stuff gets more directly into HTML.
Chapter ten is about making imaging effects look better and load fast. Some of this material is dated because the author is writing from the viewpoint of Java 1.0.2.
The appendix is a great summary of classes and commands used in the book. It serves as a very good reference source and is very helpful when trying to read through the programs in the book. The CD-ROM contains some shareware and freeware and a Java version of the old game "Asteroids". Most importantly it contains all the programs in the book. The shareware is pretty ancient and source code for the shareware is not included.
Even though this book was obviously written at a time when Java's main purpose was to jazz up web pages, it is still interesting for people who already know Java and basic computer graphics and are looking for some interesting graphic effects and their explanations. The two main bad points about this book are:
1. Everything is in the form of an applet. This is certainly due to the fact that the contents were written in 1996.
2. For a book that is supposed to be about graphic effects, the illustrations are very shoddy and they are all in black and white.
In spite of these drawbacks, it is a good source of information on how to perform effects at the pixel level, and in that respect the book will never be obsolete.

Java games are a hobby of mine, and I must say this the most practical book for the topic that I've found. It contains great practical examples, and doesn't stray from the subject - programming techniques that allow you to produce excellent-looking applets. Ever see those flashy slideshow applets, with various special effects? This book will show you how to construct one by yourself, explaining each step with great detail. It goes through great extent in helping you understand what you're doing, all while sticking close to subject, without beating around the proverbial bush.
The only downside to this book is its coverage of sounds in Java - if you need help with sounds and sounds alone, don't buy this book. It contains a miniscule amount of information regarding the subject - namely just a brief introduction to sounds, and usage of the Applet class' primitive audio playback functions (Java has great support for generating audio on-the-fly, which this book does not cover).

Lack of detailed sound documentation doesn't take away the value of this book, however, and I recommend it to anyone who would like to produce "kickass java" applets.

Firstly, as expected this book is not for the beginner programmer. It has excellent, working, examples which really takes you to the "cutting edge". Its focus is more on advanced animation (game-like programming techniques) and doesn't include for example database design and implementation, etc. Overall an excellent book, and for everyone bored with simple java UI's

My copy of this book is well worn, dog earned, and filled with enough paper clips to set off airport alarms. It has well over half a pad of pink post it notes extending from its pages. Several Xerox copies of book pages hang from my desk for quick reference. I would never go back to L*****'s book!

It was Diller's manuscript that allowed me to publish my dissertation with LaTeX in a timely fashion with minimal headache (from text processing!).

Pure TeX geeks will shun this book. It's too readable and too practical. If you want to hack away your grad school days solving Knuth's TeX programming exercises, this book is not for you.

Purchase this book if you actually want to get some productive work done with LaTeX!

This book is well written and is great for anyone trying to put together reports and simple documents with no frills (base fonts and formatting). It does not cover font selection (NFSS), customization, and many other important things for advanced documents, like a book. If you need a much more comprehensive book for LaTeX I would recommend Kopka's book. The book is structured in a very confusing and sometimes illogical manner, but it covers much more. This book is much more efficient, but you may find yourself needing more.

I've recently been through most of the beginning to intermediate LaTeX books and have found the bulk of them almost worthless in helping to learn and use LaTeX. This book is extremely readable and useful with correct syntax. The focus is unapologetically LaTeX2e and is not encumbered with outdated 2.09 commands. This is hands down the one book I would buy if I were only going to buy one. After this I would recommend Kopka, though that is much less well presented but definitely the next best (it is loaded with superfluous 2.09 command comparisons which just get in the way of getting through the book). It is way down hill after that, including Lamport's book (beautifully typeset but not clearly written).

In the TeX/LaTeX universe, I've found that you get the program for free, but then you wind up buying $200 worth of books to learn the program because no one textbook is all things to all people. This is hands down the best "introductory book." It's easy to read and gives you enough information to start up quickly. Hahn's book is outdated with its coverage of Latex 2.09, and Kopka's, while having lots of good stuff in it (if you can find it), reads like a scientific text translated from a foreign language--which it is.

If you want to start getting productive with LaTeX immediately, get this book.

I agree with the previous review. Among other nice touches the book contains a descriptive list of all LaTeX commands. This alone made it worth the money for me.

The book consists of 26 chapters plus 1 appendix.

The first 2 chapters cover the questions of "What is a robot" and "What is a program" and introduce the topic of pseudo code. There are many different methods when it comes to pseudo code, but this method will hopefully help teachers, parents, and students to understand how to take an idea for a program and turn it into actual NXT-G block code.

All 36 blocks are covered (the book is useful for both the retail version software and the educational version), and each block has its own chapter with the exception of a couple of blocks that share a chapter (such as the Random block and Number-To-Text block that share chapter 14).

There is a chapter dedicated to the concept of data plugs and wires (Chapter 7). This can be one of the more confusing elements of NXT-G, so this chapter uses a simplified method of showing how data types (number, text, logic) are passed between blocks.

Another chapter provides a walkthrough on creating a My Block. My Blocks are powerful methods for simplifying NXT-G programs, and this chapter shows how the ability to re-use My Blocks can be helpful.

Finally, the appendix covers some basic math such as converting back and forth between degrees and rotations. It also explains the LCD screen's resolution and how the X/Y coordinates work.

Teachers, parents, coaches, and kids should find this book useful. It's written in a very friendly and easy-to-read style and provides plenty of sample programs in each chapter to demonstrate how to use the blocks. Also, coverage of each block's configuration panel is also provided. Overall, the book can be used as an additional source of information on the NXT-G programming language to supplement the Help files included with the software.

This book covers a lot of ground on NXT-G programming and is a must have resource for anyone serious about programming in NXT-G as the on line help included with the NXT set is not adequate.
As a professional programmer and a robotics hobbyist, I would recommend that anyone wanting to bring out the full potential of their NXT creations move to a text based language like Robot-C instead. While NXT-G is good for simple programs, it is just to difficult to create anything of any complexity as the graphical elements and all those connecting lines distract you from what you are trying to accomplish.
I am giving this book 5 stars because it does well at what it is, a reference / guide to the NXT-G programming language. It is NXT-G itself that I would only give 2 stars.

We bought this book for our nine year old son who had recently received the Mindstorms NXT for Christmas. He could not put the book down - read it from cover to cover and thinks it is a great book. Highly recommend.

When it comes to wanting to do Lego Mindstorm NXT-G, this is the first book you should get. The book shows the reader what different blocks are and how they work. The book also reads in terms that middle school students can understand and follow. Programming is the most difficult item that you have to do with a roboit. This book shows is a great resource for people that are in to lego roboits.

There's no other book out there that covers the NXT-G programming language. Jim Kelly covers the subject thoroughly, in a clear, friendly and encouraging style.

The book not only covers NXT-G, it's also a primer on what programming is and how it works. With this book, teachers, students and beginners will have everything they need to understand how NXT-G works and how to use it. Advanced users will learn a thing or two as well, particularly with respect to some of the lesser known blocks within the NXT-G program.