2 comments about 3D Programming for Windows (Pro - Developer).

1. In his informative writing style of writing, the author of this book gives you both a good understanding of 3D graphics concepts and digs deep into the specifics WPF and XAML 3D APIs. If you're doing and 3D WPF, this title is a must have sitting next to his previous WPF title, Applications = Code + Markup.
   
   This is the definitive guide to WPF 3D.



2. This book is an excellent overview of WPF 3D.
   
   Petzold blends his development experience with his math background to explain everything quite thoroughly, from the details of the API to the hows and whys of the math underneath.
   
   * He explains why WPF 3D shades triangles differently depending on whether they share their vertices or not.
   
   * His explanation of quaternions is probably the best I have read.
   
   * He talks about why Viewport3DVisual is better than Viewport3D for printing.
   
   * He explains the math behind lighting calculations.
   
   The book contains lots of pictures, lots of sample code and a library of useful classes for WPF 3D programming.
   
   If you're doing anything with WPF 3D, you simply must have this book.

5 comments about Learning the Korn Shell (2nd Edition).

1. While not as popular (at least in Linux circles) as bash, ksh is a powerful language/tool. Put bluntly, this is one of the few O'Reilly books I have read cover to cover. That isn't to say that the others don't warrant a thorough perusal, but that this book was readily accessible and provided excellent information. I have used it as a reference countless times over the years and do not hesitate to recommend it to anyone using or considering using ksh. Moreover, if you are considering using ksh - or perhaps need a better background in Unix shell scripting - read this book.



2. I found this book very helpful in learning to write scripts for the Korn Shell. I keep it on my desk all the time now, even for other shells (Bash/etc). It's an invaluable reference to me.



3. This book is just great. It has a lot of examples and every concept is well explained. Even for those who are not used to programming, this is a great book to start shell scripting.
   The authors relate concepts (commands usage, for example) with those of bash and other shells, which is very helpful if you already know how to program with csh, Bourne, etc.
   So... if you're looking for a GOOD book about ksh, buy this one!!



4. I once was blind. Spending decades in the UNIX world I spent time with several shells. Down through the years I visited many shells and even bought a book on the Korn Shell by the designer David Korn. I sort of got complacent (know-it-all).
   
   Now obtaining a position supporting AIX I once again find that the prefer supported shell is the Korn shell; even sh is linked to ksh93. Several times I came across unexplainable anomalies; sometime paths would be absolute and at other times they would follow links. Traps seemed to work a tad different and other outcomes seemed to be hit or miss.
   
   The purchase of this book has been a real eye opener. What seemed to be arbitrary was in reality lack of personal knowledge of the latest version of the korn shell.
   
   I could not believe that a book by David Korn of AT&T did not even mention signals.
   
   Some of the highlights of the book are:
   Job control
   Functions
   Command history
   Command-line editing
   Integrated programming features
   Control structures
   Debugging primitives
   Regular expressions
   Advanced I/O features
   New options and variables
   Increased speed
   Security features
   Major features
   Security features
   POSIX compliance
   Arithmetic for loops
   Floating-point arithmetic
   Structured variable names
   Indirect variable references
   Associative arrays
   Additional text manipulation facilities
   More built-in commands



5. I bought this book a few days ago for use at work. Previously, I didn't have much of a need for interacting with a Unix shell outside of cd and ls.
   
   This book reads easy, and the author(s) seem genuinely interested in the subject - not the usual dry textbook point of view. Topics are explained well, with small examples to show how it actually works. I would suggest having access to a Unix machine with the Korn shell, as you can experiment with the commands a bit on your own.
   
   BTW, I didn't realize that the Unix machine I work on has the 1988 version of the Korn shell instead of the 93 version (the book covers 93), but most of the book is still relevant. They also cover what has changed in the 2 versions.

5 comments about Software Project Survival Guide (Pro -- Best Practices).

1. The biggest part of managing a large project with deliverables is knowing the timing and details of your deliverables to make sure that all pieces are in place and planned for...time and resource wise. This book is a huge help in providing those pieces. Whether you use all the pieces or not it gives you the details you need to think through before you incorporate a deliverable and help you weigh how much detail and effort needs to be a part of it.



