No comments about Foundations of Jini 2 Programming.

3 comments about From Program to Product: Turning Your Code into a Saleable Product (Expert's Voice).

1. I'd love to give this book more stars but unfortunately it falls short of the mark in a number of areas.
   
   Pros:
   1. It's well written.
   2. It contains some useful information.
   
   Cons:
   1. It doesn't contain that much useful information (there are better books) which can be found on the Internet without any trouble.
   2. Almost everything revolves around Access applications. I understand that the author is a great fan of Access (hard not to come to that conclusion) but a broader range of case studies would have been much better.
   3. All the case studies were the author's own software. Again, I would have rather seen more general studies.
   4. The design/UI principles etc are pretty dodgy - rather consult "real" books on this subject. The screen shots in the book are horrible.
   5. The "interviews" are repetitive and boring - same questions, mostly Access. They follow the lines of; I wrote a program, went commercial, made some money, went bust (mostly), tried again (wash, rinse, repeat).
   
   So, if you've got an hour or two to kill then read this book, but if you're going to choose one book rather go with "Eric Sink on the Business of Software".



2. Most programmers at some point think they have something they've built that, with a little luck and hard work, can be the next Visicalc of the computer world. In reality, there's a lot more that goes into it than that. Rocky Smolin talks about that process in the book From Program to Product: Turning Your Code into a Saleable Product. You'll know some of the stuff already, but it will keep you from making some other mistakes that could keep you from getting all you could from your brainchild.
   
   Contents:
   Who Wants To Be a Millionaire?; So What Do I Do First?; The Program - From The Outside Looking In; The Price of Success; Legal Matters; Some Financial Considerations; Sample Software Licence; Index
   
   Smolin has a couple of different product offerings that he's taken from idea to saleable product. He uses that experience to talk about the perils, pitfalls, and payoffs of selling your work to others. Much of what he covers is how to take a step back and actually plan the product. This ideally should be done *before* you build it, but you may already have the program built and working for the original intended purpose. He shows how it's best to have that architecture and analysis done before you actually release it, as it will give you the foundation you need to create something that is solid and doesn't start breaking down under the strain of multiple customers. Probably the best information is on licensing and other legal issues (like escrow). We may be good at slinging code, but we're not all that hot at making sure the legal groundwork is done. Without it, you may find yourself giving up all your hard-earned profits to lawyers and disgruntled customers. Worth reading and considering before you make the mistakes.
   
   There are a couple of nits I have with the book itself. Smolin is mainly an Access/SQL Server developer, so pretty much all the examples, interviews, and colleages mentioned in the book hail from that software niche. That doesn't make the core information any less valuable, but it does tend to get a bit old having all the examples showing the same type of software technology. Also, I'm not sure the interviews at the end of each chapter work as well as they could. They are nearly verbatim transcripts, so you have too many sequences of answers consisting of single word "yes" and "no"s. I realize that gives you the realism of the interview, but it also reads in an awkward fashion. I think I would have chosen clean up that area a bit more.
   
   This book is worth reading if you plan to go down the independent software vendor route. It'll save you the hassles of repeating the common mistakes that nearly everyone ends up making.



3. Mr. Smolin's book isn't for the Sergei Brins or the Linus Torvalds of the world. If you think that the author is going to reveal the most sure-fire software development environment that will have the greatest chance of acceptance in the marketplace, you'd better look elsewhere. Actually, there IS no elsewhere because there is no such source that can deliver on such a claim.
   
   Those that think that Mr. Smolin should have shown Java or C# examples in his book are entirely missing the point: this is a book that shows EVERY factor a developer should consider BEFORE releasing his much-beloved software to an unsuspecting public. The development environment particulars have no bearing on the business of selling software. Do you really believe that a jewelry shop looking for something to help keep track of all the parts needed for jewelry design really cares one way or another whether your program is written in C# or Cobol?
   
   If you're looking at this book for guarantees, you won't find any. Software writing is a business, and anyone that indulges in wishful thinking is lost right from the start. You may think some feature you've written is just the coolest thing you've ever seen, but it may be the one thing that annoys a potential buyer so much that he'll pass your cool program right by without a second thought.
   
   The 67 pages of interviews take up about a third of this book. I was charmed, informed, and bemused by them all at once. The interviews in this book read like direct transcripts from the tapes. There seems to be little editing; nothing, say, like "Ten Questions for Lotta Miles" in People Magazine. But the flow is very natural and Mr. Smolin makes an engaging interviewer. I think he felt it important to devote such a large portion of his book to the interviews because it serves up a huge dollop of authenticity.
   
   None of his interview subjects have household names. Sure, an interview with the founders of Google or with Bill Gates would certainly have increased the general public's interest in this book and helped the sales considerably. But what do you really expect from an interview with a top flight software developer that hasn't been seen before? The people that are likely to buy this book will appreciate interviews with people that made a go of it by selling small, targeted software products to limited markets. That's going to make a heck of a lot more sense to developers looking to target small markets with their software products!
   
   The "secret" to success in software development is the same as it is in every business: work hard, pay attention to what your customers say, get the details right, work hard, keep promoting your product, make sure to have enough capital at the start and keep your fiscal house in order, keep up with your taxes, work continuously on improvements to your product, work hard, watch your competitors like a hawk, don't let yourself become discouraged, keep on top of your billing, don't borrow too much money, and work hard.
   
   Mr. Smolin's book covers them all. If you don't have a head for business, this book isn't really going to give you one. Well, NO book is going to give you that, all the thousands of business-oriented book titles to the contrary.
   
   But what this book DOES give you is -- believe it or not -- a step-by-step guide to bringing your software to market. There isn't anything magical here. No, let me re-phrase that: there IS magic here, magic in the down-to-earth principles that Mr. Smolin writes about so clearly. Yes, you've heard them a hundred times, but have you drawn them to your bosom and made them a part of your everyday life?
   
   If you want to know what this book is really all about, take these words from the section in Chapter 1 called "What This Book is Really About", contemplate them, absorb them, and realize that there really is no other way:
   
   "This book is really about getting to your first day in business.
   
   "It is about taking that raw idea you have for a program and creating a saleable product. And setting up the support system you need to make your business hum.
   
   "If you're going to do this thing, you have to be ready for some tough days. But nothing worthwhile ever comes easy. Sometimes what it really takes is stupid, blind obstinacy -- the drive to keep going, stubbornly solving one problem at a time until you get the brass ring."
   
   The magic comes from what Judith Martin calls "the alchemy of the spirit": the realization that you can, indeed, make a go of it if you just keep at it with "stupid, blind obstinacy", keeping your eye on the road ahead. Why should success involve anything more than what other successful people have done to become successful?
   
   Here, in brief, are most of the steps that Mr. Smolin covers:
   
   1) Define your product
   2) Analyze it and create a system specification
   3) Build in security
   4) Design
   5) Make program navigation consistent and smooth
   6) Choose a platform
   7) Decide whether to write it yourself or hire someone
   8) Consider deeply the point-of-view of the user
   9) Test
   9a) Test some more
   9b) Keep testing
   10) Pricing and pricing options
   11) Business considerations that lead to success
   12) Financing options
   13) Legal issues: copyright and ownership
   14) The business type: sole propietor, corporation, etc.
   15) Insurance
   16) Software piracy
   17) When to stop programming and sell the product
   18) Writing a manual
   19) Packaging
   20) Going one step at a time
   
   Some of these things are treated more-or-less in the form of to-do items on a checklist, such as insurance. You won't find a list of the best software product insurers in the land in this book...it's just another one of those things you must deal with if you're actually going to make a business out of your brilliant software.
   
   Smolin's style has a light touch, particularly in the interviews. If you're somebody with little to no sense of humor, then this isn't the book for you. If you believe that business topics should be treated with seriousness and stodgy attention to every last stinking detail, then this isn't the book for you.
   
   Not that it's a laugh riot, mind you. Smolin slips in the persiflage at the right moments, I think, to keep you mindful of the fact that business can be fun and that a bit of humor helps you overcome the self-doubt that can come with the inevitable business setbacks.
   
   In "From Program to Product", Smolin treats the building of a software business, with all the attendant worries, obstacles, and triumphs, as if he's giving you advice as a very close friend who really wants you to do well. I truly wish that I'd had this book when I started my own software business. I'd still be in it ... and thriving.

