ASPMatrix.com Book Reviews

Essential ASP.NET with Examples in Visual Basic.NET

by Fritz Onion
Addison-Wesley Pub Co

There are so many books out about ASP.NET it can be a very difficult task to choose one. To me there seems to be two types of books. One is the example intensive (at times over laden) book. The other is the “how it works” type of book. The market seems to be flooded with example intensive books, but appears light in the “how it works” type. This book is a fantastic “how it works” book. It has good examples but is not drowning in them. The book’s strength is its explanations of ASP.NET core topics, and the little tips and tricks that readers will pick up along the way.

This book is well written and flows nicely. Without a doubt it is an excellent book for beginners and intermediate levels, but I would bet that even advanced users would pick up tips and tricks from the book.

Summary

Chapter 1: Architecture
This chapter explains the basic new architecture behind ASP.NET. Compilation vs. Interpretation, Code-behind, new Page architecture, Shadow Copying, Directives, and new Intrinsic Objects (HttpRequest, HttpResponse, etc) are a few of the topics covered.

Chapter 2: Web Forms
This chapter is all about Web Forms. ViewState, HtmlControls, WebControls, and Events are some of the items discussed. One section I liked the best was the “Day in the life of a page”. It explained the step by step events that occur during a page’s lifetime in a very clear and concise manner.

Chapter 3: Configuration
This is an excellent chapter that discusses the new XML based configuration in ASP.NET. Web.Config, Machine.Config, and configuration hierarchy are examined. processModel and other elements are also discussed.

Chapter 4: HTTP Pipeline
This chapter goes over the HTTP Pipeline, and all the actions that take place each time a requests comes in. It goes into great coverage of how that request is routed through the architecture. It also goes over Context, Applications, Custom Handlers, and a few other related topics. This is a great chapter.

Chapter 5: Diagnostics and Error Handling
This chapter shows us how to get out of the classic response.write method of debugging ASP apps by examining the new diagnostic and error handling capabilities of ASP.NET. Page Tracing, Application-level Tracing, Error Handling, and Unhandled Exceptions are all discussed.

Chapter 6: Validation
This is a chapter that explains form validation (client and server-side), validation control architecture, and the validation controls.

Chapter 7: Data Binding
This chapter starts by explaining the fundamentals of binding data to controls, and then goes into IDataReader Binding, DataSet Binding, and picking when to use a DataSet vs DataReader. The chapter ends by discussing templated controls (DataGrid, Repeater, and DataList).

Chapter 8: Custom Controls
This is the largest chapter of the book (69 pages). This chapter covers custom control fundamentals, state management consideration when designing custom controls, composite controls, and user controls. Designer integration with VS.Net as well as validation and data binding within custom controls is also covered. This is an excellent chapter.

Chapter 9: Caching
This chapter discusses the new caching opportunities that exist in ASP.NET. Output caching and how it works is discussed. The VaryByParam attribute is also examined, as well as page fragment caching. The chapter also covers data caching, and consideration and guidelines for using it.

Chapter 10: State Management
Application state, session state, cookie state, and view state are all covered in this chapter. I think this is a great chapter because it discusses the pros and cons of each type of state, which will help developers be able to determine which type of state management would be best for their specific situation. Good discussion, with great insights.

Chapter 11: Security
A short chapter on security ends the book. Server and client authentication start the chapter out, and then we go into ASP.NET security. The authentication and authentication elements in the web.config file are both discussed, as is role-based authentication. System identity is the last topic discussed.

I give this book a 9 out of 10. It would be a great addition to any developer’s library. It is also written with examples in C# for you semicolon worshipers. Well done!

Real World XMLWeb Services for VB and VB.NET Developers

by Yasser Shohoud
Addison-Wesley Pub Co

Web Services. I can’t believe there is anyone left alive in the technology sector that hasn’t heard these two words. Everywhere you look there are articles, books, and web sites that talk about this technology. Do a book search for “Web Services” on amazon.com and you will be quite amazed how many Web Services books there are. With so many available picking one buy may seem overwhelming. The good news is it just got a little easier to do.

Real World XML Web Services is an absolute “must have” for anyone who wants to learn more about XML Web Services. Even if you are not a VB/VB.net developer you will find great value in this book. It goes into extensive detail, and will surely teach even more savvy Web Services folks a thing or two.