2. will the book be convincing enough for you to adopt it?
   
   I have not found this book very fun to read because of its very structured and academic format. I have not learned much from it as much of its content is general wisdom that anyone with many years of experience in the industry has probably seen around before. Something positive I can say about the book is that I totally adhere to the methodology explained in the book. In my software development career, I have experienced myself the benefits of applying similar software development management methodology and I have also seen the negative consequences of not following it.



3. I'm a one-man database development shop at a nonprofit with a shoestring budget. Without the benefit of senior level programmers, I've had to learn most of my software engineering lessons the hard way- by experience.
   
   I picked up this book seven years into the job, which in retrospect was about seven years too late. In some respects, this book repeats lessons that that have already become obvious through experience (e.g., software testing needs to be performed separately from development). But, this lends credibility to my judgment, and provides new insights substantiated by software engineering research studies. Non-technical management and funders are responsive to the hard figures I often find myself citing from this book. For example:
   
   1) Programmers are 2.5 times more productive in a quiet office vs. a cubicle- so, I need to be allowed to work from home
   
   2) The most efficient programmers are 10 times more productive than the least efficient programmers- really, you would think this would be obvious, but when work needs to be contracted, the low bidder is not necessarily the best choice over the long haul
   
   Currently faced with my most substantial and challenging programming project yet, I'm essentially using this book as a cookbook to process. Upfront I was a bit overwhelmed with the scope of the project. Having finished the book, I have a well-defined process in place, am confident this will get done, and feel I am much more articulate describing the stages of software development to management and contracted vendors. Some presumably industry-standard strategies are proving invaluable- implementing a Top Ten Risk list to ensure that major barriers are addressed upfront rather than deferred, creating specific milestones, etc.
   
   This book (or an equivalent) should absolutely be mandatory for anyone about to take on their first major software project. It is most useful because it reads like a cookbook- guiding you through all the phases of software development, one after the other.



4. The book presents an analysis about the project management in a very practical way.
   
   In it, Steve demystifies that in a project the "well" and "fast" are in opposite sides. By contrast, him tells us that for do it fast and cheap, it is essential to do it well.
   
   A project leader should have it in his desk.



5. I've read this book several years ago, in 1998, I think. It was my first glimpse on software project planning. At the time, I was a bit confusing, the book has a lot of examples of very big projects. But the best practices it provides are useful until today.
   
   Don't know if it's a good book nowadays, but it's definitely a book I won't forget.

5 comments about Practical Programming in Tcl and Tk (4th Edition).

