5 comments about Sams Teach Yourself Visual C++ 6 in 21 Days (Sams Teach Yourself).

1. Experienced in C and C++ I wanted to get started using Visual C++.
   
   My first steps were through the online help of VC++, using the IDE and ClassWizard it is quite easy to build standard applications.
   
   Then I wanted to understand a bit more about VC++ and bought this book. From the first to the last page, it says actually the same thing as the basic help: two pages to explain that you have to click this and that to get to a wizard or a menu, then... you get the very standard stuff.
   
   The sample code? the code and its explanations are useless: this is almost what you find through the online help ; it will work the very standard way, but if you need to customize a bit (and you will need to) then you start to become more and more angry about this book, as nothing deeper is available.
   
   I'm decided today to write this review as to encourage publishers to better select their books. This one is really a waste of time.



2. I am new to Visual C++ and this book was recommended to me by my instructor. It uses easy to understand directions when building applications. I would suggest this book to anyone who wants to learn this language.



3. At first I began reviewing this book as I studied it but scrapped that review as being far too lengthy - I had detailed some of the bugs that I had found in both the book's code and the book's website's downloadable code. Yes, there are some bugs and I did have a certain amount of trouble running some of the days code.
   
   Nevertheless, the book does seem to have some merit: It is, for the most part, clearly written and, for an introductory text, the example programs seem very ambitious, and thus interesting and almost useful in their own right, something that is rare in many introductory texts.
   
   The author seems to be a very good C++ programmer and the presentation is very clear and concise - it just seems that the book may have been written and finished in haste, hence the (fairly "minor") errors and bugs that appear. Additionally, the downloadable source code does not always match that of the book making the programming somewhat confusing at times.Additionally, there are some lines that are in the book but commented out in the source code - apparently they had to be for the code to compile correctly.
   
   A better introductory book on MFC is Herb Schildt's MFC Programming From the Ground Up, 2nd edition,also written for Visual C++ version 6. Schildt's book is bug free and as an introductory text it does not use the Visual C++ AppWizard and
   Document/View architecture until the final chapters, thus truly teaching MFC fundamentals without the confusion inherent in the AppWizard and Document/View code.



4. this book isn't really all that bad for those who'd like a decent intro to Visual C++ unlike what the book's haters would like to have you believe.



5. I read through this after being pleased with the Sams Teach Yourself C++ in 21 Days book. I learned how to use the Microsoft Visual C++ software, and I use it as a reference regularly. I would recommend this to someone who already has a working knowledge of C++ and who would like to learn how to use the Microsoft Visual Studio/C++ software. Ideas in the book can easily be applied to Microsoft Visual Basic or any of the Microsoft Visual compiler software releases.

5 comments about Extreme Programming Pocket Guide.

1. In today's world of tech books that are hundreds of pages long, it's nice to see a short, "no fluff" guide to a subject that is actually usable. This book fills that bill nicely.

   Even if you've read about and implemented XP in your shop, there are times you need to review one of the points about how it all works together. Since the author covers all the main points of XP, you can quickly find the information you need. You also get a nice cross-reference at the end of each chapter that shows how each point relies on other parts of the methodology. I find this very useful if you are faced with having to modify XP for your use. It's recommended that you implement XP in its entirety, as it's meant to be more than the sum of its part. But if you have to tweak something, you know how it will affect the other areas.

   I would not recommend this book as your only resource if you were just starting to implement XP. You really need to read Extreme Programming Explained by Kent Beck. He's the founder of XP, and that book goes into much more detail as to the whys of the process. But this book is one that each member of the team should have to keep the concepts fresh.

   This is a very good book to use as a supplemental reference or reminder guide if you're using the XP methodology. If you were looking for a concise explanation of XP, this would also work for you. If you were looking for a more in-depth explanation of the methodology, I would recommend one of the books by Kent Beck.




2. I think this book should be required reading for anyone exploring XP. I introduced XP into a research lab of a dozen students and professionals, using the original books as reference. However, things would have gone much more smoothly had I simply read the pocket guide. Excellent!