No comments about Testing SAP Solutions.

5 comments about Pro Ajax and the .NET 2.0 Platform (Pro).

1. Pro Ajax and the .NET 2.0 Platform gets high marks from me because it is concise, informative and easy to follow. After reading the first three chapters I had a clear understanding of what Ajax really is. Author Dan Woolston has extensive experience with AJAX and he seemed to share it all here without overwhelming this reader.
   
   Woolston did not waste my time in getting me up to speed. In the first three chapters I learned how to write my own reusable (cross browser) JavaScript functions that will work together to execute an Ajax call.
   
   Of course I might rely on one of the various existing frameworks to do this for me. However, now I know what's going on under the covers and I can make an informed decision about what Ajax to use and when. I know exactly what is happening when Ajax is implemented and why.The book also does a nice job of covering CSS and the DOM (document object model). As you know (or will know after reading), these combine with JavaScript to create the foundation of Ajax! Once you understand how they work together you'll know more about Ajax than 90% of your developer friends.
   
   Excellent Feature #1: The overview of JavaScript, CSS and the DOM is fantastic. I really appreciated the fact that it was concise and dead-on accurate in addressing the specific elements that a .NET developer needs to understand in order to code Ajax.
   
   Continuing on, after the book had me up to speed with Ajax, it went into n-tier design. This is important because, in theory, a programmer can go hog wild on Ajax and break tons of rules regarding sound application architecture. So I was impressed that Woolston transitioned directly into best-practices for how and when to use Ajax.
   
   The first third of the book covers Ajax theory and best-practices. With Ajax, one size does not fit all. Therefore, chapter seven includes overviews of many popular Ajax frameworks including non .NET frameworks such as Ruby on Rails, WebORB, xajax (PHP) and Direct Web Remoting (Java). It also covers .NET frameworks including Ajax.NET, Anthem and Atlas.
   
   The other two thirds of the book are devoted to Ajax programming concepts. The author uses the Anthem framework for most of this coding. Anthem is an open-source, .NET framework in C# that is compatible with ASP.NET 1.1 and 2.0. It is extremely lightweight, requiring only one class file for core functionality.
   
   Excellent Feature #2: The book's code walkthroughs are based on a fully functional n-tier sample application that you can download free. The sample application uses the AdventureWorks database which is also a free download from Microsoft if you don't already have access to it.
   
   You might think that some .NET features and topics lend themselves to Ajax technology and therefore should be covered in more detail. You'd be right. Woolston sets aside complete chapters on Web services, Custom Controls, ASP.NET Security and Web Parts.
   
   Excellent Feature #3: When you're done learning how to build your own Ajax, there are two chapters devoted to debugging and testing Ajax.
   
   One of the last chapters was my favorite. Chapter 19 is all about usability. As you may know, Ajax solves many usability problems. But can also create new ones. Woolston addresses the good, the bad and the ugly.
   
   The book provides ideas and examples of good Ajax. The author has test-driven many Ajax controls and shares his trials and tribulations. This feedback no doubt will save developers valuable time.
   
   The book also discusses potential pitfalls of using Ajax. Woolston tackles cross-browser compatibility issues and how to best overcome them. He also talks about how to deal with the browser's back button. How to handle browsers with disabled JavaScript and how to work past the problem of pageshifting.
   
   Some of the other usability topics covered in Chapter 19 include Ajax menus, bookmarking, type-aheads, connected controls, code visibility and page paradigms.
   
   Suffices to say this book packs a big Ajax punch. I highly recommend it to any of my peers who are interested in building Ajax functionality into their web applications. This book is applicable to .NET developers who are working with ASP.NET 1.1 or 2.0. In my opinion, web developers of any skill level will find it helpful.



