Refactoring

Many businesses and organizations depend on older high-value PHP software that risks abandonment because it is impossible to maintain. The reasons for this may be that the software is not well designed; there is only one developer (the one who created the system) who can develop it because he didn’t use common design patterns and documentation; or the code is procedural, not object oriented. With this book, you’ll learn to identify problem code and refactor it to create more effective applications using test-driven design.

What you’ll learn

• What refactoring is and why you need to refactor code
• What test-driven design is and why you need to test your code
• How to write unit and functional tests with PHPUnit and Selenium Remote Control (RC)
• How to detect “bad smells” in PHP code, and refactor them using test-driven design
• How to refactor a large procedural application affected by many bad smells

Who is this book for?

This book is for PHP developers, businesses, and developers relying on legacy PHP apps.

Many businesses and organizations depend on older high-value PHP software that risks abandonment because it is impossible to maintain. The reasons for this may be that the software is not well designed; there is only one developer (the one who created the system) who can develop it because he didn’t use common design patterns and documentation; or the code is procedural, not object oriented. With this book, you’ll learn to identify problem code and refactor it to create more effective applications using test-driven design.

What you’ll learn

• What refactoring is and why you need to refactor code
• What test-driven design is and why you need to test your code
• How to write unit and functional tests with PHPUnit and Selenium Remote Control (RC)
• How to detect “bad smells” in PHP code, and refactor them using test-driven design
• How to refactor a large procedural application affected by many bad smells

Who is this book for?

This book is for PHP developers, businesses, and developers relying on legacy PHP apps.

Evolve your software system to support new and ever-changing requirements by updating your C# code base with patterns and principles

Overview of Refactoring with Microsoft Visual Studio 2010

• Make your code base maintainable with refactoring
• Support new features more easily by making your system adaptable
• Enhance your system with an improved object-oriented design and increased encapsulation and componentization
• Concepts are presented in a comfortable one-on-one, pair-programming style
• A practical approach that's packed with examples to enrich understanding

In Detail

Changes to design are an everyday task for many people involved in a software project. Refactoring recognizes this reality and systematizes the distinct process of modifying design and structure without affecting the external behavior of the system. As you consider the benefits of refactoring, you will need this complete guide to steer you through the process of refactoring your code for optimum results.

This book will show you how to make your code base more maintainable by detailing various refactorings. Visual Studio includes some basic refactorings that can be used independently or in conjunction to make complex refactorings easier and more approachable. This book will discuss large-scale code management, which typically calls for refactoring. To do this, we will use enterprise editions of Visual Studio, which incorporate features like Application Performance Explorer and Visual Studio Analyzer. These features make it simple to handle code and prove helpful for refactoring quickly.

This book introduces you to improving a software system's design through refactoring. It begins with simple refactoring and works its way through complex refactoring. You will learn how to change the design of your software system and how to prioritize refactorings--including how to use various Visual Studio features to focus and prioritize design changes. The book also covers how to ensure quality in the light of seemingly drastic changes to a software system. You will also be able to apply standard established principles and patterns as part of the refactoring effort with the help of this book. You will be able to support your evolving code base by refactoring architectural behavior. As an end result, you will have an adaptable system with improved code readability, maintainability, and navigability.

Refactor Visual Studio solutions to make them more maintainable

What you will learn from this book

• Improve code readability by applying effective concepts and techniques
• Spot discrepancies in code with code smells
• Catch and eliminate dead code and learn several such smart methods
• Make changes to your code without introducing adverse side-effects with code maintainability
• Learn smart ways to improve code navigability
• Improve your design by applying design principles and methodologies
• Enhance the maintainability of your code base by refactoring it to be more cohesive and less coupled
• Obtain an optimal level of flexibility by refactoring your code to a loosely-coupled design
• Minimize the side effects and support changes to your code by refactoring to a layered architecture
• Support your evolving code base by refactoring architectural behavior
• Back up the refactoring effort by ensuring quality with Unit Testing

Approach

This book focuses on real-world, easy-to-understand examples of code in a one-on-one style. Refactoring examples are performed and reasons why this refactoring should be applied are detailed. The book is structured from less advanced topics to more advanced topics; but is designed so that reading from beginning to end is not necessary.

Who this book is written for

This book is primarily for developers who want to refactor their code in Visual Studio. However, the book can be used by anyone using Visual Studio. Developers, designers, and architects who are eager to improve the performance of their craft will find this book useful because it details refactoring existing code to use recognized and established patterns and principles to improve code structure and architectural behavior.

The book assumes that the reader knows both Visual Studio and C#, but no previous knowledge of refactoring is required.

Automated testing is a cornerstone of agile development. An effective testing strategy will deliver new functionality more aggressively, accelerate user feedback, and improve quality. However, for many developers, creating effective automated tests is a unique and unfamiliar challenge.

xUnit Test Patterns is the definitive guide to writing automated tests using xUnit, the most popular unit testing framework in use today. Agile coach and test automation expert Gerard Meszaros describes 68 proven patterns for making tests easier to write, understand, and maintain. He then shows you how to make them more robust and repeatable--and far more cost-effective.