3. I needed a break recently, so I pulled this tiny work off the stack of review books (now 30 books high) and blasted through it in a short hour.
   
   It's short, sweet, to the point, also injected with the occasional XP Dogma Line such as if you don't implement all 12 practices then you're not doing real XP and your manhood will shrivel or your womb will be barren. I get tired of that line, but the rest of the book is truely golden.
   
   It's concise and lays out great sections on why one should consider XP, roles in XP, artifiacts, and a few others. The real wealth is the section on XP practices where the 12 tenets are laid out in concise, reasonable fashion. These practices are clear and understandable without a bunch of mystical handwaving or badly-written example scenarios I've suffered through in a couple other XP books. (Roodyn's Extreme .NET comes to mind as a painful example of that.)
   
   The book's conciseness and focus makes it a perfect tool if you're trying to sell XP to your management, team, or co-workers.



4. I bought this book as a desktop refresher on XP practices. It does that just fine. If you are looking for an in depth book, you need to go elsewhere. This is a reference guide to use as a refresher from time to time on how to implement XP practices.



5. This guide is very concise & straight to the point. Do not be fool by its size. Team and project managers along with business analysts should find this guide very useful. This pocket book is an easy read that packs enough meat to get you going with Extreme Programming. It is written for anyone who is interested on knowing about XP.
   
   By the end of the book you'll have a clear understanding of why use XP programming, practices, events, roles, code principles & style. Best of all, it provides you with clear examples and suggestions on how to adopt this methodology.

5 comments about Ajax on Java.

1. Sad to say, this book is little more than a code dump, and the code does not run without debugging.
   
   There are no explanations of technologies and concepts that surround Ajax, therefore, given the state of the code, there is not a lot of reason to work through the book. In fact, this is the first computer book that I returned to the seller, simply because I found so little reason to keep it on my bookshelf.
   
   The writing in the introductory chapter gives promise, but as the book progresses the code quickly becomes dense and the organization and writing becomes unacceptably thin. I expected more from O'Reilly.
   
   Before I gave up on this book, I was half way through it, and only one code set had ran correctly from build on. For example, the author's code has at least four variations of the basic application URL sprinkled among the Javascript and build files of the first four examples. Finding and correcting the URL was annoying but not difficult, but even after that, the examples did not run without further debugging.
   
   I finally threw up my hands and surrendered... defeated by the author's rush to publication.



2. 'Ajax on Java' by Steven Olson is a nice intro book to learning how to use Ajax with your Java code. Nothing more than a quick overview (certainly not a reference) at just over 200 pages, this book will help Java programmers get their feet wet and start learning how to program the Ajax way with instant responsiveness in the Web 2.0 world.
   
   If you program with Java and want to begin to learn how to use Ajax to make your apps hit the "turbo" button, pick up this book and start your engines!!!
   
   **** RECOMMENDED



3. Web programmers working with Java will appreciate this guide, which tells how to make a Java web application more responsive and dynamic by incorporating new Ajaxian features, from suggestion lists and drag-and-drop modes to producing third-party tag libraries and using Ajax with Struts. The idea is to streamline operations and use Java developer backgrounds to understand Ajax's strengths: AJAX ON JAVA is the place to begin the process, and is a pick for any library strong in web programming topics in general and Java in particular.



4. I was looking for a book on to explain the underpinnings of Ajax technology. What I purchased was little more than an advertisement for several Ajax development projects. Additionally, the author covers, in equally superficial detail, many side technologies which do not drive the subject matter forward; cascading style sheets (CSS) and Ant, for example.
   
   The code examples have many bugs and references code/methods that have yet to be presented in the book. Meanwhile, the text explaining the examples discusses the actual methods that should have been in the code examples. The author does not take the time to discuss good object-oriented programming techniques or why this would be important.
   
   All in all, this is a very disappointing offering.



5. This book is great for Ajax newbies who are confused with all the frameworks available out there. Provides a quick overview of a lot of them with working examples. I would have prefered if it included more advanced scenarios.

5 comments about Generic Programming and the STL: Using and Extending the C++ Standard Template Library (Addison-Wesley Professional Computing Series).

1. Rightaway, I should say I don't discuss the quality of the book. It
   has everything I would like to have when I am programming and need to
   look up a function of the STL. This is why I give it three stars. But
   nowhere did I see the following criticism, so I have to voice it
   out.

   This book consists of two parts, part I, and part II and III
   (which I count as the second part, see below). Part I is an
   introduction to generic programming as used in the framework of the
   STL (79 pages). All that stuff, you're supposed to know if you use the
   STL. It's all about using the STL, the design, and extending it. Using
   the STL is described in lots of web pages, so the book does not
   provide much added value to this. Extending the STL is discussed all
   in all in about three pages. That was the part I was most interested
   it (I am developing a new course about generic programming).

   The
   second part, making up the remaining 430 or so of the book, are Part
   II (Ref Manual: Concepts) and Part III (Ref Manual: Algos and
   Classes). They have long been available straight from the SGI STL web
   pages, ...
   and you can also download them for browsing locally. This is a much
   more convenient (at least for me) way to look up the documentation. I
   didn't see that the book provided better examples, or different
   content than, the SGI's STL pages.

   This book will be useful if you
   are aware of all the things I said, but still would prefer to browse a
   book, or for off-line study. My goal was to see a discussion of how to
   use and extend the STL (as advertised in the title). I did not expect
   the Reference Manual (which I had already). I am most disappointed in
   this.

   The difference between User Manual and Reference Manual is
   best illustrated by the Stroustrup or Lippman-Lajoie (user manuals)
   and the C++ ISO Standard (reference manual). You should be aware of
   this difference before you buy this book, and decide if you want it
   print in 430 pages or in a web site.




2. The language C++ cannot be thought of as a mere extension to the C language. It supports object-oriented programming, and even more importantly, the generic programming paradigm. This book gives an overview of how C++ fits into the generic programming paradigm, and the author does a decent job of explaining how this is done. Anyone familiar with C++ and the Standard Template Library should have no problem following the dialog in the book. The approach taken by generic programming can be very abstract, but it is extremely powerful, and one that allows generality and economy of thought in programming.

   After a brief summary of the STL in chapter 1, the author moves on to studying linear search and iterators in chapter 2. The author stresses the need to design algorithms that are independent of the data structures they operate on. The discussion sets up the terminology and concepts for later chapters on function objects and containers in later chapters. The author introduces the idea of a concept, which is essentially a collection of type requirements, types, and valid programs. Readers with a background in mathematical logic are referred to the references for a discussion of the connection between concepts and the theory of many-sorted algebras. Iterators are introduced as five different types of concepts, these all serving as a generalization of pointers. The five kinds of iterator concepts are discussed in detail in the chapter. These concepts do have properties in common, and this leads the author to consider refinements of concepts. In addition, the different iterator concepts allow the author to classify generic algorithms according to the iterator concepts it uses.

   The discussion of iterators is continued in the next chapter, where iterator traits and associated types are discussed. The idea of an iterator value type is introduced as the object type the iterator points to. The author introduces, interestingly, a generalization of the type overloading capability of C++ to concept overloading, and he shows in detail how to emulate concept overloading in C++ .

   Function objects, which I consider one of the most powerful and useful concepts in generic programming, are discussed in chapter 4. Function objects are introduced as entities that can parameterize any kind of operation, and the author gives good arguments to show that every algorithm can be generalized by abstracting some part of its behavior as a function object. The associated types of a function object are the types of its arguments and return values. The composition of functions, so familiar in elementary mathematics, is here generalized to function objects via function object adaptors. Thus one can view function objects as entities behaving as expected in a mathematical sense.

   Containers are then introduced in chapter 5, essentially as generalizations of arrays, and the author stresses that the elements of a container are actual objects and not addresses. This "value semantics" of containers is shown to be a useful strategy by the author.

   The next part of the book begins an overview of generic programming concepts that are applicable in general, and not just the STL. STL though is given as an example in the discussion, and this is somewhat disappointing given the emphasis on generality. But the author does outline with clarity the important constructions in generic programming, such as iterators, function objects, and containers. Therefore this part of the book does serve as a good reference manual.

   The next part is a reference manual on the algorithms and classes available in the STL. The discussion on memory management primitives is useful for it gives information on the algorithms used to manipulate uninitialized storage in order to implement containers. Nonmutating algorithms, which are used for operating on a range of iterators without changing the elements they point to, are given a good overview, as are mutating algorithms, which modify the values pointed to by a range of iterators. The discussion of the predefined function objects is also useful, as they implement most of the standard arithmetic operations, such as multiplication and addition, and the logical operations, such as AND and OR. In addition, the discussion of member function adaptors is useful since it shows the reader how to call member functions as function objects. A polymorphic function call will result if the member function is virtual, and this, the author states, is a link between generic programming and OO-programming in C++

   The very important Vector class is discussed also, stressing its ability for automatic memory management. In my experience, the Vector class has been one of the most useful features of the STL.




3. As one of the few non-tutorial books on the design of STL, the book serves its purpose. It illustrates that the STL is built on top of concepts, a different kind of abstraction from the traditional OO. It also explains in details how this abstraction is applied through iterators, containers, and algorithms, as well as their STL way implementation in C++.
   
   However, this book has several weaknesses. Not enough is devoted to illustrate the big picture of how the STL uses these abstractions. For example, after explaining the iterators and containers, the book doesn't explain how the iterators serve as a bridge between generic algorithms and containers - the abstraction of iterators makes it possible to write generic algorithms without the knowledge of the type of the container, and vice versa.
   
   On the practical side, I think that the book spends too much space on a complete reference manual to STL, but not enough on discussing the practical issues of extending and using STL, such as making a non-trivial custom container or a custom memory allocator.



4. i am new to the C++ STL. i try to understand how string, vector works by reading into this book. however, the book may be good for a STL designer, but definitely not for a beginner like me. the whole book lacks some practical examples to illustrate the concept.



5. This book has depth. It tells you why, at least in some cases. For example, the Musser and Saini book (2nd ed) describes class template iterater_traits, but doesn't tell you why it was designed and structured that way. This book, however, provides very good explanation on it in chapter 3.

5 comments about Win32 Programming (Addison-Wesley Advanced Windows Series) 2 Volume Set (No CD).

1. If you are an experienced Win32 programmer looking for a good reference, or you learned MFC but want to know what's going on under the hood, this is the book for you. If you are a beginner looking for a book to teach you how to program Windows, do not get this book. Lots of tables, just the right amount of code examples, lots of real-world advice, and a 200-page index. This book does not cover MFC.



2. Very good on the level of detail, and incredible on the pitfalls and specific problems they found when actually writing the code for the examples. Be careful, though - a number of the tables (and even some of the printed code samples) contain typos and other minor errors (like missing headings, making one table pretty useless!). You can figure out what's wrong, but if you just use this as a reference and happen to hit a section with an error you might not catch it without reading the accompanying text. I read it through, rather than as a reference, and it was clear which parts of the text had only been lightly checked for the latest edition.

   Again, 95+% of this book is really great! And the anecdotes and clear detail on where MS documentation is "flawed" are of terrific value - I definitely am glad to have purchased it, but I also want to point out that if something in it doesn't make sense - you're probably not crazy. It's quite likely to be a typo...

   Oh - one more thing. The "Explorer" samples they include were a fabulous idea, and have really helped me figure out what the heck some of the various style (and other) flags really meant. Extra credit for the CD! :-)