2. About 3/4 done with this book. Today I just built my 1st Ajax feature in a few hours at work with the suff I learned. This books is a quick read with great examples works in both 1.1 and 2.0. Buy it!



3. i didnot think that i would like this book because for me apress is famous with their books having lacking style of examples. Normally you find yourself lost in the examples eventough the topic is covered very well.
   This book is different than others absolutely; it starts with what is ajax; and why ajax and with simple examples.
   if you dont know javascript; it is still ok because one of the chapters covers javascript; so you can learn enough javascript to handle the simple ajax pages.
   Before diving into ajax; it tells you about different ajax libraries; so i like this part too; you will have an idea about other ajax libraries too.
   I could not run the first example which is the easiest one and i struggle a lot to solve it;but most of the codes in the book is easy to implement.
   And guess what; as you can see from the title; the book is for .NET developers; so if you are a .NET developer; this is right book to buy.
   It is not like other apress books that have coding examples problem. the sequence for the chapter makes the book easy to follow.
   After reading this book; i start reading some tutorials about Atlas ( which is basically Microsoft's Ajax ) and it really helps you to understand atlas too;
   If you like google maps; or virtual maps; this books has a suprise for you :)
   i read 4-5 different books from apress and this one is the best; i will highly recommend this book to all .net developers who want to learn ajax with .net



