Programming Books

Wow, could this be the best computer book ever written? Well, if you are using Oracle and you want to understand how Oracle works, it just might be. It's packed with performance information, and even if you are not using Oracle this will be helpful for any (esp for Postgres users)

This is hands down the best book I've read on Oracle. It should be mandatory reading for anyone working with an Oracle database. Period.

I have close to 15 years of experience with Oracle, and have designed and developed large scale (>1TB) transactional systems. I've worn the hats of DBA, architect, developer, consultant, etc. The information in this book is invaluable.

If you work with Oracle this is a manual you need on your desk. Not just for DBA's but also for developers who will derive a good insight into how they should be developing their code.
Very technical but not to the point that brain freeze occurs.
Would highly recommend it.

This book is accurate and undoubtfully an excellent source to learn more about the Oracle Database.
Tom is an author full of humor with a versatile approach to performance. In his book he shows his approach to performance and put light on common practice like database independence and read-write consistency or like constraints enforced by triggers and autonomous transaction.
No doubt I learned a lot in this book!

I actually helps you understand, rather than just throwing information at you (as many books do)

It's amazing how much is assumed in most after-market Java books! I can't estimate how often I've seen, "It is assumed you know about Threaded Programming, and therefore it is not covered here." Well, good news, It IS covered here. And is is covered well.
As a professional programmer for 20 years, I can attest to the fact that Thread programming is the most schizophrenic of disciplines. In addition, since most legacy thread concepts come from 'procedural' languages, the Java implementation tends to be hard to hold on to.
I found this book to be a wonderful 'primer' into Java's Thread capabilities. It doesn't attempt to relate to older languages. It starts from the begining, and presents its subject clearly. It's a good learning tool, and is organized well enough to be a reliable refference.
Even if you have experience with threading, this is worth it to orient your head to Java Threading.

If you find Doug Lea's "Concurrent Programming in Java" too daunting, this is the book you should have read first. The examples were easy to follow, and were to the point -that is, you will only learn how to work with the Thread API, and there is not much talk about design patterns. The diagrams in the book were very handy to follow Hyde's explanation. I enjoyed reading this book.. I recommend this book for every beginner in java programming.

This is a good book to learn Thread fundamentals and how to use thread in Real Life. The code examples uses a lot of AWT thats why the 4 stars I would have been a little bit happier if it used something else.
Any way a good purchase for learning Thread I brushed up my knowledge on Thread before sitting for the SCJP

This is a particularly easy to understand book on Java threads. If you are new to Java or to threading then don't hesitate to buy this book. The topics are clearly explained and in a logical order. The examples are small enough that they are easy to understand, but big enough to get the point across. And they work! Mr. Hyde has clearly gone to a great amount of trouble to make his presentation clear and simple to digest. As examples the diagrams he presents for explaining a deadlock and the timing of events in a wait/notify sequence make what is going on very clear.

If you are an experienced thread programmer looking for the finer points of threading, this book might not be the best. It does not go into the level of detail that some other books do, for example Holub's book "Taming Java Threads". On the other hand, these books are not the best for beginners.

Very straightforward and gentle introduction to the Java threading mechanics.It features basic theory and examples for about 3/4 of the book with the rest of the pages dedicated to a few useful techniques to ease and streamline threads programming, which you can use in you applications or as inspiration and examples for your own devices. My only complaint is the presentation method: a bunch of code followed by a bunch of explanations. I think presenting the more relevant lines of code interleaved with explanations and then the whole example program would make learning much more effective and easy. This book is also starting to show its age, so until a second edition comes out I would recommend the O'Reilly book over this one, unless you can get it real cheap.

Thank You Fergal, for a "steady pen" in writing "Microsoft .NET for Programmers". The use of a FUN case study (Poker client-server) to synergize understanding of .NET principles in a "real-life" application is a boon to communicating such a vast subject.