3. I have owned this book for at least seven years and have made a couple of good attempts to read/study it with some success as it may not be the best first book for programming the Win32 API although it certainly treats the subject in excruciating detail and with insights garnered by the two authors who are two of the most consummately professional programmers in the world - Brent Rector and Joseph Newcomer. For example Herb Schildt's Programming Windows 98 from the Ground Up teaches WIN32 programming and I find myself more productive in less time studying that book, even though WIN32 programming teaches with a philosophy that one is (ultimately) going to be writing large multifile programs, and this philosophy isn't apparent in Schildt's book. Additionally, an added bonus of Win32 Programming are the insights one gets into writing more robust and professional code - the C code (and there is a lot of it - 140,000 lines included on the CD ROM) has been written by the very best programmers. Additionally, the treatment of each topic is probably more in depth in this book - one example being the discussion of the GDI. More advanced topics included are chapters on writing a DLL, writing an MDI application, and writing multithreading applications. Finally, at 1500 pages the book is reference-like and also like a textbook thus I would assume that it may well take the better part of a year to study each chapter and the associated applications, making it one of the finest and most comprehensive books ever written on WIN32 API programming. I paid $50 for it at UCLA and the book has stood the test of time and proves to be an invaluable work well worth the cost. Finally, this book would seemingly rank among the most professional and scientific computer science/programming titles ever written - certainly it would be one of the most massive - the index is around 200 pages long in itself!