Because of the books detail level, I don’t think that it is a first-read on the subject though. I think that someone who really doesn’t know much about Web Services will be drowned in the detail (which is incredible). A person can get more out of this book by doing some tutorials, and experimenting with Web Services first. Then, after having a good base of understanding is when this book should be cracked.

Summary

Chapter 1: Introduction to Web Services.
This is a brief intro chapter that gives some history and background info about Web Services. Some of the overview consists of typical Web Service architecture, and when to use (and NOT to use) Web Services.

Chapter 2: XSD: The Web Services Type System.
Great chapter. Goes into the concepts of XSD. Topics include the XSD Type System, XSD and XML namespaces, authoring XSD Schemas, and a ton of information about XML Serialization.
.
Chapter 3: SOAP: Invoking Web Services.
This chapter covers what SOAP is, SOAP architecture, SOAP message formats, RPC with SOAP, and also covers error handling.

Chapter 4: Describing Web Services.
A chapter all about the Web Services Description Language (WSDL), which is the language used to describe Web Service interfaces. I liked this chapter a lot because Yasser does a great job of really illustrating and explaining it well. Clear, easy to follow examples are used to drive concepts home.

Chapter 5: The Microsoft SOAP Toolkit.
As you might have guessed, this chapter is all about using the Microsoft SOAP Toolkit to invoke and expose Web Services. If you would like to know more about the toolkit you will like this chapter. Exposing and invoking Web Services via the high and low-level API’s is covered, as well as using header handlers to invoke and expose.

Chapter 6: .NET Web Services.
This chapter discusses creating .Net Web Services with Visual Studio .Net, as well as customizing the WSDL of the Web Service to meet your needs.

Chapter 7: SOAP Header and Fault.
All about SOAP headers and SOAP Fault. There is some great information about communicating errors in a common way so that any platform can get to it.

Chapter 8: Interface-Based Web Service Development.
Explains about Interfaces and the .Net Web Services world. Defining interfaces, implementing multiple interfaces, and programming against interfaces are some of the topics covered.

Chapter 9: Handling Data IN.NET Web Services.
This is a chapter that shows how to take data from many different types of sources and be able to manipulate it using XML Schemas, ADO.Net, and the XML Framework. Typed Datasets are also covered.

Chapter 10: Reusable Infrastructure with Soap Extensions.
This chapter teaches how to built a flexible and reusable infrastructure using SOAP extensions.

Chapter 11: UDDI: A Web Service.
This huge chapter pretty much tells us everything about UDDI that you could want to know. The chapter starts with an explanation of what it is and what it is made of. Then the chapter goes into different usage scenarios and various other UDDI topics. Programming, querying, and publishing Web Services with UDDI are just some of the other topics covered. This is an excellent chapter.

Chapter 12: Other SOAP Toolkits.
This chapter talks about Web Services Interop . Different clients are discussed including JAVA clients, VB 6 clients, and NET clients.

Chapter 13: A Web Service Walkthrough.
This chapter wraps up the book by walking the reader through building a Web Service. This is a great way to end the book as it ties together all the things that were discussed.

Appendix A: Data Type Mappings
Appendix B: .NET Web Services Tips and Tricks.
Two good appendixes that give us more information, as well as tips and tricks.

I give this book a 10 out of 10. Yasser did a fantastic job on it. Again, although I do not think this is a “first read” book on Web Services, I believe it is a “must have” Web Services book. Any developer that works with, or wants to work with Web Services will find it valuable.

Pragmatic ADO.NET: Data Access for the Internet World

by Shawn Wildermuth
Addison-Wesley Pub Co

The world of ADO.NET can be confusing to someone who is used to the old versions of ADO. I remember the frustration of trying to wrap my mind around the new concepts of the “disconnected data” world.

I read a couple of books that had information on ADO.NET and some decent examples. Even though the examples helped me grasp some of the “how to do” questions in my mind, none of them really explained how the new version of ADO.NET worked, why it was designed the way it is, or gave any best practices. Luckily, I was able to review this book and a million pieces of the puzzle came flying into place.

Pragmatic ADO.NET is an excellent teacher of what ADO.NET is, how it works, and how the everyday developer can use it. This is THE book to read if you want to understand how ADO.NET works, and learn best practices of how to use it.

