5 comments about How Computer Programming Works (Technology in Action Series).

1. Not when the illustrations are as poorly drawn and pointless as these. eg people staring at computers, sweeping arrows with colored blends, or pointing hands (proving, yes they are hard to draw!). I can however follow the reasoning.
   
   This is yet another programmer who has trouble explaining the jargon but has noticed books that do a good job of being user friendly, have pictures. I found this book to be just like those inane PowerPoint presentations that middle executives think expresses the right side of their brain. A right side that seems to be made of cheap PC clip art.
   
   It doesn't help every time the book gets to a core idea, that it glosses over it as if it is obvious, without explaining the detail. Nor that on top of the meaningless graphics, the book is full of DTP blunders that obviously nobody has checked. Such as text set in fonts with mismatching encodings, resulting in strange accented characters being substituted for whatever the author intended.
   
   Why do programmers have such difficulty producing clear, sequential, logical and carefully crafted expression, that has been checked for errors?
   
   I thought that was their job.



2. The other reviewers here that reference their 13 year olds enjoying this book are absolutely right. This book is for 13 year olds. As a 25 year old trying to wrap his mind around programming, it leaves much to be desired.
   
   If all you want is a gloss-over for someone who has no intention to continue in the field of programming, but just wants a non-programmers understanding of programming, this book is for you. If you want something you can take with you on a journey into real programming, you will have to really dig deep to distill the few morsels of theory offered here. In fact I had to reread most paragraphs dozens of times in order to find the underlying concept he was trying to teach; to find something that would still be useful to me after finishing the book.
   
   Bottomline: A waste of time if you are out of high school and attempting to truly learn something about programming. Take a few minutes to skim thru the pictures at your local bookstore, then go buy a real programming book.



3. I bought this book based on the reviews. It was for my 11-year old son who is a whiz working with computers and wants to learn more so he can eventually start programming. I have been writing software for 20 years and find it difficult to make my knowledge and understanding relevant to someone so young. I don't want to dash his enthusiasm with too much technical jargon, yet he should learn enough to get curious and start tinkering with confidence.
   
   This book was not relevant for him. He's a pretty smart kid for 11, but the references in this book are for adults. It will bore a kid under 18.
   
   On the other hand, this book will probably be pretty good for an adult wanting to learn how computers work.
   
   I don't want to blame the writer since he never said this book was written for kids, but it's tough to rate it higher since the book now sits on the shelf.
   
   By the way, if you've gotten this far in this review, then you might know or have a youngster (isn't that an old-foggey word?) who wants to know more about computers. When kids have fun learning, they stay interested. With this in mind, a fun book to learn about computers is, surprisingly, "Head First HTML" by Elizabeth and Eric Freeman. By taking a fun approach to learning how to make web pages kids are introduced to programming.
   
   It's also an enjoyable book for adults.



4. I bought this book and felt disappointed.
   
   I think it's a wrong decision of me not carefully looking into the index portion to check my expectation. It is also a result from Amazon side, only a portion of chapter one, not revealing enough examples for readers to judge.
   
   It's a general introduction of some basic "ideas" about programming. It focuses on one idea per chapter. The illustrations are indeed very good to demonstrate those ideas. The whole book is like a delighted lemon juice, with very thin content.
   
   But, I feel the whole book best serves the teens as an introduction book about programming. If an amateur has a clear intention to head into the world of computer software, this is not a good entry book. He'd better consider other books and don't waste time on this one. This is just suitable for those whose time is free and ease.
   
   By the way, I feel not worthy to return this book because of the shipping fee. So, I decided to keep it for my son to minimize the waste.



5. "How Computer Programming Works" offers a useful compilation of major Computer Science topics. The artwork, spread liberally though this book, is generally quite useful and offers some unique insights into certain topics, but is at times overdone.
   
   Daniel Appleman has done a good job of condensing many of the major topical areas and themes in the field of Computer Science in fewer than 250 pages.
   
   For anyone with more than a peripheral knowledge of Computer Science and computing in general, but with a lack of formal Computer Science education or training, this is a book worth reading. It can serve as a launching point for more in-depth and detailed coverage of the topics addressed in the book.
   
   I recommend this book...especially to the reader segment mentioned above.

5 comments about An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens' Open Source Series).

