Phu Xuan University Library
|
PXU E-LIB
Sign in
Object-Oriented Reengineering Patterns

External

Object-Oriented Reengineering Patterns

This text is a guide on how to reverse engineer legacy systems to understand their problems, and then reengineer those systems to meet new demands. Patterns are used to clarify and explain the process of understanding large code bases, to transform them to meet new requirements. The key insight is that the right design and organization of your system is not something that can be evident from the initial requirements alone, but as a consequence of understanding how these requirements evolve.

Computer ScienceEngineering
Author
Serge Demeyer, Stéphane Ducasse, & Oscar Nierstrasz
Publisher
LibreTexts
Source
LibreTexts
License
CC BY-SA
Language
EN
Category
Information Technology
Read online Download PDF (open licence)
Contents· 77 sections
  1. 01: Reengineering Patterns
  2. 1.01: Why do we Reengineer
  3. 1.02: The Reengineering Lifecycle
  4. 1.03: Reengineering Patterns
  5. 1.04: The Form of a Reengineering Pattern
  6. 1.05: A Map of Reengineering Patterns
  7. 02: Setting Direction
  8. 2.01: Setting Direction
  9. 2.02: Agree on Maxims
  10. 2.03: Appoint a Navigator
  11. 2.04: Speak to the Round Table
  12. 2.05: Most Valuable First
  13. 2.06: Fix Problems Not Symptoms
  14. 2.07: If It Aint Broke Dont Fix It
  15. 2.08: Keep It Simple
  16. 03: First Contact
  17. 3.01: First Contact
  18. 3.02: Chat with the Maintainers
  19. 3.03: Read all the Code in One Hour
  20. 3.04: Skim the Documentation
  21. 3.05: Interview During Demo
  22. 3.06: Do a Mock Installation
  23. 04: Initial Understanding
  24. 4.01: Initial Understanding
  25. 4.02: Analyze the Persistent Data
  26. 4.03: Speculate about Design
  27. 4.04: Study the Exceptional Entities
  28. 05: Detailed Model Capture
  29. 5.01: Detailed Model Capture
  30. 5.02: Tie Code and Questions
  31. 5.03: Refactor to Understand
  32. 5.04: Step Through the Execution
  33. 5.05: Look for the Contracts
  34. 5.06: Learn from the Past
  35. 06: Tests Your Life Insurance
  36. 6.01: Tests Your Life Insurance
  37. 6.02: Write Tests to Enable Evolution
  38. 6.03: Grow Your Test Base Incrementally
  39. 6.04: Use a Testing Framework
  40. 6.05: Test the Interface Not the Implementation
  41. 6.06: Record Business Rules as Tests
  42. 6.07: Write Tests to Understand
  43. 07: Migration Strategies
  44. 7.01: Migration Strategies
  45. 7.02: Involve the Users
  46. 7.03: Build Confidence
  47. 7.04: Migrate Systems Incrementally
  48. 7.05: Prototype the Target Solution
  49. 7.06: Always Have a Running Version
  50. 7.07: Regression Test After Every Change
  51. 7.08: Make a Bridge to the New Town
  52. 7.09: Present the Right Interface
  53. 7.10: Distinguish Public from Published Interface
  54. 7.11: Deprecate Obsolete Interfaces
  55. 7.12: Conserve Familiarity
  56. 7.13: Use Profiler Before Optimizing
  57. 08: Detecting Duplicated Code
  58. 8.01: Detecting Duplicated Code
  59. 8.02: Compare Code Mechanically
  60. 8.03: Visualize Code as Dotplots
  61. 09: Redistribute Responsibilities
  62. 9.01: Redistribute Responsibilities
  63. 9.02: Move Behavior Close to Data
  64. 9.03: Eliminate Navigation Code
  65. 9.04: Split Up God Class
  66. 10: Transform Conditionals to Polymorphism
  67. 10.01: Transform Conditionals to Polymorphism
  68. 10.02: Transform Self Type Checks
  69. 10.03: Transform Client Type Checks
  70. 10.04: Factor out State
  71. 10.05: Factor out Strategy
  72. 10.06: Introduce Null Object
  73. 10.07: Transform Conditionals into Registration
  74. 11: Appendix A Thumbnail Patterns
  75. 11.01: Testing Patterns
  76. 11.02: Refactorings
  77. 11.03: Design Patterns