This book has many examples, but is not over laden with them. They are shared in a very clear and precise manner, which is always straight to the point. The examples will help you put into play the best practices that are discussed in the book. One thing I would have liked to see were more examples in VB.NET. 99% are in C#.

The book is very well written, and flowed very smoothly from one topic to the next. Shawn has a way of explaining things very clearly, and in such a way that anyone can understand. That being said, this is NOT a beginner’s book. I would say that this is a “Must Read” book for anyone who knows ADO and wants to get into the world of ADO.NET, or for intermediate and higher level .Net developers who want to know more about ADO.NET. Without a doubt, even seasoned developers would benefit from this book. The best practices that Shawn shares are priceless, and come from his real world experiences.

Summary:

Chapter 1: Why ADO.NET
This chapter gives a short history of Universal Data Access, and then gives a primer on ADO.NET. It discusses why the new ADO.NET is better than the old ADO, and also goes into things like ADO.NET data structures and managed providers.

Chapter 2: Getting Connected with ADO.NET.
This chapter deals with connections in the ADO.NET world. SQL Server, OLE DB, Oracle, and ODBC connections are discussed. Connection pooling for all these connection types are discussed. Returning OLE DB database schema information and ADO.NET exception handling are also covered.

Chapter 3: Commanding the Database.
ADO.NET command types are discussed, as well as how to execute them. Some other topics include, wrapping stored procedures, using parameters, and parameterized queries. The chapter ends by covering Transactions and Batch Queries.

Chapter 4: Reading Data.
All about the world of DataReaders. How they are made, how they work, etc. Dealing with Database locks, multiple result sets, and working with datareader Meta Data are some of the other topics covered.

Chapter 5: Constructing DataSets.
This is one of my favorite chapters. It helped put a lot of my “missing puzzle pieces” in place. DataSets are thoroughly discussed, and topics include TableMappings, multiple DataTables, DataAdapters, creating DataSets from XML, etc. The chapter also covers defining the DataSet schema, which includes how to work with primary keys, relationships, constraints, triggers, and many other things.

Chapter 6: Typed DataSets.
This chapter discusses Typed DataSets. What they are, how you make them, and how to use them. The chapter ends with a discussion on simplifying Business Object Layers with Typed DataSets.

Chapter 7: Working with DataSets.
Now that we know what DataSets are, this chapter begins working with them. Topics covered include changing, navigating, searching, and merging Data in DataSets.

Chapter 8: Updating the Database.
Disconnected data is great, but it “comes at a cost” as Shawn puts it. This chapter teaches the ins and outs of concurrency in the ADO.NET world. Inserts, updates, deletes, and the different concurrency types are covered. It is a great chapter and you will finish with a great understanding of how to get the DataSet changes back into the actual Database.

Chapter 9: ADO.NET and XML.
This chapter is all about the DataSet and XML. Getting the data into XML, saving it as XML, and getting XML to fill a DataSet are a few of the topics discussed.

Chapter 10: Data Binding with ADO.NET.
This chapter discusses the different types of ADO.NET data binding for Windows forms and ASP.NET.

Chapter 11: Scalability and Performance.
This is another one of my most favorite chapters from the book. Shawn’s real world experience shines light on to the world of performance and scalability. When to worry, why to worry, and how to avoid problems are all discussed. The last section of the chapter is all about best practices, and is a great read.

Appendix: ADO Migration Strategies
Broad overview of migrating to ADO.NET from ADO. How to migrate ADO recordsets, connections, and a few other related topics are covered.

In conclusion, I give this book a 10 out of 10. It is an excellent book, and one that is worth your while to read. I highly recommend it. I wouldn’t really change much about it, except I would tell Shawn not to use Atlanta Braves players in his examples... He should use a better team, like the Arizona Diamondbacks.

Design Patterns Explained: A New Perspective on Object-Oriented Design

by Alan Shalloway, James R. Trott
Addison-Wesley Pub Co

Design Patterns Explained is a book that was recommended to me by a friend. He told me he really liked it so I decided to give it a try. I had always been hesitant to really investigate Design Patterns after hearing some of the stories people had told me about different books they had read. It didn’t sound like much fun. Luckily, I decided to give this book a try. It was a great experience. Read on to find out why!

Summary:

