Customer Reviews

File Structures: An Object-Oriented Approach with C++

5 star:		(7)
4 star:		(5)
3 star:		(3)
2 star:		(0)
1 star:		(3)

 

 

The book is an excellent introduction to what goes on inside databases.

I used an earlier edition of this book when I was suddenly put in the position of writing database internals, and I had to modify and improve the B-tree code of a database.

While the book is not advanced, it gave me an understanding of how B-trees work which helped me master this assignment. After reading this book, I was able to read more advanced articles in the database literature.

The discussion in the book is extremely clear. The content is fascinating and it gives you a solid introduction to topics that are basic to modern computer systems.

The book will not make you an expert (you have to have suitable mentors and suitable reading of the literature for that) but it will get you off the ground which is all you should expect from an introductory book.

You have to recognize that the code and algorithms are not industry quality - they are teaching quality - they do not have all the optimizations one would expect to use in industry; the code in the book is designed to make the concepts clear.

The book is a great introduction to file structures concepts like representation on disk, issues of record deletion, indexing with B-trees, and hashing techniques. The book is very readable and the examples make sense. (For some more advanced reading, especially in the area of hashing, check out Alan Tharpe's "File Organization and Processing".)

Unfortunately, I found myself cringing numerous times at the code. There are many places where it is obvious that the authors have only basic C++ knowledge. For example, a pointer from strdup is deleting using the non-bracketed delete operator. That will produce undefined behavior according to the C++ standard. There are many issues like this in the code. Also, there are many performance issues with the code. I would have preferred that the authors use pseudocode instead and discussed object-oriented design in a language agnostic way.

All that said, this is still a good book about file structures if you just ignore the shoddy code. The presentation of concepts is very readable, I breezed through the book in no time and came away with new knowledge.

This book gives you a down to earth and very practical introduction to File Structures. It contains lots of well explained C++ code in the main text.

It might be a simple matter of taste. Personally I do not like the writing and the code. It is clear but somewhat uninspired and shallow. But see for yourself.

Before reading this book I do highly recommend reading Alan L. Tharp "File Organization and File Processing". This is a true gem in the computer literature, but you do not find sample code.

It's a very good book, and it covers a very rare topic (I actually don't know of any other similar book--you'd have to hit database-specific sources to get this kind of info.) I haven't touched the code in it, though, so it's possible there are errors, but the conceptual and algorithmic wealth that's contained in the book makes it worth the price (twice over, actually.) So, the reviews are probably correct, but unduly harsh in their criticism, and unfair in stressing some relatively unimportant weaknesses (potentially--I haven't used the code) over the huge overall usefulness of this work. What sucks about it is that bookpool.com doesn't carry it, and therefore you'll have to pay pretty much the sticker price <g>. Still it's worth, I think.

This text was used for a junior-level File Manipulation Techniques course. We skipped around quite a bit in this book and did not use any of the C++/Unix material. I think (and I'm sure my professor does) that this book could be stripped down a quite a bit to present more topics when used for the classroom. What is presented is done well. This is a well-rounded text that should appeal to students and professionals alike. However, from the student's perspective, there is a lot of superfluous material. It is still one of the best, if not then it is the best, book on file structures and algorithms.

The programs for class were in Visual Basic .NET . It was not hard to adapt sections from the text when writing programs for a different language.

Our class moved through the book as follows: chapters 1-4 (introduction to external storage, files of records); start of chapter 8 (cosequential processes); chapters 5 and 6 (record access, insertion and deletion); end of chapter 8 (sorting large files); chapter 11 (hashing); chapter 7 and 9 (indexing and B-trees).

Once I was able to figure out what I could skip and what was important, I was able to read the chapters quickly and understand the material without a lot of re-reading. This book shed new light on an area of computer science that I didn't know much about. After taking the class/reading the book, I feel that I understand well what was being taught. I would still recommend this book to students because there is nothing else quite as up-to-date and it is quite easy to read and learn from.

Have you ever wondered how that database you bought works way down in the basement? This book is the place to find out as far as the actual storage on disk is concerned. The book is well-written and well-equipped with glossaries and summaries. Also of note is that the authors make good use of the facilities of C++ for implementing object-oriented access to the file structures. Frankly, I don't expect to actually apply anything I've read in this book in practice. Nevertheless, it was well worth reading -- and in case I need to implement file structures myself, I know where to find the details.

I find the book to present excellent concepts. The method to be used on analysis of file structure problems is explained in great detail.

The examples, though, need some rework. There are some errors (not a lot though). With just a few changes, I was able to run and use the code, without any problems. The criticism here seems unjust: following Comer in his book Internetworking (, in which he codes XINU, which I typed in completely and which compiled and ran flawlessly the first time around), I have never found code in books to be without errors of some kind.

Another point is, that the modelling methods used for the OO part just might be out-dated. As far as I could see, no specific method was used, neither OMT, UML nor software patterns. I'm not an expert in this field though.

A BUY, if you're willing to hack some of the code.

If you need a book that just covers the concepts, this will do the job well... I used this book in a File Processing Class, and found it was not bad, but I did have to use other sources to actually code the different concepts. Of course this is to be expected unless you use the exact same compiler that the author uses, and since C++ is still "new", even version changes might leave the authors coding examples obsolete...

In summary, a good reference book for the concepts, but don't buy it if your looking for concrete examples of the actual code. (In fairness, for me, once I learned the concept, it was not hard to actually program it)..

While the book may have been a reference in the past, it is not aging well. Reference to telephone switch operator in the first chapter set the tone. Programs viewed as only processing ins and outs of bytes stream continues it. The time spent on tape or thinking that hundred of MB of data is a lot keep on the same trend. Flash, a complete departure for sequential-access magnetic storage, is of course not covered. Distributed storage in the cloud... how could they have even thought than someone would need a file system for that?

Yes, there are useful things like B+ Tree which were relevant 10 years before the book was published and remain relevant now 10 years after. But in general, much has aged poorly in this book.

Sadly, I am yet to find a 2011-modern book on file systems.

great book about file structures, covers everything you need to know from hard drive activity to file indexing with bynary trees and hashtables