<< 1 >>
Rating: 
Summary: Good book!
Review: Apart from a solid introduction into writing more efficient code, this book covers mostly advanced topics. However, I found these were explained very clearly, with plenty of programming examples given in the text making it surprisingly easy to follow. I would certainly suggest picking up this book if you want to know more about optimized programming, or if you just need a quick reference to, say; speedy sorting techniques, efficient storage structures, pattern matching or intelligent IO.Beware though, this is not a C++ tutorial. For that you will have to go elsewhere. But if you are able to write programs a little more complicated than 'hello world' on your own, then you are already ready for the next step in your education. This book will advance your c++ programming skills a good many more levels.
Rating: 
Summary: My Take
Review: Bascially this book does a good job of showing you what's going on behind the scenes when your compiler turns your source-code into a program. And what can go wrong, read: end up being wildly inefficient. The cool thing is, the book not only shows you how to optimize your programmes but also explains exactly when and why certain solutions can enhance your software's performance. I feel I have really gained much needed insight, which makes it possible for me to work out my own solutions to problems concerning stack frames, multitasking, data processing, parsing and so on. And helps me in finding those bugs that seem invisible because they have crept deep into the architecture.
Rating:
Summary: Examine performance implications of programming decisions
Review: Concentrates on a broad range of performance optimization techniques. The author strikes a nice balance between programming in-the-large and programming in-the-small techniques. The programming in-the-large chapters discuss language selection (assembly, C, C++, Pascal, Visual Basic, or Java), O notation, memory managers, string searching, sorting, and data structures (arrays, linked lists, hash tables, binary trees, and red/black trees). Includes a lucid analysis of memory managers. Programming in-the-small issues are variable types, variable scope, variable initialization, structures, bit fields, unions, selectors, jump tables, loops, invoking functions, macros, inline functions, iteration vs. recursion, pass by reference vs. pass by value, global data, virtual functions, and templates. Excellent set of charts containing timing comparisons of the various techniques. The source code is available from the publishers web site. There are several lapses in this text. All of the timing charts for comparing the various techniques should have been printed in the book. The third section of the book on avoiding C traps and pitfalls is off topic. Programming in-the-small optimization techniques are not covered comprehensively. One glaring omission is the technique of using a sentinel element as a loop termination signal. The author does not provide a bibliography or references to standard industry texts. At a minimum the sorting and string searching sections should have referenced Donald Knuth's "The Art of Computer Programming: Sorting and Searching, Vol. 3" and Dan Gusfield's "Algorithms on Strings, Trees, and Sequences: Computer Science and Computational Biology".
Rating: 
Summary: Great outline, no substance
Review: I kept looking at the heading of a section and going "yah this will be good" but when I read it, it said nothing that was not common knowledge of first year university.
Rating:
Summary: Great outline, no substance
Review: I kept looking at the heading of a section and going "yah this will be good" but when I read it, it said nothing that was not common knowledge of first year university.
Rating:
Summary: A different approach to C++ programming...
Review: Let me start off by saying that this book contains a wealth of information for the professional programmer. The reason I found this book so useful is probably because the authors took a very different approach to writing about C/C++ programming than other books currently available. Instead of showing some tips and tricks on isolated subjects (or giving mere functional descriptions of language components) this book actually focuses on the practical problems that C++ developers have run into when writing professional software. Think for instance of coping with changing system requirements, updating existing software projects, UI design, using external devices, design trade-offs between flexibility and performance, prototyping and setting and evaluating performance targets. The way Footprint and Performance deals with these subjects makes it as much a book for software designers and architects, as programmers. Though parts of the book contain essential background theory which you can read sitting comfortably on your couch, the technical parts have you experimenting with example code behind your PC. The examples help you master topics that should be part of the standard skill package of every programmer, such as: multithreading, callback functions, input file parsing, data block pattern matching, memory usage strategy, sorting user data types and so on. Footprint and Performance clearly aims to make its readers all-round software engineers by letting them benefit from the authors extensive experience in the field of professional C++ programming. In that respect the title could perhaps have been chosen better. Though the book elaborates in depth on performance issues related to data type design and access, and implementation issues, it has far more to offer than the title implies. So is this book readable then? I can answer yes to that question without prejudice. What I noticed particularly was how the authors were able to maintain the same clear and easy to read approach to the complex subjects as to the simpler ones. No small feat given the subjects the book deals with.
Rating:
Summary: Very good for non-pros
Review: Other reviews mentioned that this is not a book for advanced people. That's true. It was very helpful to me, however. I did some C++ and application development in high school, but put it away and didn't think about it much. Now when it came time to perform a computationally-intensive simulation, I found myself with pretty vague knowledge of C++, and how it actually works. This book was exactly at the right level for me. It's a bridge between beginner and intermediate/advanced. Lots of good practical knowledge. Professional yet comprehensible writing style.
Rating:
Summary: Not enough substance
Review: The book is well written but there is not enough facts. Not enough meat for your money.
The chapter on compilers and profilers is very weak. It talks about the Gnu C++ compiler and mentions MS Visual C++ in short. The Intel compiler is not mentioned even though it is probably the most optimizing compiler for Intel and AMD processors. VTune code analyzer and profiler is the best tool available for measuring code performance and reveil processor stalls. It is not mentioned.
Performance of different datatypes is handled in 1/3 page and it concludes that integer computations are faster than floating point computations and should be used where ever possible ! "So, to judge whether to replace floats and doubles with integers, an implementer must determine how often the different arithmetic functions are likely to be used" !!. In my world integer and floating point numbers are two entirely different things.
The chapter about sorting algorithms contains nothing else than any other book on the subject. The O notation is the only thing regarding algorithm performance. The entire chapter looks like something that is thrown in to give the book a little thickness.
There is no information on modern processors. Data caching and optimizations on it is explained in one page. No such thing as level 1, level 2 caches or cache line splits are mentioned.
Who cares about printf and putc performance these days.
The book contains little that could not be found out doing a little timing on a few basic codesnippets by yourself. A lot of easy going language is used - walking carefully around substance without touching it.
The book can serve as a ligth introduction on code performance for beginning SW developers - nothing else.
Rating:
Summary: Not just optimization
Review: This is a very practical book; all concepts are supported by several concise example programs (most of which evolve in seperate steps to clearly highlight what is being explained.) and the layout is wonderfully accesible, e.g., text, source code and output etc. The authors have really gone beyond the quality of similar books on the market by providing an amount of detail above that of introductory text, which makes it benefitial to professionals as well as students. Apart from covering performance and footprint related topics, this books contains a wealth of c++ "should know"s and "do's and don't"s.From multitasking techniques, text parsing and UI design to better understanding of c++ language concepts. In this respect the title really runs short of describing the book's actual content.
Rating: 
Summary: Where is the EDITORIAL REVIVEW ?
Review: Why is there NO EDITORIAL REVIVEW for this book? How can a potential customer who is searching Amazon.com knows what this book covers? It is such a waste when the authors or publishing company spent a lot of money to develop the book but forgot to write an Editorial Review when posted it on the net!
<< 1 >>
|