Chapter 1: The Object-Oriented Paradigm
The first chapter introduces us to Functional Decomposition, handling changing requirements, and the OO Paradigm. Functional Decomposition is the process by which many developers would break down a problem and create a solution. The Authors state this is a fairly natural process that many folks use. The problem is that this process does not really look at other alternatives, which may be available. It also makes it harder for the developer to handle changing requirements. The Authors finish the chapter by discussing the OO Paradigm and concepts of OO Programming. This chapter is well written, and you come out of it ready for the rest of the book.

Chapter 2: The UML - The Unified Modeling Language
This chapter gives an overview of UML. Even though it is a quick chapter, the authors do a fantastic job explaining UML and how to read the diagrams.

Chapter 3: A Problem that Cries Out for Flexible Code
Chapter 4: A Standard Object-Oriented Solution
In chapter 3 the author illustrates a problem that needs to be solved, actually using an example from his real world experiences (CAD/CAM Application). He shows us the process by which we can get a better understanding of the problem, and then how to describe and define what the problems are. In chapter 4 a solution is given and discussed. It is shown why this is a good first solution, but why it is not a good final solution. Code examples are given in Java and C++, but don’t worry if you are not real familiar with those languages. The theory is written in such a way that it is easy to understand, and the UML lesson in chapter 2 will be a great help.

Chapter 5: An Introduction to Design Patterns
This chapter is, as the title would indicate, an intro to Design Patterns. The origins of Design Patterns are discussed, and we find out how it was taken from the Architecture world and brought into the software realm. It is a very well written and understandable chapter that sets the reader up for the next 5 chapters.

Chapter 6: The Facade Pattern
This chapter discusses the Facade Pattern, which is a pattern that most have probably used but not realized it. This pattern is used when you have a very complex system and only need to use a subset or part of it. This is a small, but well written chapter

Chapter 7: The Adapter Pattern
The Adapter pattern is creating a new interface for an object whose interface just isn’t doing the job. A great example is shown, and you leave the chapter understanding what the Adapter Pattern is and what it should be used for.

Chapter 8: Expanding Our Horizons
In this chapter the authors talk about Object, Encapsulation, and Inheritance but not just in the ways you might think. They introduce different ways of thinking about them than the usual, and expand our understanding of what is possible.

Chapter 9: The Bridge Pattern
This chapter discusses the Bridge Pattern in great detail. The authors state that this is a very difficult pattern to understand because it is extremely powerful. The two main ideas are “find what varies and encapsulate it” and “favor composition over inheritance”. This chapter will teach you what this actually means and how to use it.

Chapter 10: The Abstract Factory Pattern
This chapter starts out with an example that will that will lead to knowing what the Abstract Factory Pattern is, and then shows you how to implement it. The authors do a great job illustrating their ideas.

Chapter 11: How Do Experts Design?
In this chapter the discussion returns to the roots of Design Patterns, and discusses Christopher Alexander’s approach to Architecture design. From this the authors can extend Alexander’s theories and practices into the software world.

Chapter 12: Solving the CAD/CAM Problem with Patterns
This chapter returns to the original CAD/CAM example. Armed with the knowledge of patterns we have learned, the discussion goes in depth to show how we can use patterns to solve the same problem more efficiently and with room to grow in the future.

Chapter 13: The Principles and Strategies of Design Patterns
This is a very brief chapter that covers designing from context, and encapsulating variations in classes. I am not sure why this chapter needed to be here, and not added in to a different one. But, it is well written and gives good insights into these two design strategies.

Chapter 14: The Strategy Pattern
Chapter 15: The Decorator Pattern
Chapter 16: The Singleton Pattern and the Double-Checked Locking Pattern
Chapter 17: The Observer Pattern
Chapter 18: The Template Method Pattern
Chapter 19: The Factory Method Pattern
In chapters 14-19 a new case study is introduced. It involves e-tailing which is defined as electronic retailing over the Internet. I am not going into specifics on each chapter because they would basically each describe the new pattern, and how it can be applied in the case study. Each chapter builds on the ideas of the one before it, and gives great insight into the when and why of using each of the patterns discussed. These chapters flow very well into one another. The authors provide us with not only clearly written ideas, but also excellent illustrations and charts that drive their ideas home.