4. This is a GREAT book! Unfortunately, it NO LONGER comes with a CD-ROM!!!
   
   So if YOU have the time to MANUALLY key in over 140,000 lines of code, then you SHOULD buy this book....assuming that you could make NO ERRORS!!!!???
   
   As a minor point, it also comes as two(2) paperback volumes.
   
   This is not a problem for me...I like paperback, BUT it is one more point where this product is being MISREPRESENTED.



5. Lotsa of projects to help in understanding Win32.
   I compiled projects with VS 2005 and plan to try
   others. Some tutorials like Forger's win32 would
   definitly help before you approach this book.

5 comments about JavaFX Script: Dynamic Java Scripting for Rich Internet/Client-side Applications.

1. If you are looking to have fun with programming, JavaFX is a good place to start. And if you want to learn JavaFX Script, this book can help. The book starts by giving you an overview of JavaFX and its future. Then we get a classic Hello World example which is used to explain declarative programming and how to split up source files and begin binding to a model. Then we get to do some code by example. The main example chosen was a word search program. This gives us a chance to exercise a lot of the features of JavaFX. There is even a section on 2d animation and translation. Throughout the book there are practice problems and challenges to help you exercise your programming muscles. The book also makes a great reference with detailed tables for most of the language features. Overall this is a great introduction to this exciting language. There is a slight learning curve when you get to the Hello World example. I would take it slow after that and make sure you have the foundations of declarative language down. It's just a thought hurdle you have to make, but well worth it in the end.