1. I am extremely impressed by this book - not only does it provide excellent information on design patterns, and using Qt 4, but its written so that those new to C++ and Qt can understand and progress throughout. This book is heft, but extremely informative, and I would recommend it to anyone interested in C++ development!



2. If Qt is what you are interested in, go to trolltechs website or another online resource and don't waste you money on this book. The book is not very well laid out, the exercises are ambiguous and you have to work on the example code to get them to work. Although a lot of material is covered, the coverage of certain topics is barely adequate, although they do supply information on where you can get additional information.



3. The book is an easy read and has good examples, but unless you already know how to use Xcode or have KDE on your Mac this book is not for you, because you will find that the build instructions found in the book do not work in Mac OS X. Has anyone tested them on Unix or with KDE? I can only assume that they work there.
   
   Qt4 is not compatible with Xcode. (It is not possible to display Qt4 Objects like QString in the Xcode debugger. This used to work with Qt3, but was lost in Qt4.) While this is not the book's fault, it makes it very difficult to step through the examples or debug your own coding efforts in the exercises.
   
   I like the way the book introduces topics a chapter or two before going into detail. Also, the book makes an effort to reinforce what was learned in previous sections and chapters, making it a very good learning tool for anyone new to the topic.



4. This is a very good good which teaches you C++, Qt and design patterns.
   
   I am surprised by the commentaries saying this is not an introductory book. Quite the opposite: this is the perfect book if you do not know any one of Qt, C++ or design patterns but you want to use them together.
   
   Some may say the book worries too much about syntax. Wrong. The authors want to make sure you understand C++ perfectly well because subtle differences (such as the 'static in declaration' vs 'static in definition', introduced in chapter 2) may have devastating effects in your software. The same goes for Qt macros: the book explains them because when you know and understand them, you will write better code; the book by Blanchette and Summerfield barely names them.
   
   As the title says, this book is only an introduction. There are three natural companions you should get if you want to delve deeper in the wonderful world of Qt and design patterns:
   * A Complete Guide to Programming in C++ by Prinz and Prinz
   * C++ GUI programming with Qt by Blanchette and Summerfield
   * Design Patterns: Elements of Reusable Object-Oriented Software by Gamma et al.



5. I don't major in CS but I have to use C++ and QT for my PhD research. Although I had pretty good general understanding of IT and some experience in web programming, I struggled to teach myself C++ from scratch. I tried a few popular books, but none of them worked very well. As someone said, "the trouble with C++ is there's an awful lot to remember". Those big thick books are often quite easy to follow from page to page, but very quickly all the details become overwhelming. C++ is a powerful and flexible language that incorporates different paradigms so there're always many different ways of doing things but quite often (particularly for beginners) we only need to know the best practices. As Bjarne suggests: "A focus on details can be very distracting and lead to poor use of the language. You wouldn't try to learn a foreign language from a dictionary and grammar, would you?" (http://www.research.att.com/~bs/learn.html). Ironically, most of the big books I read did exactly the same for me. They all tend to provide too many details upfront. You could end up reading 500 pages but still don't have a clue what's the correct way of programming in C++. Plus you'll probably forget what read before...
   
   
   
   I felt a great relief when I came across this book. I would say the authors have done a marvellous job. From the very beginning they teach you how to program in the C++ way, more precisely in the Qt way. The book suggests Qt coding style is not "pure" C++ but that's a different story. By throwing away all the irrelevant bits, they give you a good idea of the whole picture so that you'll be on the right track very quickly. Then you can let you knowledge grow by accumulating more technical details - it's just a matter of time and practice. Of course, a big thick book is still needed as reference. If you don't know anything about programming, I would suggest you read the first few chapters of one of the primers, then switched to this book. I feel it still requires some basic programming background.
   
   
   
   I would definitely give it a five star and recommend to anyone learning Qt

5 comments about Building Automated Trading Systems: With an Introduction to Visual C++.NET 2005 (Financial Market Technology).

1. Unlike some other comments about this book, the intended readers are serious developers who have not started or just begining to use .Net 2005 framework. That is why some readers do not like this book.
   
   A pure programmer do not need to read this book.
   A pure quant strategist do not need this book.
   A network specialist do not need this book.
   
   It is only good for the intended readers.