Chapter 20: The Analysis Matrix
This chapter concludes the e-tailing case study in chapters 14-19 by discussing variations that occur in the problem domain. The authors state, “In the real world, problems are not tidy or well behaved”. My personal experiences have taught me to believe the same thing. The numbers of exceptions and / or variations that pop up seem to be infinite. Through use of the Analysis Matrix, we can reveal patterns that manifest in the problem, and can deal with them accordingly. The authors use excellent examples of how to use the Analysis Matrix, and use real world examples to reinforce the use of such a tool.

Chapter 21: Design Patterns Reviewed From Our New Perspective of Object-Oriented Design
This short summation chapter takes us on a brief high-level review of key points.

Chapter 22: Bibliography
The authors give a listing of books they feel would be good further reading so you can continue your journey.

To conclude this review I would like to say a few things. One is that I was very impressed by the way that this book was written. It takes some pretty hard concepts and breaks them down into understandable comparisons to real-world examples. Not only that, but the ideas are very well organized, and written in such a way that just about anyone could understand them. The entire book is this way, and the authors are adept at it. That is not as easy as it may sound. Many have tried, but few have succeeded. The authors excel in this, and as a result create a finished product that is one of the most well written technical books I have ever reviewed.

Another thing I liked about the book was that the chapter end summaries were very short, and outlined each chapter’s key points perfectly. Also, the margins of the book have the key points next to the main paragraphs for each. This is a great idea because it makes looking back through the book for specific points much easier. Since the key ideas are in the margin surrounded by white space, they stick out and are easily noticeable while flipping through pages. I wish more of my favorite books had this little nifty feature.

If I could change one thing about the book it would be to write it with VB examples in addition to the Java and C++ ones it has. Maybe by the next edition there will be some VB.net examples since VB.net is now truly Object-Oriented. I would really like that. Don’t be scared of the book just because it has only Java and C++ examples though. They explanations of theory are so well written that the example language would not be a barrier.

I give this book a 10 out of 10. It is an excellent book, and one that is worth your while to read.

An Introduction to Object-Oriented Programming with Visual Basic .NET

by Dan Clark
Publisher: Apress

To me “introduction” books are always an interesting venture. Some are great experiences, and others are nightmares. This book was a pretty good experience. Except for a few bumps in the road it was a pretty smooth ride. In the chapter summary below I will go into a little more detail on the positive and negative points.

Chapter Summary:

Chapter 1: Overview of Object Oriented Programming
This chapter starts with a very brief overview of the history of OOP. Brief is good. It also has brief definitions of OOP characteristics; Objects, Abstraction, Encapsulation, Polymorphism, Inheritance, and Aggregation. It ends with a blurb about the history of VB.

Chapter 2: Designing OOP Solutions: Identifying the Class Structure &
Chapter 3: Designing OOP Solutions: Modeling the Object Interaction
These chapters go into UML and things like Use Cases, Class Diagrams, Sequence Diagrams, Collaboration Diagrams, and Activity diagrams. This seemed exciting to me because I never really get into anything like this on the job, and I wanted to know a little more about it. Well, while interesting this ended up being a bump in the road for me.

The Author says to either do the exercises with a UML Modeler you can download from the net, or creating the diagram by hand. Well, I wanted to try the tool he used in the examples so I downloaded it. At this point just let me say that you should be prepared to spend a lot of time figuring out the tool if you decide to try it. It is not easy. The directions for doing the exercises don’t quite flow with actually using the tool either. The author does state that it is pretty tricky to use, but I really feel that the directions for these exercises should have been better. I managed to get through some of the examples in chapters 2 and 3 after a couple of hours, but I finally gave up and went to pencil and paper in interests of not losing my entire weekend. I would recommend that readers should use the pencil and paper approach to save a lot of time.

Chapter 4: Designing OOP Solutions: A Case Study
This chapter talks about the process by which one would design an OOP solution with a case study. The Author goes into good detail about the actual steps needed, and does a good job explaining the methodology by which this is accomplished. He also gives some good advice on how to avoid some of the more common pitfalls of designing an OOP solution.

Chapter 5: Introducing VB .NET
This chapter gives an overview of VB.Net as well as the .Net Framework. After the overview it gives you a hands on tour of the Visual Studio .Net IDE. Of course, you will need to have the IDE to do the tour. This tour shows you many of the screens, option settings, and menus of Visual Studio .Net. The second exercise shows you the debugging features of VS .Net. At his point you will need files that you can download from the following location on the Apress web site: http://www.apress.com/book/supplementDownload.html?bID=90&sID=538
I may have missed it, but I never saw any mention that downloading files was needed for the exercises. It certainly was not at the beginning of this exercise, and I think their should be some kind of direction about it present. Anyway, once you have the downloaded files the tutorial goes perfect.