4. I had done some little test applications utilizing Ajax and/or Atlas prior to reading this book, and I wanted this book to really give a solid base from which to move forward with.
   
   Mr. Woolston's writing style is personable but not too over the top. One thing I did not like about the writing style is the manner in which code is laid out at times. For instance, with many of the sample applications, Mr. Woolston will dump about 5-6 pages of code into the book and then work towards restating it in part afterwards with some explanation. I can see where it would be useful if not in front of the sample code/a PC, but in reality this book will not be useful if not in front of a computer working on the examples.
   
   There are other times where some of the content is not really useful in furthering education about Ajax and certain examples it feels are stretched to make the chapters longer. I think there was likely a challenge in filling out a reasonable sized book because simply put - the fundamental elements of Ajax aren't that complex. I found myself done with the book in a period of less than a week.
   
   Those things said, after reading the book I can certainly say the overall content has an excellent "perspective of the landscape". From a history of Ajax to a little primer on Javascript, CSS/DOM, and the XmlHttpRequest, he moves forward to examples of Ajax demonstrating the technology with an Ajax framework named Anthem. The main meat of the book are really these examples, where practice implements the ideas from the prior chapters.
   
   Lastly, the book closes with a few chapters covering security, testing, usability, performance, and a token chapter on Atlas.
   
   One other element that I appreciated in this book was the identification of a few free tools out there to aid in Ajax development. Those tools in their own right would have definitely contributed to some time savings a week or two ago when I was struggling with a couple DOM/CSS issues prior to reading this book!
   
   In summary, perhaps a book stretched to fit it's cover but nevertheless a very useful read to me and I would certainly recommend it.



5. I hardly ever review books and probably wouldn't have bothered this time if it were not for an email from Amazon seeking one. I decided to go ahead with a review because this book really filled a need I had for working with AJAX for the first time. It had me up and running in very short order. Did it go over a couple things along the way that I already knew? Yes. But I didn't mind it in that it treated all topics in an intelligent manner and helped explain where AJAX fit into the broader world of web development. Definitely geared for .NET. That's what I wanted. If that's what you're looking for, you won't be disappointed.

5 comments about 3D User Interfaces: Theory and Practice.

1. A fortnight ago, at the Siggraph 2004 convention in Los Angeles, Addison-Wesley had a booth with many of their graphics books. This book was garnering a fair amount of interest. Now that I've had a chance to read it, I can see why.
   
   It is a lucid explanation of how to design three dimensional user interfaces. The authors summarise a vast body of work done in past decades. Plus, unlike perhaps some books that might focus on only US research, they show the global scope of the effort.
   
   Being a text on 3D graphics, you might expect considerable maths. There is indeed some, including a brief description of quarternions. But the amount of maths is deliberately downplayed. Enough is used to impart a basic flavour in certain sections. However, the general tenor of the book is at a higher level of design.
   
   Many serious issues remain unresolved. The book shows you what these are. Very helpful if you are in this field. Especially for newcomers.



2. I hope nobody takes academic in the negative sense. This is fascinating book that provides an overview of all of the different hardware and software techniques in the 3D user interface world. And it does a very capable job of using a combination of images and text to describe the technologies. It's academic in two regards; first, it's written like a paper, and second that it has little in terms of practical implementation.
   
   Frankly I doubt you could go far beyond the academic in an overview of a field that is this broad and this early in it's development. What this book does do is provide some real incentive to enthusiasts and developers to evaluate and combine these technologies. I thoroughly recommend this book to anyone who is in the field or has an interest in it.



3. If you are interested in knowing 3D UI, you should buy this book. It covers almost every technologies designed or developed in recent years. This book consists of about 13 chapters. In each chapter, it explained the different aspect of 3D UI interfaces following chronological patterns. So, if you want to follow or know technological paradigms, it can be one of useful books you should reference.



4. The book present a very good perspective that how is walking the tecnology of 3DUI, and limits that are growing down versus time.



5. If you will entering the world of virtual environments, 3D graphics and worlds, virtual reality and even augmented reality, this book will give you ALL the background information you need. It summarizes everything from software, hardware devices, interaction and everything that deals with the Third dimension.

