5 comments about Expert C Programming.

1. What an amazing book. Who better to write about the subtle nuances of C programming than a man that wrote a compiler? This book is not an introduction (if you couldn't tell by the name), nor is it a place for quick tips. The explanations are not long-winded, but they are complete. Peter hits on all the high points that are often not adequately explained in most books on C, that you really need to know to program correctly. After reading this book, I think the whole pointer/array thing is put to rest...at least for me. The job interview questions at the end were very helpful to me...I'm not going to take a job as a programmer any time soon, but they still tested my knowledge of the language and of programming in general. I gained a lot out of the last chapter, which is an intro to C++...I've been floundering trying to understand OOP and how to program in it, and Peter gave a VERY nice, clear introduction to the basic concepts.
   
   I enjoyed Peter's humor (sometimes laugh out loud, which makes anyone raise their eyebrow when they see the book title) and writing style. It was a very delightful text to read.
   
   This book is an absolute must have for anyone that programs in C (as a second book on the subject). It should be required reading for anyone that teaches a course on C programming.



2. Every programmer should read this richly detailed tutorial for/polemic against the C programming language. While it will certainly help programmers improve the quality of their C code, it also shows definitively why developing reliable C software will always be far more difficult than it needs to be. This is one of the finest software engineering books I have ever read.



3. This book helps you on the way of becoming an expert on the C programming language, it is not much help for the purpose of becoming an expert on programming in C.
   
   What's the difference? Well, on the dimension from language lawyer to poet, this book falls more on the lawyerish side. In the same way that grammatically correct sentences in a natural language are rarely great poetry, so correct C programs are not necessarily great programs. Correctness is necessary, yes, but hardly sufficient.
   
   Van der Linden has little to say (or if he has, he doesn't tell) about topics such as good style at a small scale and doesn't at all touch how to structure programs at the large scale. Things like how to avoid name clashes, structure header files, handle errors, avoid resource leaks.
   
   The C programming language is still very much alive, and as far as I can tell, the place on the shelf for a book on C Patterns & Idioms is still vacant, waiting to be filled.



4. One of the best books I have seen on C programming. Interesting stories and author's ability to explain dusty corners of C language are really appreciated. I wish someone could have recommended this book to me during school days. Anyway, it is never late to read this book.



5. I had this book in PDF format before and liked it so much that I bought the book. An excellent book for advanced c/c++ programmers, a very good insight in linker, assembler. The book is all you need to learn many ambiguities of c.
   Also, the book arrived in condition as described. Great service.

5 comments about Advanced Rails.

1. As Ruby on Rails rocketed into the development community's hearts and minds a few years ago, the number of books on the subject climbed with it. However, a lot of these books were introductory in nature (Agile Web Development with Rails, Beginning Rails, Build Your Own Rails Applications, etc.). What's a budding Rails-head to do once they've gotten the basics down? Books like Advanced Rails -- which was released late last year by O'Reilly - aim to fill this void.
   
   Author Brad Ediger has been kicking around the Rails scene since the pre-1.0 days. Though not a Rails "luminary" necessarily, he certainly qualifies as an advanced user. He is CTO for a Real Estate tech company called Tasman Labs and runs a web design (and Rails consulting) firm called Madriska Media Group. He seems like a sharp cookie and a decent writer.
   
   Advanced Rails covers quite a bit of territory, going for breadth rather than depth most of the time. Each chapter covers a classic, pivotal development concern... well, at least most of them do. The chapters are as follows:
   
   1. Foundational Techniques
   2. ActiveSupport and RailTies
   3. Rails Plugins
   4. Database
   5. Security
   6. Performance
   7. REST, Resources, and Web Services
   8. i18n and L10n
   9. Incorporating and Extending Rails
   10. Large Projects
   
   By "Foundational Techniques", Ediger is referring to Ruby and Rails techniques, principals and patterns like Metaprogramming, Don't Repeat Yourself, and Functional Programming techniques. The chapter also goes into a fair amount detail about the Object/Class/Module relationship. A bunch of this may not be particularly new material for most Rails users who've been at it for at least a few months. However, it's still nice to have all this stuff in one forty page chapter... good to have handy to refer to. Also, there are some nice nuggets in there that could save you some head-scratching. For example, what's the difference between Kernel#lambda and Proc.new? The answer is that, if you *return* a value from the block passed to Proc.new, the calling method is exited as well, abandoning any code that you might have after it.
   
   If the first chapter feels like it's leaning towards a reference work, the second chapter -- which digs into all the goodies offered by ActiveSupport and RailTies -- pretty much falls over right into reference-land, complete with a method-by-method listing of features added to standard library classes. This may seem even more like just putting api docs available online into print, but Eidger defintely adds a bit more explanation. And, I haven't really seen anyone give a rundown of just what the heck RailTies does. That's the library that provides the glue to pull together the more famous Rails libraries to make it all work together as rails: generators, initializers, etc. There is definitely some interesting and not necessarily readily available information here.
   
   Chapter three covers Rails Plugins, and is quick and painless. It explains the common files and directory structure in a plugin and talks about how Rails loads them. It also talks about using Piston instead of svn:externals to manage plugins and show some example plugins.
   
   The following three chapters cover more of the classic eternal problems faced in running high-traffic sites: databases, security, and performance. These really make the most sense in an "advanced" book; they are the "brass tacks" that everyone must get down too if they go beyond the "toy app" stage. Ediger talks about the strengths and weaknesses of the various popular database systems. He also goes into the benefits of using the filesystem to store data, which is largely because web servers can make use of fast system calls to dump files straight into the TCP socket. He also covers some advanced db features like composite keys, stored procedures and clustering.
   
   The security chapter isn't all that long and a lot of the info it covers can be found in beginner Rails books... SQL injection, cross-site scripting etc. However, the book would be remiss to not include this material and it is presented in a concise and complete manner. This would be good to refer back to now and then to make sure you haven't slipped in your security awareness. Ediger also doesn't hesitate to make specific recommendations, like "whitelist rather than blacklist".
   
   He also jumps right into recommendations while writing about performance optimization in the next chapter: "Algorithmic improvements always beat code tweaks", "As a general rule, maintainability beats performance", "Only optimize what matters", "Measure twice, cut once". He then goes on to cover specific tools and techniques for uncovering your bottlenecks, from a quick explanation of basic statistics to using httpperf, benchmark, and Rails Analyzer Tools, improving database calls (using indexes and "include" on finders), and the various caching solutions. There is plenty of good information in this chapter; also a good bit of reference next time you need to track down a logjam.
   
   Chapter seven covers RESTful Rails, from the very basic theory as outlined by Roy Fielding to exactly how Rails has chosen to use these concepts, and is the longest chapter in the book. The amount of coverage REST gets seems questionable since Rails has been very heavily into the RESTful approach for over a year and embraced the philosophy so thoroughly that it's hard to imagine anyone using Rails today without being exposed to the concepts.
   
   On the other hand, one can still wire up verb-oriented actions in routes.rb and might be able to get away with ignoring all the RESTful goodness. So maybe there are some out there that can benefit from this chapter. Plus, having such thorough, theory-to-practice coverage allows the chapter to stand on its own as a solid reference to the whys and hows of RESTful Rails. It also has one of the better sections on RESTful routing that I have seen (routes being one of the more mysterious and sometimes frustrating pieces of Rails).
   
   Rails has gotten plenty of grief for its lack of official support for Internationalization and Localization, but in Chapter eight, Ediger lays out the options, such as gettext, Gibberish, and Globalize. He is most enthusiastic about this last library and it does appear to be quite powerful, including support for translating strings, translating model fields, localizing numbers and dates, and even recording what needs to be translated by saving them in the database. Creating multi-lingual websites is a hard problem in any web-development framework and most other frameworks have plenty of head start. However, Ruby and Rails certainly isn't without options and it will only get better.
   
   The next to last chapter of Advanced Rails runs through a number of alternatives to the standard components of the Rails framework. On the database end, it covers DataMapper, Ambition, and Og, giving this last one the most attention. For alternatives to ERB templates, Ediger talks about Markaby, Liquid and Haml, all in a very brisk fashion. He also talks about using traditional Rails components -- like ActiveRecord and ActionMailer -- outside of Rails applications. The chapter closes with a discussion of how to contribute to Rails (hint: submit a patch... don't just bitch!).
   
   The last chapter is called "Large Projects" and covers some useful information about working on a Rails project with a team, beginning with version control (though anyone who is writing code that covers more than a single file and *not* using version control is just plain insane). This starts with a quick overview of Subversion, however this feels like it is really a set up for making a case for "decentralized version control". Ediger does a good job of explaining these concepts, using Mercurial for his examples. This seems a bit unfortunate, since many people on the Rails core team have embraced Git and it is looking like Rails will eventually move its repository to Git. However, Mercurial has a reputation of being more user-friendly, so that may have influenced his decision. And it's useful information regardless.
   
   Chapter ten continues on to discuss avoiding migration numbering collisions, issue tracking, keeping Rails and required gems within a project, web servers, load balancers, production architecture and deployment tools like Capistrano. This is all covered in a fairly quick fashion so don't expect a lot of depth.
   
   That last sentiment came up often while reading this book. It often felt like Ediger was trying to get every possible Rails-related topic into the book that he could, but didn't want to come out with some 1000-page behemoth. Plenty of the topics mentioned don't have much more coverage than you could get with a quick "googling". However, there is something to be said for being exposed to a lot of tools, projects and concepts in one go, even if the exposure is sometimes superficial. I definitely found reading this book worthwhile and will keep it around to refer back to now and then. I don't know if I'd go so far as to label it required reading, but then again books on web frameworks rarely are.



2. With 'Advanced Rails' the O'Reilly family of Rails books is looking to add a Rails book that talks about some of the extra stuff you can do with this great technology. At 300+ pages long this isn't a book with 'Learning' in the title, rather it assumes that you have some fundamental Rails knowledge and are looking to improve your skill set.
   
   Chapter Overview:
   
   01. Metaprogramming
   02. ActiveSupport and RailTies
   03. Rails Plugins
   04. Database Stuff
   05. Security
   06. Performance
   07. REST and Web Services
   08. i18n and L10n
   09. Incorporating and Extending Rails
   10. Large Projects (Source Control and the like)
   
   Rails is a powerful framework but it isn't an easy one to always understand and get working. If you are looking to use Rails in your web app and want to get better at understanding the ins and out of it, this book can really help fill in the blanks.
   
   If you want to become a better Rails developer/admin pick up this book and get better immediately.
   
   **** RECOMMENDED



3. This book is almost worth it just for the first chapter's dive into Ruby metaprogramming, but the rest of the book doesn't disappoint. Ediger delivers useful advice regarding available methods, alternatives and considerations that all serious web developers should take into account.
   
   This book should be non-optional for all Rails development teams, as it has some of the most sane and sober treatment of relevant topics I've ever read in a single book. From security to databases to deployment, this book gives the reader a solid foundation in nearly all of the major disciplines involved in building web applications.



4. Although the title suggest otherwise, Advanced Rails is really required reading for anyone using Rails - beginners and gurus alike. The information provided is excellent, with essential tips and sound advice. In particular, the chapters on routing, security, internationalization and database issues are well worth the purchase price. Like Obie's The Rails Way (Addison-Wesley Professional Ruby Series), this book should live on your desk in your workspace. What's missing? Well, it would have been nice to see information on Git considering the effort put into covering source control systems. It's also surprising that there is not more on testing techniques and issues. But overall, this book is fantastic, and chocked full of juicy info you won't find in any of the other Rails books currently available.



5. I loved that, for once, a Rails book did not start out telling me how to install Rails. Ok, maybe they don't all do that, it just feels that way sometimes. Instead, by page 6 you are looking at charts on how Ruby class inheritance works.
   
   I really enjoyed Chapter 1 "Foundation Techniques". It covers interesting topics such as "Metaprogramming Techniques" and "Functional Programming".
   
   The other chapters weren't as interesting to me as the first, but all contained practical information that could be put to use by the working Rails Developer depending on the requirements of your specific project.

5 comments about Ivor Horton's Beginning Visual C++ 2005 (Programmer to Programmer).

1. This book is and has everything you need to learn VC++ and MFC. It takes you through every step to get you on track.



2. I own many programming books and I code in many languages. I need a book that cuts through the idle chatter and lets me get to work. Ivor Horton's book is well organized and follows a format of: topic, example, explanation. The examples are good real-world examples and the explanations are easy to follow.



3. I found this book of little or no use. When a buy a book that is this big (1180 pages) you think, "Wow this thing is so big it must be the one." I am more and more of a mind that programming books that are bloated are just poorly thought out. I would not recommend this book to anyone.



4. This is a great book. However, the chapters are long and can be boring.
   
   Also, if you hate math then you might be a little annoyed at all the simple exercises using basic math. Maybe, if Ivor Horton referenced food instead .. hmmmm.
   
   One other downer about this book ... as you get more advanced you will find yourself working on only one example. The author should have used new examples in each chapter to help the learning experience.
   
   I've found that if you work with one example and someone misses something along the way ... they will have difficulty as they progress.
   
   Other than that ... this is a great book and very well written. You will definitely learn a lot reading this tutorial.
   
   I would definitely recommend this book to anyone!



5. Excellent, readable, and comprehensive intro to Visual C++ for folks with a smattering of programming knowledge. You don't have to have any C++ experience to use this book, but I do recommend that if you are an absolute beginner to the world of computer programming, you pick up an easier book, say, COBOL for Dummies. I bought this book as a refresher...I've done Visual Basic for years and want to go back to something closer to the machine level--I miss the granularity and sheer power of C++ and I'm tired of the slowness of the .Net line and their buggy frameworks. These Horton C++ books exhibit a friendly and relaxed writing style: I find most programming texts too terse and psychotic for my taste. I picked up a more advanced text from Wrox, Professional C++, to get back to the intermediate level later on and I will get the Stroustrup and Myers texts to help me cross the threshhold of advanced C++ development once again.
   
   If you are truly new to C++, don't get discouraged with the many battles you'll encounter ahead...the payoff down the line is very great if you can master this Maserati of programming languages. Don't believe all the negative talk you hear about C++...most of this comes from folks who lack true mastery of the C++ language and how to use it effectively (C++ goes where C#, Java, and VB will never ever go). The Horton books will take much of the pain away--work quickly through this book and maybe try out the Dietel books simultaneously to get a jump start on your fellow C++ students! Good luck!

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 MCPD Self-Paced Training Kit (Exams 70-536, 70-526, 70-548): Microsoft® .NET Framework Windows® Developer Core Requirements (Bpg General).

1. I like this book because it is easy to read and I believe it has enough information to pass the exam



2. Some previous reviews say the book is not sufficient. The question is. Do you really think you can buy a book, read it, practice it and make the highest web application certification exam ? It does not seem to be logical does not it ? The 70-547 exam contains also areas from "architect" point of view. So I want to say you have to have the basics already in your blood. The book is very good.



3. I used this book as my primary study guide for the exam.
   I passed 1st go with score of 875. So it definitely pointed me in the right direction.
   The self-test software is really REALLY useful to test how ready you are.
   Though you have to remember that this exam is intended for people with working experience, you can't expect to pass just by reading a book.



4. At first, while skimming through the pages I thought this was a much lower quality product than some of the O'Reilly books I had read.
   
   But after reading and doing the exercises I realized that Microsoft is spot on.
   
   They have a good approach to teaching which is going by: "Understanding rather than Knowing" and by giving you the opportunity to manually test everything yourself to integrate the concepts. I believe this is the only right way to teaching stuff.
   
   Plus, it allows to do the certifications at a tenth of the price the courses would costs.



5. I'm amazed that Microsoft let this book leave the press. I have never seen such a disconnect between what the book teaches and what is on the actual test. Not only that, but on the practice exams provided by the book, there are questions that are NEVER covered by the book, and questions where the book tells you one way, and the test tells you it's wrong and to do it another way. The book is riddled with inconsistencies, typos, and code errors. I have bought other Study Guides from Microsoft and have been very happy with them. This one is not worth the money, and should be re-written. If you can find another study guide for the 70-547, then do so. Or at least wait until the second edition of this book comes out.

5 comments about Definitive XML Schema (Charles F. Goldfarb Definitive XML Series).

1. Since all other reviews are very positive, I'm here to offer a different opinion.
   
   I've had this book for over a year now, and I barely use it. Each time I attempt to find something useful in it, the information is scattered over the entire book making it extremely difficult to understand.
   
   For example, right now I'm looking up the "ref" attribute, and according to the index, it appears on 7 different locations throughout the book, each portion shorter than 1 page. Also, I have seen many tables scattered throughout with exact same information, or one or two differing field values, making it very confusing to understand which table is doing what.
   
   And at over 500 pages long, there is a large amount of filler information in this book.
   
   Is this book "definitive"? It looks like it is. Is this book usable? Absolutely not. This is one of the worst investments I've made in computer books.
   
   And there is a place about strings in the book where it differs from the official W3C specs.



2. Walmsley's book is the one I go to as the reference for W3C Schema. It is clear and very accurate and reliable. I find the examples relevant and helpful.
   
   I had to chuckle at a previous review that couldn't understand why something was found in multiple places. Well perhaps it is used in several places. I would be happy that the index was thorough. Schema is a somewhat complicated language but Walmsley provides transparency and order.
   
   I recommend this book to my clients and in classes I teach on XML and Schema regulalrly.



3. Imagine yourself sitting in front of the formal w3c standard(s) and trying to read it cover to cover...
   
   I tried that and it is very hard, boring, and very unproductive.
   
   Now, try to read it with this book as a companion -- you will find yourself understanding everything on the spot.
   
   There are a lot of useful examples and explanations which are (in my opinion) missing from the standard's text. This is what makes this book so useful.
   
   Also, the organization of the book makes it very easy to locate information you need and to use it as a reference book.
   
   Trying to understand the fine details of the XML Schema standard and the capabilities of XML Schema? Trying to implement an XML parser or an XML validator? If so -- you will probably appreciate this book and will probably use it a lot!
   
   Even now, several years later, I sill find it useful and revealing.



4. This book was very helpful in getting me up to speed with XML Schema. It was written well and I have provided the added detail I needed to go above and beyond up at work. Priscilla's Walmsley's extensive experience is conveyed well in the book and has proven to be a great resource.



5. XML Schema can be really confusing but this book has made it much more clear to me. In particular, I muddled through my project never really understanding things like namespaces and elementFormDefault and weirdnesses like why complex types can have simple content, until I decided to sit down and read this book. Now I feel like I've got a handle on how these things work, plus it made me realize that XML Schema has a lot more features I didn't even know about. The chapter on extensibility was a bonus because it compared and contrasted some of these advanced features and gave me a better idea when to use them. The index is good, too - which makes it easy to use as a reference.

5 comments about JavaScript: The Complete Reference, Second Edition.

1. The text is a very good and complete explanation of JavaScript. It describes the best usage of JavaScript with the latest common browsers at the time of writing (early 2004). There are numerous examples which express the programming ideas in a simple fashion.
   
   If you have programmed in other languages, JavaScript should be an easy learn with this book. Programs written in it tend not to be very long, as they are associated with a single web page. While JavaScript deals nicely with the various objects in a browser, like a window or document, the programs tend to have a procedural flavour.



2. This is a fairly comprehensive book. This is not the best "beginner" book. The "beginner" info is in there - but it's mixed with so much advanced stuff that it can seem overwhelming. If you have previous experience, there's a lot of good stuff here. This is an excellent "second book."



3. The future is Javascript. Being a Microsoft technologies fanatic, I always wanted to make use of the AJAX library. My javascript needed some brusing and this was the book I went after. The complete reference, and a good companion to HTML/XHTML Complete Reference. David Flaganan's book is good too. Both deserve 5 stars.



4. Arrived in specified time, no issues. Use the book all the time. Pretty good reference.



5. I think the line tends to fall between the programmer types and those of us with less of a comp-sci background on this book. I stepped up to this from Jeremy Keith's DOM Scripting after a wild self-teaching binge and enjoyed reading it. It's considerably less dry than you would expect from a book of its size and I thought the author did a good job of explaining more complex JS topics. That said, some topics were starting to show their age and it's overdue for a new edition.
   
   Overall it's a great introduction to people who want to pick up tricks across the entire gamut of JS and I found myself running into a number of objects and methods I wasn't very familiar with. When I'm looking for new JS ideas I would go to this one and start browsing sections I hadn't read as thoroughly. When I want to know exactly what is up with a given facet of JS, I go to O'Reilly's version, the Definitive Guide.
   
   My copy was from the library unfortunately and I miss it, but I'm still holding out for a third edition as it's getting a bit long in the tooth in some sections, but this is usually obvious (like pre-ajax coverage of the XMLHTTPRequest object).
   
   There is definitely room for both the definitive guide and this JS book on my bookshelf, however, and I personally thought it did a great job on prototypical inheritance for doing OOP-style JS.

5 comments about Java Programming.

1. First off... I am not a natural programmer. 70% of the class I am in are. Let it be known that I am not dumb either. I graduated with my first college degree in Biotechnology Magna Cum Laude. That's a 3.78 gpa for me, and pretty good for those who don't know the term. At least half of the students in your class already know how and why these programs work and function. That is where this book totally falls apart. I approach everything as a scientist would. I have to know the how, but more importantly the "WHY" and the thought process behind each new idea. Why do we set up the program this way? What is the reason for jumping around back and forth in every chapter??? She leads us through the exercises by the nose, but never shows the whole code or comments about the program as a whole.
   She never goes through the following: This section of code will do this, we need a section to do that and a section to do this other thing. This feeds off that... etc.. What it totally misses is that logic involved with programming. When a problem is put forth, you stop and think about it. You lay out what this program needs to do. List all the variables you'll need, etc. Get the sections of programming ideas down, then start turning them into code.
   
   This book ignores this thought process completely. I'm no slouch either. The exercises tell you to place your cursor here in the method of the class of the main... (if you can find it... there's no actual code listed in its entirety so good luck)
   press enter... okay, now type this... Why??? Who knows, she never tells you why you want to place this little piece of code in this other part of the program... Then, you go to a totally different part of the program and type this... little snippet of codeWhy??? Who knows. You know what the individual line of code will do, but not WHY you put it in this particular part of the program. What makes it worse is half the time you're looking at the sections of code she had you make and you think to yourself, 'Self, What was she thinking, I wouldn't make it like that, who places code in that order?' What's the thought process behind these chunks of code?
   
   If real programmers make their programs the way she takes you through them I gaurantee they'd all kill themselves by the age of 30.
   
   At times you'll bounce around so much, you will go bonkers, I'm telling you.
   
   I am learning more from the Java for Dummies books than I did in a class with an actual professor using this horrible book. Bring a different book to class, use the different book. If the programs your instructor wants you to write don't have to be done using this book, then, don't get it. Or at least get it but get another book and read them both. Trust me, it sounds like more work, but it's acually a lot less work as you won't waste hundreds of hours interpreting this confusing book.
   
   I wonder if she made it confusing to maintain her own Job Security...
   
   Thanks,



2. I used this book for a Java development class. I felt that it was a good book and overall I have little ill to say about it. The examples are well written and do a good job of reinforcing what you read in the chapter. You read a little then do an example, then read some more, then add to the example and so on. You don't need any Programming experience to use this book just a decent understanding of programming logic.
   The only criticism I could offer is that the editor should have used arrows when content is being continued on a new line for reasons of page space so that readers will know and understand (beginners can have trouble with this). It's a good book for learning the whole language from the ground up and for this reason it's worth the money. It's not an overnight crash course (if that is what you are looking for).



3. In the interest of full disclosure I'll let you know that I am one of the reviewers of the 4th edition of the book. I use this book for a college introductory programming class and get good results. This book is a "gentle" introduction to Java. It is not a Java reference text. I use the Deitel "How to ..." book for my advanced Java class but that book would be way beyond what my introductory students could handle. This book assumes you know nothing about Java and little about programming. There is good coverage of topics based on what you need to know to get started in Java. All the basics are covered.
   
   Object-oriented concepts are explained well and simply. The short examples provide reinforcement. I compare these examples to the examples in the Deitel book that can go on for pages. Each has its place but I believe shorter is better for the beginner. Several other reviews mentioned the difficulty of using examples that were done in pieces interspersed with text explanations. It looks like these reviews were written before the current 4th edition was published (February 6, 2007). Most of the examples in the latest edition are complete applications with explanation before and after - not in - the code. The end of chapter exercises do contain a "You Do It" section where line-by-line instructions are provided.
   
   It is still true that source code for the examples is not provided. This is not a problem for me as a Java instructor. The examples are short. I think students learn more by actually writing the statements themselves as opposed to loading pre-written examples and just running them. This may be a personal bias as I learn more this way. It gives you a chance to make errors and fixing errors sometimes teaches you a lot!



4. This is an average Java textbook. I have all of Farrell texts and this is her best one. The book is too simple to use in my Java courses as a text- but I primarily use it for reference...
   
   Advantages:
   1. Good chapter coverage (miss the section on Mutithreading)
   2. Game Zone and Up For Discusssion are great
   3. Nice programming exercises
   
   Negatives:
   1. Does not fully support Java 5 (i.e. Use of Scanner class, files, etc)
   2. Heavy use of Applets (Applets are not as important as they use to be)
   
   If you are looking for a good simple Java textbook- get this; otherwise there are better choices like Deitel, Liang, Malik, etc. for use in programming course.



5. I used this text for my Introduction to Java class at Yakima Valley Community College. Farrell gave good coverage to all the important topics and assumed little or no programming background. Students appreciated the in-chapter examples and scenarios. There is no such thing as a perfect text book, but I've used this one for five years because it's the best I have found. The only opportunity for improvement I can provide is that I wish she would include screen captures of the complete program code instead of point and click directions in the "You Do It" sections.

5 comments about Practical C++ Programming, Second Edition.

1. Overall, the book offers a balanced and well-presented introduction to C++. However, there are too many typos and mistakes for a programming text. O'Reilly needs to kick their editing team into gear. In addition, many topics could and should be explained more in-depth. As is, many topics are only lightly touched on and more of the nuts and bolts of the language (i.e. characteristics that really lead to a quality understanding) are omitted.



2. This is the first time I am actually writing a review for a book, coz I find this book the best I have ever read for C++ programming. It serves great for sophomore level C++ programming class at my univ. and otherwise as a great book to have on your reference shelf too. It starts with an intro to setting up your programming enivroment in .NET and Borland enviroment. After that it delves into programming styles and techniques in general and then goes C++ fulltime. The chapters about pointers,advanced pointers and the debugging/optimisation are some of the best readings I have ever done on the respective topics. Throughout the book the material stays relevant to the title of the book and thus is a great reading for anyone who is making transition from java to c++ or from a beginner C++ programmer to advanced level. The book is great reading for strengthening C++ concepts. If you look through the contents of the book you might notice the only thing that the book lacks is a chapter on data structures. However dont let that fool you. You will be in a better position to perform pointer manipulation on your linked lists and trees after reading advanced pointers chapter in this book, than any other book that just has the code for the entire implementation printed. Besides the book is about letting you loose to do it yourself (rather than hand feeding you) which I believe is what programming books are about.The book has something about almost everything in C++ and lot more like using the gnu debugger .Highly recommended for anyone who wants to have a strong conceptual knowledge of C++.



3. This is not the one. The book is just swarming with typos and programming errors. But don't take my for it, just check out O'Reilly's errata page. The most astonishing thing is that they accidentally omitted an entire chapter. Even after I painstakingly marked every correction in the errata list, I was finding more errors constantly. The other major fault is that it is just too full of ideology, which has its place of course, but he's gone way overboard with it in a book that should be primarily about the language. If you happen to find a copy in the trash, you might give it a skim, but otherwise, I'd avoid it.



4. Stay. Away. From. This. Book.
   
   This book covers a great deal very quickly, and does so in an easy-to-understand way. Unfortunately, it is riddled with novice programming mistakes, has a poor and unmaintainable programming style, and displays many of the things that are widely considered to be "worst practise" in C++ programming. The coverage of the STL is poor and its proper use is not encouraged as it should be. I'm glad I never had the misfortune of ever having bought it. There are many, many other books that cover C++, and nearly all of them cover it better.
   
   If you're looking for a good book to learn C++, buy anything but this one. It is by far the worst O'Reilly book ever released, and I'm amazed that such poor code quality was ever approved by the editorial staff.



5. It's very difficult to write a good and clear computerbook, that's proven over and over again when I order books about the various subjects. Enter O'reilly and enter this book. It's follows a clear, logical path. Since programming is all about doing it and experiencing it on your own the many exercises (without them being worked out at the back) help tremendously. The author knows his subject and can translate this very well into easy to read, and lively chapters that are not boring in the least. For everyone that wants to learn C++. Also a note that the buildup of the book is such, that the very beginner can start with this, but also experiences C-programmers of C++ programmers can find this excellent (directions are given at which chapter to start for them). Excellent and truly deserves 5 stars.

5 comments about Swing Hacks: Tips and Tools for Killer GUIs (Hacks).

1. This book had ways of implementing all the useful features that users expect such as drag and drop, transparent/non-rectangular frames, and lots of other things. Well worth the money



2. This book gives a good set of more in depth approaches to building GUI in Swing. While reading it I had a lot of 'that's interesting' moments. However, a lot of the examples feel more like an idea of what needs to be done to achieve something rather than a complete (and robust) implementation. What is more disappointing, I found that some advice in the book is misleading. For example Hack #57 demonstrates how to use the glass pane to intercept and riderect mouse events. Unfortunately, as demonstrated, this approach doesn't work at all in the applications that use any components that have menus. A very significant shortcoming, in my opinion, that is not mentioned in the book.



3. Lacking some up-to-date information is usually not a problem that impacts most books. You can usually pull out one or two decent tricks, methodologies or pieces of information you didn't know before. This book, however, falls flat on its face.
   
   Filled with completely useless "hacks", use of extremely common knowledge/practices and general lack of content make this book a complete waste. Beginners may find the information interesting, but in terms of use in their professional lives, useless. Advanced users will find that other methodologies and "hacks" out there are much more useful and function much more efficiently.
   
   Aside from the uselessness of the information provided for use within enterprise GUI front-ends, what bothered me most was the inefficiency of the data provided. With some simple tweaking, complete rewrites based on the ideas presented, etc. you can come up with much more efficient and powerful components and component extensions yourselves.
   
   Don't waste your time.



4. It met my test because what I needed to know was easy to find and I was able to make a quick fix while maintaining Java software and I knocked out a couple of problems that way. It was easy to read, a good index and had sample implementations. The only problem I found is that it seems out of date and I would gladly purchase a more recent edition.



5. This book has some interesting tips and tricks. It would probably be a good read for developers that aren't too deep into the Swing framework, because most of the examples provide quick ways to accomplish various tasks without having to know the swing framework inside and out.