Professional Refactoring in Visual Basic and over one million other books are available for Amazon Kindle. Learn more
CDN$ 37.79
  • List Price: CDN$ 59.99
  • You Save: CDN$ 22.20 (37%)
Only 1 left in stock (more on the way).
Ships from and sold by
Gift-wrap available.
Add to Cart
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Professional Refactoring in Visual Basic Paperback – Apr 7 2008

See all 2 formats and editions Hide other formats and editions
Amazon Price New from Used from
Kindle Edition
"Please retry"
"Please retry"
CDN$ 37.79
CDN$ 10.99 CDN$ 11.12

Join Amazon Student in Canada


Product Details

Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on (beta) 7 reviews
6 of 6 people found the following review helpful
Great book for putting your team on agile track May 31 2008
By P. Reyes - Published on
Format: Paperback
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!
5 of 5 people found the following review helpful
Must read for any serious VB developer. May 2 2008
By D. Mijatovic - Published on
Format: Paperback
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.
4 of 4 people found the following review helpful
Great Book on Refactoring May 4 2008
By Slavko Glisic - Published on
Format: Paperback
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 ;).
2 of 2 people found the following review helpful
Very well done! June 13 2008
By Jason Down - Published on
Format: Paperback
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 of 1 people found the following review helpful
A worthwhile, unique, focused book for VB.NET developers Feb. 2 2010
By B. G. Palin - Published on
Format: Paperback
This is a unique book. It is non-introductory material, and it specifically targets VB.NET developers. This is a refreshing change, as most specialized books for .NET target C#.

Refactoring in Visual Basic introduces the reader to the concept of refactoring, using some simple examples, and then moves forward with various larger examples. The examples are all based on a running sample, which is explained early on in the book. Danijel describes each refactoring technique and the problem that it addresses, both in general and with respect to the running sample. By the end of the book, the reader has a healthy knowledge of various refactoring techniques and is able to start on his own refactorings.

Some nice mentions in this book include unit testing, refactoring to patterns, refactoring code from VB6 to .NET form, and VB9 features.

Throughout the book, the relevant smells are shown in light gray boxes, which helps to distinguish them from regular text. Unfortunately, there seems to be some repetition between the boxed text and the normal text...this was slightly offputting, but not a big issue really.

This book is a worthwhile read for any VB.NET developer. It is very focused on the topic, and it provides discussions specifically regarding code in VB.NET.