2 comments about Focus On Mod Programming in Quake III Arena (The Premier Press Game Development Series).

1. Don't let the size of this book fool you.
   ID put together an incredible program with Quake series,
   and this is THE book to read about it!
   Good Job.



2. The Book refers you to a web site for additional code; however, the web site does not contain any information about the book. This makes it difficult to follow the instruction.

5 comments about Beginning Java Objects: From Concepts To Code, Second Edition.

1. I got this book from reading the user recomendations here. I just want to warn people this book is about 900 pages long, and the whole book goes into making just one program (a student registration program for a university). If you have the patience to read a book like this, fine, but for me its a little too drawn out, and nothing I saw thumbing through the chapters jumped out as being interesting or trying to make a point. I have read "Head First Java" and recommend that book for someone who is trying to make sense of OOP.
   
   Edit: I want to update this review by saying that I was too rash in critisizing this book. This book does do a good job of explaining how to plan and organize object oriented constructs to address real world problems rather than just a nuts and bolts overview of OO syntax that most other Java books give. This book however is not a "how to program in Java" book. You are going to have to move on to other Java books to become proficient in coding.



2. Regarding Brad's comment, the 'one program' is complex enough to give the reader a lot of practice in understanding the relationships between objects, and that seems to me (an out-of-practice former COBOL programmer) to be the biggest hurdle in understanding object-oriented programming. Barker's book gives more help in this area than the other Java books I've read. I read Eckel's Thinking in Java, and got lost by the middle of the book. Once I've finished Barker, I think I'll get a lot more out of Eckel.



3. I had the first edition of Beginning Java Objects From Concepts to Code sitting on my bookshelf for about 4 years. Meanwhile, I've taken several different Java training courses ranging from beginner to advanced level. I've been part of a development team, and although my role has generally been more of a business subject matter expert, I have also gotten my hands dirty and done some large chunks of coding, debugging, and refactoring other people's code.
   
   So what's my point? Well, although I've gotten by well enough in a pretty intense OO/Java environment, I've always felt like it was exactly that - getting by. I finally took this book off the shelf and worked my way through ALL of it over the last couple of weeks, and it really pulled things together for me in a way that nothing else has done. I've read about half of Eckel's Thinking in Java (a couple of times), and most of Deitel's Java How to Program, among others, and they're really great at what they do, but I wish I had worked through ALL of this book before (or at the same time as) reading those. Even though I already had a good understanding of Java syntax, this book helped me understand more than just the syntax of "System.out.println()".
   
   I've seen a couple of reviewers comment on Jacquie Barker's friendly tone, and I certainly agree with those reviewers. I felt like she was a trusted colleague helping me along, but not talking down at all.



4. "Beginning Java Objects" es un excelente libro que muestra las minucias de los objetos, la manera correcta en que deben de implementarse, la importancia de la encapsulaci?n y de los beneficios que nos proporciona la herencia.
   Estupendamente escrito, claridad y sencillez pero sin llegar a banalidades.
   La Programaci?n Orientada a Objetos desde el mejor ?ngulo.



5. This book has a real emphases on the object oriented aspect of Java. It explains it very well using an example of a student registration system which is built out throughout the book to enlight the things treated in each chapter.

5 comments about Building Application Frameworks: Object-Oriented Foundations of Framework Design.

