Brownfield Application Development in .Net

Home Page......Page 1
Preface......Page 4
Roadmap......Page 7
1.1 The components of a brownfield application......Page 9
1.1.1. Existing codebase......Page 11
1.1.2. Contaminated by poor programming practices......Page 12
1.2. Inheriting an Application......Page 14
1.2.1. Pain points......Page 16
1.2.3. Challenging your assumptions......Page 17
1.2.4 Balancing the client’s expectations......Page 18
1.2.5 The Big Rewrite......Page 20
1.3. The Challenges of a Brownfield Application......Page 21
1.3.1. Technical factors......Page 22
1.3.2. Political factors......Page 23
1.3.3. Team morale......Page 25
1.3.4. Client morale......Page 26
1.3.6. Being an agent for change......Page 28
1.4. Selling it to your boss......Page 32
1.5 Summary......Page 35
2 Version Control in Brownfield Applications......Page 37
2.1.1 Missing references and assemblies......Page 38
2.1.3 Maintaining production code......Page 39
2.2 What’s in a version control system?......Page 40
2.2.1 Required features......Page 41
2.2.2 Greasing the wheels......Page 42
2.2.3 File Management......Page 44
2.2.4 Branching......Page 47
2.3 Organizing your project for version control......Page 50
2.3.1 Dealing with third-party dependencies......Page 51
2.3.2 The Folder Structure......Page 53
2.3.3 The VCS Folder Structure......Page 56
2.3.4 What not to include in the repository......Page 58
2.3.5 The first check-in and verification......Page 59
2.4 The Check-In Dance......Page 60
Check In Often......Page 63
Decide on a labeling/tagging strategy......Page 64
2.6 Summary......Page 65
3 Continuous Integration......Page 67
3.1 Pain points......Page 68
3.2 What is Continuous Integration?......Page 69
3.2.1 The Feedback Loop......Page 70
3.3 Automated Builds and the Build Server......Page 71
3.4 An Updated Check-in Dance......Page 73
3.4.1 Breaking the build......Page 74
3.4.2 Removing the pain – A check-in walkthrough......Page 76
3.4.3 The Metronome Effect......Page 77
3.5 Setting up a CI Process......Page 79
3.5.1 Compile the application......Page 81
3.5.2 Run automated tests......Page 85
3.5.3 Create deployable releases......Page 86
3.6 Build Components......Page 89
3.7 Tweaking the CI process......Page 92
3.8 Summary......Page 95
4 Automated Testing......Page 97
4.1 Pain points......Page 98
4.2 Living in fear of change......Page 99
4.2.1 Regaining confidence and control......Page 101
4.2.2 The need for tests......Page 103
4.3 Types of automated tests......Page 104
4.3.1 State-based tests......Page 105
4.3.2 Interaction-based tests......Page 106
4.4.1 Examine existing test projects......Page 109
4.4.2 Address existing tests......Page 112
4.4.3 Separate unit tests from integration tests......Page 116
4.4.4 Re-examine your tests......Page 118
4.4.5 Execute the tests in your build script......Page 119
4.5 Adding a new test project......Page 120
4.6.1 Tests on existing code......Page 121
4.6.2 Tests on new code......Page 123
4.7 Integration tests......Page 124
4.7.1 Integration tests in brownfield applications......Page 126
4.8 User interface tests......Page 127
4.9 Managing your database......Page 128
4.9.1 Auto-generating the database......Page 129
4.10 Summary......Page 131
5 Software Metrics and Code Analysis......Page 133
5.1.1 Why do you need code metrics?......Page 134
5.2.1 Code coverage......Page 135
5.2.2 Cyclomatic complexity......Page 137
5.2.3 Class coupling......Page 138
5.2.4 Cohesion......Page 139
5.2.5 Distance from main sequence......Page 141
5.2.7 Maintainability Index......Page 143
5.3 Becoming a slave to statistics......Page 144
5.4.1 Automating code coverage......Page 147
5.4.2 Automating other metrics......Page 149
5.4.3 Metrics with CI......Page 150
5.5 Other tasks for automation......Page 151
5.6 Summary......Page 152
6 Defect Tracking......Page 153
6.1 Pain Points......Page 154
6.2 Types of Defects......Page 155
6.2.2 Incomplete entries......Page 156
6.3 The Initial Defect Triage......Page 157
6.3.1 Addressing Un-reproducible Defects......Page 161
6.4.1 Tackling the defect list......Page 162
6.4.2 Maintaining momentum......Page 163
6.4.3 Dealing with spurious defects......Page 165
6.4.4 Defects vs. Features......Page 166
6.4.5 Easing fears and concerns from stakeholders......Page 169
6.5 Anatomy of a Defect Entry......Page 170
6.5.2 Clear......Page 171
6.5.3 Complete......Page 172
6.5.4 Constructive......Page 173
6.5.5 Closed......Page 174
6.6 Instilling a culture of quality......Page 175
6.6.1 Zero Defect Count......Page 177
6.7 Working with a defect tracking system......Page 180
6.8 Defect reporting......Page 182
6.8.1 Trending data......Page 183
6.8.2 Release Notes......Page 184
6.9 Summary......Page 185
Part 2 The Code......Page 187
7 Bringing Better OO Practices to the Project......Page 188
7.1.1 Encapsulation......Page 190
7.1.2 Inheritance......Page 191
7.1.4 Polymorphism......Page 192
7.2 Code “Abilities”......Page 193
7.2.2 Readability......Page 194
7.2.3 Testability......Page 195
7.2.5 Reversibility......Page 196
7.2.6 Adaptability......Page 197
7.3.1 Favour composition over inheritance......Page 199
7.3.2 Separation of Concerns/Single Responsibility Principle......Page 201
7.3.3 Open/Closed Principle......Page 205
7.3.4 Principle of Least Knowledge......Page 210
7.3.6 Interface-Based Design......Page 212
7.3.7 Introducing Design Principles to a Team......Page 214
7.4.1 Keep it Simple, Stupid (KISS)......Page 219
7.4.2 You Ain’t Gonna Need It (YAGNI)......Page 220
7.5 Summary......Page 221
8 Re-Layering Your Application......Page 223
8.1 Pain Points......Page 224
8.2.1 Tiers......Page 226
8.2.2 Logical Layers......Page 228
8.3.1 Isolation and Insulation......Page 229
8.4 Anti-Corruption Layer......Page 231
8.4.1 Seams......Page 233
8.5 Vertical layers......Page 235
8.5.1 Aspect-Oriented Programming......Page 238
8.6 Taking a domain-centric approach......Page 241
8.7 Refactoring to Layers......Page 246
8.7.1 Pick a starting point......Page 247
8.7.2 Make incremental improvements......Page 248
8.7.3 Re-factor another screen......Page 251
8.7.4 Recognize the advances being made......Page 252
8.7.5 Know when to stop......Page 253
8.8 Summary......Page 254
9.1 Pain Points......Page 255
9.2 The Dependency Inversion Principle......Page 262
9.2.1 Abstractions: Abstract classes vs. interfaces......Page 263
9.3 A sample dependency inversion......Page 264
9.3.1 Why invert dependencies?......Page 266
9.3.2 The Testing Impact......Page 267
9.3.3 What are we testing?......Page 269
9.3.4 The effect of breaking out responsibilities......Page 270
9.3.5 An alternative using mock objects......Page 271
9.4 Dependency Injection......Page 273
9.4.1 Constructor Chaining......Page 276
9.4.2 Containers......Page 277
9.5 Dependency Inversion in Brownfield Applications......Page 280
9.5.2 The jumping off point......Page 281
9.5.3 Work incrementally......Page 282
9.5.5 Apply the Dependency Inversion Principle......Page 283
9.5.6 Review (and add) unit tests......Page 285
9.5.7 See the benefits......Page 286
9.6 Summary......Page 287
10 Cleaning Up the User Interface......Page 288
10.1 Pain Points......Page 289
10.2 Separating the UI layer\'s concerns......Page 291
10.3.1 The Model......Page 292
10.3.4 Why the separation?......Page 294
10.4 User Interface Patterns......Page 295
10.4.1 Passive View......Page 296
10.4.2 Supervising Controller......Page 300
10.4.3 Event Handling in Passive View and Supervising Controller......Page 303
10.4.4 Presentation Model......Page 304
10.5 Refactoring to MVP......Page 306
10.5.2 Identify the components......Page 307
10.5.3 Isolate the code......Page 311
10.5.4 A Sample Refactoring......Page 313
10.6 Model View Controller......Page 317
10.6.1 Comparing MVC and MVP......Page 319
10.6.2 Refactoring to MVC?......Page 320
10.7 Summary......Page 322
11.1 Pain Points......Page 323
11.2 Isolating Your Data Access......Page 326
11.2.1 Refactoring Infrastructure......Page 328
11.2.2 Refactoring CRUD......Page 330
11.2.3 Anti-Corruption Layer......Page 332
11.3 Centralizing Business Logic......Page 334
11.3.1 Refactoring away from stored procedures......Page 335
11.3.2 Refactoring out of the Data Access Layer......Page 337
11.4.1 Encapsulation......Page 338
11.4.2 Transactional/Unit of Work......Page 339
11.4.3 Persistence Ignorance......Page 341
11.4.4 Persistence by Reachability......Page 343
11.4.5 Dirty Tracking......Page 345
11.4.6 Lazy Loading......Page 346
11.4.7 Caching......Page 348
11.4.8 Tips on updating your DAL......Page 349
11.5 Options for creating a Data Access Layer......Page 350
11.5.1 Hand-Rolled......Page 351
11.5.2 Code Generation......Page 352
11.5.3 Object-Relational Mappers (ORMs)......Page 354
11.6 Improving the Deployment Story......Page 356
11.6.2 Versioning the database......Page 357
11.6.3 Managing connection strings......Page 358
11.7 Summary......Page 359
12.1 Pain Points......Page 360
12.2.1 Compile-time dependencies......Page 362
12.2.2 Run-time dependencies......Page 363
12.3 Handling External Systems......Page 364
12.4 A sample refactoring......Page 366
12.4.1 Extending the refactoring – A recap......Page 372
12.4.3 How far do you go in minimizing your risk?......Page 374
12.5 Example 2: Refactoring a web service......Page 377
12.6 Example 3: Wrapping a component......Page 379
12.6.1 Made for wrapping: Microsoft Office integration......Page 383
12.6.2 The dependencies don\'t have to be third-party......Page 385
12.7 Design patterns for dealing with third-party dependencies......Page 386
12.7.2 Proxy......Page 387
12.7.3 Façade......Page 388
12.7.4 Other patterns......Page 389
12.8 Summary......Page 390
13.1 Pain Points......Page 391
13.2 Changing your course......Page 392
13.3 Setting the Pace......Page 394
13.3.1 Review your progress......Page 397
13.4 The \"Spring Cleaning\" Iteration......Page 398
13.4.1 Changing the culture......Page 399
13.5 Making the time......Page 401
13.6 Summary......Page 403
Productivity Tools......Page 405
Aspect Oriented Programming......Page 406
Code Profiling and Diagnosis......Page 407