2. JavaFX is a great tool to leverage the advantages of all the vast Java class libraries and Swing in a declarative but statically typed style. I had come to this conclusion when I first noticed JavaFX through stumbling across a link on Sun's Java web-site and portal.
   
   The one thing that JavaFX lacked was a basic, get up to speed tutorial or book which didn't assume you were a programming dunce, didn't assume that you were somehow clueless about how Swing or SWT (or any modern) user interface library worked.
   
   This book filled the gap for me.
   
   I am a reasonably adept Swing GUI developer, can understand SWT and write it (but can't see any particular advantage to SWT unless you're using a product that already uses it or it's an Eclipse based product) and understand GTK+. Hence, I don't need a lecture on how GUIs work, what an event model is, what a widget is; nor do I need a how to program, what does Java syntax look like.
   
   This book gives you sufficient information to: determine if JavaFX may fit into your GUI needs, how to use JavaFX and Java classes together and how to put together a small, JavaFX application. Others have stated the application isn't real-world: I challenge them - I wrote a "real world" word place program for a client...games aren't "real world" but they contain very real concepts both in their play and in their creation.
   
   The book doesn't: teach you how to program Java or any other programming language; it's a fairly tutorial style book. JavaFX is the type of tool where you can bring up a small(ish) example and fiddle with bits to work out what changes. It doesn't teach you a heap about Swing but gives pointers to Swing documentation where appropriate. Those not used to programming or Swing may find it difficult to translate Swing documentation into what JavaFX does. It will show you how to make classes, but not why you'd make them and it presupposes you know a little about programming.
   
   That said, I do know these things and it was certainly worth my money.
   
   I think this book would suit anyone who wanted to peek at JavaFX to see what a basic, but functional example does. It would also suit someone who knew Java, who wanted to add JavaFX to their toolset. It would be less suitable for someone who didn't know what a "for" or "while" loop does and it doesn't go into great detail about "classes", "class hierarchies" and such.
   
   It's a good book and it augments and isn't, by any means, a regurgitation of online documentation.



3. Maybe I'm just an old entrenched Java programmer, but quite frankly, after reading this book, I just don't get why somebody would want to use JavaFX. First off, you are forced to use Netbeans if you want to program in JavaFX. I don't use Netbeans and I'm not interested in doing so. I don't know many Java programmers who are interested in doing so either. Second, the JavaFX language itself doesn't parallel well with the Java language. Many simple constructs are completely different from what is done in Java. In short, I'm having to learn yet another language. Finally, it just doesn't deliver what I'm looking for - a simpler faster way of writing reliable multimedia applications. Sure you can put up some nice 2D GUIs and displays, but Sun had been promising a Java answer to Flash, or at least the beginnings of one. The problems with pure Java solutions to multimedia - runtime startup time, resource usage, and a lack of complete multimedia solutions including audio, animation, etc. is a problem that has existed since the early days of Java Media Framework and its eventual orphaning by Sun. JavaFX doesn't solve any of these problems or even put a real dent in it.
   
   However, to the author's credit, I learned all of this by reading his book. He doesn't editorialize on the language, but his examples make clear the shortcomings of this new language and therefore prevent you from wasting anymore time than necessary on it. I commend him on that.



4. This book is poorly typeset. The block structure of the code is almost impossible to discern because the indentation varies. APress, there's a reason that code is usually typeset with constant spacing courier fonts. It's much easier to read.
   
   This book has no index rendering it absolutely useless as a reference.
   
   
   I had intended to use JavaFX Script to create simple guis for displaying data. Perhaps, JavaFX Script is capable of doing this, but if it is, you certainly couldn't prove it from this book.



5. I'm starting in the JavaFX world and this book is helping me on this. I'm using some JavaFX tools and the Netbeans JavaFX plugin.
   James L. Weaver is always in the jfx discussion lists and is very accessible. Thanks. :)

