I try to read as much as possible. Usually close to fifty books a year,
both
recreational and technical. I have found I learn more by reading
and hearing what others have to say than I do from any classroom
instruction. It’s also one of my passions. When I retire I plan to open a small bookstore
and spend everyday reading.
This page will contain reviews of technical books, though if you are
interested in seeing what else I read, I have been tracking the books I read on my web site,dkRanch.net.
Some of these books are provided free of charge by the publisher, however, I review each
book independently and write what I think. I do give the publisher a chance to respond and potentially
veto the review, in which case I will not post it (and probably will not get any more books). I
do not recommend books I do not like and do not hesitate to tell you. I can always buy my own
books. So read on, let me know what you think, and feel free to disagree with me. One recommendation
that I do have is to read a few reviews on a book, buy it, and then compare your thoughts with each
reviewer. It will help you to learn more about the reviewer and his/her thoughts. Hopefully you agree
with me more than you disagree.
If you are a publisher and would like me to review a book, please send me an email.
Click on any of the images to jump directly to this book at .com.
A good introduction to SQL Server for developers and good information on Access and
alternative access methods for SQL Server DBAs. (October 2000)
Recommended as reference for beginning SQL Server programmer methods using VBA/ASP or developers
seeking to learn about SQL Server and the differences from Access.
A good source of information for people looking for a low cost, open-source database. This
is also a good SQL reference and very well written and organized. One of the best written technical
book I have read. If you are not comfortable with command line or 3GL programming, this is not for you.
(October 2000)
Recommended if you are interested in an alternative database.
The jury is still out on this one, though it appears to be a good OLAP reference.
No Recommendation
Secrets and Lies
Security is kind of a hobby with me. I think it is both interesting and scary
and an area that most people treat pretty lightly. I find lots of security problems
in companies mainly because people do not take a few minutes and set things up in
a logical manner. I have flipped through (though never purchased) Applied Cryptography
by Mr. Schneier, and when I saw this book on the shelf, I was very interested.
First, this book is well written and even funny in places. I think that always helps
to make a book interesting when the writing is good. Second, this is a scary and
fascinating look at security in the modern world. Mr Scheier presents many of the
issues and problems with securing data. There are well organized and logical descriptions
of the issues, definitions, and reasons for security problems.
While I am interested in security, I am not an guru by any means. This book is written for
the technical person, but without requiring a thorough knowledge of security. I could give
this book to my Mom, and though some of the discussions might be confusing, she would
understand most of the book.
The reason I am presenting this book here is that data security will become more important
in the future. I think most DBAs would do well to learn about the possible the issues they
may encounter and be prepared for the future. Unfortunately, Mr. Schneier does not present
too many solutions for the problems, mainly because they do not exist. I wholeheartedly agree
with My. Schneier that insurance is the likely solution to many of these problems. I expect
to hold malpractice insurance at some point in my career if I continue in this business for the
next thirty years.
Regardless of whether
there is a solution, I think it is worth learning about the risks and this is a great
book for learning about security and risks in the digital world.
Steve Jones
March 2001
Microsoft SQL Server 2000 Optimization Guide
Recently, I was setting up a new production SQL Server for an e-commerce web
site. I ran across this book and decided to give it a try along with the Windows 2000
Performance Tuning guide reviewed below.
Overall I think this is a good book, especially for someone getting into performance
tuning. It is not as comprehensive as I would like and spends quite a bit of time
going over calculations. I think the Windows 2000 book below provides better descriptions
and tips for tuning Windows 2000 and the OS.
I did like the index section and the performance monitor sections, though I would like to
have more in depth technical explanations of what many of the options mean and how they
can affect performance. For example:
Page Requests/sec
Request for buffer pages
Logical Read: if page is in cache, there is no physical I/O.
When I read this, I am wondering, does this mean that the SQL Server requested a page
that was found in cache, or that this is a request and I have to decode the physical reads
. If a page is not in the buffer and must be physically read, is that included in here as well.
I think most performance tuning guides lack this level of detail, so this is not a huge knock on
this book.
The Profiler section is also ok, but I was hoping for more detail on how the profiler can be
used and some sample setups and tuning operations. Or even some auditing operations. So far this is
the best Profiler chapter I have seen, but it is still lacking.
If you are only going to buy one book, this may not be the book, but it does have some
good information. There is another SQL Server 2000 book that I have not gotten to
take a look yet. I was disappointed with this book, but it is still worth 3 stars.
I was walking in the bookstore one day and saw this on the title and was
intrigued by the title. After reading the jacket, I decided to buy the book and
was excited about reading it.
I hate buggy software. Everytime Windows 98 locks up on my oldest, everytime Word locks up
when I am writiing, evertime I lose work, I curse the programmers who built the software.
Like most people, I have come to expect a certain amount of bugs in most software. I shouldn’t,
and neither should you.
Since this is a book review, I will jump off the soapbox and get to the content. This book is basically
about three parts. The first part talks about the problems of buggy software, how bugs can be introduced,
and why they are tolerated. I somewhat agree with the issues presented; lots of software is buggy
and can be written better. However, bug-free software is extremely difficult, if not impossible to write.
A few of the examples cited, such as the space shuttle, come very close, however there are still some
defects in this software. There is also the problem of proving that something does not exist.
The middle part of the book discusses software licenses and the problems with them. A good portion of
this section is devoted to the UCITA proposed legislation. This is some scary legislation and
everyone should oppose it. Here are a couple links that discuss this law which has already passed
in VA and MD.
I have never written commercial software, but I believe that commercial comapnies are harmed by this law
in the long run as much as comsumers. Already most of the best security software is being written and sold
in Israel rather than the US. A great deal of this is due to silly regulations in the US regarding software.
Of course, the talent of a number of Israel’s citizens is greatly responsible as well. I urge you to
visit the links even if you do not read the book and send a letter to your congressperson.
The last part of the book discusses what you can do about buggy software. Mr. Minasi also recommends
that you get involved with Beta programs and try to make a difference with vendors. This is something that
I have given up for the most part because of the buggy software. I like for most of my software to just
work (one reason I use Wordpad more than Word).
Overall, this was an interesting book and worth reading. It definitely can inspire you to do
something about the bugs in your software. The tone of the book, however, often seems to cry “conspiracy”
and it did not read as smooth as I would have liked. Often the author seems to be whining more than
presenting informatin. The message, however is an important one and one that I would recommend to
my Mom who is not very computer literate.
I had been having problems with our Cold Fusion web server and was trying to determine the best
way to tune the server. I picked up another book from MS Press (review coming soon) on tuning
Windows 2000, but I was not thrilled with it. While I was digging through that book, my boss dropped
this one on my desk and asked me to take a look and see what I thought.
I started reading this book and within 5 minutes had learned a couple things. The first chapter immediately
presents a few tools that can assist in performance tuning, a few of which I had not heard about. It
also immediately presents in a concise table a few performance counters and how they can help detect
bottlenecks.
As I glanced through the chapters on memory and disk systems, the author describes the technologies
in use today and how they affect performance of a Windows 2000 server. The author also spends the latter
half of each chapter providing good step-by-step methods for tuning a system. There is a good use of
charts with quick reference information and screen shots of performance monitor screens.
The book ends with sections devoted to tuning a server specifically for the various MS applications
that are available (SQL, Exchange, File Server, Web Server, Backup Server). I think this is a great
book for anyone using Windows 2000, including DBAs. Even if you do not have control of the OS for your
SQL Server, this book can help you understand why your server performs as it does.
I was really looking forward to this book as a potential “bible” for DTS. Ever
since DTS has been released, information has been sparse and most books that
I have seen provide the same few types of examples, none of which have really
helped me to learn DTS.
Until this book was published, the best information I had seen about DTS was in
OLAP Unleased which contained a few hundred pages of information. Unfortunately,
most of this information appeared to be aimed towards VB programmers
implementing DTS into VB. There is nothing wrong with this, but as a
DBA, I try to stick to the native SQL Server tools as much as possible. This
way, I have fewer dependencies and do not have to install anything on my
machine or server.
So, with much enthusiasm and some high hopes, I dove into Professional SQL Server
2000 DTS.
The first four chapters present a nice overview of DTS and walks the user
through a few basic and fairly standard examples. The tasks that are included
with SQL Server 2000 are each presented with a good exmaple of each option
and setting. I think the explanations are fairly straightforward and written for
most imtermediate to senior level DBAs. I especially like the way that the
various constants that are available are defined along with a few examples of
how to use each. If you have done Windows programming, then these constants
will look familiar, though none of the DTS books I have looked at before
this one have presented very good explanations of each in this much detail.
Chapters 5 and 6 discuss accessing heterogeneous data access, which is probably the main purpose behind DTS. Chapter 5 looks at linked servers and how they are setup in SQL Server. It is nice to have this chapter separate so it can be skipped by those who know how to do it, but still there to build a base for those who have never setup a linked server. Chapter 6 then dives into various examples of how to access data. There is an Excel example that includes formatted titles and headers in the spreadsheet (how many Excel spreadsheets do you get without a title or header in the first couple rows?). That alone is something that lots of people that have not used DTS very much would get frustrated trying to get working. And it’s a simple fix (set first row to the real first row on the options tab)!!
There is also a nice example converting data from DB2 using the Host Integration Server from Microsoft. One nice thing in this example is the inclusion of specific errors (using screen shots!!!) that may occur when using this tool. I do not have a copy of either DB2 or Host Integration Server, so I could not test this. The only thing that would round out this chapter would be an example of data transfer from Oracle. Since it is so heavily used, it would be nice to see a specific example that queries an Oracle database.
Chapter 7 is the chapter that I was most interested in reading. ActiveX scripting is something that I have hacked around with, but have not really had the time to develop good skills here. No other book I have read on SQL Server walks the beginner through ActiveX scripting. This chapter presented a nice introduction to programming using scripting and the various types of programming constructs that are available. I am familiar with most of the constructs, but the seeing the specific implementation of loops, variables, etc. in scripting was nice (with screen shots).
Chapter 8 deals with dynamic packages. Since most packages that I have built with SQL Server 7 have to be tested by me, moved to another server for QA, and then deployed to a production server, I am constantly developing tricks to allow the same package to be used in all three environments. Usually I have had to alter the package as it moves between each environment to reset some of the connections or tasks as databases and servers change. This has been a constant hassle, not to mention a concern for our QA people.
This chapter was helpful because it explained how to add dynamic steps and packages from within DTS. Without VB! Of course, the chapter does then walk the user through setting up a new VB project and creating a package, including saving this package to SQL Server. For someone whose VB skills are a little rusty, this was a nice read.
Chapter 9 goes into advanced ActiveX scripting, including some file system manipulation. I have spent quite a bit of time learning how to manipulate the file system from with DTS, so this was not much help, but it was a straightforward explanation.
Chapter 10 introduces security. It also talks about backing up and restoring databases, including using the maintenance plans included with SQL Server. I am not sure why this much detail is devoted to an admin task and I think this is the weakest chapter in this book. The explanations are a little skimpy and I think this chapter is a bit misnamed.
Chapter 11 is devoted to error handling. Most people will probably skip this chapter, but it is important to building solid DTS applications. I recommend reading this chapter, which contains a good explanation and examples for handling the errors that occur in different tasks. There are both DTS native and VB examples.
Chapter 12 discusses custom tasks and then walks the user through building one in VB. This was a great explanation of building a custom task. I have not built any for my own use (outside of this example), but I look forward to trying some of the techniques in this chapter.
The final three chapters are devoted to data warehousing and integration with other applications. The treatment of the integration with other applications is a little light, but there are a few examples of how to build a custom package, make a DLL using VB and then call this from other applications.
The data warehousing sections, though, provide a good introduction to data warehousing and how to build a DTS solution for loading a warehouse. There is a detailed example that reminds me of some other WROX programming books where a good sizes project is presented as the final chapter.
The nicest thing about this book is that there are lots of screen shots. And by lots, I mean LOTS. More than most any book I have seen. It really helps with such a GUI intensive application such as DTS to have lots of screen shots that guide the reader through the examples. This book as pretty much lived up to the high expectations that I had and I highly recommend this for all SQL Server DBAs.
This is the third edition of this book and I think this is a must have for SQL Serve
DBAs out there. Kalen Delaney wrote the second edition for SQL Server 7 and she has once
again written a great book on the interal workings of SQL Server. I highly recommend this book
for anyone working with SQL Server. It is a great desktop reference and has answered some “how
does it work” questions for me.
I would not sit down and read this entire book cover to cover, and actually have not read the entire
book. I have read a substantial portion of it as research in understanding how some proceses work in
SQL Server 2000. Once very interesting thing I learned about cached execution plans is that they are not
reused if you do not specify the owner of a table. If the server must make the implicit conversion to “dbo”
then the execution plan will be recompiled to verify the ownsership chain.
Overall, I found this book, like the version before it, to be easy to read and explain most
SQL Server behavior in a straightforward and easy to understand manner. I read mostly the second half
of the book as the beginning sections would not really help me. I was very impressed with the locking
and query processor chapters. This is a great complement to Books Online and one that I purchased for home,
even though we have a copy at work. If you have to get just one general SQL Server 2000 book, this should be
it.
This is a quick review of this book as I am not going to be concentrating on this exam at this time. I received
this book from New Riders (thanks to them) to write a review. My impression is that this book does what it says:
It prepares you for the exam, though it skims over quite a few of the topics. If I compare the Windows 2000 Professional
installation section in this book with others, this one boils it down to facts without much supporting information.
I would not recommend this book as a primary source of information for any of its topics. Will it help you pass the
exam? Stay tuned and I will expand this review when I start really studying.
I got this book for a couple reasons. First, I am dusting
off some old VB skills and thought that this book might provide some insight
into how VB programmers might access SQL Server. Second, I wondered what is
being taught to VB programmers about databases and SQL Server in particular.
Most of the VB and Web developers that I have worked with know the basics of
databases and can write simple queries, but often do not understand
normalization, what foreign keys are, and many of the more complex parts of a
RDBMS.
I have to say that I was pleased with how this book presents
SQL Server to the novice VB developer. The concepts are laid out and explained
in .layman.s. terms (non-DBA) and each new concept has a .Try It Out. section
that walks the user through a practical application of the concept. Throughout
the book, a hardware and software tracking system is built with enhancements
occurring in each chapter.
The book devotes a chapter to explaining how an RDBMS works,
including many basic concepts like normalization, keys, and relationships. This
section is well written and worth a read for everyone. Even experienced DBAs
might pick up a good explanation for these concepts that can be passed on to
others. I know quite a few DBAs have trouble explaining these complex ideas to
developers, myself included. I have seen quite a few developers walk away with
a glazed expression and return later with the same question.
There is a section devoted to explaining how to install the
personal edition of SQL Server, which is a worthwhile exercise for developers,
so they can understand what is involved. This section is well written, though I
hate to see examples that create databases with unlimited growth for the data
and log files. Like the blank sa password, this is a pet peeve of mine and
should never be used as an example. Set a limit! Unlimited growth means that it
will grow until your hard disk is full, and (potentially) crash your machine,
leaving you to diagnose and correct the problem.
The remainder of the book walks the user through T-SQL
commands to perform the four basic functions (INSERT, UPDATE, DELETE, and
SELECT). There are also a couple chapters devoted to the basics of XML and its
integration with SQL Server. These are really good explanations, though with
just enough knowledge to be dangerous. If you are working with XML as a mission
critical transport, you should seek other reference material. This will provide
you with the basics for getting XML formatted data out of SQL Server along with
a couple examples of how to use this data. It is a better explanation than in
BOL.
I would not recommend this book for DBAs, even junior
levels. If you are going to be a DBA, then there are much better choices for
learning about SQL Server. This is a good book for developers who are new to
SQL Server or want to learn more about SQL Server. If you are a DBA who works
with VB or ASP (or other web scripting language) developers, then this book
will explain many of the concepts that are needed for working with SQL Server.
While written from a VB programmer.s perspective, most of the code will work
with ASP. I would even recommend this for any system administrators who are
familiar with scripting or have any desire to do some light programming. The
tracking system that is being built is rather useful and needed in any
organization.
Let me first disclose that I received this book complements of the folks at WROX Press.
It was also not a book that I would have ever picked up on my own. I have a natural bias
against Access from the days when it competed against FoxPro and was a hacks way of
developing an application. I have also never used Access prior to the fall of 2000 to do
anything. The only reason I picked it up was an experiment to see how quickly I could
build a data editing form for my SQL Server tables.
So what did I think of this book? I wish I had read some parts of it before my experiment.
Since I am not an Access developer or user at all, my thoughts are from the point of view
of a strictly SQL Server developer. I learned things from this book. Which is the most
important thing to get from a technical publication, IMHO. Some of the things I learned
are things I will likely use in the future, like the Auto Form Wizard and the Parent/Child
forms for data editing. I can see an administrative application for data maintenance being
something that Access programming would be perfect to build in a very short time frame.
The book is organized well and reads easy. I also like the way Mr. Dobson presents an
example and shows multiple solutions using different database access methods (ADO,
SQL-DMO, ODBC DSN). There is ample space devoted to code samples as well as
explanations of how those samples work. I also liked the references in places to other
chapters or sections rather than repeating the same information over and over. In places
where the topic is complex (like FrontPage 2000 or the ADO Object model), Mr. Dobson
refers the user to another WROX publication that would provide more in-depth
information. The user is not left with this, however, an explanation of the topic is given
that should prove sufficient for most people.
This book also includes sections on SQL Server 2000 in most sections where deviations
or enhancements to the behavior of SQL Server 7 and Access are explained. These notes
are based on Beta 2, and are consistent with what I have learned from Beta 2 as well. The
last few chapters of the book deal with WWW publishing of data and include Access
tools, FrontPage Extensions, Active Server Pages, and Data Access Pages. While non of
these chapters will allow you to build the next Amazon.com, they provide sufficient
information to allow an Access or SQL Server developer with limited familiarity with
web technologies to publish data dynamically on the web.
Overall I was pleased with this book and would recommend it if you are familiar with
Access and wish to begin migrating or developing with SQL Server. I also think if you
are a user that needs to develop prototypes; this book would allow you to use Access to
do this with data on a SQL Server. Lastly, SQL Server people: This book has some good
ideas for using Access with SQL Server or MSDE. It is worth reading or keeping as a
reference so that you can understand how you can help migrate Access applications to a
larger environment. If you are not familiar with ASP, this book provides a gentler
treatment of ASP than some of the other ASP books I have read. Often books devoted to
ASP are a little overwhelming for the novice programmer. I wish I had read the sections
on connectivity and ASP from this book a few years ago.
I have never used MySQL, but was sent this book by New Riders Press, so I decided to
check it out. From what I gathered from the book, MySQL is a database server that is
available under the GNU Public license (GPL) which means the source code is available
and you are free to modify it. You can check this out and get more information from
www.mysql.com. There is information, links, downloads, and a list of clients.
On to the book: my first thoughts on this book were that it is very well written; my
impression after finishing the book (OK, I admit, I skimmed the Perl and PHP chapters
since I do not program in these languages in general. I read enough to see how it was
written and organized, but did not really spend time reading and understanding the source
code.) was that it is very well organized. In fact, I wish Mr DuBois would write a book
about SQL Server since I am pleased with the way that he organized the concepts in the
book and explained the concepts. Most of my time was spent in the SQL Tutorial sections
since these were the areas that I am most competent (I think?) in understanding.
The book provides some background on MySQL and explains how to download and
install the software. The slant of the book is definitely towards UNIX, but there are a
number of places where the differences in the Windows versions are noted. The tone of
the book is definitely for a fairly experienced programmer and technical developer. The C
API section seems very well organized and while I did not build the examples, the code is
well written and organized and explained sufficiently so even an intermediate C
programmer (like me) can understand and build basic applications using MySQL. The
same applies for the Perl and (I guess) the PHP sections. I have never programmed in
PHP, so I cannot really comment as to how accurate or understandable these sections
would be to someone using this language.
The SQL sections appear to be written for a developer new to SQL in general and are
well organized and logical in structure. I am going to ask a friend to look over these
sections, since I think they could easily be changed to work for SQL Server and provide a
great introduction to developers to SQL.
If you are searching for a low-cost or Open Source client-server database, MySQL is
worth a look and this book would be a great introduction to this database. If you need
another MySQL reference, this is worth a look.
I picked this up as an introduction to Analysis Services which I have not had the opportunity to use in
my work. I had not had a chance to get to it and was planning on reading something else, but a viewer of this
page told me it had a nice and long DTS section, so I decided to pick it up.
I am only reviewing the DTS section of this book for the time being. Mainly because I do
not have the time to work with the OLAP sections. I hope to get to these soon. My impression of
the DTS sections is that this is a good reference, especially for VB programs. For trying to learn
DTS for most junion DBAs, this will be a bit above them and they will probably spend some time
struggling if they are not from a programming background.
Here are my notes as I read the book
I read the first two DTS chapters, Microsoft Data Transformation Services and The Core Data Transformation Tasks.
I was starting to like this book until I read the section on the data driven query. I will be honest, I have not
completely understood this task and have really not spent any time trying to figure it out. The documentation with
SQL Server was poor (IMHO) and the Transform Data Task works great for me. After reading the explanation in this
book, I am still confused. Maybe more so. One day I will figure this one out and write a simple explanation with
examples for people, but for now I am not using this task and am a little turned off by this book.
To be fair, I have not really spent time on the server working with this task and perhaps the book will make more
sense once I do so, but my first impression is this was not a good explanation. I plan to continue reading this book and
will update this review as I do so. (10-4-2000)
OK, I take back some of what I said in the previous paragraph. As I read further I see that the first chapters are
describing DTS and some features and there are more details in later chapters. That being said, I read another chapter which
described ActiveX tasks in more detail, but had very little code or examples. Maybe there will be more in future chapters, but
it does not help me as I am reading to get descriptions of the options without seeing how they work in practice. I could
sit there and mess around with DTS and probably learn as much. I was hoping reading a chapter would give me a bigger
headstart when I sit down at the computer.
I completed the Active X chapter and Object Model Programming chapters. My opinion of this book is rising to meet
my expectations, though I am also learning where this book fits into my library. These chapters
have done a good job explaining these concepts as described earlier in the book. While I have
not installed the sample code on my server and walked through some of the samples, they are
making sense to me and as I hoped, I will have a head start in working with DTS when I get the
time to work on the server. (10-11-2000)
I think this may be my bible for T-SQL. Lots of query techniques and
ideas for programming
in new ways. I think this is a great book for the intermediate to advanced
programmer who
wants to write better T-SQL. A forward by Joe Celko, one of the most
respected database
programming authors of the past ten years.
I have learned quite a bit by reading this book and plan to
continue to use it for reference for the foreseeable future. I even learned
how to solve a SQL problem that
has bothered me for over a year and no postings in the newsgroups have
solved.
For intermediate to advanced SQL programmers, this book is a great read
and a
worthwhile reference. There are even a number of undocumented functions
explained
in the book. For begining SQL developers, it may eb a bit overwhelming, but
still worth the
purchase price to learn some advanced lessons and good habits early on.
One of the better SQL Server v7.0 reference books that I have
read. More specific to SQL
Server 7 than the Guru’s guide above with an easy to read style. I flip
through both of these books,
each one providing a little different slant on problems or issues I am
looking up. This is more
of a beginning to intermediate level programming book.
I picked this up as a reference
for cursor information one day (My 2000 BOL is a little lite on the
subject.) I found it to be a better introduction than most books to
SQL 7 programming. Not quite the
advanced item I was looking for, but pretty good at explaining concepts and
a
decent reference for me. A good substitute for when I tire of Books Online.
I was looking for information on indexes
and structures and this book had a much better writeup than anything
else in the office at the time. It was helpful and explained pretty
well
how SQL Server uses indexes and a good start to how you can analyze
your
indexes.
I have worked my way through just about the entire book and the
remaining sections are pretty basic so I probably will not read
them. I
think this is a great reference for SQL 7 DBAs/developers and highly
recommend it. Along with the Guru’s Guide (currently reading) this
is
worth your $$ as an investment.
After becoming a full-time DBA, I purchased this book as another
reference companion
to Books Online. I learned a fair amount from this book and it was much
better then Learn Transact-SQL In 21 Days, but still a fairly basic book on SQL
programming. If
you are just learning Transact-SQL and would like a paper reference (as
opposed to Books Online), then
this is a good purchase. Advanced programmers, purchase one of the books
above.
I was hoping to learn something about DTS from this book but was
extremely disappointed. The
site maintained by Darrel
Green on Swynk puts this volums to shame. It has some information on
DMO and NS that I did not know, but I do not really like these interfaces
for programming, so it
was not of much use to me. Unfortunately there are not really any other
books on the market for
DTS. That should change in October 2000 with the introduction of a new book
by Brian Knight and one
other devoted to DTS. I look forward to reading these new volumes and will
report on them here.
