Software Books

RMAN is the present and the future of Oracle solution for backup.
It has a simple concept, but a great variety of commands, by this way, as a solution for all the complexity inside the RMAN solution, Oracle Database 10g RMAN Backup & Recovery come as a special "friend" to help us discovering all posibilities inside Oracle RMAN software.

I had no idea about backup and recovery but after reading this book and trying out the examples, I can say with confidence I can recover a RMAN backed database. Written extremly well!!! One of the good technical boooks I have read....

We had to install and configure Oracle10g 4 node RAC with ASM+FLASHBACK and implement backup/recovery procedures using RMAN and Veritas Netbackup. This book covers everything I need to know in depth.

I had bought his book on Oracle 9i RMAN Backup and Recovery...
And very much impressed with the technical details and examples given in the book... Same way, the book on 10g also excels in technical depth and details...

Backup and Recovery is one of the most critical tasks that a DBA has to perform. Sadly, it is also one of the most misunderstood. RMAN should be the tool of choice for backup and recovery for Oracle databases. There is so much that can be done with RMAN.

What Robert and Matthew do is break it down piece by piece. There is a great intro and they build on that in subsequent chapters. If you want to link RMAN directly with your backup software (i.e. Veritas, EMC, Legato, etc..) then the authors show you how. I used the Veritas piece to link RMAN in and it worked flawlessly. They go over the latest features including block changing files (for faster incremental backups), merging level 1 and level 0 backups (for faster recoveries without the overhead of backing up the whole database), and even cover what the flash recovery area is and how to use it. There is so much great material packed in this book. Yeah, you can try and read Oracle's docs, but rather than just show you how to do it, the authors also teach you why to do it.

You can read this book chronologically or use it as a reference. The authors writing style make this book a great joy to read. They also include a lot of great examples in case you like to learn by seeing.

I would highly recommend this book if you are an Oracle DBA, whether you use RMAN or not. Afterall, RMAN is what you should be using :).

The strength of this book is its combination of breadth and completeness: there is working code (well beyond the toy stage) of a large number of different AI systems that cover a large subset of what is commonly considered AI.

The programming itself is rather basic, and very straightforward. In many places an advanced programmer would have avoided a global variable, unified code through the use of higher-order functions, had functions communicate through a shared local environment, created a lazy list, you name it.

The author avoids most of these more advanced approaches in order to present the ideas behind the approaches without being sidetracked into programming technique issues, and that is the correct choice for this book. Even as it is, there is already the duplicity of teaching Common Lisp and teaching AI programming.

That being said, the code in general is not bad at all, even though I wouldn't want my students to learn CL programming from it. The author has simply bent down to the level of, a good C programmer, and worked from there. His main intention being to teach AI programming approaches, he has spent much less time to raise the programming level of his audience.

Knowing the author's level of Lisp programming, I can't wait to see a book by his hand on how to use abstraction as an organising principle in programming.

I have no background in computer science or AI, but found myself needing to use Lisp for various creative and artistic purposes. I've spent a lot of money on books relating to Common Lisp, but I wish I had just gotten this one and Touretzky's "Gentle Introduction to Symbolic Computation." The particular strengths of this book are its detailed discussion of advanced topics, especially optimization, and the practical overview of current and historical AI topics through programming examples. Very clearly written.

This book is equally excellent regardless of whether you wish to regard it as:

a) A historical study of Artificial Intelligence, with USABLE examples of code, or

b) A book presenting techniques for programming in Common Lisp.

As a reference about Common Lisp, it is certainly lacking, but this is no great problem when both the Common Lisp HyperSpec and Steele's book are readily available in electronic form. It provides something more important: SIGNIFICANT examples, and significant discussions on WHY you would use various Lisp idioms, and, fairly often, discussions on HOW pieces of Common Lisp are likely to be implemented. Its discussion of an implementation of the LOOP macro, for instance, provides a very different point of view than the "references" to LOOP. (Contrast too with Graham's books, which largely deprecate the use of LOOP.)

From an AI perspective, it is also very good, providing WORKING SAMPLES for a whole lot of the historically significant AI problems, including Search, PLANNER, symbolic computation, and the likes.

It would be interesting to see parallel works from the following sorts of perspectives:

- The same sorts of AI problems solved using functional languages (e.g. - ML, Haskell), to allow contrasting the use of those more modern languages. Being more "purely functional" has merits; such languages commonly lack macros, which is something of a disadvantage.

- The use of CL to grapple with some other sorts of applications, notably random access to data [e.g. - databases] and rendition of output in HTML/SGML/XML [e.g. - web server].

This book has been called "The best book on programming ever written". I'd have to agree--it is certainly the best that I've ever read.

William Zinsser said, "The essence of writing is rewriting" and the same can be said for writing computer programs. Norvig's book presents this process--how the limitations of a program are overcome by revision and rewriting. What sets Norvig apart as a writer is that, amazingly enough, he can write about debugging (the most dreaded part of computer programming) and make it a fascinating read!

Lisp has been getting a higher profile lately because of essayists like Paul Graham and Philip Greenspun; in particular, Greenspun's Tenth Rule of Programming which states: "Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp." So, should this book be read as an exhortation to return to Lisp as the preferred programming language?

Paradoxically, I think not. One third of the way through the book, Norvig shows us how to implement Prolog in Lisp. From then on out, most of the AI techniques he presents either directly use Prolog instead of Lisp (such as his excellent discussion of natural language processing using Prolog) or use Prolog as a base to build on (such as his discussions on knowledge representation).