1. I got interested in Tcl when a friend of mine had presented me with the Expect application and all the wonderfull things it can do for a sysadmin. Since knowledge of Tcl is required for Expect, I set off looking for a book on the topic... and having read the lines "for beginners and expirienced programmers alike" I thought I hit the target. But what a disapointment...
   First of all, most books for beginners follow certain format which is not the case with this book. Nothing like "here's how to declare variables", "variables are typeless", "here's how procedures/functions are done", "here's what sets Tcl apart from other languages" or "how to do those things that other languages cannot" that other books for beginners so often cover. I had to look online for the line that starts off the freshly written Tcl script... and this is for beginners?!
   From skimming over Tcl implementations on different platforms (I guess that covered the beginner's part) authors dwelve straight into the HTML processing by Tcl (as in "hey Tcl programmers, here's how to do web pages!") which only adds to confusion. It doesn't stop there though... Tcl is said to be a glue language that puts different blocks together, but how come that passing commands to the system from the Tcl script isn't covered? Yes, there are dedicated commands for cruising through the directory tree, creating/removing/deleting files, but is that all?! Linux has a rich arsenal of commannds, many of which go beyond those tasks... and you cannot pass them from a Tcl script? Where's the glue then...
   Same confusing format is followed in the Tk part, except for the canonnical "Hello World" example (straightforward "type it in- here's how it works" breakdown) the rest is off the beginner's path. How to clip a Tcl procedure to a Tk button? Nope, that's not shown- but geometry managers examples plenty abound.
   Examples are incomplete, explanations vague and I often caught myself reading same line several times trying to understand the point that author tries to make.
   As for my reason for learning Tcl, the Expect application- it is MENTIONED on couple of paragraphs that end with a web address. Although it may be the shiniest example of Tcl's power, it is not even skimmed over...
   The content offered doesn't justify the price tag for a beginner's book. If you're a beginner you'd be better off working through the online tutorial at tcl.tk page. It is not only money that you'll save...



2. I am an experienced SW developer, having used many languages. I needed to "get up to speed" in Tcl/Tk in a hurry.
   This book presented the needed topics in an orderly fashion, had clear examples, and doubles as a very handy reference.
   I ordered some other Tcl/Tk books (to be on the safe side), but this one has become my "Bible" (along with the Help info built into the IDE I am using)
   Highly Recommended!



3. Tcl is a nice language and it is not hard once it "clicks", but learning it can take quite a bit work for someone new to the language. This book, unfortunately, does not ease you into the language. The basics are skimmed over, which is fine for some. The basics will come easily for someone who has written in other scripting languages before, but those who are new to scripting languages will be disappointed with the introductory material. The section "Tcl Basics" seems lengthy in terms of page count, but I don't think that anyone who is considered a novice programmer will doubt that some of this section isn't basic, so don't be misled into thinking that it spends more time on the basics than it does. If you've been programming for several years, you might find it basic. The "advanced" stuff receives more attention, but it is not always explained well. When I first flipped through the book, it looked quite vervose, but it turns out that little of that will actually help you. I've had times when I wanted to know something and I consulted the book, but never really understood the solution despite the fact that the author writes many lines on the subject. If a topic that a good writer could clearly explain in half a page receives two pages worth of discussion from this author, you would assume that you would walk away understanding it. Nope.
   
   The Tk (graphics) sections also have their issues. In addition to poor explanations, the examples were confusing. They are short and clear in the "Tk Basics" section, but then they end up becoming a little too long and a bit obfuscated later on. When you are trying to illustrate a short and simple topic, the example should be short and simple itself and here it rarely is.
   
   The "Tcl & C" sections? Even worse explanations. Difficult examples once again.
   
   So why two stars instead of one? That's because this book is very, very comprehensive. Essentially anything that you want to know about Tcl/Tk is in here, although you have to squint and concentrate to see it since it'll be hidden by poor explanations and poor examples. It's a difficult reference book to wade through, but I can't give a book that I refuse to sell or throw away one star.



4. I bought this book at the bookstore since I had to learn TCL for work. This was one of the few book I was able to find at the time. This is not organized in the presentation. Instead of showing some syntax followed by a few examples, it shows this CGI example. I learned some of the language from looking at code.
   
   In the next chapter, the book picks up where it left off. By that time, you have forgotten what was discussed. I would not recommend this book.
   Now that I have been laid off, many companies are making the request for TCL knowledge and I am looking for a suitable book.



5. I used this book since my first day of Tcl scripting.
   This has covered each topic with excellent clarity.

5 comments about SQL Tuning.

1. I was entangled in the web of horrible response time queries, not knowing what to do (except the darn hit ratios were maximum). In utter frustration, I was putting an index here and dropping an index there, inserting a hint here and then setting a parameter there.
   
   Within 1 day of reading Mr. Dan Tow book, I was able to bring my biggest thorn query from 8 hours response time to just 10 minutes. Boy was I blissful. Certainly Dan Diagrams rock.



2. like new as described,fast shipment.



3. I have worked with Oracle databases and SQL tuning since 1987, and the reason I recommend Dan's book so highly to anyone working with SQL is that his method is the first real method I've seen in this field. There are many approaches out there, but they all fall into the Guess & Grimacing or Checklist categories. Dan's is a REAL method, and it works for all SQL-based databases. It's so far the only SQL tuning book I can recommend. Any DBA, developer and troubleshooter working with database-centric systems should know this stuff.
   
   Mogens



4. I have withdrawn my earlier review because I did not properly understand the importance of this book until the second reading. That is a difficult admission to make since my business is database performance tuning.
   
   This book is about tuning SQL queries in a systematic and scientific manner. It is above all about determining the optimum order in which the query engine should access the tables involved. My quibble was that join order is only a part of the whole tuning problem and most of the time the query optimizer got it right anyway. While this is true, I see now that it misses the point.
   
   The fact that the optimizer gets it right so often allows us to take join order for granted. But how do we know the optimizer got it right unless we know what the optimum join order is? That is what this book teaches, a methodology and an elegant system of notation that allows us to determine the optimum join order of the most complex query. As the author points out, the number of possible join orders increases factorially with the number of tables involved. An 8 table join has 40,320 possible join orders. That rules out trial and error for all but the simplest queries.
   
   It turns out that analyzing and diagramming according to Tow's method gives you a deep architectural understanding of the query and the problems that face you. It gives you a plan to which you can apply the tools of the trade, indexes, code optimization, etc.
   
   This is a book that will be on the shelf of serious performance tuning professionals for as long as SQL is the language of data manipulation.



5. Dan Tow has created a marvelous resource. With complex queries, it is often uncertain what is the best query plan. Dan Tow takes the mystery out of that process. He details a methodology that will give you the best query plan with a high degree of certainty. He also provides insights into how to achive the desired query plan.

5 comments about Perl Pocket Reference, 4th Edition.

1. Of the many O'Reilly books that I have purchased,
   this is the first one that was really poor.
   I'd give it -5 stars, but the lowest you allow is 1.
   The author seemed more interested in being clever
   and funny, then imparting information.
   
   However, I also have two very large Perl books
   that are also almost useless, so maybe it's
   a Perl problem.



2. Gerald W. Irmler writes in his review "I also have two very large Perl books that are also almost useless, so maybe it's a Perl problem." Well yes, Perl is not an easy language, but I suspect that the main problem here is an Irmler problem. This book does a very good job of doing what it intends to. Another clue that Irmler is lacking a clue is the baffling comment that "The author seemed more interested in being clever and funny, then (sic) imparting information." Huh? The book is comprised entirely of very succinct facts about the language. There is no style here to speak of, due to the nature of the book.
   
   I rate this book 5 stars, Irmler -5 stars.



3. good and give me a quick review/reminder of perl commands



4. Perl Pocket Reference only gives lists and tables. No explanation of how to use the various functions, variables, etc. Definitely not for new-comers.
   
   I was very disappointed by this pocket reference. I was expecting something more like the very high quality "Python Pocket Reference", which manages to give complete description of the language, all functions, standard modules, etc, ALONG WITH EXAMPLES FOR EACH; The Python Pocket Reference is able to be used as a standalone reference. This is definitely not true for the Perl Pocket Reference; You will need other books to make this pocket reference make sense... what a pain!



5. This book is a good quick reference. If I can't find previous code I always reach for this book when I need to get a quick syntax reference.

5 comments about Mastering Oracle SQL, 2nd Edition.

1. Half of this 450 page book surveys basic SQL, and the other half is on features Oracle added to SQL in versions 9i and especially 10g. I bought the book because I believed the title, and the reviews here that said it was an excellent reference. But, to quote one of its authors, "This book is NOT a reference manual, and it is NOT an administrator's guide". It's an overview of SQL only. It is not an introduction; nor can it be used, reference book-fashion, all by itself.
   
   So for my purposes, I was quite disappointed. But the book has some utility, in its explanations of what can be done with Oracle SQL. Especially in the explanations of analytic functions, regular expressions, and XML. It's like a series of magazine articles, with discussion and examples.
   
   The book has some weaknesses:
   
   * The index is very skimpy and incomplete. This is what you'd expect actually, in a book that isn't ever meant to be referred back to.
   
   * The focus on SQL is diluted and inconsistent. For example, there is an explanation on how to set up partitioning. Another section compares Oracle's implementation of regular expressions to Perl's . Sometimes background and comparisons are present, sometimes they're not.
   
   * There isn't much explanation of *why* you'd want to do some of the *whats* that can be done. Yes, it's possible to build classes and objects into a database, but why do it in SQL instead of Java? (Of course the *hows* would be quite inadequate, if this were a how-to book).
   
   * There is too much explanation of how things used to be done in 8i. That version was five years old back when this edition was published. 8i shouldn't take up more than a paragraph or three in a book that purports to cover 9i and 10g.
   
   In summary, if you don't read trade magazines, and you don't care to spend your time on Oracle websites and forums, and you know you won't have access to 11g anytime soon, you may find this book a decent (altho somewhat pricey) way to broaden your horizons of what you can do with Oracle SQL.



2. I'm no SDE, but I had a need to learn enough SQL to enable me to hit my company's Data Warehouse tables directly and employ some complex joins. This was the book recommended to me, and it did the trick. I sat down and began reading it and was quickly writing increasingly complex queries. I found the explanations easy to follow, and the format intuitive. The only fault I found is that there is a lack of more complex join examples, as when there are more than one field being joined on or more than two tables being joined.



3. The goal of the authors is to explain how to write good readable SQL queries in Oracle 10g. The book starts with how to construct SELECT statements to group, filter and format result sets for dates, reports and data analysis. Then it proceeds to cover Oracle-specific queries and functions for hierarchies (data in tree structures), object-oriented types, XML documents, regular expressions and models (spreadsheet-like objects). Where relevant, there are notes about the differences between SQL for Oracle 10, Oracle 9 and the ANSI standard.
   
   As expected from the title, the chapters using declarative programming (i.e. SQL queries) for relational data, hierarchical data and reports are the most comprehensive. Chapters on interfacing Oracle SQL with other technologies such as scripting (Oracle's PL/SQL), object-oriented types, XML and regular expressions, or on optimization, are brief but sufficient to get you started, especially if you have a existing background in those technologies.
   
   This is the 2nd edition, so it's not surprising that the scope of the book is well-defined and that the writing is easy to read and polished. The example data and queries are just complex enough to demonstrate the issues without obscuring the main points. Minor annoyance about Chapter 15, "SQL Best Practices", which does not explain how to use the query analyzer and bind variables.
   
   I was already familiar with basic Oracle SQL but didn't really understand the language; this book blew away many of the fuzzy concepts in my mind and provided me the framework to tackle more complex problems.
   
   Kam-Hung Soh, 21 May 2007.
   [...]



4. The book does a nice job of dissecting the syntax of SELECT statements and their various components, but in my opinion would fall short for most practical users. The examples are closer to what you might find in one of those "SQL for Smarties" books than what a normal developer writing applications that interface with Oracle databases might be looking to master. For example, there isn't in depth coverage of flow-of-control mechanisms and only a few pages in the first chapter covering DML operations.



5. It's the only Oracle book I seem to need. Great explanations. Includes new Oracle features. One of the best descriptions on inner, outer, left, right joins. Saved my tail a couple of times. It includes just the right amount of information.

5 comments about The Cathedral & the Bazaar: Musings on Linux and Open Source by an Accidental Revolutionary.

1. This book is a great and very interesting read. While you can get the collection of essays online, for free. I prefer the book, easier on my eyes. ESR (author) tries to keep it straight foreward, however at times he drifts into a technical world, which somewhat flew over my head. If you are interested in the Open Source community, namely what makes it work, and what problems it has in store, this is a great book.
   He Gives personal experience which I really value, and he doesn't try and hide the short comings of Open Source Development.



2. I like this book for many reasons. First of all, it uses lots of specific examples to prove a point. Two, the author was right at the front lines during the formative days of Linux and open source and he does not hide his biases. Three, he is a very insightful guy and he sure as heck knows how to turn a phrase.
   
   That said, the book is not that far removed from a polemic. He has drawn his conclusions and moved on from contemplation to conviction. So if there is any point along the way you disagree, what follows is going to give you frustration.
   
   I'd suggest reading this in conjunction with The Success of Open Source, which despite its title, is far more balanced and has the best history of the open source movement I have ever read. I've given that book 5 stars. The two balance each other out quite nicely.



3. The title says it all,
   however, the caveat is that if the "instigator" of the particular form of software does not have the "cache" or "credentials" in the open source community then the chances of a REALLY BIG item being developed is rather small. BUT, if the "item" can catch on, then it can be done better and faster than a "paid for development".



4. I felt the book had some good points and then other times I was struggling to get myself to pick it back up. Overall worth the read but not in my top 5 list by any means.



5. The Cathedral and the Bazaar is a collection of essays originally meant for programmers and technical managers, written by Eric S. Raymond on software engineering methods, based on his observations of the Linux kernel development process and his experiences managing an open source project, fetchmail.
   
   I you like a deeper work on Linux development, I can recommend the book "Rebel Code" by Glyn Moody.
   
   fetchmail, is an open-source software utility to retrieve e-mail from a remote mail server. It was developed by Eric S. Raymond from the popclient program, written by Carl Harris. Its chief significance is perhaps that its author, Eric S. Raymond, used it as a model to discuss his theories of open source software development in this book. Some programmers, including Dan Bernstein, getmail creator Charles Cazabon and FreeBSD developer Terry Lambert, have criticized fetchmail's design], its number of security holes, and that it was prematurely put into "maintenance mode". In 2004, a new team of maintainers took over fetchmail development, and laid out development plans that in some cases broke with design decisions that Eric Raymond had made in earlier versions.
   
   The essays in the book describe open-source software, the process of systematically harnessing open develplment and decentralized peer review to lower costs and improve software quality. contrasts two different free software development models:
   
   - The Cathedral model, in which source code is available with each software release, but code developed between releases is restricted to an exclusive group of software developers. GNU Emacs and GCC are presented as examples.
   
   - The Bazaar model, in which the code is developed over the Internet in view of the public. Raymond credits Linus Torvalds, leader of the Linux kernel project, as the inventor of this process. Raymond also provides anecdotal accounts of his own implementation of this model for the fetchmail project.
   
   The essay's central thesis is Raymond's proposition that "given enough eyeballs, all bugs are shallow" (which he terms Linus' law): the more widely available the source code is for public testing, scrutiny, and experimentation, the more rapidly all forms of bugs will be discovered. In contrast, Raymond claims that an inordinate amount of time and energy must be spent hunting for bugs in the Cathedral model, since the working version of the code is available only to a few developers.
   
   When O'Reilly Media published the book in 1999, it achieved another distinction by being the first complete and commercially distributed book published under the Open Publication License.

4 comments about Microsoft® Office Visio® 2003 Step by Step (Step by Step (Microsoft)).

1. This is a well-written and easily understood intro to Visio, which does a good job of covering diagrams, flowcharts, Gantt charts, floorplans, and the like. But, it has absolutely no information on building database diagrams with Visio, for which I deducted a star.



2. Well organized and easy to study. Suits multiple learning styles. The CD has some excellent additional information.



3. I really enjoyed going through this book. It is laid out well and has lessons you can do to help you learn.



4. This book "Microsoft Office Visio Step by Step" is yet another example of an almost useless manual, that barely duplicates what is available in the online manual for Visio.
   
   It basically consits of screen shots and procedures.
   
   It doesn't sit back and say "well, what might a user want to do here? Oh, you want to create a circle with center and radius? Then look for such and such a shape in such and such a stencil." Etc.
   
   Because it lacks this "meta-contemplation", this manual is only as good as the programmers - it is basically like talking to the programmers, in their mindset. (I'm a programmer: this is NOT good). If what you need to draw is exactly covered by Visio, this manual may help you. If what you need to draw is not exactly covered by one of Visio's pre-packaged setups, this manual is not much help.
   
   I work in an intensely graphical field - VLSI design. But Visio has no pre-packaged setup for my area --- the "electrical engineering" and "digital design" stencils and templates are not very useful. (This opinion confirmed by surveying my fellow engineers at Intel and AMD - all of us want to use Visio, but all find Visio sorely lacking.)
   
   This manual is utterly useless with respect to advanced Visio, e.g. using ShapeSheets to create "smart" shapes.
   
   ---
   
   Because I have mentioned my employers' names, past and present, I must add this disclaimer: this review is my own personal opinion, not the official position of Intel and AMD.
   
   Although I daresay many engineers at Intel and AMD agree with these sentiments, it may be hard to put this on the record.

5 comments about Microsoft® Office Outlook® 2003 Inside Out.

1. A most comprehensive treatment of Outlook. Extremely well suited for an experienced Outlook user, with many details on the use in a server/business environment. Describes the interrelationship with Windows Outlook Express. Probably a little too comprehensive for the single system user just trying to read and write a few email messages. Subject matter is exceptionally well presented and thorough.



2. Previous reviewer's comments are noted well, but I was somewhat disappointed in the coverage of forms development. I really wanted to learn to move/place fields on a contact form and designate them drop-down, etc. Simple enough, I thought, for a book of this coverage. But even though the author talked about the abilitiy to do this, there were no directions, no examples, and no description of the 'Controls' options required to do it. For a book of this size and price, I had hoped for more meat. No, not to the detail of VB scripting, but certainly more detailed coverage of Outlook's powerful forms and macro abilities. To my chagrin, I'm finding my answers under the Outlook 'Help' section in the program itself!



3. Too much said about the various steps. Not brief and to the point. Found it difficult to go step by step without reading, and reading, and reading.



4. Comprehensive and approachable. Good index and highly illustrated.



5. I found myself as the Outlook support for a new small business and I had only used Outlook for e-mail and contacts previously. This book has quickly become my total reference guide. It has helped me solve several problems. It's easy to read, well organized and very complete.
   I recommend it to anyone who needs to support an Outlook installation or an Exchange Server installation.