5 comments about Foundations of Ajax (Foundation).

1. It is not a thick book. Easy to read, to finish. It does a good job to introduce Ajax to beginner. It introduces several situations you can start to use Ajax, like data checking, auto page refresh... Almost every web project can apply Ajax on these areas.
   
   I do not give it 5 stars because it talks too much javascript. This is not a javascript book, why does auther need to tell reader how to debug javascript?
   
   But it is still a very good book for beginner to quickly learn ajax with its great sample code.



2. This book from Ryan Asleson and Nathaniel Schutta is a basic introduction to Ajax focused on the user interaction aspects. Therefore, most of the book focuses on how to use JavaScript to enhance user experience on web sites. After introducing the XMLHttpRequest object and server communication, the authors show how the Ajax approach can be used in various interaction contexts. The final chapters of the book are dedicated to tools than can ease JavaScript development, particularly for the testing and debugging activities.
   
   Although it is targeted to developers that already master JavaScript and HTML, the clarity of examples makes this book accessible to a larger audience, even if you do not have a PhD in JavaScript. Some may think that the focus of the book (client side scripting) is limited, but I see this book is a good starting point for practical Ajax implementation, especially to enhance an existing web site. The fact that the few server code examples are in Java may however be seen as a disadvantage for readers using another server-side language and that are looking for a broader coverage on their specific configuration.



3. This book is terrible. The exposition is rather poor and shallow. Too focused on Java and not JavaScript/Ajax. The authors knowledge of JavaScript come across as being peripheral and unfocused. This book is simply riding the Ajax craze wave and if you're a self-respecting programmer, you'll be returning this book in no time. Terribly disappointed. There are two other books on Ajax/JavaScript that do a much, much better job at explaining the technology and its uses than this primer; I'd give the names, but don't want to cross-advertise.



4. I am a professional Java guy but i can't get what I want (knowledge about Javascript/AJAX programming objects) from this book because the book highlights on advanced concepts from related technologies to explain things. So unless you are a pretty competent Javascript programmer you will struggle to understand this book and struggle to understand the significance of what you are being told and why.



5. This is a good book if you are looking for an introduction to Ajax programming with straight to the point examples and common tools.

5 comments about Professional Refactoring in Visual Basic (Programmer to Programmer).

1. First of its kind for VB.Net developers. While it does not contain a complete catalogue of all known refactorings, you get a thorough study case used throughout the book, tooling, how to use refactoring for upgrade of legacy VB6 code, a chapter on VB 2008, some important object oriented principles and even short intro on refactoring to patterns.
   This book is deep and takes a while to digest. However, it's not about showing off some irrelevant academic knowledge. Author is not afraid to mention "Dependency Injection" or "Single Responsibility Principle" but all of these are demonstrated to be relevant and get illustrated through very practical and real-life examples.



2. Really great book on refactoring. Although it is based on Visual Basic examples, same advices can be applied to C#, Java or any other OO language.
   Martin Fowler finally has a fair partner on my shelf ;).