Loaded with information, this book feels like three books in one. The first part is a detailed tutorial on test automation that covers everything from test strategy to in-depth test coding. The second part, a catalog of 18 frequently encountered "test smells," provides trouble-shooting guidelines to help you determine the root cause of problems and the most applicable patterns. The third part contains detailed descriptions of each pattern, including refactoring instructions illustrated by extensive code samples in multiple programming languages.

Topics covered include

• Writing better tests--and writing them faster
• The four phases of automated tests: fixture setup, exercising the system under test, result verification, and fixture teardown
• Improving test coverage by isolating software from its environment using Test Stubs and Mock Objects
• Designing software for greater testability
• Using test "smells" (including code smells, behavior smells, and project smells) to spot problems and know when and how to eliminate them
• Refactoring tests for greater simplicity, robustness, and execution speed

This book will benefit developers, managers, and testers working with any agile or conventional development process, whether doing test-driven development or writing the tests last. While the patterns and smells are especially applicable to all members of the xUnit family, they also apply to next-generation behavior-driven development frameworks such as RSpec and JBehave and to other kinds of test automation tools, including recorded test tools and data-driven test tools such as Fit and FitNesse.

Visual Summary of the Pattern Language 
Foreword
Preface
Acknowledgments
Introduction
Refactoring a Test
PART I: The Narratives
Chapter 1 A Brief Tour
Chapter 2 Test Smells
Chapter 3 Goals of Test Automation
Chapter 4 Philosophy of Test Automation
Chapter 5 Principles of Test Automation
Chapter 6 Test Automation Strategy
Chapter 7 xUnit Basics
Chapter 8 Transient Fixture Management
Chapter 9 Persistent Fixture Management
Chapter 10 Result Verification
Chapter 11 Using Test Doubles
Chapter 12 Organizing Our Tests
Chapter 13 Testing with Databases
Chapter 14 A Roadmap to Effective Test Automation
PART II: The Test Smells 
Chapter 15 Code Smells
Chapter 16 Behavior Smells
Chapter 17 Project Smells
PART III: The Patterns 
Chapter 18 Test Strategy Patterns
Chapter 19 xUnit Basics Patterns
Chapter 20 Fixture Setup Patterns
Chapter 21 Result Verification Patterns
Chapter 22 Fixture Teardown Patterns
Chapter 23 Test Double Patterns
Chapter 24 Test Organization Patterns
Chapter 25 Database Patterns
Chapter 26 Design-for-Testability Patterns
Chapter 27 Value Patterns
PART IV: Appendixes
Appendix A Test Refactorings  
Appendix B xUnit Terminology 
Appendix C xUnit Family Members
Appendix D Tools
Appendix E Goals and Principles
Appendix F Smells, Aliases, and Causes
Appendix G Patterns, Aliases, and Variations
Glossary
References 
Index 

Large Refactorings looks at methods of establish design improvements as an important and independent activity during development of software, and will help to ensure that software continues to adapt, improve and remain easy to read and modify without altering its observable behaviour. It provides real-world experience from real refactored projects and shows how to refactor software to ensure that it is efficient, fresh and adaptable.

Refactoring has proven its value in a wide range of development projects—helping software professionals improve system designs, maintainability, extensibility, and performance. Now, for the first time, leading agile methodologist Scott Ambler and renowned consultant Pramodkumar Sadalage introduce powerful refactoring techniques specifically designed for database systems.

Ambler and Sadalage demonstrate how small changes to table structures, data, stored procedures, and triggers can significantly enhance virtually any database design—without changing semantics. You’ll learn how to evolve database schemas in step with source code—and become far more effective in projects relying on iterative, agile methodologies.

This comprehensive guide and reference helps you overcome the practical obstacles to refactoring real-world databases by covering every fundamental concept underlying database refactoring. Using start-to-finish examples, the authors walk you through refactoring simple standalone database applications as well as sophisticated multi-application scenarios. You’ll master every task involved in refactoring database schemas, and discover best practices for deploying refactorings in even the most complex production environments.

The second half of this book systematically covers five major categories of database refactorings. You’ll learn how to use refactoring to enhance database structure, data quality, and referential integrity; and how to refactor both architectures and methods. This book provides an extensive set of examples built with Oracle and Java and easily adaptable for other languages, such as C#, C++, or VB.NET, and other databases, such as DB2, SQL Server, MySQL, and Sybase.

Using this book’s techniques and examples, you can reduce waste, rework, risk, and cost—and build database systems capable of evolving smoothly, far into the future.

Many businesses and organizations depend on older high-value PHP software that risks abandonment because it is impossible to maintain. The reasons for this may be that the software is not well designed; there is only one developer (the one who created the system) who can develop it because he didn’t use common design patterns and documentation; or the code is procedural, not object oriented. With this book, you’ll learn to identify problem code and refactor it to create more effective applications using test-driven design.

What you’ll learn

• What refactoring is and why you need to refactor code
• What test-driven design is and why you need to test your code
• How to write unit and functional tests with PHPUnit and Selenium Remote Control (RC)
• How to detect “bad smells” in PHP code, and refactor them using test-driven design
• How to refactor a large procedural application affected by many bad smells

Who is this book for?

This book is for PHP developers, businesses, and developers relying on legacy PHP apps.