Professional Refactoring in Visual Basic Paperback – Apr 7 2008
|New from||Used from|
Customers Who Bought This Item Also Bought
No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
To get the free app, enter your mobile phone number.
From the Back Cover
Professional Refactoring in Visual Basic
In this one-of-a-kind book, Microsoft MVP Danijel Arsenovski shows you how to utilize the power of refactoring to improve the design of your existing code and become more efficient and productive. He provides you with a hands-on approach so you'll quickly learn how to manage and modify your code with refactoring tools and features. You'll also discover how to perform unit testing, refactoring to patterns, and refactoring to upgrade legacy Visual Basic code.
As you progress through the chapters, you'll build a prototype application from scratch. You'll then utilize refactoring techniques to transform the code into a properly designed, enterprise-level application. Arsenovski walks you step-by-step through each process while offering expert coding tips. You'll then be able to apply this information to real situations that arise as a result of company expansion, policy changes, or similar business decisions.
What you will learn from this book
The steps involved in assembling a refactoring toolkit
How to activate explicit and strict compiler options
Effective strategies for error handling
How to eliminate dead code, reduce scope, and remove unused references
Method consolidation and extraction techniques
Advanced object-oriented concepts and related refactorings
How to organize code for large-scale projects
Tips for taking advantage of LINQ and other VB 2008 enhancements
Core refactorings and basic code smells
How to use the free Refactor! add-in for Visual Basic
Visual Basic–specific refactorings and smells
Who this book is for
This book is for intermediate to expert programmers, developers, or .NET software architects who are familiar with basic object-oriented concepts, Visual Basic, and the Visual Studio environment.
Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.
About the Author
Danijel Arsenovski is a software developer from Santiago, Chile. Currently, he works as Product and Solutions Architect at Excelsys S.A, designing Internet banking solutions for numerous clients in the region. He started experimenting with refactoring while overhauling a huge banking system, and he hasn’t lost interest in refactoring ever since. He pioneered the use of refactoring as a vehicle for a VB 6 code upgrade to VB .NET. Arsenovski is a contributing author for Visual Studio Magazine and Visual Systems Journal, holds a Microsoft Certified Solution Developer (MCSD) certification, and was named Visual Basic MVP in 2005.
You can reach him at email@example.com, and you can take a look at his blog at http://blog.vbrefactoring.com.
Most Helpful Customer Reviews on Amazon.com (beta)
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.
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.
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 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.
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.
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 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.
Deals with some core refactorings like Dead Code Elimination, Scope Reduction etc. It's like cleaning up your code for some serious refactoring stuff.
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.
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?)
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.
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.
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.
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.
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!
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.
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!
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.
Martin Fowler finally has a fair partner on my shelf ;).
I highly recommend this book for any .NET developer, not just those who use Visual Basic.
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.
Look for similar items by category
- Books > Computers & Technology > Microsoft > Development > Visual Basic
- Books > Computers & Technology > Programming > Languages & Tools > Compilers
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Development
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Testing
- Books > Textbooks > Computer Science & Information Systems > Programming Languages