2. I wish there was slightly more explanation of the code. 1 small paragraph doesnt cut it for me. I have ran the code merely as a puppet of the author and really dont 100% get a grasp on it. I dont think this book is for beginners, you should have a decent knowlege of c++ (pointers especially) already before getting into this book. The ony intro involved in this book is a slight .net informational. Title should be "Building Automated Trading Systems with Visual C++ .NET 2005, featuring slight intro to .NET framework". Probably an awesome book for people w/ good working knowledge of c++ and want to tie in with .net and financial systems programming. I have put the book down for now and am going to hit the programming gym before I pick it back up. Maybe I will make a follow up post at that point.



3. If you want a very practical introduction on how to design and implement your first trading system, this book is for you.
   The initial chapters cover all the C++/CLI concepts needed to understand the detailed case studies of two actual trading systems. The reader is assumed to have some general understanding of OO languages, preferably C++.
   
   Be realistic. As the author points out in the book, the algorithms driving these trading systems are well known, so they probably will not make you a millionaire. But the software included with the book will give you a head start to try out your own ideas in a simulated environment.
   
   People interested in running a hedge fund are advised to read the chapter on development methodology. It will help you get a handle on the software development side of the business.



4. Hands down this is the most useful financial-programming guide on the market. I would question the capabilities or intellectual capacity of any person who thinks anything less.
   
   Step-by-step, it shows the user how to take the concepts of object-oriented programming and apply it directly to the financial markets, ultimately yielding an automated-trading system designed to trade futures through Trading Technologies' XT_API.
   
   The book is thorough, yet simple to follow, descriptive, but not drawn out.



5. Waste of paper.
   I've started reading this book a few times but find myself paging through it trying to find something worth reading.
   As an introduction to Visual C++ .NET it might be useful but most chapters cover the matters in about two pages and I have a sneaking suspicion this is just a copy of MSDN with new code examples.
   As for Automated Trading systems it has about 10-15 pages on the subject and of that probably 8 are just code (could have been omitted and just put on the CD).
   If you don't have access to the internet this book will come in handy. Otherwise go for Practical .NET for the financial markets instead.