1. This book in conjunction with the books "Domain-Specific Application Frameworks: Frameworks Experience by Industry" and "Implementing Application Frameworks: Object-Oriented Frameworks at Work" are a series of three books that constitute a complete and necessary guide for the design and implementation of application frameworks. They are based on multiple academic and industrial contributors experience building a wide range of domain-specific application framework. These books are very easy to read and understand and you can learn from them not only what a framework and an application framework are, but also how to apply this technology to real world domains, like manufacturing, health care, distributed computing, real-time systems, simulation environments, ...

   First book, "Building Application Frameworks: Object-Oriented Foundations of Framework Design" introduces application frameworks, their benefits and problems. It addresses all the fundamental concepts behind OO application frameworks and provides guidelines for OO application framework development. It is organized in eight parts. Part one provides a complete overview of OO application framework technology describing what is an application framework, what are the problems and benefits of application frameworks and how to use, develop and evaluate an application framework. Part Two presents some historical application frameworks and discusses some general guidelines to increase the reusability of application frameworks. Part Three describes how to build a framework analysing a concrete domain. The rest of the book provides all the necessary information to completely build an application framework. It presents all the concepts managed in framework development, which are the different development approaches, how to test the resulting frameworks, the problems derived from integration and a question sometimes forgotten but very important, the framework documentation.

   Second book, "Domain-Specific Application Frameworks: Frameworks Experience by Industry" is focused in the experience of industrial and academic contributors in the development of OO application framework in different domains. Each chapter covers step by step the complete development of an application framework in manufacturing, distributed systems, real-time systems, telecommunication, multimedia, chemistry and data visualization domains. It includes the motivation developers founded to choose application framework technology, the problems they had to solve and the final solutions they developed.

   Third book, "Implementing Application Frameworks: Object-Oriented Frameworks at Work", shows step by step how to implement application frameworks in different domains. It is organized in six parts covering examples about i) Business Frameworks with different examples in sales and administrative domains, ii) Artificial Intelligence, iii) Agent Application Frameworks, presenting interesting frameworks for speech recognition, neural networks and agents. iv) Specialized tool frameworks, v) Language Specific Frameworks, vi) System Application Frameworks, which present and analyse the application of OO frameworks in combination with other methodologies as component-oriented programming, language constructs or constraint programming and vi) Experiences in Application Frameworks. This last section is very useful because analyse the lessons learned using the application framework technology.




2. I was quite impressed by the book as it spans a wide range of academic and industrial issues. As a matter of fact, I recommend Dr. Fayad's publications to my graduate students as well to professionals. His writing is clear, concise, inspiring and evocative.



3. This three-volume reference is a good collection of articles that provide theoretical concepts and practical experience in designing, implementing, and documenting application frameworks.

   Volume 1, "Building Application Frameworks", addresses several problematic topics crucial to the success of object-oriented application frameworks. It presents a complete reference on how to develop a good application framework and provides guidelines for dealing with issues related to application frameworks.

   Volume 2, "Implementing Application Frameworks", illustrates the development and use of frameworks technology in several domains, such as business, artificial intelligence, agents, tools, environments, and system applications. It describes diverse application frameworks and discusses real-world experience.

   Volume 3, "Domain-Specific Application Frameworks", provides valuable insight into successful application framework examples. All the material is presented in a practical, easy-to-understand manner.

   I strongly recommend this three-volume reference for anybody planning to use the hottest technologies related to software reuse, frameworks, in the software development process.




4. Before the advent of frameworks (MFC, JDK, etc.) developing software systems of any size was hard, and large system development was close to impossible, with a harrowing failure rate. This book lights the way toward a future in which the development of large software systems can be thought of as a much more workable activity, one with a reasonable chance of success.
   "Building Application Frameworks" is a book that has been designed to be extremely useful as a reference for experienced software developers or as a textbook highly suitable for a wide variety of graduate level courses in the Computer Science field. The book comes complete with well thought out question sections and a large variety of real world examples. I highly recommend it!



5. For one that works on frameworks and tools almost every day, I'm one that understands the production of frameworks and the OO methodology very well - however I got this book on a recommendation for its rich content and ideas, but I was left dissappointed.

   First of all, the book is more of an academic book. I have no problem with this as the Design Patterns book produced by the GoF was written in the same manner, but the language and tone could have more informal to make it a more enjoyable read for the working architect rather than the university student.

   That not really being the real issue, there are many chapters in this book that are almost useless to read. I understand this book shouldn't be read from cover-to-cover (seeing as the chapters have hardly any real order to them - another bad point), but reading about a smalltalk framework for something so trivial and talking about it's significance for a hundred pages or so doesn't make me learn anything - simular to the Mythical Man Month. I'm sure these kinds of chapters or books even are an important, integral part of computer science and should be captured, but this isn't the book I'm afraid.

   The chapters on example frameworks, although helpful, didn't tell the reader a lot of inforamtion. For instance, the Hypermedia framework was written as it was being told with an overview. Although the patterns and some driving design decisions were made, the actual purpose of the framework was unclear until the end of the chapter that I put in the missing pieces myself. The author wrote it like a review or an abstract to a larger case study - which doesn't help those that truly want to understand what's going on.

   The chapters on formalizing and understanding frameworks, although I appreiciate the academic effort to describing frameworks, were useless reads as well. As an architect that has built many frameworks and continues to do so, their so-called "simplified model" couldn't even potentially describe half the frameworks i've built. For a book that is supposed to be the "definitive guide/reference" on frameworks, it most surely doesn't meet to the level of frameworks being produced in the enterprise today. Perhaps volumes 2 and 3 can clear this up.

   Given all this, however, the book has some good chapters, albeit reviews and abstracts of white papers and other books. If you really want to start building frameworks, maybe this would be a good start, but I'd recommend Design Patterns: Elements of Reusable Software, Refactoring, EJB Design Patterns and many other books about advanced OO and designing software that focus on the "smaller" elements of producing frameworks instead. If you truely understand these works, learning how to build frameworks is almost trivial and you won't really need to read this book. Maybe I'm just smart too, I dunno - you decide.

   Just my thoughts - hope that helps someone's buying decision.