From this we can abstract what I'd like to call Norvig's Corollary to Greenspun's Tenth Law of Programming: "Any sufficiently complicated LISP program is going to contain a slow implementation of half of Prolog". I'm leaving out the "ad hoc", "bug-ridden" part of Greenspuns's law, because Norvig's programs are neither. But it is quite remarkable the degree to which, once having absorbed Prolog, Norvig uses Prolog as the basis for further development, rather than Lisp.

Is this a book about Prolog then? Again, no. What is the take-away message? It is this: as our world becomes more and more complex, and as the problems which programmers are facing become more and more complex, we have to program at a higher and higher level.

Norvig does not stop at just embedding Prolog in Lisp. He also shows us how to embed scheme as well. Excellent discussion on the mysterious call/cc function and on continuations.

In a capsule review, it is impossible to really give an overview of a 1,000 page book like this one. But the scope and heft of the volume really needs to be commented on: the programs presented in this book are like basis vectors, the totality of which nearly span the space of programming itself. In no way should this be considered "just an AI book" or "just a LISP book". This book transcends language, time, and subject matter. It is a programmer's book for the ages.

"Paradigms of Artificial Intelligence Programming" is one of the best books of computer science that I have ever read. I put it up there in the pantheon with "Structure and Interpretation of Computer Programs". I have found more useful and mind expanding material in these case studies than I have in many other books on computer science. I highly recommend this book to anyone, even if they have never used Lisp.

This book covers everything you need to know to write a ray tracer with
advanced features like photon mapping, volume scattering, path tracing,
etc. The scope of the material it covers is stunning. It starts from the
basics of topics like 3D geometry and ray/object intersections and then
builds up to explain reflection models, advanced texturing techniques, and
then light transport algorithms.