Though this book seems geared to other than beginners (in both C# and .NET), starting at page 1, reading and doing the examples, and maintaining a steady course until the last page, is sure to "enlighten" the .NET inquiring mind. A more global perspective and understanding of this large subject is pretty much guaranteed.

One foot in front of the other, put yourself through the paces: Buy the book, download the files, read the prolific and responsive author participation list on Manning, read and practice from cover to cover. Your programming skills in .NET will be enhanced enjoyably for all future .NET ventures. As a bonus, you'll go to sleep at night without that large and uneasy .NET question mark look on your face.

Cover all the what and how-to about .NET in a simple and clear way. Can't believe the author does that so nicely in 300 pages. Great for experience programmer get started with .NET

Ok, this book means business. 2 chapters intro about .NET then right into the code. The problem is that IF you don't have a background in C, C++ or C# you are hosed. I had my geeky .NET Microsoft head brother help me with it. Otherwise, excellent book. For 4GL, COBOL and VB programmers like me not familiar with any of the C flavors, I recommend Microsoft Visual C# .Net step-by-step from Microsoft Press written John Sharp and Jon Jagger.

This is one of the best technical books I have read. It takes a very large subject and distills it down to a concise and manageable text.
Each chapter takes you further into .Net in a fast paced yet very well-explained way. The poker game developed in the book is also fun to play with and enhance.
This is a must-read text. However, read an introductory book first.

I've been through many of the C# books, some from Microsoft Press, and some from O'Reilly, and on and on.
For beginners there is no clear winner. However, for experienced programmers looking to expand their knowledge into many of the more advanced areas of C#, I recommended Grimes book, Microsoft .NET for Programmers.

It's for intermediate to advanced, and it's quite a bit of fun working through the example that builds and builds upon an engine, adding many interfaces, where each interface exploits a particular area of .Net. Plus he throws in his years of programming expertise to add in lots of programming tricks that also highlight .Net's flexibility and ease of programming.

Do svidanija - moi tovarischi!

I am an experienced developer but fairly new to VB.NET. This book is not for beginners but it is great for someone like myself who knows what they want to do and just wants some good examples and tips. It's a great reference book and a good alterative to Google. The English is clear and to the point. The book is a sturdy hardback and the pages are well laid out. It's easy to read afters hous of staring at a screen. To sum up, I'm glad that I brought it. It has saved me time and money and you can't ask for much more than that :-)

There is a lot of information in this book, covering a broad range of subjects. It is well laid out and easy to reference. The CD comes with the current version of the book as well as the author's previous book on VB6. Not really a beginner's book as there are more intermediate and advanced topics. I had not used .NET and hadn't touched VB6 in a couple of years. I needed a resource to help jump from rusty VB6 skills to .NET - this book did it perfectly. It is also filled with advanced topics that I am not currently using but now know where to go when the need arrives.

Fast service, great quality... What more can you ask for. I recommend this seller.

I bought this book few years. It is an excelent source of information and writers style is very clear. I just came back to see if Balena has book for C# 2005. Looks like I found something. I am going get that one. However, present book is quite good, check if there is a newer release you may want to get that one.

This was the first .NET book I purchased, and in many ways if I hadn't bought any others it would have been sufficient. It has thorough coverage of the .NET environment, with lucid code examples in VB.NET. I found the chapters on ADO.NET and the framework internals to be most useful to my job as an ASP.NET developer, but the coverage is deep enough that a person with very little programming experience could read this book and come away as a well-rounded .NET programmer. Even if you're writing in C#, as I am, the book is worth the money. I would also recommend Dino Esposito's Programming Microsoft ASP.NET for more depth if you're a web developer.

I found this book to be extremely helpful in constructing an eCommerce site. It's a great book for an experienced VB developer to use to jump into developing an e-commerce site, even if you only go through the PayPal integration. It's also a great source of material on the construction of a shopping cart, and even if your "shopping cart" is only going to be used on a companie's intranet for product/supply request/issue, it's a great starting point. As a developer I can modify the business tier code to conform to my companies requirements and concentrate on the presentation layer.

This little book is chock-full of detailed explanations and examples of an e-commerce site built with ASP.net and an SQL database. It's simply the best and definitely most-used technical book on ASP.net I've picked up in the past 2 years! In addition to the detailed explanations, I especially like the lucid examples of creating and calling the SQL Stored Procedures. Learning by example seems to be the most effective way for this novice programmer to complete an e-commerce site, and this book has greatly reduced the amount of time it normally takes to scan through multiple sources of technical information when creating a complex application. Thanks to the authors, Christian Darie & Karli Watson, for providing a comprehensive resource!