3. I am working with group of developers that came to VB .Net from VB6. Currently we are in process in improving the way things operate using some agile stuff. The overall disposition is pretty good, team has already been formed and things like daily stand-ups, client involvement or short iterations are generally welcomed by all. However, when more technical, code level stuff is discussed, there is more discussion (if not opposition). These folks pack years of experience and will not accept that you can teach them their job just like that. There is no way you can force things like unit testing or refactoring. You have to be able to hold your ground and answer all the questions with some good arguments.
   This book gives you in-dept view of refactoring with a lot of practical, code examples. This means that you are well prepared to answer any uncomfortable question. It builds up gradually, so it is easy to follow.
   Almost every chapter ends up applying the stuff that was just exposed on a sample application with a lot of code. Surely author spent a decent time on this title. You can download the code and see it progress from chapter to chapter. This gives a great insight since you can read and debug the code at the same time and not just some toy or isolated example.
   Here is chapter to chapter break-down of the book.
   
   Chapter 1
   Intro chapter, defines refactorings end code smells and explains the kind of baggage VB carries because of its origins. Cool section on misinterpretations, this will prepare you for some tough questions that might come from uninitiated developers or managers.
   Explains the importance of writing simple, comprehensible code. For example:
   Dim oXMLDom as New DOMDocumet() vs Dim portfolio as new DOMDOcument.
   The first statement gives you no idea of what first DOMDocument represents, in second it's the portfolio, and if you know the application context you will know what to expect.
   
   Chapter 2
   Teaser chapter but also good single-chapter sample of some typical refactoring work. Captures well typical process of development of VB applications. Starts out with few event-handling methods, ends up with number of domain classes and some inheritance thrown in.
   
   Chapter 3
   Chapter on refactoring tools, also gives you some insight of how different tools like refactoring add-ins and unit testing framework fit the big picture of agile development process.
   
   Chapter 4
   Intro chapter on application that is used to illustrate refactorings throughout the book. Explains the business case, requirements, lists some use cases. It is important to understand the context of the application to be able to follow-up on refactorings. Also some funny stuff here, like freshman developer that takes pride in copy-paste development.
   
   Chapter 5
   In-dept discussion on Static vs. Dynamic and Strong vs. Weak Typing that is rarely dealt with in such depth. This is basically controlled with Option Strict and Option Explicit options. If you program in VB, you must be aware how these work out.
   
   Chapter 6
   Chapter on error handling, especially legacy vs. structured error handling. Again, something everyone should know, but rarely explained in such depth. Cool stuff is step by step recipe for converting legacy to structured.
   
   Chapter 7
   Deals with some core refactorings like Dead Code Elimination, Scope Reduction etc. It's like cleaning up your code for some serious refactoring stuff.
   
   Chapter 8
   First step in structuring your code is getting serious about the problem (or business) domain. Also explains Rename and Safe Rename refactoring, talks about Interface vs. Abstract class, Open-Closed principle etc. some serious OO stuff.
   
   Chapter 9
   Some core refactoring stuff. Teaches you how to eliminate duplicated code and why it is the worst thing it can happen to your code. Explains Extract Method and Replace Magic Literal with Symbolic Constant variable. Nice and simple example based on circle geometric shape on how procedural design is transformed to Object Oriented design (Module and Shared method rings a bell?)
   
   Chapter 10
   If only method extraction would be as simple in real life... This chapter goes further with method extraction and deals with some common problems like temps.
   
   Chapter 11
   Where do objects come from? How you design classes? Some core OO stuff in this chapter, including Extract Class, Move Member (Method or Field) refactorings, smells like Database Driven Design or Data Class, Large Class, OO principles like Single Reasonability Principle etc. Lot of stuff and handful of pages in this chapter.
   
   Chapter 12
   Build upon previous chapter. Deals with inheritance, polymorphism, genericity. Explains the difference between class and interface (or implementation vs. interface inheritance), difference between delegation and inheritance and criteria to chose one or another, list some common misuses of inheritance etc. Again, a number of refactorings like Replace Inheritance With Delegation or Extract Interface, Extract Super etc. Some heavyweight OO concepts in this chapter, takes a time to digest.
   
   Chapter 13
   Explains what is important when taking a birds-view of software. This chapter is especially important for software architects. Talks a lot about dependencies in software and why you should minimize dependencies in your code.
   
   Chapter 14
   Single chapter for huge subject, still a lot of material covered. Design patterns are the most advanced subject in OO, so refactoring your code in order to make use of patterns is in no way child's play. Mostly deals with creational patterns. First mention of Dependency Injection in some VB book I come across. Now taking into account that Unity application block [...] has been released in April, this is really cutting edge stuff!
   
   Chapter 15
   Talks about latest VB improvements that come with VB 2008. Starts with XML enhancements like XML literals and then the rest is about LINQ. Explains a LINQ implementation called LINQ-to-SQL. This is first Microsoft Object-Relational Mapper (ORM). Again, cutting edge.
   
   Chapter 16
   If you still deal with VB6 code, than you know that migrating to .Net is no easy ride. This chapter explains some techniques that will help you migrate your code and make it .Net in sprit, not leaving it crippled by simple migration that will only make it execute in .Net. VB6 lacks inheritance, generics etc, so you need refactorings to make it VB .Net.
   
   This book has no real competition as far as I know, no book on refactoring or agile for VB .Net developers. The one that come close is Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series) but it is for C# developers and requires a lot higher starting point.
   When other books come up, I am sure Professional Refactoring in VB will continue to hold its ground. Highly recommended!