5 comments about Sams Teach Yourself Object-Oriented Programming with VB.NET in 21 Days.

1. Sams Teach Yourself Object Oriented Programming with Visual Basic.NET in 21 Days by progamming expert Richard Simon is specifically focused on mastering the basic concepts as well as teaching beginning to intermediate level users how to apply OOP concepts in the new version of Visual Basic. The reader is not expected to have any mastery of a given OOP language. In fact, the stress of having to learn the syntax of an OOP language, without first having a strong conceptual foundation about the OOP paradigm, often prevents the programmer from doing effective Object Oriented Programming at the language level. Still, it should be recognized that a beginner's knowledge of the Visual Basic language undeniably helpful. Highly recommended for anyone needing a basic, practical, "user friendly" introduction. 432 pages.



2. After spending heaps of time sudyinh the UML - finally a book that brings OOP - UML and VB.NET together. I was wrong. After 1 chapter where the code doesn't match the examples in the book and where saving visual basic id actually .vb I am thouroughly lost and confused.



3. this book attempts to teach the reader how to develop VB.net applications using object-oriented methodologies.
   While it tries in meeting this objective, it falls short in a few areas.
   First, the codes in the book seem to be different from what you get, even when you follow the authors' guidelines religiously. Some lines of code just appear almost from nowhere; some of those that are accounted for are mysteriously rearranged in the book.
   The authors' coding styles are neither here nor there. They do not seem to be within easy grasp of the VB.net newby or at the league of the blackbelt category.
   Secondly, there are several omissions and inadequate explanations in the text. The authors obviously know their jobs. But they have difficulty imparting that knowledge to their readers. 21 chapters in a book of 360 pages mean each chapter, including the code snippets and screenshots, occupy less than 18 pages. Not that I am a fan of fluff, but I believe that adequate explanations would require many more pages.
   Thirdly, a few explanations are simply wrong. E.g. you don't save files with .visual basic extension, but with .vb; neither do you write:

   Me.TextBox.AcceptReturn = True
   Me.TextBox.MultiLine = True
   .......

   But you write:

   With Me.TextBox
   .AcceptReturn = True
   .MultiLine = True
   .......
   End With

   I gave it three stars because it gives the reader a bird's eye-view of what OOP looks like in VB.net. But that's how far this book can go. If you really want to learn OOP in better details, you will need to use additional resources--either one that is geared to the newbies, or one that is aimed at the gurus out there. This hermaphrodite of a book defies easy placement.




4. This book is not well written, it looks like the book was based on a Beta Version of Visual Studio .NET, and was never validated against the final release version of VB.NET.

   I like creating the programming examples from the book, I find that helps me to learn the product better and faster, however, I could not get the programs to work correctly when entered from the book.

   I stopped reading the book after the first chapter, because the information is incorrect.




5. Sorry guys but I thought your book was not comprehensive and it confused the heck out of me when I read it couple of years back. (John Sharp- C# step by step is an excellent book to learn OOP).
   
   I took this book as a teach yourself/ intro to OOP and unfortunately the authors didn't do a good job with their intended audience- people trying to learn OOP. Plus there were multiple bugs in their code, which was not helpful.

2 comments about Microsoft Office for Teachers (2nd Edition).

1. This is a well-written book on Microsoft Office, but if you are able to learn a software program (or even know what one is) on your own then you probably don't need this book. Flipping through it I do not venture to say it teaches me much beyond the basic of Microsoft Office. But if you are brand new to all this technology stuff it is well written and a good choice.



2. The content in this book is adequate and it is easy to follow the projects listed. Be clear on your purpose for this book and then check the table of contents to ensure it will support your need. It does not provide instruction for preparing newsletters and spreadsheets.