Chapter 6: Creating Classes
This chapter is all about classes. How to restrict them, access to them, creating methods, overloading methods, using constructors to name some topics. This chapter too has exercises you complete with VS .Net. They all seemed to work fine for me, and were very easy to follow.

Chapter 7: Creating Class Hierarchies &
Chapter 8: Implementing Object Collaboration
These chapters discuss things like inheritance, polymorphism, interfaces, delegation, error handling, shared properties and methods to new a few. These two chapters also have multiple hands-on activities so you can continue to learn how to operate VS .Net as well as learn more concepts of OOP. These activities are well documented, and I had no problems completing them all without incident.

Chapter 9: OSO Application Revisited: Implementing the Business Logic
This chapter helps bring together all the ideas you were introduced to in chapter 4. From there it goes into data access by talking about stored procedures, ADO.net, sqlclient namespace, and many other details. In order to do the examples you will have to have SQL Server. All the examples work, and are pretty interesting. Again, this is all done using the VS.net IDE so you continue to become more familiar with it.

Chapter 10: Developing Windows Applications
This is a fun chapter that talks about windows forms, event handlers, dialog boxes and different types of bound controls. This chapter is full of hands on activities that are well done. They all worked fine for me, and really helped me become familiar more familiar with the IDE.

Chapter 11: Developing Web Applications
This long chapter deals with web forms, server controls, server control inheritance, server-side event processing, ASP.net, state, and many other things. It is all about designing an application for the web. The activities are easy to follow, and work.

Chapter 12: Wrapping Up and Reviewing
A quick summation of what the book covers and some tips on where to focus next.

Appendix A: Fundamental Programming Concepts
This appendix is basically a primer for beginning programmers. It defines terms and concepts. There are some good definitions and explanations. It would be a good knowledge builder for a beginner.

Appendix B: Exception Handling in VB .NET
A quick 4-page explanation of how exceptions are handled in VB.Net

After finishing this book I had a hard time deciding what grade to give it. I ended up giving it a 7 out of 10. The many problems I had with the UML activities using the UML modeler were just too painful and frustrating to give it higher than a 7.

I will admit that the rest of the book was great and would be very useful to a beginner trying to become more familiar with VB.net and VS.net. The VS.net activities were flawless, and gave good hands-on experience that beginners would love. The UML material was actually good as well, but the problems with the modeling tool activities really influenced my final judging of the book.

In summation, this book is without doubt a beginner’s book. Do not buy this if you already basically familiar with VS .net or UML. If you do it will be very disappointing for you. If you are a beginner and do the UML activities with pen and paper I believe it will be a great learning experience.

VB.NET Language in a Nutshell

by Steven Roman, Ron Petrusha and Paul Lomax
O'Reilly & Associates

My experiences with ‘Nutshell’ books have been both bad and good. I wasn’t sure which I would get with VB.Net Language in a Nutshell. After reviewing this book I am happy to say this is a good one. Not only good, superb.

I have used this book about 20 times in the last 2 weeks when I needed to look something up quickly. The funny thing was that the pile of books I usually keep close by on my computer table seemed to diminish the more I used it.

I have really only used the VB and VBScript languages (no C or C++, and just a smidge of Java), so going with VB.Net was definitely the path of least resistance when starting to work with ASP.Net. This book will be a great asset to someone who wants to stay in the VB world. Through out the book you will find VB.Net / VB 6 differences pointed out. These tips will really help during the transition to VB.Net.

Chapter by Chapter Summary:

Chapter 1: Introduction
This very short chapter gives a little background on VB and VB.Net. It is very brief, and I do not know if it is really needed. Most VB people will know the history of VB, and anyone getting this book will probably have heard all the info on VB.Net that is given. That being said it may just be in for the non-VB people getting the book.

Chapter 2: Program Structure
This chapter goes in to the details and nuts-n-bolts of what the structure of a VB program is. It also gives quick overviews of functions, sub procedures, property procedures, events, console apps and window forms apps.

