Metric driven refactoring
1 like881 views
This document discusses using metrics to identify areas of code that need refactoring. It outlines some common metrics like lines of code, number of defects, and cyclomatic complexity. While metrics can help identify problem areas objectively, they must be easy to understand and provide actionable data. Refactoring involves small incremental changes that improve code quality without changing external behavior. Code smells indicate areas that would benefit from refactoring, and metrics can help identify smelly code. Sample refactors are also discussed.
1 of 18
Ad
Recommended
Introduction to agile
Introduction to agileonewomanmore witl
油
Agile is an iterative approach to software development that builds software incrementally by splitting work into small pieces, prioritizing tasks, and delivering working software frequently for continuous feedback. It focuses on individuals, working software, customer collaboration, and response to change rather than rigid processes, documentation, contracts, and plans. Agile testing emphasizes continuous collaboration with developers, targeted automation, defect prevention, exploratory testing, and adding value rather than detached objectivity, widespread automation, defect detection, scripting, and persistent criticism.Mihai mahulea the zen of test driven development
Mihai mahulea the zen of test driven developmentCodecamp Romania
油
The document discusses test-driven development (TDD) and best practices for unit testing. It recommends testing behaviors rather than classes or methods. Code should be self-testing, with tests providing feedback on breaking changes and functionality. The author advocates writing unit tests for each public method in isolation with dependencies mocked. TDD provides benefits like fewer bugs but challenges include difficult refactoring and convincing others of its value. Tests should exercise application ports and integration while mocking other ports but not internal code or adapters. Both development and acceptance should use the test suite.Continuous testing for continuous delivery
Continuous testing for continuous deliveryDavid Hart
油
This document discusses smarter approaches to testing in continuous delivery environments. It recommends starting testing earlier in the development process through techniques like test-driven development and behavior-driven development. It also recommends minimizing duplicated testing efforts across stories and teams through strategies like reducing unnecessary documentation, prioritizing common scenarios, and understanding what parts of the system are tested at each level. The document also emphasizes the importance of test automation, building testability into the system design, and taking a one team approach to delivering working software frequently.Best Practices In Apparel Color Communication
Best Practices In Apparel Color CommunicationMichelle Roberts
油
The document discusses best practices in apparel color communication, focusing on optimizing the color approval process and team collaboration in design phases. It emphasizes the importance of clarity in color standards, effective communication within color teams, and the need for proper referencing in artwork files to minimize critical colors. The overall goal is to enhance efficiency and reduce costs in apparel production.Code Inventory
Code InventoryNick Harrison
油
The document discusses the importance of tracking software investments to understand their current state and enable future initiatives. It highlights the challenges in making ROI propositions without proper metrics and outlines the need for gathering metadata and providing reports. Key questions are posed to determine if software changes align with business metrics.[DevDay2018] Lets all get along. Clean Code please! - By: Christophe K. Ngo,...
[DevDay2018] Lets all get along. Clean Code please! - By: Christophe K. Ngo,...DevDay Da Nang
油
The document provides guidelines on writing clean, high-quality code, emphasizing the importance of readability, proper naming, and documentation. It outlines several key rules, including adherence to style guides, avoiding code duplication, and unit testing, along with techniques for managing code complexity and automating code reviews. Additionally, it highlights the role of peer code review and continuous improvement in achieving excellence in software development.Clean Code
Clean Codeswaraj Patil
油
The document discusses the importance of clean code, defining its characteristics and benefits while identifying common pitfalls of bad code. It provides guidelines for maintaining readability, understandability, and changeability in code, as well as highlighting refactoring techniques to improve code quality. Additionally, it emphasizes the collaborative responsibility of development teams to ensure code cleanliness and presents the Boy Scout Rule as a guiding principle.Refactoring PHP
Refactoring PHPAdam Culp
油
This document is a presentation on refactoring code. It discusses refactoring an existing movie rental application to improve its design. The presenter walks through refactoring steps like extracting methods, replacing temporary variables with method calls, and moving code to more appropriate classes. The goals of refactoring are to simplify code, reduce duplication, and make it easier to understand and modify. Code "smells" that indicate needs for refactoring are also outlined. The presenter emphasizes that tests are crucial to refactoring to prevent introducing bugs.Code Refactoring
Code RefactoringMilan Vukoje
油
1. Code refactoring involves changing the internal structure of code to improve its understandability and maintainability without changing its external behavior.
2. Refactoring techniques include extracting methods, inline methods, managing temporary variables, simplifying conditionals, and moving features between objects.
3. Refactoring should be done regularly in small steps to avoid bugs, improve readability and design, and facilitate future changes, but it is important to avoid over-refactoring or refactoring close to deadlines.Keeping code clean
Keeping code cleanBrett Child
油
The document discusses practices for maintaining clean code within agile development, covering techniques like pair programming, automated unit testing, and refactoring. It emphasizes the benefits of these practices, such as improving code quality, flexibility, and developer collaboration while defining concepts like code smells and test-driven development (TDD). Additionally, it outlines object-oriented design principles to enhance software design and architecture.Refactoring
RefactoringAngelLuisBlasco
油
The document discusses software refactoring, which involves modifying code to enhance understanding and reduce modification costs without altering behavior. It describes the optimal timing and circumstances for refactoring, advises against scheduling extensive refactoring sessions, and emphasizes the importance of a solid test suite. Additionally, it provides practical refactoring techniques and lists methods to simplify conditional logic and improve API usability.Refactoring 2 The Max
Refactoring 2 The MaxAlfredo Morresi
油
The document discusses various aspects of refactoring code including underengineering, overengineering, code smells, Cunningham's metaphor of design debt, when to refactor, how to refactor using small behavior-preserving transformations and test-driven development, the relationship between patterns and refactorings, and important readings on refactoring. The overall message is that refactoring helps improve code quality by removing duplication, simplifying code, and clarifying intent through a process of continuous small changes while preserving behavior.Chapter17 of clean code
Chapter17 of clean codeKuyseng Chhoeun
油
This document summarizes code smells and heuristics related to comments, environment setup, function design, and general coding practices from Chapter 17 of Clean Code. It provides 29 guidelines for writing clean code, such as avoiding redundant comments, ensuring building and testing require only one step, keeping functions small with few arguments, removing dead code, and following standard naming conventions.Agile Metrics
Agile MetricsErik Weber
油
The document discusses the importance of metrics in agile project management, emphasizing their role as indicators for decision-making and understanding complex systems. It critiques traditional metrics for potentially causing negative behaviors and highlights the need to focus on team-based outcomes rather than individual metrics. Ultimately, it suggests that agile metrics should foster conversation and investigation rather than serve as isolated gauges or predictors.Quality metrics and angular js applications
Quality metrics and angular js applicationsnadeembtech
油
This document discusses various ways to measure and ensure code quality in JavaScript programs. It covers topics like linting, testing, complexity analysis, and static code analysis. Linters like JSHint and ESLint can check for style and syntax issues. Testing tools like Jasmine, Karma, and Protractor allow writing unit and integration tests. Complexity can be measured using metrics related to lines of code, arguments, nesting, and more. Tools like Plato and complexity-report provide metrics and visualizations. Adopting these practices helps reduce bugs and technical debt.Measuring Your Code
Measuring Your CodeNate Abele
油
The document discusses the importance of measuring code quality and various metrics to assess software development, emphasizing continuous improvement (kaizen) rather than high-level project metrics. It highlights specific measurable elements like code complexity, unit test coverage, and documentation standards, alongside tools such as PHP CodeSniffer for maintaining code quality. The talk also argues for the necessity of using granular metrics in continuous integration to catch issues early in the development cycle.Refactoring workshop
Refactoring workshop Itzik Saban
油
This document provides an overview of refactoring legacy code. It discusses the importance of refactoring to maintain and reduce complexity as a system evolves. Refactoring improves code design without changing behavior. Tests are important for refactoring to preserve existing behavior and allow changing code safely. The document outlines a recipe for refactoring legacy code, including identifying change points, adding test points, making code testable, writing tests, and then refactoring and changing code. It emphasizes that legacy code is often not initially testable, requiring changes to break dependencies before adding tests.EFFECTIVE IMPLEMENTATION OF AGILE PRACTICES OBJECT ORIENTED METRICS TOOL TO...
EFFECTIVE IMPLEMENTATION OF AGILE PRACTICES OBJECT ORIENTED METRICS TOOL TO...ijseajournal
油
The document discusses the challenges of maintaining software quality in agile development, emphasizing the role of software inspections and refactoring. It introduces 'metricanalyzer,' an object-oriented metrics tool designed to enhance software quality by evaluating different codebases and providing metrics for refactoring. The findings suggest that applying this tool can significantly improve software design and maintainability.Clean Code
Clean CodeChris Farrell
油
The document discusses principles for writing clean code, including:
- Functions should do one thing and be small, with descriptive names.
- Code should be organized in a way that reads like well-written prose from top-level functions down.
- Comments are usually a code smell and cleaning up code is preferable to adding comments.
- Overall the goal is for code to be easy to read and understand at a glance.Improving your CFML code quality
Improving your CFML code qualityKai Koenig
油
The document discusses tools for improving CFML code quality through static code analysis, specifically focusing on the CFLint tool which analyzes CFML code by checking it against configurable linting rules to identify potential issues, it also discusses other metrics and tools for measuring code quality factors like complexity, performance and maintainability.Integreation
IntegreationSean Killeen
油
The document describes the challenges of integrating technology and human processes in project management, emphasizing the need for a structured, unemotional approach to handle uncertainties. It outlines a 12-step process utilizing various tools (like Subversion, NUnit, and Octopus) to ensure code quality, traceability, and automation. The goal is to foster a dependable development environment that allows for efficient code management and customer satisfaction.Transitioning to quality software
Transitioning to quality softwareM叩rton M辿sz叩ros
油
The document discusses the importance of measuring metrics related to code quality and health in order to transition from working software to high quality software. It provides examples of metrics that can be measured such as coding standard violations, duplicated code, dead code, code coverage by tests, number of open tasks, complexity of expressions, and modularity. It explains what different trends in these metrics may indicate and considerations for utilizing the metrics such as tools, policies, and developer skills. Regular measurement and response to trends helps avoid issues like increasing technical debt and the "Broken Window Syndrome."Mine Your Own Code
Mine Your Own CodePeter Norrhall
油
The document discusses the challenges of determining when and how to refactor code, emphasizing the importance of analyzing software evolution, code decay, and technical debt. It introduces methodologies for identifying 'god classes,' code churn, and architectural weaknesses through mining software repositories and utilizing tools like Code Maat. Ultimately, it aims to provide metrics that guide refactoring efforts by highlighting the business value and urgency of maintaining code quality.Refactoring Fest
Refactoring FestNaresh Jain
油
The document outlines the principles and practices of refactoring in software development, emphasizing the importance of improving code quality and maintainability without altering external behavior. It discusses various techniques, common code smells, and the significance of tests and collaboration in fostering a refactoring culture. The content also includes hands-on activities and practical strategies for dealing with legacy code and implementing refactorings effectively.Day2 - Refactoring (Lecture SS 2015)
Day2 - Refactoring (Lecture SS 2015)wolframkriesing
油
This document discusses test-driven development (TDD) and refactoring in JavaScript. It begins with an introduction to TDD and refactoring, then defines common code smells like long methods, duplicated code, and bad names. It also discusses refactoring techniques like extracting methods and renaming variables. Test smells are covered as well, such as obscure tests, conditional test logic, and dependent tests. Overall, the document provides an overview of code smells and refactoring best practices to write cleaner, more maintainable JavaScript code.Arch factory - Agile Design: Best Practices
Arch factory - Agile Design: Best PracticesIgor Moochnick
油
This document provides guidance on agile architecture and design principles. It emphasizes that agile design is about responding quickly to change for customers and teams through transparency, lightweight processes, and continuous learning. Key principles discussed include designing incrementally without large upfront design; getting early and continuous feedback; delaying commitment and complexity; and maximizing evolutionary design through reversibility and packaging. The document also covers topics like testing, distributed teams, and delivering frequently.Best-Practices-in-Writing-Clean-Maintainable-Code
Best-Practices-in-Writing-Clean-Maintainable-CodeOzias Rondon
油
Writing clean and maintainable code is essential for software developers aiming to create efficient, error-free, and scalable applications. This presentation delves into key principles such as adhering to consistent coding standards, utilizing meaningful variable and function names, implementing modular design patterns, and writing comprehensive documentation. By mastering these practices, developers can enhance code readability, facilitate easier debugging, and promote seamless collaboration within development teams.Big code refactoring with agility
Big code refactoring with agilityLuca Merolla
油
The document discusses strategies for handling big code refactoring within agile methodologies. It describes various refactoring approaches like "big bang", "divide and conquer", and planned refactoring periods. The best approach emphasized is incremental refactoring as a regular part of work to continuously improve code quality. Agile practices like defining a clear vision, completing work in small batches, and iterating help enable big refactoring. Tools like trunk-based development, branch by abstraction, and feature toggles can also aid refactoring within agile.Revisiting refactoring
Revisiting refactoringNick Harrison
油
This document discusses refactoring code to improve its structure and quality. It defines refactoring as changing code without changing its external behavior to improve non-functional properties like readability. Code smells are hints that refactoring may be needed, like duplicate code or large classes. Code smiles are aspects that make code easy to maintain, like clear naming. The document suggests identifying common issues through lessons learned and implementing prefactors to prevent future problems.Refactoring workshop
Refactoring workshopNick Harrison
油
The document discusses refactoring code examples to improve readability and maintainability. It provides examples of switch statements, conditional logic, and suggests replacing switches with polymorphism. The last code example is identified as having complex conditional logic that could be simplified.More Related Content
Similar to Metric driven refactoring (20)
Code Refactoring
Code RefactoringMilan Vukoje
油
1. Code refactoring involves changing the internal structure of code to improve its understandability and maintainability without changing its external behavior.
2. Refactoring techniques include extracting methods, inline methods, managing temporary variables, simplifying conditionals, and moving features between objects.
3. Refactoring should be done regularly in small steps to avoid bugs, improve readability and design, and facilitate future changes, but it is important to avoid over-refactoring or refactoring close to deadlines.Keeping code clean
Keeping code cleanBrett Child
油
The document discusses practices for maintaining clean code within agile development, covering techniques like pair programming, automated unit testing, and refactoring. It emphasizes the benefits of these practices, such as improving code quality, flexibility, and developer collaboration while defining concepts like code smells and test-driven development (TDD). Additionally, it outlines object-oriented design principles to enhance software design and architecture.Refactoring
RefactoringAngelLuisBlasco
油
The document discusses software refactoring, which involves modifying code to enhance understanding and reduce modification costs without altering behavior. It describes the optimal timing and circumstances for refactoring, advises against scheduling extensive refactoring sessions, and emphasizes the importance of a solid test suite. Additionally, it provides practical refactoring techniques and lists methods to simplify conditional logic and improve API usability.Refactoring 2 The Max
Refactoring 2 The MaxAlfredo Morresi
油
The document discusses various aspects of refactoring code including underengineering, overengineering, code smells, Cunningham's metaphor of design debt, when to refactor, how to refactor using small behavior-preserving transformations and test-driven development, the relationship between patterns and refactorings, and important readings on refactoring. The overall message is that refactoring helps improve code quality by removing duplication, simplifying code, and clarifying intent through a process of continuous small changes while preserving behavior.Chapter17 of clean code
Chapter17 of clean codeKuyseng Chhoeun
油
This document summarizes code smells and heuristics related to comments, environment setup, function design, and general coding practices from Chapter 17 of Clean Code. It provides 29 guidelines for writing clean code, such as avoiding redundant comments, ensuring building and testing require only one step, keeping functions small with few arguments, removing dead code, and following standard naming conventions.Agile Metrics
Agile MetricsErik Weber
油
The document discusses the importance of metrics in agile project management, emphasizing their role as indicators for decision-making and understanding complex systems. It critiques traditional metrics for potentially causing negative behaviors and highlights the need to focus on team-based outcomes rather than individual metrics. Ultimately, it suggests that agile metrics should foster conversation and investigation rather than serve as isolated gauges or predictors.Quality metrics and angular js applications
Quality metrics and angular js applicationsnadeembtech
油
This document discusses various ways to measure and ensure code quality in JavaScript programs. It covers topics like linting, testing, complexity analysis, and static code analysis. Linters like JSHint and ESLint can check for style and syntax issues. Testing tools like Jasmine, Karma, and Protractor allow writing unit and integration tests. Complexity can be measured using metrics related to lines of code, arguments, nesting, and more. Tools like Plato and complexity-report provide metrics and visualizations. Adopting these practices helps reduce bugs and technical debt.Measuring Your Code
Measuring Your CodeNate Abele
油
The document discusses the importance of measuring code quality and various metrics to assess software development, emphasizing continuous improvement (kaizen) rather than high-level project metrics. It highlights specific measurable elements like code complexity, unit test coverage, and documentation standards, alongside tools such as PHP CodeSniffer for maintaining code quality. The talk also argues for the necessity of using granular metrics in continuous integration to catch issues early in the development cycle.Refactoring workshop
Refactoring workshop Itzik Saban
油
This document provides an overview of refactoring legacy code. It discusses the importance of refactoring to maintain and reduce complexity as a system evolves. Refactoring improves code design without changing behavior. Tests are important for refactoring to preserve existing behavior and allow changing code safely. The document outlines a recipe for refactoring legacy code, including identifying change points, adding test points, making code testable, writing tests, and then refactoring and changing code. It emphasizes that legacy code is often not initially testable, requiring changes to break dependencies before adding tests.EFFECTIVE IMPLEMENTATION OF AGILE PRACTICES OBJECT ORIENTED METRICS TOOL TO...
EFFECTIVE IMPLEMENTATION OF AGILE PRACTICES OBJECT ORIENTED METRICS TOOL TO...ijseajournal
油
The document discusses the challenges of maintaining software quality in agile development, emphasizing the role of software inspections and refactoring. It introduces 'metricanalyzer,' an object-oriented metrics tool designed to enhance software quality by evaluating different codebases and providing metrics for refactoring. The findings suggest that applying this tool can significantly improve software design and maintainability.Clean Code
Clean CodeChris Farrell
油
The document discusses principles for writing clean code, including:
- Functions should do one thing and be small, with descriptive names.
- Code should be organized in a way that reads like well-written prose from top-level functions down.
- Comments are usually a code smell and cleaning up code is preferable to adding comments.
- Overall the goal is for code to be easy to read and understand at a glance.Improving your CFML code quality
Improving your CFML code qualityKai Koenig
油
The document discusses tools for improving CFML code quality through static code analysis, specifically focusing on the CFLint tool which analyzes CFML code by checking it against configurable linting rules to identify potential issues, it also discusses other metrics and tools for measuring code quality factors like complexity, performance and maintainability.Integreation
IntegreationSean Killeen
油
The document describes the challenges of integrating technology and human processes in project management, emphasizing the need for a structured, unemotional approach to handle uncertainties. It outlines a 12-step process utilizing various tools (like Subversion, NUnit, and Octopus) to ensure code quality, traceability, and automation. The goal is to foster a dependable development environment that allows for efficient code management and customer satisfaction.Transitioning to quality software
Transitioning to quality softwareM叩rton M辿sz叩ros
油
The document discusses the importance of measuring metrics related to code quality and health in order to transition from working software to high quality software. It provides examples of metrics that can be measured such as coding standard violations, duplicated code, dead code, code coverage by tests, number of open tasks, complexity of expressions, and modularity. It explains what different trends in these metrics may indicate and considerations for utilizing the metrics such as tools, policies, and developer skills. Regular measurement and response to trends helps avoid issues like increasing technical debt and the "Broken Window Syndrome."Mine Your Own Code
Mine Your Own CodePeter Norrhall
油
The document discusses the challenges of determining when and how to refactor code, emphasizing the importance of analyzing software evolution, code decay, and technical debt. It introduces methodologies for identifying 'god classes,' code churn, and architectural weaknesses through mining software repositories and utilizing tools like Code Maat. Ultimately, it aims to provide metrics that guide refactoring efforts by highlighting the business value and urgency of maintaining code quality.Refactoring Fest
Refactoring FestNaresh Jain
油
The document outlines the principles and practices of refactoring in software development, emphasizing the importance of improving code quality and maintainability without altering external behavior. It discusses various techniques, common code smells, and the significance of tests and collaboration in fostering a refactoring culture. The content also includes hands-on activities and practical strategies for dealing with legacy code and implementing refactorings effectively.Day2 - Refactoring (Lecture SS 2015)
Day2 - Refactoring (Lecture SS 2015)wolframkriesing
油
This document discusses test-driven development (TDD) and refactoring in JavaScript. It begins with an introduction to TDD and refactoring, then defines common code smells like long methods, duplicated code, and bad names. It also discusses refactoring techniques like extracting methods and renaming variables. Test smells are covered as well, such as obscure tests, conditional test logic, and dependent tests. Overall, the document provides an overview of code smells and refactoring best practices to write cleaner, more maintainable JavaScript code.Arch factory - Agile Design: Best Practices
Arch factory - Agile Design: Best PracticesIgor Moochnick
油
This document provides guidance on agile architecture and design principles. It emphasizes that agile design is about responding quickly to change for customers and teams through transparency, lightweight processes, and continuous learning. Key principles discussed include designing incrementally without large upfront design; getting early and continuous feedback; delaying commitment and complexity; and maximizing evolutionary design through reversibility and packaging. The document also covers topics like testing, distributed teams, and delivering frequently.Best-Practices-in-Writing-Clean-Maintainable-Code
Best-Practices-in-Writing-Clean-Maintainable-CodeOzias Rondon
油
Writing clean and maintainable code is essential for software developers aiming to create efficient, error-free, and scalable applications. This presentation delves into key principles such as adhering to consistent coding standards, utilizing meaningful variable and function names, implementing modular design patterns, and writing comprehensive documentation. By mastering these practices, developers can enhance code readability, facilitate easier debugging, and promote seamless collaboration within development teams.Big code refactoring with agility
Big code refactoring with agilityLuca Merolla
油
The document discusses strategies for handling big code refactoring within agile methodologies. It describes various refactoring approaches like "big bang", "divide and conquer", and planned refactoring periods. The best approach emphasized is incremental refactoring as a regular part of work to continuously improve code quality. Agile practices like defining a clear vision, completing work in small batches, and iterating help enable big refactoring. Tools like trunk-based development, branch by abstraction, and feature toggles can also aid refactoring within agile.More from Nick Harrison (9)
Revisiting refactoring
Revisiting refactoringNick Harrison
油
This document discusses refactoring code to improve its structure and quality. It defines refactoring as changing code without changing its external behavior to improve non-functional properties like readability. Code smells are hints that refactoring may be needed, like duplicate code or large classes. Code smiles are aspects that make code easy to maintain, like clear naming. The document suggests identifying common issues through lessons learned and implementing prefactors to prevent future problems.Refactoring workshop
Refactoring workshopNick Harrison
油
The document discusses refactoring code examples to improve readability and maintainability. It provides examples of switch statements, conditional logic, and suggests replacing switches with polymorphism. The last code example is identified as having complex conditional logic that could be simplified.Introducing fx cop
Introducing fx copNick Harrison
油
FxCop is a tool that analyzes code to validate that it complies with coding standards and detects defects. It includes many predefined rules and allows custom rules to be created. FxCop fits into the development lifecycle by allowing automated code reviews through command line integration or integration into the IDE. Custom reports can also be generated from FxCop results.Developer power tools
Developer power toolsNick Harrison
油
The document discusses various "power tools" that can be used to build adaptive and maintainable software solutions, including regular expressions, reflection, and code generation. It provides an overview of each technique and demonstrates how to use reflection to simplify parsing fixed-length record files with different formats in a way that is less complex and brittle than hard-coding the logic. Reflection allows identifying the correct record object type at runtime based on the record prefix rather than requiring separate parsing code for each type. The sample also shows using code generation and reflection to dynamically create and document the record object classes.Revisiting Refactoring
Revisiting RefactoringNick Harrison
油
This document discusses refactoring code to improve its structure and quality. It defines refactoring as changing code without changing its external behavior to improve non-functional properties like readability. Code smells are hints that refactoring is needed, like duplicate code or large classes. Code smiles are aspects that make code easy to maintain, like clear naming. The document advocates identifying problems early through lessons learned and prefactoring to prevent issues.Reflecting On The Code Dom
Reflecting On The Code DomNick Harrison
油
Reflection allows viewing metadata and dynamically invoking methods of classes at runtime. It allows discovering and using new classes without recompiling. Key reflection types include System.Type, System.Reflection.Assembly, and MemberInfo. The Type object provides metadata like methods and properties. Assembly loads metadata for a DLL. MemberInfo is the base for method and property metadata. Reflection is used for documentation, plugins, adaptive solutions, and converting scripts to compiled code.Refactoring Workshop
Refactoring WorkshopNick Harrison
油
The document discusses refactoring code examples to improve readability and maintainability. It provides examples of switch statements, conditional logic, and suggests replacing switches with polymorphism. The last code example is identified as having complex conditional logic that could be simplified.The Nature Of Patterns
The Nature Of PatternsNick Harrison
油
This document discusses patterns in software development, explaining that patterns encapsulate best practices, provide reusable solutions to problems, and form a vocabulary for architecture. It acknowledges that patterns can be misunderstood and misused, causing confusion. The document provides steps for using patterns effectively, and explains the strategy pattern in particular, giving examples of strategies like plugins, providers, and state objects. It concludes with an example of using strategies for password validation.Adaptive Architecture
Adaptive ArchitectureNick Harrison
油
The document describes an adaptive architecture for .NET applications with the following goals:
1) Streamline development for faster time to market while facilitating adherence to standards and best practices.
2) Improve consistency to simplify maintenance and enhance stability.
3) Be built on best practices from the Enterprise Library and incorporate a customization layer to adapt to future changes while protecting applications.
4) Use interfaces, proxy methods, business entities and a model-view-presenter pattern to separate responsibilities and limit the scope of changes.Ad
Metric driven refactoring
- 2. Metrics The Bad The Good The Compromise
- 3. The Bad Often misleading Often misunderstood Lines of Code Number of Defects Turn time
- 4. The Good Can add objectivity to a subjective exercise Can help us focus on problem areas Can provide guidance at an early stage
- 5. The Compromise Metrics must be easily understood Metrics must provide actionable data Metric must be easy to calculate
- 6. What is Refactoring Small incremental changes Changes the internal structure Does not change the external behavior
- 7. Why Refactor Improve maintainability Improve performance Improve legibility Make code reusable Pay off design deficit
- 8. Code Smells Indicate that something maybe wrong with code Smells point to the need to refactor Individual smells are often associated with specific refactors
- 9. Sample Code Smells Long method Feature Envy Switch Statement Smell Shot Gun Surgery Large Class Comments
- 10. Smelly Metrics Metrics that Help identify Code in need of Refactoring Metric provides discrete values that can be compared against guidelines
- 11. Instruction Count Number of IL Instructions in a Method More instructions = Longer Method More Instructions = Less Focused Method More Instructions = More Effort to Support
- 12. Cyclomatic Complexity Number of Logical Paths Through a Method Number of Test Cases Needed for Full Coverage Higher Complexity = More Difficult to Support Higher Complexity = More likely to Have Errors
- 13. Guidelines Guidelines Not Hard and Fast Rules Exceptions Allowed but Must be Understood 200 Instructions per Method or Less Cyclomatic Complexity below 10 Cyclomatic Complexity = 1 in a View
- 14. Running Metrics
- 15. Common Refactors Extract Method Replace Method with Method Object Decompose Conditional
- 17. New Best Practices Review Metrics Before and After Each Round of Code Changes Do No Harm Improve the Methods that You Touch Adhering to these Guidelines will Create Better Software
- 18. Where to Get More Information http://www.geekswithb logs.net/nharrison http://www.simple- talk.com/author/nick- harrison/ http://www.refactoring. com/catalog/index.html http://www.red- gate.com/products/refl ector/index.htm