No comments about Cocoa Design Patterns (Developer's Library).

2 comments about PCI Compliance: Understand and Implement Effective PCI Data Security Standard Compliance.

1. When I first received this book from Syngress I was very excited. I knew nothing about PCI compliance -- other than it was big ticket item and everyone processing Visa transactions was affected in some way because of it. I can honestly say that I tore through this book and didn't put it down until I reached chapter 13. I was completely wrapped up in it as it was something I knew nothing about and wanted to know more!
   
   Chapters 1 through 3 introduce you to the concepts behind PCI compliance including what it is and who needs to comply. These chapters really set the stage for what the rest of the book has to offer the reader.
   
   Chapter 4 provides a technology overview of firewalls, intrusion systems, antivirus solutions, and common system default settings. Personally I felt that Chapter 4 was filler content just to add a chapter. It may, however, serve as a good reference for those in management roles who do not have "hands-on" interaction with the architecture of their environment.
   
   Chapter 5 explains how to go about protecting your cardholder data as dictated by PCI requirements 3 & 4. This is a great chapter for anyone new to securing infrastructure to meet the requirements of a PCI audit. The authors also provide a fantastic section entitled "The Absolute Essentials" which offers suggestions on the minimum protection you can employ to protect your cardholder data.
   
   Chapter 6 was by far my most favorite chapter and Syngress has offered it as a free download from their website. Many of you know what I do for a living and know how important understanding logging and requirements for logging is for my day-to-day duties. This chapter focuses around PCI Requirement 10 which details how you must handle the log data collected in your PCI environment. As soon as I started reading this chapter I knew that Dr. Anton Chuvakin had written this section of the book, or at least had a heavy insight into its direction. This chapter alone makes the book worth its weight in gold.
   
   Chapter 7 details the importance of access control in your PCI environment. For obvious reasons, access to your cardholder data must be recorded and checked with a fine tooth comb. User privileges, authentication, authorization, and user education is also covered in this chapter. This chapter goes further to provide examples of ensuring your Windows, Unix/Linux, and Cisco infrastructure meet PCI requirements.
   
   Chapter 8 explains how to leverage vulnerability management solutions to meet the requirements outlined in sections 5, 6, and 11 of the PCI requirement. The authors also provide two very good case studies to help the reader put things into perspective.
   
   Chapter 9 focusses on the monitoring and testing of your environment. The authors are quick to point out that monitoring and testing must continue even after the audit in order to ensure you remain compliant.
   
   Chapter 10 details how to drive your PCI project from the business side in order to ensure you accomplish your objectives. Suggestions are provided on budgeting time and resources, keeping staff in the loop, and justifying the business case to your executive team. The authors also offer a step-by-step "checklist" for ensuring your project runs smoothly and that all of your bases are covered.
   
   Chapter 11 explains the various responsibilities within the organization for ensuring the PCI project succeeds. One of the key things to take away from this chapter is the role of the Incident Response team and its need to understand the requirements of PCI compliance.
   
   Chapter 12 is a really good "eye-opener" that prepares you for the failure of your first audit. The key thing to take away from this is chapter is to not blame the auditor the same way you shouldn't blame a referee in sports. They're simply there to do their job to the best of their ability. If you have a problem with the way they are doing their job, bring it up with their superior. Perhaps their decision will get overturned?
   
   Chapter 13 brings you into a "OK, now what?" phase. This chapter provides a detailed overview of the various requirements and breaks each requirement into "Policy Checks" and "Hands-on Assessments" sections. The policy checks discuss policies that should be reviewed to verify that they are up-to-date and the hands-on assessments sections give ideas on testing these policies. The beauty part is that the authors suggest open source solutions to help you protect your PCI compliant investment.
   
   I give this book 5 stars as it is the best PCI reference I have found on the market. Everything I found in this book will allow me to understand the compliance requirements of my existing customers, their process, and their overall goals. Hats off to the entire team of authors.



2. It has long been rumored that manufacturers of items such as razors and batteries specifically produce their products an inferior level in order to ensure repeat business. A similar paradox is occurring in the information security space where many are complaining that the PCI Data Security Standard (PCI DSS) is too complex and costly. What is most troubling is that such opinions are being written in periodicals and by people that should know better.
   
   PCI came to life when Visa, MasterCard, American Express, Diner's Club, Discover, and JCB collaborated to create a new set of standards to deal with credit card fraud. PCI requires that all merchants and service providers that handle, transmit, store or process information concerning any of these cards, or related card data, be required to be compliant with the PCI DSS. If they are not compliant, they can face monetary penalties and/or have their card processing privileges terminated by the credit card issuers.
   
   The primary purpose of PCI is to force organizations to embrace common security controls to protect credit card data and reduce fraud and theft. The following are the six primary control areas and 12 specific requirements of the PCI DSS:
   Build and maintain a secure network
   1. Install and maintain firewall configurations
   2. Do not use vendor-supplied or default passwords
   
   Protect cardholder data
   3. Protect stored data
   4. Encrypt transmissions of cardholder data across public networks
   
   Maintain a vulnerability management program
   5. Use and regularly update anti-virus software
   6. Develop and maintain secure systems and applications
   
   
   Implement Strong Access Control Measures
   7. Restrict access to need-to-know
   8. Assign unique IDs to each person with computer access
   9. Restrict physical access to cardholder data
   
   Regularly monitor and test networks
   10. Monitor and track all access to network resources and cardholder data
   11. Regularly test security systems and processes
   
   Maintain an information security policy
   12. Maintain a policy that addresses information security
   
   A quick review of these 12 items shows that PCI is a textbook example of the fundamentals of information security. With that, PCI Compliance: Understand and Implement Effective PCI Data Security Standard Compliance is an excellent resource that provides the reader with all of the fundamental information needed to understand and implement PCI DSS.
   
   The books 13 chapters provide the reader with a comprehensive overview of all of the details and requirements of PCI. The first three chapters provide an overview of the basics about PCI and the basic requirements of the standard. The following six chapters go into detail about each of the primary control areas.
   
   In particular, chapter 6 provides a good overview of the PCI logging requirements. This requirement can be time-consuming to put into place. The author notes that a commonly overlooked but essential requirement, namely that of accurate and synchronized time on network devices. Enterprise information network and security infrastructure devices are highly dependent on synchronized time and PCI recognizes that correct time is critical for transactions across a network.
   
   In a further discussion about synchronized time in chapter 9, the author unfortunately makes an error when he states that local hardware is considered a stratum 1 time source since it gets its time from its own CMOS. From an NTP perspective, only a device that is directly linked to a stratum-0 device is called a stratum-1. CMOS clocks are notoriously inaccurate and can't be relied upon.
   
   The title of chapter 12 is both amusing and accurate `Planning to fail your first Audit'. The irony is that so many organizations lack a CISO or formal business security program in place designed to protect corporate information assets. They don't focus on information security as a process, rather as a set of products or regulatory items to be checked-off. Yet, these same organizations are surprised when they fail an audit.
   
   The book concludes in chapter 13 with the well-known observation that security is a process, not an event. The book astutely notes that it is impossible to be PCI compliant without approaching security as a process. Trying to achieve compliance without integrating the various aspects in an integrated fashion is bound to fail.
   
   Overall, PCI Compliance: Understand and Implement Effective PCI Data Security Standard Compliance is a great book for one of the most sensible security standards ever. Anyone who has PCI responsibilities or wants to gain a quick understanding of the PCI DSS requirements will find the book to be quite valuable.

3 comments about Introduction to Programming in Java: An Interdisciplinary Approach.

1. Undoubtedly the finest computer science book published to date. This will be the standard for years to come.



2. This is the only textbook that really helped me understand programming in Java - I was so glad to find it!



3. Truly an excellent book: well-written, clear, and very interesting (unusual for a cs textbook). This book is a great introduction to programming, but also to the field of computer science, and is full of exciting examples of applications to problems in other fields, including physics and genomics. A real gem!

4 comments about Java Messaging (Programming Series).

1. As we look at how much we use the web, it is sometimes hard to remember just how new this concept of worldwide packet switching really is. Java was started as a new language before a lot of the new concepts like XML and SOAP were conceived. But as a new language it has been able to move into using these new concepts faster than nearly any other language.
   
   What I especially liked about this book was the first chapter. So often computer books start with programming. This one starts with a description of what we're trying to do here. He gives several examples of the types of communications that he is going to cover in the book. I had a particular application in mind when I got the book, but in reading the first chapter I began to see several other ways that messaging would help our system.
   
   After the first chapter, I've go to say that it's a pretty regular computer software book. It tells you how to do the things that you want to do. It is quite clear on all the different software protocols, packages, and philosophies. Basically it is all that a Java programmer needs to implement messaging in Java.
   
   The CD included with the book gives you all the sample code from the book, as well as the complete messaging toolkit and several open source tools.



2. Eric Bruno's JAVA MESSAGING explores different ways of messaging using Java software, from JavaBean events and JMS to SOAP. Web programmers receive all the basics to using these features, tips on how and why to use each feature and when to choose something else, how to combine features, and more. The basics of Java communication processes are revealed in chapters which form 'classes' to link related information in a logical progression. An excellent, basic foundation for Java users.



3. Excellent introduction to messaging, including healthy portions on JMS and web services.
   
   The writing style is clear, consistent, and to the point. Probably what I liked most was this no-nonsense writing style. If it's on a page, it's important to understand. The author doesn't waste your time with irrelevant discussions or out of scope topics.
   
   Editing and code presentation are top notch, making it easy to follow, and build upon from one example to the next. The author also shares some gotchas and considerations that I wouldn't have expected to see in an introductory discussion which were particularly valuable.
   
   Another great feature is one of the drawbacks of the book. The framework presented in the book is elegant, but in many of the examples, there is too much cognitive overhead involved in grokking the level of abstraction in the framework, and this takes away from actually learning the concepts. I would have liked to see more non-framework code for the introduction, which is then tied together with the framework.



4. Although the book uses a specific JMS engine for the examples the details and the concepts were all right on and covered everything I needed for JMS. It literally saved my bacon, especially the peer to peer stuff over topics. Whew!
   
   Super job.
   
   Sam

5 comments about Debugging.

1. This Book Demonstrates How you could debug SOMETHING systematically, from most important principle to least important principle.(All 9 As the Book name said.) The Examples covers software, hardware, electrical, mechanical debugging. It is just amusement to read the example. HIGHLY RECOMMENDED.



2. This book is absolutely indispensable for anyone working in any job where things occasionally work in an unexpected manner. It's concise, funny, well-written, and full of immensely useful tips on how to go about debugging problems.
   
   One of the great things about this book is that it's generalistic in nature, not specific. Agans's decades of troubleshooting experience has given him great insight on how to go about debugging in all sorts of environments, so he lays out nine rules for approaching any problem:
   
   Understand the System
   Make it Fail
   Quit Thinking and Look
   Divide and Conquer
   Change One Thing at a Time
   Keep an Audit Trail
   Check the Plug
   Get a Fresh View
   If You Didn't Fix It, It Ain't Fixed
   
   [...]
   
   Debugging isn't an art performed only by folks with some odd genetic disposition, it's a critical craft which can and must be learned. I was fortunate to have some good troubleshooters as mentors during my days working radar inflight in the Air Force, but I've fallen out of many of the good practices those folks beat^H^H^H^Hinstilled in me. Agans's book is helping me pull out of the thrash and churn mode of debugging.
   
   This book's only 175 or so pages long and is well-worth adding to your library. Actually, substitute "a critical addition" for "well worth adding". I'm also going to make sure this book gets added to the professional development reading list I'm working on creating.



3. I worked with Dave Agans for over 10 years and I can tell you first hand the man knows what he's talking about. From developing hand-held controllers in the late eighties to single-board OS/2-based videoconferencing products to software collaboration tools, we have debugged problems of every ilk. Whether the problem was an FPGA bug, a faulty component in a board, a race condition in a device driver or a dangling pointer in a DLL, Dave always approached the problem with his same set of debugging rules, and they never let him down. Read this book. It's engaging and fun to read. But more importantly it will make you a better debugger, whether you're debugging hardware, software or your lawnmower.



4. Quite liked it. I now have a game plan for approaching bugs in a nonrandom manner (including intermittent bugs):
   
   
   Understand the System
   - Read all related documentation
   - Draw a system diagram and understand how things are connected
   - Know the capabilities of your debugging tools
   
   
   Make It Fail
   - Start from a clean initial state
   - Consider automating lengthy steps
   - Make it fail in situ; don't waste time simulating the environment
   - For intermittent bugs: list possible factors and try varying them one at a time; output a logfile and look for patterns
   
   
   Quit Thinking and Look
   - Watch it fail
   - Use Remote Desktop / VNC
   - Add logging and monitors
   - Don't start thinking until you've limited the number of possible causes
   
   
   Divide and Conquer
   - Binary search
   - Use test data with an easily identifiable pattern
   - Start at the failure point and work backwards
   - If you discover other bugs that may be related, fix them before continuing your search
   
   
   Change One Thing at a Time
   - Don't panic
   - Back out changes that have no effect
   - Compare the logfile with that of a good system
   - Check earlier versions
   
   
   Keep an Audit Trail
   - Keep a detailed written log
   
   
   Check the Plug
   - D'oh!
   - Have the components been properly initialized?
   
   
   Get a Fresh View
   - Try explaining the problem to someone (or something)
   - Ask an expert: co-workers, the vendor, documentation, bug database, the web
   - Report symptoms (including possibly unrelated observations), but not your theories
   
   
   If You Didn't Fix It, It Ain't Fixed
   - Fix the root cause
   - Make the problem happen again by undoing your fix



5. This is an excellent book on debugging. Whether you're debugging mechanical systems, electrical circuits, or software, the methodology presented is extremely practical and systematic. The author presents nine debugging rules that can be applied to any problem. The text is well-written, engaging, and humorous. The author also included a wealth of war stories that are worth the price alone. Highly recommended.

5 comments about Advanced Compiler Design and Implementation.

1. Ok, let's be fair. This book provides a broad coverage of useful optimizations and it will be useful in case you work writing compilers AND have some experience.
   
   However, for learning the concepts, it is a very bad material. At the end you end up confused under a pile of thousands of lines of pseudocode in a weird notation (invented by the author) called "I CAN" (yes you can write a very bad book Mr. Muchnick) instead of reading useful explanations of the topics. The author also assumes that you already know some concepts and that's why he does not explain them as he should. If you want to really understand this book, first review Chapter 10 of the Dragon Book. I thought that the Dragon book was not so good because you have to re read some things in order to fully understand, but with Muchnick's book that is not always possible.
   
   You can also take a look at Morgan's book (unfortunately, out of print) or just read the papers (as the first reviewer suggested). This book is not enough, and sadly, a lot of "teachers" think of it as a kind of "bible" and as a very bad excuse to teach very poorly. Some of them even don't master all the concepts presented there and have to use other books (their "dirty little secret") but they don't tell you which ones and continue praising this bad piece of work. If you are a CS student who really wants to learn, be warned that this book is not for you (it has at least three erratas and still has errors!)



2. I've seen chapter 14 of this book referenced (by a university professor giving suggestion to his students, not by a random guy) as:
   
   "Another conventional approach to strength reduction. 35 pages of the same kind of confusing crap we've all come to expect from this book."
   
   This could not sum it up better. A confusing book at best, presenting basic material so as to make it look "advanced", and without any covering of even relatively new techniques. A good source of references to papers that you should read, but not at all a valid reference on its own.



3. Compiler development is more of a craft than a science, although there's plenty of science involved. It involves huge numbers of tradeoffs in features, optimizations, and use of the underlying processor. But, as long as people keep coming up with new computing platforms (and not just instruction set processors), new languages, and new performance demands there will always be need for new compiler developers. If you can't apprentice yourself to masters of the craft, or even if you can, this book is a great introduction 2000-era compiler development.
   
   Muchnik does a clear, thorough job of laying out the basics, starting with the intermediate representation used. (If you get that wrong, nothing else is going to work.) He then moves on to the basics of symbol table structure - an issue that can get immensely complicated in systems like Microsoft's CLR. He also discusses run time support briefly. Although that discussion is good as far as it goes, it skips past a lot of the complexities of dynamic loading, debug symbol tables, simulation support, and related issues. They aren't strictly part of the compiled, executable code, but responsibilities of the compiler developer nonetheless. Next comes a brief description of code generation, crucial in normal environments but tangential to my own needs.
   
   That's just the first quarter of the book, though. The rest is the real meat of the topic: code analysis and optimization techniques, over 600 pages of discussion. It's way too much to summarize here, but even that just an introduction to a huge technology. Still, you have to start somewhere.
   
   By this point, you may be asking "But what about tokens, lexemes, and grammars? Isn't that what compilers do?" Well, yes, but it's done. Tool developers have made lexical analysis a commodity. The easily automated tasks are not where modern compiler distinguishes itself. This book addresses the semantic levels, getting the reader into the shallow end of the industry's huge pool of specialized compilation knowledge.
   
   If you have to self-teach compiler development - good luck. Start here, though, and luck will have a lot less to do with the outcome.
   
   //wiredweird



4. It's the bible of compiler data-flow analysis. The author had the experience of building an industrial strength compiler. One tip: skip books authored by those who haven't implemented an industrial strength compiler by themself.



5. This is a very good intermediate/advanced text for codegen & optimization.
   
   Having spent nearly 15 years working on compiler development, with most of it spent on codegen & optimization in compiler backends, I was very happy to see this book published ten years ago when I was relatively new to the field and hungry for more information.
   
   The good: Coverage of many important topics, and a better discussion of the phase ordering issues than I've seen in other texts.
   
   The bad: The writing style is okay, but not great. Little insight is typically given for the problems discussed. A very annoying aspect of the book is that the author sometimes goes into great detail about one technique, and then later mentions another (often superior, IMO) way to solve the problem at hand, without going into much detail. As a working compiler writer, I would have preferred it be the other way around.
   
   The very very bad: The ICAN notation used throughout the book is verbose, unintuitive, and ultimately takes away from the presentation. Compare the complicated detail-filled ICAN listings in this book to the simple, elegant algorithms in the Dragon Book or Cooper/Torczon's text.

2 comments about Computer Science: A Structured Programming Approach Using C (3rd Edition).

1. I am a new beginner for learning the C programming, and this is
   our textbook. It's really helpful. I'll recommend it to others.
   BTW, the condition of the book is not so good as what I expected.
   Looks like a used one. That is the only thing I am not so satisfied.



2. If you want to learn C, this book might eventually get you there, but it felt pretty fluffy. 1000+ pages is a little much for such a simple language as C.
   
   I also was floored to see code samples in the book that have syntax errors and don't compile.