Chapter 3: Variables and Data Types
This is a good chapter. It talks about everything from variable properties and scope to arrays and passing objects. VB data types, binding, and arguments are among the other things covered. All topics have very concise definitions and meaningful examples. No extraneous fluff.

Chapter 4: Introduction to Object-Oriented Programming
The chapter title pretty well says what this chapter is about. Encapsulation, Inheritance, Interfaces, Polymorphism, etc. are all discussed with a VB.Net twist. In reality this chapter and chapter 1 could have been integrated together, but I won’t bust them too bad on this since I really liked their information on Garbage Collection.

Chapter 5: The .Net Framework: General Concepts
This is a short 6-page chapter on general .Net Framework information. Briefly touches on Namespaces, Assemblies, and the CLR.

Chapter 6: The .Net Framework Class Library
This is another very brief chapter that highlights just a few of the more than 90 Namespaces in the .Net Framework Class Library.

Chapter 7: Delegates and Events
This chapter is an 8-page brief on delegates, events, and event binding. Not much more to really say.

Chapter 8: Attributes
This 10-page chapter goes into Attributes. Their use and syntax, as well as instruction on using custom attributes is covered.

Chapter 9: Error Handling in VB.Net
This chapter does a great job of explaining Error Handling in VB.Net. The difference between error detection and error handling is defined. Structured (Try, Catch, Finally) and unstructured error handling are discussed. Exception classes, logical errors, and error constants are also briefly talked about. This is a great overview chapter.

Chapter 10: The Language Reference
This is THE chapter. This almost 450-page chapter alone is worth the $45 price tag. It is a listing of the VB.Net language elements. There are many things I really like about the way that they cover the language elements. Besides return values and descriptions of the elements, they also have included ‘Rules at a glance’, which quickly informs you of all the important information as to the usage of the element. Another thing I like is the ‘Programming tips and gotchas’ section that some of the elements have. All are full of useful information that will save you time. The thing I probably like the most is the ‘VB.NET / VB 6 Differences’ blurbs they give when there is a difference in the language element from VB 6 to VB.Net. Those blurbs are invaluable to someone transitioning from the VB 6 world. Excellent, excellent, excellent chapter. Well done.

Appendix A: What is new and different in VB.Net
This appendix specifically covers the changes from VB 6 to VB.Net. This is an excellent supplement to the ‘VB.NET / VB 6 Differences’ blurbs in chapter 10. I also like that they give a listing of the obsolete programming elements that have been removed from VB.Net.

Appendix B: Language Elements by Category
This is an excellent supplement for chapter 10. It helps you find which language elements you need to use when approaching a specific kind of situation. It is a very nice and useful appendix.

Appendix C: Operators
This appendix covers the 4 kinds of Operators in VB.Net. They are Arithmetic, Assignment, Comparison, and Logical. Order of precedence is also covered. Excellent reference material.

Appendix D: Constants and Enumerations
This is a reference for all the built-in Constants and Enumerators for VB.Net. Again, great reference material.

Appendix E: The VB.Net Command-Line Compiler
A reference for the VB.Net command-line compiler. The switches are well explained.

Appendix F: VB 6 Language Elements Not Supported by VB.NET
This gives an alphabetical listing of the language elements in VB 6 that are not present in VB.Net. Once again, this reference will be very helpful for those transitioning to VB.Net from VB 6.

Well folks, without a doubt this book is a 10 out of 10. Get it. It is well worth the price. Well done!

Refactoring: Improving the Design of Existing Code

by Martin Fowler with contributions by Kent Beck, John Brant, William Opdyke, and Don Roberts
Addison-Wesley Pub Co

A little while back I was introduced to a word I had never heard before, Refactoring. I was told to get Martin Fowler’s book and read it so I could gain a better understanding of what Refactoring was. Well folks, I would classify this book as a ‘Hidden Treasure’.

Although it is not a flashy or well known title, I believe its impact can be much deeper and long lasting than many of the mainstream, more popular technology books. The underlying theories that it teaches can be applied for years, even when technology changes.

There are only a couple of things I would change about this book, which I will mention below.

Preface
The Preface it brief enough, and gives the definition for the word Refactoring. This is a good thing because right form the start you get the true definition of Refactoring. In short, refactoring is the process of changing code to improve the internal structure, but not changing the external behavior.