It has excellent discussions of the theory and underlying math of physical
rendering blended (rather well) with very very useful practical
implementations of the theory. The leap from theory to implementation is
often difficult to do, and to do well or efficiently even more difficult.
(The ray acceleration code alone is worth it's weight in gold.) This is an
indispensable book for anyone who wants to write their own ray tracer or
learn more about the latest techniques used in photorealistic rendering.

This book mixes detailed algorithm descriptions with actual code in a book that never loses sight of the "big picture" of physically based ray tracing and image synthesis. Although it is very well written and is not a dry academic book at all, it would help if the reader is already familiar with basic computer graphic techniques, linear algebra, calculus, and optics in order to get the most out of this book. It was never meant to be a replacement for Foley & Van Dam's classic book on computer graphics, even though the first few chapters go over basic computer graphic material. The book includes a website where the source code of the authors' renderer can be downloaded. This code is very well organized and commented so that if you wish to lift individual pieces from the entire software package you can with just a little bit of work. I highly recommend this book to the programmer who wishes to implement physically based rendering in his/her own code or wants to know about the practical implementation of image synthesis techniques. Amazon does not show any details about the book here, so I shall explain the contents in the context of the table of contents:
CHAPTER 01. INTRODUCTION
This chapter talks briefly about all kinds of topics related to ray tracing. It also talks about how to understand the code in the book and the book website.
CHAPTER 02. GEOMETRY AND TRANSFORMATIONS
This chapter is pretty basic computer graphics stuff. It talks about coordinate systems, vectors, arithmetic, scaling, dot and cross products,etc. Applying transformations via matrices is also discussed as well as the representation of points, vectors, normals, rays, and bounding boxes.
CHAPTER 03. SHAPES
More basic computer graphics continues with discussions on spheres, differential geometry, cylinders, and disks, paraboloids, triangles and meshes, and the representation and bounding of all of these shapes.
CHAPTER 04. PRIMITIVES AND INTERSECTION ACCELERATION
This chapter is about accelerating the speed of your graphics through grid acceleration, tree construction and representation, and object instantiation.
CHAPTER 05. COLOR AND RADIOMETRY
XYZ color system is discussed along with radiometric integrals including integrals over projected solid angles, integrals over spherical coordinates, and integrals over area. Beginning in this chapter the math becomes more advanced.
CHAPTER 06. CAMERA MODELS
Projective camera models are discussed along with orthographic, perspective, and environment camera models. This information will already be familiar to students of computer vision.
CHAPTER 07. SAMPLING AND RECONSTRUCTION
Frequency domain techniques are discussed starting with the Fourier transform and ideal sampling and reconstruction. Also, antialiasing techniques are explained.
CHAPTER 08. FILM AND THE IMAGING PIPELINE
This chapter talks about topics such as luminance, photometry, bloom, and imaging pipeline stages.
CHAPTER 09. REFLECTION MODELS
The various reflection models are discussed including specular, Fresnel, Lambertian, Oren-Nayer disfuse reflection, and the Lafortune model.
CHAPTER 10. MATERIALS
Matte, plastic, bump mapping, and other material effects are explained very well.
CHAPTER 11. TEXTURE
We return to frequency models some in this chapter. The texture sampling rate, filtering functions, and mapping in spherical, cylindrical, and planar form are explained. Procedural textures are also discussed including the famous Perlin noise, marble, and windy waves.
CHAPTER 12. VOLUME SCATTERING
This chapter is considered more advanced material, and discusses volume scattering processes, absorption, emission, in and out scattering, phase functions, exponential density, and volume aggregates.
CHAPTER 13. LIGHT SOURCES
All kinds of light sources are described including point lights, spotlights, texture projection lights, distant lights, area lights, and infinite area lights.
CHAPTERS 14 and 15 both discuss Monte Carlo integration techniques including improving efficiency.
CHAPTERS 16 and 17 are about light transport. The first chapter is about surface reflection and the second is about volume rendering.
CHAPTER 18. SUMMARY AND CONCLUSION includes a design retrospective, a discussion of abstraction versus reality, and design alternatives including triangles only and streaming computation.
APPENDIXES- These include sections on utilities, scene description interface, input file formats, an index of code fragments, an index of classes and their members, and finally an index of identifiers.

I do ray tracing and GI for a living. When I got started on my ray tracer I was struggling with several basic issues. Even though I tried to locate all the published material on those subject there was still significant gaps. Issues like 'how to shot photons', what about all these 'cosines'. How do you actually implement a kd-tree. I read Shirley's, Jansen's, Glassner's and Advanced Global Illumination and a lot of the older Siggraph papers. PBRT came out just in time to rescue me. It contains the only complete implementation of a photonmap.

It's strong point is a complete running GI engine. However the literate programming style used in the book meant a lot of time I cannot read a subject by itself. The use of abstract interfaces sort of force you to use the class browser to follow the logic. You pretty much have to read it from the beginning. The quality of the code contained goes beyond the usual standard of code published as examples. It contains a rather sophiscated random number generator. Its treatment of LDS plus sampling and recontruction in general is excellent. It is the only source that shows how to implement Li's algorithm to generate random rays to sample a sphere. Same goes for Malley's. Shirley and Chui's concentric sampling method is hidden in the appendix of a old Siggraph paper.

The book also has code to sample and model most of the common light sources. Which is surprisingly non-trivial.

I highly recommend this book but it does require a certain level of commitment to get the most out of this book. The chapters on sampling, ray differential, texture filtering, light transport I consider must reads for all graphics programmer even though you might not be working on ray tracing.

I cannot praise this book more than the others already have. The book is about producing high-quality images using raytracing. It basically walks you through the creation of a fully-functional raytracer, discussing all the different algorithms and techniques that are needed along the way.

It's written in the context of their particular implementation of a working raytracer, using the fweb programming/documentation system, where basically the program source and the documentation are written as one document. I've always thought this was academic nonsense as far as writing real code in a production environment, but it turns out to be an EXCELLENT way to write a book or code intended for a learning environment.

This strikes the perfect balance between explaining the theory thoroughly and showing how the ideas can be implemented in a real, functional raytracer. They avoid the trap of many other book that focus on a particular implemention, by not getting too bogged down into pecularities of their system.

The source code itself also stands out as a strong point. There are so many books out there with poorly written and unorganized code that you'd never want to read, much less try to work in. The code is well organized, and the coding style easy to read. It's one of the few books I own that contain source code where I actually read the source code and it added something to my experience. I wish everybody who wrote about programming was actually a decent programmer and not just a mathemiticion.

This book has academic rigor and but also well-written explanations. I'm still learning a lot from it. I expect to refer to it frequently over the next years as we (in the video game industry) take more concepts from raytracers and apply them to real-time graphics, as the processors get more and more powerful.

You probably should not be an absolute newbie when it comes to basic 3D math and things like vectors and basic graphics concepts before buying this book. The authors use some calculus, too, if that scares you off.

Although it is not possible here, I am fairly sure this book deserves such rating. This is truly remarkable work and is likely to become a classic text in the field of computer graphics.

It is not a survey-type book, instead of trying to describe every possible method out there, the authors have concentrated on a few selected techniques, that are not only good (modern, fast, easy to implement, etc.), but also have some pedagogical merits and can serve as a gentle introduction to the world of ray tracing and digital image synthesis. Despite focusing on selected areas, the authors managed to squeeze here in an amazing amount of material. Among other topics, this book covers: subdivision surfaces, ray-primitive intersection acceleration techniques (3D DDA and kd-tree), color and radiometry, anti-aliasing, tone mapping, physically based reflection models, texture mapping (including texture anti-aliasing using ray differentials), area lights and HDR Image Based Lighting, volume scattering and much more.

A large part of the book has been devoted to the light transport and Monte Carlo techniques. One can find there an introduction to the theory of Monte Carlo estimation (including selected methods for reducing variance and computation time, like Russian roulette, multiple importance sampling or stratified sampling) and explanation of important light transport equations (rendering and transfer equations).

Finally the authors have described (and implemented) several solutions for the rendering equation: Whitted-style recursive ray tracing, direct illumination estimation, path tracing, irradiance caching and photon mapping.

However, it is not only the vastness of the material covered in this book, that causes this volume should be praised so highly. Perhaps, the style, in which this book has been written, is even more impressive. For each of the topics, the authors start with what is usually known as "dry math and theory", and then show how it is supposed to work as an algorithm (including its dirty details) and finally they explain how to turn this algorithm into C++ code. Each of those transitions concentrates on a small portion of the problem, so it is still easy to understand. Anyone, who had to turn a SIGGRAPH paper into something that works, will immediately recognize what kind of gem this book is - it actually shows how to do it!

This brilliant blend of theory and practice is one of its brightest spots, for learning the theory and math formulas is one thing, but writing a working, robust implementation is completely another.

Those, who prefer studying sources, will get source code of a very good, physically based, extensible ray tracer (called pbrt) with the best documentation one could ever imagine. Documentation that gives the rationale for almost every line of code. It shows not only how they did it, but also why they did it that way.

It is not the only book, that one will ever need - computer graphics is a vast topic - too big to be covered in a single volume, even as huge as this one. However, it is certainly one of the books that everyone interested in photorealistic rendering should buy. The price of this book is really low, if you think about it as of an excellent, first-rate computer graphics course.

Aimed at students, researchers and people interested in computer graphics algorithms, it is an indispensable book for anyone willing to write his own photorealistic (not necessarily physically based!) ray tracer and learn more about computer image synthesis.

When I bought this book I never realized how handy it would be. Reading it from cover to cover is a pleasure but it's also very easy to use as a reference -- I've never spent more than a minute trying to find whatever I need. This book has saved me uncountable hours both while debugging software and while porting to various platforms.

After 10 years of developing real-time software for DOS and embedded systems, I needed to develop software for the real-time O/S, QNX, a POSIX compliant O/S. Unlike DOS, QNX is a real operating system which demands a different programming paradigm. Without Lewine's book, I'm not certain I could have made the shift.

This book may be too complicated for somebody unfamiliar with C programming. But, if you know the language, it provides all the basics to successfully create software on a POSIX system. The first half of the book elaborates on how to do things in POSIX. Lewine does not assume that the reader knows anything about UNIX. Plenty of example code clarifies the the theory. All the examples are heavily annotated. One cannot *not* learn the POSIX programming paradigm from this book.

For real-time programming, information about POSIX.4 was needed, and I gleaned this from Gallmeister's PROGRAMMING FOR THE REAL WORLD: POSIX.4, also an O'Reilly book. Once through these books, code began to flow from my keyboard. The QNX library manuals made far more sense.

As an "expert" (I've been doing this for about 5 years), I still refer to the back of Lewine's book. The last half is a reference to the POSIX library functions. Although I haven't done much programming under LINUX, I presume this would be a useful reference for that O/S. The latter half of the book documents the function calls at least as well as any manual for a C programming library that I've ever seen. I've gotten to the point where this book mostly sits on my shelf--but it's comforting to know that when I can't remember the arguments for sigprocmask(), I can take it down and find the answer quickly.

For many programmers, interoperability is the name of the game.
Write once, compile everywhere. Yes, compile, because a compiled
program runs 80 times as fast as an interpreted program. Now comes
the gotcha: different compilers come with different libraries.
C source written for HP-UX might look different from C source written
for Solaris, which might look different from C source written for AIX
or Linux. What features of the language should we use? What library
calls should we use? Answer: Use ANSI C with IEEE 1003.1 POSIX
standard library calls. This gives you the most bang for your buck,
because nearly all C compilers support these standards. Write your
code on one platform, compile it on the other platforms. If you
conform to the POSIX standard, you will minimize your porting
headaches. Follow this book and you'll conform to the standard.

When I bought this book I never realized how handy it would be. Reading it from cover to cover is a pleasure but it's also very easy to use as a reference -- I've never spent more than a minute trying to find whatever I need. This book has saved me uncountable hours both while debugging software and while porting to various platforms.

After 10 years of developing real-time software for DOS and embedded systems, I needed to develop software for the real-time O/S, QNX, a POSIX compliant O/S. Unlike DOS, QNX is a real operating system which demands a different programming paradigm. Without Lewine's book, I'm not certain I could have made the shift.

This book may be too complicated for somebody unfamiliar with C programming. But, if you know the language, it provides all the basics to successfully create software on a POSIX system. The first half of the book elaborates on how to do things in POSIX. Lewine does not assume that the reader knows anything about UNIX. Plenty of example code clarifies the the theory. All the examples are heavily annotated. One cannot *not* learn the POSIX programming paradigm from this book.

For real-time programming, information about POSIX.4 was needed, and I gleaned this from Gallmeister's PROGRAMMING FOR THE REAL WORLD POSIX.4, also an O'Reilly book. Once through these books, code began to flow from my keyboard. The QNX library manuals made far more sense.

As an "expert" (I've been doing this for about 5 years), I still refer to the back of Lewine's book. The last half is a reference to the POSIX library functions. Although I haven't done much programming under LINUX, I presume this would be a useful reference for that O/S. The latter half of the book documents the function calls at least as well as any manual for a C programming library that I've ever seen. I've gotten to the point where this book mostly sits on my shelf--but it's comforting to know that when I can't remember the arguments for sigprocmask(), I can take it down and find the answer quickly.

POSIX is only one operating system standard in IEEE/IEC.
But now ISO have another oerating sysm standard, OSEK OS.
OSEK OS is more slight, simple and real time oriented.
Why Posix is not so portable and not so Open.
NIST made a POSIX Test Suite based on old POSIX standard.
But where is POSIX Test Suite based on new POSIX standard.
This book was based on old POSIX.
So, you can understand this with NIST posix test suite.

Gallmeister splits this book into two main sections, an introduction to the material and a reference section, which provides detailed documentation for the various function calls and header files. Somebody new to the material will find the first section indispensable, while the pro will flip to the reference section to answer questions.

Chapter one provides an overview of the problems this book addresses. The second chapter examines POSIX, POSIX options, and POSIX namespaces. Chapters 3 - 6 define real-time problems and POSIX.4 solutions. Chapter 7 considers the issues of real-time performance.

Gallmeister provides many example code fragments to illustrate his points. He would have done better to have annotated his examples, instead of writing a number of descriptive paragraphs after each fragment. A particularly useful feature is his discussion of "current UNIX practice."

Overall, this book provides a reasonable introduction to the concepts of real-time programming, and a number of "recipe" examples for the POSIX environment. Recommended if you'd like to develop real-time skills or need a reference work on the subject. I found it useful learning to develop QNX software, even though QNX implements a number of "optional" features differently.

This is the best book on the subject. One can tell that the author is an expert and knows very well what he is talking about.
Unlike one reviwer mentioned below - I dont think he has read any part of the book - this is not an "reasonable introduction" at all. This is an in depth handling of the topic.

If you know C and know UNIX, this book is for you. Simply put, he knows what he's writing about and he presents the material in a logical, methodical manner.
This book was written just before the POSIX4a standard was completed, so no PThreads are covered.
As long as you're not expecting PThreads coverage, you won't be disappointed. Most of the topics you need to know about mutli-threaded programming (besides PThreads) are here.

The book consists of 2 parts. The 1st part is a detailed guide to the real-time POSIX programming. The 2nd part presents a reference to all POSIX real-time functions. The book also has an appendix with various sample and exercise code.

All explanations in the first part are very clear and complete. Writing style resembles the best programming books (like those from K&R or R.Stevens). At the same time everything is given in a distilled manner without unnecessary water, so that you might handle the stuff surprisingly fast.

The second part is less valuable since all this material can be found in UNIX man. But if to see it as just a free bonus for the 1st part it is not bad at all. In any case having printed manuals is quite useful.

Sample code in the appendix is also interesting to look at.

Actually I didn't notice any considerable drawbacks in the book and recommend it to everyone interested in the subject.

The prerequisites are minimal. You should know C and be familiar with the basic UNIX/POSIX API (like working with files, etc.). The next reading is obvious - some book on POSIX threads (I'd recommend one by Mr. Butenhof).

This is a great book for anyone interested in project management, or has been given the PM role without any prior training. It's also good for those of us who already think we know it all - I'm sure there'll be gems in it for everyone.

Any project one can undertake is not necessarily going to be like all the others. "The Principles of Project Management: Run Projects on Time and To Budget Using This Simple Step-by-Step Guide" is an informed and informative handbook for managers in charge of making their projects the best they can be with proper planning, strategy, and beginnings. With advice on warning signals to help people stay on the right track, "The Principles of Project Management: Run Projects on Time and To Budget Using This Simple Step-by-Step Guide" is a top pick for community library business collections and any would be project leader.

This is a short book, but it's packed with useful information about project management. It neatly avoids getting bogged down with PM jargon, instead cutting to the core concepts. It's not designed to get you through a project management qualification (though it might help!), but will certainly help you to become more efficient at managing projects, which at the end of the day is what *really* matters. Aimed at people who want to get projects done, even if they're not officially 'project managers' within their organisation.

The book is broken into five sections - what project management is (and just as importantly, what it isn't), getting started with projects (covering the who, what, where, why and when of project initiation), getting the project done (tools, best practice, project control), the essentials of good project communication, and finally following through - closing off the project.

Rounded off with appendices covering essential project tools, templates, and links to useful software apps, this is a great book for people starting out in project management. And whilst not strictly aimed at experienced project managers, I'm sure that everyone will find something useful to take away.

Great stuff.

Do you find yourself responsible for executing projects and need some guidance on how to get the job done? If you do, then this book is for you! Author Meri Williams, has done an outstanding job of writing a book that shows you how to get projects completed and delivered on time.

Williams, begins by explaining why Project Management is a difficult thing to do effectively. Then, the author explains why leading teams, managing schedules and implementing ideas, takes a lot of focus and hard work. Next, she gives advice on work styles and issue tracking. The author also discusses why stand-up meetings are very difficult to prepare for. She continues by showing you why closing on handling is a total disconnect. Finally, the author discusses how to measure operational success, ongoing support and maintenance.

This most excellent book aims to lay out defined steps to get projects done right and on time. But, more importantly, the author designed this book for people who are working on larger projects by themselves.

'The Principles of Project Management' is one of those books that does nearly everything right in my eyes. A small footprint (204 pages = don't say more than you need to), fantastic design, and good writing and content. It's no secret that sitepoint is one of my favorite technical publishers out in the field today and nearly every one of their books gets 5 stars from this reviewer.

This book is no different.

Project Management is a difficult thing to do and do effectively. Managing schedules, leading teams, getting ideas to fruition all takes a lot of hard work and focus. To be a good project manager you have to wear all sort of different hats and it's a daunting task. Like salespeople, if you are a great project manager you can have a lot of success and a lot of times it's the kind of skills that can't be taught, but are ingrained inside you.

But you can make those skills stronger no matter what level project manager you are.

From Gantt charts to tables to delegation, estimates, and becoming an amateur psychologist working with your team, this book is one of the best inros to becoming an effective project manager. You will learn all the necessary skills to be successful and have fun while learning.

If you are an experienced PM you owe it to yourself to read this quick book and if you are newbie this should be required reading. Great content and ideas + a great design make for an outstanding effort and book!!

***** HIGHLY RECOMMENDED

Judging by the number of reviews, MacDonald's fan base is similar to that of Alison Balter-Mastering Access 97 Development (one of SAMS best). The learning and example experience is fairly similar. I got Pro WPF before the VB version came out. Migrating from VB to WPF is difficult enough without dealing with C#. The downloaded code of the VB version is only for examples but they are generally relevant to me. I still break out Visual Basic 2005 (.NET or Bust) for a succinct reorientation.

This review is a comparison between
Windows Presentation Foundation Unleashed (WPF) (Unleashed) by Adam Nathan

and

Pro WPF: Windows Presentation Foundation in .NET 3.0 by Matthew MacDonald

I have been using both of these books for learning WPF. What I like about "WPF Unleashed" is the quality of the pages with the color printing. I believe this higher quality is a great step in the right direction and I know a lot of developers appreciate good quality printing such as this. But as good as the printing is I still find myself spending more time in the "Pro WPF" book.

I think it has to do with the flow of the book and how the information is presented to the reader. I'll do my best to explain my experience. In the "Unleashed" book I found myself reading a bit of knowledge, looking at the example, try to work with it in Visual Studio and struggling. Then going back over the knowledge, going to the internet, find out some more, work with it in Visual Studio, back to the book and in some cases giving up because I couldn't achieve some result.

In the "Pro WPF" book though I didn't have this happen nearly as much. In the Pro book it had a really nice flow to it where he would present some basic information, give and example, present some information, give an example. So here I found myself reading some knowledge, do it in Visual Studio like his example, read some knowledge, do it in Visual Studio. I didn't have to reread nearly as much and the knowledge seemed to build upon itself nicely; taking you from simple to more complex. He was really good at NOT introducing newer topics (WPF class/methods) that he hadn't already covered.

The books work well together though and that's how I used them. I use the "Pro WPF" as my main and the "Unleashed" book for more examples.

The "Pro WPF" book has also been updated since publishing and split into two books for C# and VB.NET in .NET 3.5:
Pro WPF in C# 2008: Windows Presentation Foundation with .NET 3.5, Second Edition (Books for Professionals by Professionals)
Pro WPF with VB 2008: Windows Presentation Foundation with .NET 3.5 (Pro)
I haven't read these books yet so I cannot comment on them. I just wanted to include them as a note to the reader.

I really didn't need another book on WPF, at least that is what my girlfriend would say. I already own "Applications = Code + Markup" by Charles Petzold, "Essential Windows Presentation Foundation" by Chris Anderson, "Foundations of WPF: An Introduction to Windows Presentation Foundation" by Laurence Moroney, "Windows Presentation Foundation Unleashed" by Adam Nathan, and "Professional WPF Programming: .NET Development with the Windows Presentation Foundation" by an assortment of Wrox authors.

But I saw Pro WPF: Windows Presentation Foundation in .NET 3.0 on Amazon and decided to investigate the possibility that I need to have it. After reviewing the TOC I still wasn't sure. But after downloading the code from Apress I was sold. I have been a fan of Matthew MacDonald for some time. He has definitely worked his magic on this title.

Some of the highlights I like:
His in-depth coverage of printing.
His Custom Elements chapter.
His approach with 3-D drawings makes extensive use of the 3DTools from CodePlex.
The chapter on using ClickOnce with WPF.
Everything is gone into in depth. This is not a brush over the topic book.
The usability of the code makes the book all that much more valuable.

He also has a great site named ProseTech that has a companion site for the book. It contains all the links found in the book

For extreme coverage of Expression Blend you will have to by a book specifically on Blend. Too bad no good ones exist yet. One I have seen that is out has bad reviews. None of the books I have listed above cover Blend in-depth at all. The Wrox book has 2 high level chapters on it, but I have been playing with Blend 2 a lot and find myself in the XAML most of the time because I don't know how to get to what I want to do in Blend. On that note, this book is excellent for showing you how to work XAML to the maximum.

This book also does not cover Silverlight. It is a book about Windows Applications, not Browser Applications.

I highly recommend this book as addition to any developer's or designer's (those who need to know XAML) library. It was definitely worth buying.

Books stated purpose: This book is an in-depth exploration of WPF for professional developers who know the .NET platform, the C# language, and the Visual Studio development environment.

This book introduces the developer to the WPF (Windows Presentation Foundation), which is a new graphical display system for Windows. This book is well written from beginning to end, and takes the developer through the process of learning how to utilize the capabilities of WPF. The author provides references to outside sources throughout the book. These either provide a more in depth look at the current topic, or point to a tool that would be useful. The author introduces WPF in a manner that lets developers of any level understand what WPF is and the benefits of using WPF. Then chapter by chapter he provides instructions and examples that take the developer through the learning process about WPF.

System Requirements;
* To run WPF applications, you must be running Windows Vista or Windows XP with Service Pack 2.
* To create WPF application, you must have either Visual Studio 2005 with .NET 3.0 and the WPF extension, or Visual Studio 2008.

The early part of the book is about the basics in and about WPF. The author gives basic, but understandable examples that lead the developer in a growing understanding of WPF. Once the developer has the basics of WPF down, the author begins to build on this base.

One of the basics covered is the creation of the Application object. This is the foundation for all the code throughout the book. Another basic operation covered is the layout of the forms. WPF provides the ability for Windows forms to dynamically grow and resize based on data and language, similar to Web Forms. It takes more work to set up a form, but it will give the user a much better experience in using it.

Now that the developer has the basics, the author moves along the path for using them. The developer is introduced to the WPF controls and how to develop with them. There are a number of features added to familiar controls. Some examples include: Tooltips can now contain both images and text. Multi-line text boxes can grow dynamically and text does not have to always break where it fits the textbox edge. You can add a dynamic spell check to textboxes.

There is a chapter on building control templates or modifying existing controls. This feature appears to be more powerful, and quicker than the old method of building a new specialized control from scratch.

The following topics are part of what is covered as the book continues. Data Binding to a database, Printing, Animation, Sound and Video and 3-D drawing.

The author wraps the book up with a short tutorial on using the ClickOnce Deployment. If the developer has already learned to use the ClickOnce Deployment, this chapter can be skipped. However, it is a useful conclusion to the book if the developer has not yet used the ClickOnce Deployement.

The book is pretty detailed. This review only touches on a few of the highlights from the book that specifically caught the reviewer's eye. It is worth adding to any developers library if they are looking to do new development for Windows Vista or Windows XP SP2.

I already have several WPF books now, each of them has something to offer and it's a rare day when you can find all the information you need on a complex, wide ranging topic like WPF in one book.

Without detracting from the other books that I admire, I think if one book does come closest to being a one-stop source then possibly it is this one. Coverage of topics is comprehensive, detailed and accurate. At just under 1000 pages it's definitely a heavyweight, although you're unlikely to want to be parted from it long enough to use it as a doorstop.

The author's writing style is clear and friendly without being patronising. If I have a gripe about the book, it's the same complaint I've been making since the middle of 2007 - this is yet another WPF book that only has code behind samples in C#. However I understand that there will be a VB2008 version out early in 2008.

Of the books I have on WPF, I turn to this one early in most researches. I consider this book to be a good investment. I have several of Matthew MacDonald's earlier books, which I have always found relevant, well-written and useful; this book is in the same mould.

Mr. Bassiri definitely has an excellent grasp of the Netscape Server architecture. After reading this book, I have gained a better understanding of the Netscape server inner workings. I found the chapters on WAI very helpful! I would definitely recommend this to anyone developing applications for the Netscape platform.

My only complaint is that some of the sections are too wordy and redundant.

I thought I knew a lot before I read this book. I was just fooling my self..... Must own book if you work with NES.

Just got my copy of this book and it is great. Wish Netscape provided such accurate and detailed information in their books. Mr. Bassiri seems to know what he is writing about. He seems to write from experience instead of reading Netscape manuals and rehashing the old story. Appendix A and B are really helpful. They included a complete list of server configuration settings. The NSAPI tutorial is the best around and the WAI section provides a true programmer's review of this API. This book is packed full of information. If you want to know how the Netscape server works and program applications for it, you should definitely buy this book.

If you administer or develop for Netscape servers, you will benefit from this book. Administrators: the knowledge you gain from this book will allow you to modify the config files to do correctly what the Server Manager sometimes doesn't do properly, and configure features that simply cannot be administered from the Server Manager. Developers and Architects: Having read this book, you will know what options you have, and be more easily able to decide which architecture is best for your application -- and you'll be able to code it. In addition, your understanding of the key concepts will allow you to grasp quickly how external but related technologies (like Forte's Web Enterprise) work. Well-written, detailed and comprehensive; highly recommended.

Easy to read, I delved in and finished it in 2 workdays without falling asleep. The info is clear and the examples great. Two suggestions: more examples, and greater focus on what the non-threadsafe functions are. He lists NSAPI funcs and says to use 'em (util_sprintf() for instance) but doesn't mention if strlen or other functions are threadsafe. Also, the time function - I can't get a compile using time funcs that don't have a local time_t or timeb structure (instead of pointers to system structures). That should be noted. Otherwise, totally required book and excellent for beginners to get into it.

I used Mr. Burton's book to study for the Remote Access Exam. The material is very relevant to real world issue I deal within our network day to day. His chapters match close enough to the exam topics to cover what you need and his examples are excellent.
I had first picked up the Cisco Press Book: Building Cisco Remote Access Networks edited by Catherine Paquet. I have endured some boring, painful reading in my time ( I've got a Civil Engineering degree to prove it) but this came close to being the all time worst (ok, groundwater modeling was worse). I was so delighted to read Mr. Burton's material after that and would recommend, at a minimum you pick this book up in addition to the Cisco Press. At least you can get some great working sample configurations out of the book which I consider lacking in the Cisco Press title.
The errors and spelling mistakes were minor. This book is well worth the money. Oh, I passed the Remote Access Exam also.
- Ed Horley, CCNP, CCDA

This book is excellent as a reference and learning the technolgies if you have the equipment in a lab. Very well documented. It walks you through step by step (with out getting very detailed and boring) in configuring and basic troubleshooting. I used the ciscopress BCRAN for the test and this book to actually learn, install, and troubleshoot the stuff.

Incomparable with Cisco press CCNP books on this same topic. I've rated both of those - "Building Cisco Remote Access Networks" and "CCNP Remote Access" with only 2 stars.

This book, unlike Cisco Press books, is very coherent, very clear and goes to the right level of depth to give you proper understanding of the material. What is more important it will give you understanding of how to apply the information on the job.

One tip however, all remote access books I looked at miss one important piece - they do not explain the complete set of interrelationships between serial interfaces, asynchronous interfaces, lines, controllers, vtys, ttys, etc. Therefore you need to read the introduction section from "Cisco IOS 12.0 Dial Solutions". It is a horrible read and you will have to fight through it. Read it five times, if you have to. But, it will give you the mental map and the foundation needed to understand any book on this topic.

I had the good fortune to take Bill Burton's BCRAN class at Chesapeake not long ago. He is an excellent and enthusiastic teacher and that is reflected in his book. It is written in a witty, conversational style, which makes it easy to follow. There are lots of sample configurations for the most common remote access configuration scenarios. He "holds your hand" as you are walked through these, including the 'show' and 'debug' commands you need when things aren't going well.

He notes in the Introduction, that the book is intended more as a practical reference to use in real-life than as an exhaustive BCRAN test preparation guide, which I think is a pretty accurate assessment. I've read some parts in depth, and skimmed most of the rest of the book. I expect it to be a useful and accessible guide in configuring all flavors of remote access. I bought the book because of my classroom experience, and was not disappointed.

I was given this book to read along with the course material for the CCNP v2 BCRAN exam. This book has much more information in it then the course material. Bill Burton does a great job in explaine some very difficult subjects. Good job. Highly recommended as both a study aide as well as a reference aid.

There seem to be three categories of computer security books. The first category is books written for system administrators or computer owners, and explains how to protect the computers under their control. The second category is the "true crime" genre that recounts the exploits of black hat hackers or explains the hacker culture (sometimes as "how-to" books for non-programmers). The third, and rarest, category is books for professional programmers that explain the coding idioms that make programs more secure or more insecure.

This book is an excellent contribution to the third category. It explains how certain ways of programming in C and C++ make programs vulnerable to security attacks. There are many code examples throughout the book illustrating the issues.

Although everything is explained in great detail, the treatment is not superficial. (No background in computer security is required, but the reader should be at least a journeyman C or C++ programmer.) Some of the security holes will surprise readers familiar with the basics of computer security. My favorite example: Many programmers know that the gets() function once was involved with compromising 10% of the computers on the Internet in a single day, but did you know that printf can also be a security flaw in some cases? The statement:
printf(s);
can allow an attacker to run any code of his choosing if s is a string provided by the attacker. Even more surprising is the printf attack has been used successfully on popular programs.

This book should be read by any programmer who does I/O across a network, or who writes applications that provide a captive environment for their users (data entry stations, information kiosks), or who writes programs to manipulate sensitive data. Even programmers merely curious about security issues will find this book a readable treatment. I guess the Black Hats can read the book to get more ideas for future attacks.

I can personally vouch for Seacord's expertise. He is a security analyst as the Computer Emergency Response Team/Coordination Center, and I've worked with him on the ANSI/ISO C Programming Language Standards Committee. I've found his information on computer security both educational and valuable.
[...]

I had the honor of taking a short course at a software security summit from Robert Seacord. I would have to say it was one of the most informative security related courses that I have taken. This book encompasses the course that I took and does a great job of explaining what to watch out for when writing code.

I highly recommend this book for any serious developer.

This is an important book for people that write computer programs and their managers.
It is also very well organized and well written. Seacord reveals how the bad guys take
advantage of bugs in programs to break into a system or damage it. It is the most
complete list of exploitable bug types that I am aware of.

Many examples are given, naming software that have been exploited by bad guys. Some
may protest that this provides the bad guys with a list of easy targets. All of the
vulnerable software has been updated to fix the bug, and the improved version has been
available for a long time.

Everyone that writes software intended to be used by someone else should read this book.
Every organization that writes software should have a copy.

Most of the security flaws are buffer overflows. Secord shows how, from the simple use of
gets() through mistakes triggered by subtle differences in the rules for signed and unsigned
integers of various sizes. There are other ways, and some are quite subtle, but still
preventable. The bad guys are not Jay Leno's "Dumb crooks."

The primary way to frustrate the bad guys is to not have any of the bugs they exploit.
Seacord admits zero bugs is an elusive goal and recommends defense in depth by the use of
various freeware or commercial packages intended to trap or prevent certain errors.
He lists and describes many, with their strengths and weaknesses.

Read this book and make your code better. Read it again, next year.

The following are my opinions, based on over 40 years writing software, but I doubt
Seacord would disagree. Every security bug is also a bug that can cause a crash or a
wrong output from a program. The major cause of fewer bugs is the attitude of the
programmer. Managers can affect the attitude of the programmers by their choice of
questions. Do not ask "Is it done yet?" Instead try approaches like: "Tell me about how
you validated the inputs and how you identified all the inputs." "Who reviewed your test
cases?" "How did you decide you had tested enough?" The fewer bugs of any kind in your
product, the less likely the bad guys are going to target it, other things being equal.

This book slipped under my radar, but I recently picked it up and was quite impressed.

This book is fairly unique in that it is accessible and well-written, yet, at the same time, unabashedly technical. It's quite simply a very good book, and it should prove valuable to readers new to software security, as well as experienced security consultants and vulnerability researchers.

I know the problem domain intimately, and was quite impressed at the level of thoroughness and the technical depth of the coverage. This book isn't merely a well-written exploration of known insecure programming idioms and attack techniques; there's actually a considerable amount of original research and material that you won't find elsewhere. Specifically, the coverage of integer issues goes above and beyond what has been previously written, and it's incredibly topical given the current trends in vulnerability research. Seacord's mastery of the C language and his ability to distill the practical rules of thumb out of the somewhat fragmented C standards really results in an excellent resource.

Seacord gives an unsettling walkthrough of vulnerabilities present in much of C and C++ coding. Buffer overflows take up a significant portion of the discussion. Which leads into considering how these can be introduced into unwary code. Consider C. The common string functions of strcpy, strcat, gets, streadd() and others are shown to be very exposed to error or attack. C++ also has similar drawbacks.

The text explains that much of these trace back to some bad usages. Strings are defined to be null terminated. And bounds checking is often not done. While this is often true of code that the programmer writes, it is also true of various common C library functions, like those mentioned above. In fact, Seacord goes so far as to emphatically assert that gets() should never be used in your code. Instead, he suggests fgets() or gets_s().

Seacord also covers other topics, like dynamic memory management, which might have vulnerable heaps. Various 3rd party analysis tools are suggested, to find these errors.

Overall, the book can be quite disturbing, if you are maintaining a large body of C or C++ code. Might make you want to delve in and replace those gets(), at the very least.

While the text doesn't mention this, it turns out that recent languages like Java and C# have far more robust string handling abilities. They were written after the above flaws in C and C++ become apparent.