4. Not a typical Wrox title, generally these tend deal with specific technology in "no-nonsense" fashion. This book has more theory in it and is not technology specific, you will find it valuable if you program in just any version of Visual Basic .Net and any type of application. Not likely to become obsolete very soon, since basic premises of refactoring will continue to be relevant even in upcoming versions of VB.



5. Arsenovski has done a great job with this book. It is clearly written, easy to follow and very practical. A great one to keep on the shelf and reference as needed. The free tools that he covers in the book are a bonus! They really help to get you applying what you've learned quickly.
   
   I highly recommend this book for any .NET developer, not just those who use Visual Basic.

1 comments about Starting Out with C++: Early Objects (6th Edition) (Starting Out With...).

1. This books explains all the reserve words for C++. Author uses Borland Turbo C++ (compiler). I used both Turbo and Dev C++. Starts from ground zero to STL, Object Orientation and to binary trees. Its introductory level course and anyone can understand and start coding, if you have some computer knowledge or have some programming experience.

5 comments about The Elements of Java Style.

1. I'm very disappointed at the amount content in this Book. Sun posted a Java style guide that was essentially the equivalent, but free. Equivalent in terms of topics covered while there were some noticable difference such as variable naming.
   
   One of the redeming qualities of the book though is that it can serve as a coding standard thus saving one from tidious chore of deciding on your own standards. In the end does it really make that much of a difference as long as everyone on your team is following the same standard?
   
   Best part of the book is the title.



2. Several years have passed since this book was first published. Many things have changed in the Java world since then.
   
   However, it looks like development at a corporate level of a software product without adherence to some sort of development and code standards is disappearing. This book contains a very good set of rules and code standards one can start with.
   
   Not that it is important to follow exactly some specific already existing guideline but it is rather vital to have one and keep going with this set of standards. The book suggests a wide range of various well described code standards so that a Development team might build their own set of rules using the book as an example.
   
   I would like to recommend any Development team to have this small but helpful book in their library.



3. Clear, consise and short enough that developers will actually take the time to read, and filled with enough common sense that very few disagreements come from the developers about this.
   We use this book as the basis for our corporate coding standards for our on-shore, off-shore and near-shore. The standards page on our wiki is very short and contains only the few places where we've chosen to deviate from the standards in the book.
   If you've ever tried to have a team develop standards from scratch, you know what a painful process that could be. This book got the whole team (in multiple countries) on the same page very quickly and let us focus our time on getting down to the business of writing software.



4. Other reviews here that attack this book for not being a good design guide are missing the point. This book is a set of practices to make your code easier to read and work better in groups. Each chapter is about some kind of convention (formatting conventions, documentation conventions, etc.). You're not going to learn to program with this guide; you're going to learn to make your programs more usable in a group environment. Yes, it is a pamphlet-sized book: that's the point.



5. As stated in the previous review this "pamphlet sized" book is invaluable to programs working in any sized group. Not only do you need programming style rules, these are pre-defined for you, so there is no time wasted with your team trying to decide on one. I am a project manager over a several groups of computer and software engineers, and after hearing more style arguments than I care to remember this book is now law at our company, it is also followed by our c/c++ programmers in a fashion of sorts... style is important, it does need guidelines, and if you dont follow them you may not have a job for very long... its common since!!!!