Chapter 1: Refactoring, a First Example
In this chapter Mr. Fowler tries to start by showing a simple Refactoring example. The problem is that the chapter then goes on for 50+ pages. Mr. Fowler explains his reasons for doing this, but I think that a simple example should have been much simpler. Especially when it is in the first chapter of the book. It’s not that this isn’t a good chapter. I feel it’s just too soon in the book. I would have put it at the end.

Chapter 2: Principles of Refactoring
This is an excellent chapter. The definition of Refactoring is discussed as well as the following questions: Why should you refactor? When should you refactor? What do I tell my manager? This last question may seem funny, but when you read this chapter you will understand why it is in there. This chapter also discusses common problems that occur during Refactoring, and Refactoring and performance.

Chapter 3: Bad Smells in Code
In this chapter things that cause code to ‘smell’ are discussed. When code ‘smells’ it could be an indicator that refactoring is needed. 22 different ‘smells’ are discussed. My favorites were Duplicated Code, Large Class, and Lazy Class. This is a chapter full of awesome hints.

Chapter 4: Building Tests
Building tests is an important part refactoring. Refactoring is done in small steps, and after every step you should test. In this chapter the discussion covers the processes and methodology of applying tests during refactoring.

Chapter 5: Toward a Catalog of Refactorings
This chapter is a quick setup for chapters 6 to 12. Mr. Fowler explains his method for cataloging the individual refactorings. What is pretty amazing is that he has taken a lot of time naming and detailing each refactoring.

Chapter 6: Composing Methods
One of my favorite chapters. Mr. Fowler opens by saying, “A large part of my refactoring is composing methods to package code properly.” This chapter is all about that. 9 total refactorings are explained. My favorite ones are Inline Method and Extract Method.

Chapter 7: Moving Features Between Objects
Sometimes you need to move things from one object to another. This chapter discusses the art of moving features between objects. 8 total refactorings are discussed and detailed. My favorite from this chapter is Extract Class.

Chapter 8: Organizing Data
A very large chapter that discusses in meticulous detail 16 refactorings that will make it much easier to work with data. One thing that becomes very obvious in this chapter is that certain refactorings can go either way. What I mean is illustrated by these two: Change Value to Reference and Change Reference to Value. So some refactorings are not just one way deals. It just depends on the situation.

Chapter 9: Simplifying Conditional Expressions
This is a very useful chapter since conditional logic is a common occurrence in the programming world. Because conditional logic has a tendency to get very complex, this chapter has 8 refactorings that will help you simplify things.

Chapter 10: Making Method Calls Simpler
The 15 refactorings in this chapter help teach us how to make method calls easier to deal with. They range from the very simple Rename Method to the more complex Replace Constructor with Factory Method.

Chapter 11: Dealing with Generalization
Here are 12 refactorings dealing with the situations that arise from generalization. Inheritance, Delegation, and Interfaces are some of the topics discussed.

Chapter 12: Big Refactorings
Kent Beck co-wrote this chapter with Mr. Fowler. They discuss what they call the 4 Big Refactorings: Tease Apart Inheritance, Convert Procedural Design to Objects, Separate Domain from Presentation, and Extract Hierarchy. These refactorings are of a more all-encompassing type than the smaller individual refactorings from the preceding chapters. The co-authors do a great job at putting in a nutshell what would normally take very long explanations.

Chapter 13: Refactoring, Reuse, and Reality
William Opdyke writes this chapter. He discusses his experiences with refactoring as well as other subjects like why developers are reluctant to refactor and reducing the overhead of refactoring. This chapter is an excellent ‘putting it all together’ chapter, and really helps put into perspective the ideas that the book teaches.

Chapter 14: Refactoring Tools
Don Roberts and John Brant co-author this chapter. They discuss, as the chapter title would indicate, refactoring tools.

Chapter 15: Putting It All Together
Kent Beck gives a quick 4-page wrap up.

One other thing I would change about the book is that I would want there to be examples in other languages besides Java. I have practically no Java skills. For me the book would have been an easier and faster read if it would have had examples in VB.net. Fortunately I understand enough to get the idea of what is being taught, and that is the most important point.

Well as I said above, this book is really what I would consider a ‘hidden treasure’. The things discussed will help many people write better, more understandable code for years to come. I would give it a 9.5 out of 10. It is well worth the price.