I've used this book to construct my first e-commerce website, and I don't think I could have managed without it. The 3 tier design of the sample site is very well organised and easy to adapt to your own requirements. It also makes it simpler for a novice like me to understand how everything works. I found the second part of the book (dealing with the order pipeline and credit card transactions) harder to follow. However, when I contacted the authors about a problem I was having, I received a prompt and friendly reply that soon got me back on track. Thanks, Cristian and Karli!

This is an exeptionally well written book for the beginning webstore developer with

It walks you through a complete design of the side with the end result that you have a basic webstore that you could actually take operational. The only weakness in the credit processing section. It's written for a European credit card gateway. It would be nice if one of the more popular US gateways (e.g. authorize.net) was also included.

I also sent a couple of questions to the author and he was responded very quickly ... obviously he's interested in making sure everyone reading the book is successful. 5 stars for that alone.

This is primarily a book about constructing an ASP.NET web site using stored procedures, and less a book about e-commerce. There are a few sections, mostly at the end, which are specific to e-commerce. These include the order processing pipeline chapter and the credit card transactions chapter.

This is not to say the book is bad. It's very well written and the code is described step-by-step in detail. There could have been more emphasis on architecture, and a little more on e-commerce. I would also like to see some emphasis on the sticky legal issues like customer data management, password security, transaction security, and how and when to migrate the data off of the machines on the open Internet and back into safe storage on the Intranet.

OO design and analysis is so very gray. No book can cover every aspect because the possibilities are endless. Everyone's application and environment is different which causes each and every one of us to approach our design differently and value different affects of our coding practices. By far this is the best book I have read that simply lays out OO rules-of-thumb and then explains why each is beneficial and when they might contradict other rules-of-thumb. The book encourages the reader to be reasonable and practical in your application of OO best practices.

I strongly recommend that every development team read this book and discuss it amongst themselves.

Ok, I had to look up heuristics in the dictionary before buying this. But other than that I found this to be one of only a handful I've read that tells you how to look at OOD work you've done and decide if it is good (and how to improve it). Particularly good was the discussion of cases where design goals conflict and how to resolve the conflict.

Regrettably, I disagree with the other reviewers here who seem to have liked this book. I didn't. Not that it's terrible: I found myself in agreement with most if not all of the rules of thumb the author talks about; the problem is more that this book is not well done.

First, this is a textbook; as such it is aimed at a student, that is someone who doesn't know the material yet and tries to learn. But for a tutorial this text overwordy and imprecise, with a generous quantity of confusing, misleading metaphors. If you happen to know what the author is trying to say, then you sorta get it -- I mean, you get it 'cause you already know it -- but a newcomer will be confused.

Sometimes the author doesn't seem to know why a particular rule is good, so he goes something like this: rule such-and-such is good because most software engineers would agree that it's good. I doubt the author conducted a statistically valid survey -- but forget that, suppose most software engineers do in fact agree: so what? All the author has now is a nice and juicy ad populum. But he, obviously, isn't even aware that something's wrong -- and that may be one of the problems with this book: the author may not be experienced enough to write books of this sort. He may be a competent practitioner, but this is not the same as teacher.

He tries to compensate via an over-abstract and smart-sounding terminology (one of the reviewers below jokingly complains that he needed to look up the word "heuristics": that is a telling comment, and it is valid. I, too, noticed that the author takes delight in using a dozen hifalutin words where one simple word would do (and result in a clearer text).

Riel also likes to belabour commonplace excessively ("data should be hidden inside objects"; "Objects should not depend on their users", blah-blah, brush teeth daily, apple a day etc.), anything to make the book thicker -- which brings me to its second defect, less important and quite a common one today: the book is blatantly padded. Out of about 400 pages only about 200 have readable text; the rest is mostly a source code printout (this code could have been supplied on an attached disk or put on the net somewhere). There's also a few pages with a concise restatement of the author's rules, which could have been printed on the cover insides (like in the Stevens network books) or supplied as a pullout; otherwise this list is hard to find and serves no purpose.

To summarize: were it better written, Heuristics could be useful for a newbie, but it's not and so it isn't. A more experienced reader, despite being annoyed, will understand it -- but only because he already knows the stuff himself and will be recognizing rather than learning. YMMV, but in my opinion this tome isn't worth reading time for any reader, new or experienced. I'm sending it back.

I have plenty of books on patterns, but I want to get more information on the basics of OOP and why the patterns are effective instead of "this is pattern X, and this what it does." This is a very complicated subject, which I have no doubt that most programmers on the planet have very little understanding of. We mostly write crummy code that "works", and most of the time that's good enough.

I was uncertain about getting this book because of how old it was, but after reading most of it, I'm happy I got it. Although complex, it is written in an understandable manner with useful diagrams. I wasn't as interested in the "one-liner" heuristics as I was the detailed explanations of the problems caused by particular design mistakes and the other examples and pitfalls presented.

I have been studying the object oriented methodology for some time now. I felt that I had a good understanding of what OOP was all about. I have studied OOA/D and design patterns from numerous sources. All of my sense for OOA/D knowledge changed completely when I read this book. This book really showed me that I was stuck somewhere in the middle of the paradigm shift between action oriented programming (aka procedural programming) and object oriented programming. After reading this, I feel like my knowledge in OOA/D has truly advanced to the next level.

Are you the type of person that knows what OOP is? I mean, if you've studied up on OOP then you are probably aware of what an abstract class is. You know what interfaces, inheritance, polymorphism, information hiding (...etc) are. You may have a sense in when you should use inheritance and when you should use containment. You probably follow certain OOP practices like keeping all of your variables private, hiding secrets from other objects (information hiding). This may all make sense to you but are you also the type of person that just never feels comfortable about your designs? Do you look at your classes and just get a sense that something doesn't seem right, yet you just can't figure out what it is even if your software system is running fine? I am willing to wager that you are in the middle of a paradigm shift. You are probably taking the route that a lot of developers take when they shift from thinking in a procedural fashion (action-oriented design) into object oriented design. There is nothing wrong with this, but if you're like a lot of developers you will have a long hard journey utilizing a lot of experience before you really make that shift. This book is an essential tool that will help you make that shift a LOT faster. After reading this book you will see why you felt your designs were't quite right.

One of the first topics that really hit home for me was when the author Arthur Riel talks about God classes in chapter 3. God classes are classes that have too much implementation in them. Most of the complexity of a piece of software resides in these classes. They are the all-knowing classes that delegate messages between the much smaller, less complex classes. Signs of God classes are classes that have words in their name such as "Manager" or "System" in them. This one hit home because there are numerous classes in the software i'm working on now with the name Manager in them. For example one of our classes is called the "BiDirectional_Dataflow_Manager". This is definitely a God class through and through. While I was reading about the disadvantages of these types of classes I couldn't help but agree with everything Arthur was saying. I began to see the light already and I was just on chapter 3. There are 59 other Heuristics, all equally important in this book.

Most books that teach OOA/D seem to really only teach the definition of OOA/D and perhaps clue you in to the whole idea. You learn the terminology well and you see a few examples (I'm sure you've seen an animal hierarchy a time or two), but you don't really gain a solid understanding in how you actually think in objects. This book will bridge that gap. This is the best book i've read by far on OOA/D. This book will apply to you no matter what your skill level is in OOA/D, unless you're a complete beginner then you might find yourself a little bit lost. If you are brand new to OOA/D then you should probably read a short book on OOP, just to gain the basic concepts first. "Object Oriented Thought Process" might be a good start as it's short and sweet, then you should move on to this book. If you are advanced then you may know a lot of this information, but this book will probably help tweak your OOA/D skills; helping you become an even more solid developer. But for you guys and gals out there that know what OOP is and read a few books on it, but still don't feel quite right about your designs, this book is essential. You guys out there are the sweet spot for a book like this. That's how I was. Now I feel so much better, I feel like i've gained more knowledge in OOA/D with this book then all other books on OOA/D and OOP that i've read combined - and then some.

Arthur Riel is a very talented programmer and author. He is able to communicate ideas to you that are sure to hit home, as if he's right there with you and understands your problems in OOA/D. This book is densly packed. Not including the bibliography and index this book is a mere 367 pages. Even more, if you don't include the example code at the end of the book (all C++ code) this book is only 243 pages. The real meat of this book is in the first 9 chapters (where he talks about all of the heuristics), which totals 182 pages. After that he talks about topics such as handling memory leaks and such. Most of the dim lights will shine brightly after a mere 182 pages! This may sound too good to be true, but as I said earlier Arthur is VERY talented in communicating his ideas. You just have to read this book very carefully, don't skim! Because it's so dense, it may take a couple of passes before you really get the idea but once you understand it you will surely belt out a resounding "AH HA!". This book is 10 years old at the time of this review, but the information inside is far from being outdated.

To conclude this lengthy review (sorry about that) I would like to say that I give this book my highest recommendation. In fact, this may be the best book on software development that i've ever read! This book has influenced my software development more then any other book i've read and that's a fact. This is truly a rare gem. The only downside (not this books fault) is that it's become a bit harder to work on the software that i'm currently working with because I now see where all of the pitfalls are. My co-workers think i'm just being anal about design now, but you don't have to be like them. Step up, become the best software developer that you can be. Just read this book and you will take a giant leap forward in your OOA/D understanding, especially if you're stuck in a paradigm shift like I was. Thank you very much Arthur!

I can't recommend this book highly enough. There is a wealth of advice on best practice for both Excel and VBA, which has not only prompted me to change the way I design new projects, but to revise old projects also. There are also a huge number of examples, including an application developed throughout the course of the book, which demonstrate applications for all the techniques discussed. Definitely not for the beginner, but there's loads of stuff here for intermediate to advanced developers. I think I'll be using this as a desktop reference for a long time to come...

This book of advanced Excel development was recommended to me by a co-worker whose project I inherited that used the concepts in the book based on the "Petras Template" example. It's classy and polished VBA programming and sure, you can brag about the concepts to the techies interviewing you during your next job hunt.

But, be careful.

The book introduces us to the concept of add-ins and templates. So, there you are showing off your project to your manager or users. But, what do they click on? The add-in or the template? What are all those true/false cells over there? How can the user save the workbook? What heppens if you forget to hide the columns that use cell logic. Hmmm. These questions and others will be asked of your typically non-technical users who have NO idea what goes on behind the scenes. If they open up the template and screw around with the code or re-name the add-in, you'll have chaos.

To be fair, there's tons of advanced concepts to learn here and no doubt you'll benefit from them. But, remember, as a developer, your first goal is to produce a robust application. However, you may have click a couple of functions to get all tabs in your template to show. If you don't do that, you can't see them! Oh, and don't forget to save your add-in.xla or all your changes won't take effect.

Not for beginners or dummies, but for VERY careful developers!

This is a great book for power programmers. But be aware, this book is not for those who want to learn Excel. It's just for those who know Excel and want to imrove their programming capabilities.

When picking up this book, I was an advanced Excel user. Having discovered most of its features by trial-and-error, and coming from a fairly solid programming background, I understood well the interaction between the underlying object model and the sheets appearing on the screen to end users. I have also crafted many sophisticated worksheet formulas, and explored just about every suggestion of literature such as "Excel Hacks" and "Advanced Excel Report Development".

Professional Excel Development offers ideas and tools necessary for designing full-fledged, robust Excel-based applications. It does not spend time explaining how various features work, but rather goes into detail on how to put these features to best use.

Here is what I picked up from this book, together with the authors' Excel 2003 VBA reference:
* ways to leverage Excel's built-in features to avoid excessive coding
* advanced design techniques for using Excel as a WYSIWYG interface designer
* techniques for creating custom menu bars and programming their behavior
* various means of interacting with the user and simplifying their sessions by providing guidance as to which steps need to be taken
* restricting the Excel environment to take on the appearance of a product condusive of the goal stated in previous bullet
* using VBA in conjunction with the Excel object model to create powerful object-oriented structures for spreadsheet-based applications
* programming Excel-based solutions in an executable to provide a more standalone application
* using Windows API calls to increase robustness of the application

One key feature of this book is its consistent approach. The authors maintain a consistent structure, using the same application throughout the book for their "practical example" to demonstrate new features made available through the material in each chapter. Also, the "best practices" approach provides a level of consistency that is generally desired of anywhat sophisticated applications. Useable modules are provided on the accompanying CD, ready to be used in readers' own applications.

In the beginning, the authors explain the audiences for which this book may or may not be intended. They separate these into users, power users, VBA developers, Excel developers, and professional developers. The latter three categories of users will benefit the most from this book, each in his/her own way. VBA developers will learn how to use built-in features (I think this is where I started); Excel developers will learn how to incorporate Excel-based solutions into larger applications; Professional developers will be exposed to a great variety of "best practices", optimization techniques, and various other means for developing consistency in Excel applications.

If you do not fall into the latter three categories, you might not pick up much from this book. It is not useless to you, however; you can still find many worksheet/userform design techniques, and get an introduction to the kind of power VBA-based programming can offer. Nonetheless, you may be well-advised to start off with something simpler, such as John Walkenbach's Excel Power Programming (as alluded to by the authors of this book), simply because the present book assumes a good degree of knowledge and leaves much for the reader to figure out from the fully-functional examples provided - thereby covering the ground that it does.

Overall, this book makes for a wonderful reference to the various under-the-hood features of Excel. Even if you've already encountered many of the techniques described, and could technically discover them further on your own, it is useful to have them readily available in a single collection. Very few items are left out; application design, object-oriented programming techniques, database applications, debugging techniques, Office automation, and external interop are all covered here. Professional Excel Development is a solid reference to be consulted for years to come.

When you search the web and most of the books around, you can find solution to your problems most of the time, but you are rarely sure it was the best way to do it and how it would fit to the rest of your code. The authors of this book are not afraid to tell what they suppose to be the best for you, along with full featured versions of code illustrating each chapter.

I found it easy to take the code from a sufficiently leveled chapter and adapt it to get just the application that I needed, knowing it would be fast, clean and complete at the same time, although I didn't understand all the details at first. Now, the book serves as a widely findable documentation for the packages that I make. Highly recommendable.

This book is a huge step up from the first edition. It's totally rewritten. I bought it a couple of weeks ago and now it's between the keyboard and the screen. I am continually referring to it.
The chapters on assemblies and reflection are worth the price of the book alone.
I could not ask for more.

This is an excellent reference on C#, the .NET framework, and LINQ. It's not just a rewrite of MSDN, but gives some great insight into how to use the core pieces of the .NET framework for practical applications.

The chapters on LINQ alone are worth the cost of the book. The authors dive deep into LINQ and really give you a good understanding of how it works.

I also like how the authors stay focused on the core pieces of .NET, and don't stray too deep into things like WCF and WPF. There are plenty of good books for that.

I highly recommend this for anyone desiring to learn more about C#, the .NET framework, and LINQ.

I have only read about twenty-five pages of this book, mainly at the beginning of the first chapter on LINQ; so I may have to revise my opinion later on. For now, however, this book is like a breath of fresh air. It gets straight to the point and pulls no punches. Great job!

This is a must have reference book. If you are new to C# maybe you should try first an introductory text (such as the "Visual C# 2008 step by step", or the "Head first C#") but keep in mind that introductory books usually have things spread around ... and as such this "nutshell" text is still essential (not only as a reference, but also for filling-in any gaps/details the introductory books might not mention).

This book is a really great combination between a tutorial and a reference book. What I like the most about it is that it not only explains you how to use the different elements of the C# language and the .NET Framework core namespaces, but it also explains to you how they work in the inside. This gives you a notable insight when you try to understand a strange side-effect in your code.

All explanations are made very clearly and it is very easy to read. The different chapters of the book are arranged by topic, so it is easy to use it as a reference when you can't exactly remember something. It can also be read from cover to cover.

It is, however, not recommended for beginners (as it is stated in the introduction); if you are looking for a programming tutorial this book is not a very good idea.

This C++ core language book is so often used that I thought it may deserve a review.

I own 3 books about C++ and this one became the reference. Only 200 pages (compared to the 1000 pages of another one :) but every useful feature is well explained. Authors payed careful attention in order to prevent the reader to fall in common traps. Lots of examples, always accompanied with relevant comments.

C++ in a core language really answers the questions the beginners have in mind. Concise, pragmatic, the authors are not showing off, they simply remember they were beginners one day and their explanations are exactly what one can expect. Well, I'm so happy about this book (this morning again, I was looking for a reminder about "virtual" functions or a detail about the copy constructor and all my worries were answered with no ambiguity at all) I went straight to to Amazon for a review :)

This book is relatively short, but many people might see this as a good thing, since it is really intended to transition C programmers to the basics ("core") of C++. I believe it does a decent job of this, although there are some topics (such as const) that I think it should cover but, surprisingly, does not. I liked the comparisons between polymorphism in C and C++, and the explanation of virtual functions. The examples are pretty good. There is some great humor in the book, and some parts actually made me laugh out loud. Overall, I would suggest the book to any C programmer who wants to transition to C++. Get this as your first such transitional book, then once you understand the basics, move on to a more comprehensive intermediate level book.

C++: The Core Language is a well written book and a pleasure to read. It appears that that authors made an extra effort to remove unneeded verbiage. I appreciate this because I have so much to read.

The bread and butter OOD concepts of abstraction and polymorphism are well covered. The chapter on templates covers this difficult subject well, however, I would have liked to have seen a little more on template functions.

I came from a Kernighan and Ritche C background (the "C' bible), and this seemed to pick up right where they left off. You could call this book K&R part II, and it is also about the same size. If you want a complete C++ bookshelf, I would also recommend buying (in this order) Effective C++ by Scott Meyers, The C++ Standard Library by Nicolai Josuttis, and C++ in a Nutshell by Ray Lischer.

-ND
www.NicholasDiToro.com

This is an excellent book for C programmers coming to C++ for the first time. I found the writing style and organisation of topics to be very good. The authors describe key object-based and object-oriented concepts first using familiar C constructions and then extend those ideas into the C++ domain. The ease of transitioning from C structs to C++ classes was very good, as was the discussion of subtle points like the copy constructor. Almost all major C++ concepts are described, including inheritence, virtual functions, and even templates.

My only negative criticism is that the authors leave out some important C++ functionality from their view of the C++ "core." They only mention in passing the use of const, considered by many to be vital to good C++ design. Also, since this book was published in 1995, it does not discuss the C++ standard library, which was finalised in 1997. It is therefore missing a discussion of the very useful 'string' class, among many others. Readers should defininitely follow up on these topics.

Regardless of this missing information, this book will give C programmers a solid foundation for using C++.

As an undergrad and passionate dbl major, having read many books in C and C++, this book quickly became my friend. It's a good read for those breaking out of C to C++. This book helped me cope with the shock experienced while I was trying to learn ADTs, BSTs, splay trees, skip lists, multiway tries and extendable hashing in the high level programming courses where if you asked questions you'd look dumb. The information in this book made me feel contiguously good while sitting in class. It also served as another perspective and filled in the gaps that the professor and school text left out. Also, pick up Robert Sedgewick's Algorithms in C++ 3rd Edition, which is also a splendid read.

Enjoy helping computers understand people!

late-

This book literally launched my CG animation career. I later took a class in CG animation and modeling and the tutorials in this book were in that class. Its was an excellent class, since it helped you learn the book's content is covered in 3 weeks instead of 2-3 months of night time after work animation. But this book is $30 not $2k.
What a great book. It does assume you know the basics, so learn the basics first and then dive in head first.

not even worth giving it up to my dog to chew on.

I have read several books about 3D Max but I consider this book one of the best books ! and I have learnt a lot from it ...If you want to make professional media animations logos you have to own one !

I have read several books about 3D Max but I consider this book one of the best books ! and I have learnt a lot from it ...If you want to make professional media animations logos you have to own one !

Finally a book that merges great tutorial writing and impressive content. Going through this book, I was intrigued with every sentence. Not only did I want to read what Chismar had to say but I would learn things at random times. New techniques and tricks sprawl throughout this book, were at times I even felt a little guilty getting all this info for just a few bucks. Don't keep us waiting too long for the next one, John.