Some Best Practices & Refactoring Techniques

Some Best Practices & Refactoring Techniques. SE3070 - Case Studies in Software Engineering Semester 2, 2025 SLIIT.

Learning Outcomes. After completing this topic, you will be able to, Explain the relationship between coding standards, best practices, and code quality. Apply best practices to improve maintainability and readability. Identify code smells in a given codebase and propose appropriate refactoring techniques. Use refactoring to improve cohesion, reduce coupling, and align with SOLID principles..

Contents. Coding Standards and Best Practices Why Best Practices & Coding Standards Aren’t Enough From Code Smells to Refactoring Refactoring Fundamentals Some examples When Not to Refactor Summary.

Poor code quality leads to technical debt. Design quality ≠ Implementation quality Even great designs can be ruined by bad code. Good code is easier to understand, modify, and extend without breaking existing features..

Coding Standards. A collage of a person with clown makeup AI-generated content may be incorrect..

Consistent naming conventions for classes, methods, variables, constants etc. Package/module structuring that matches system architecture. Consistent formatting indentation, braces, whitespace, line wrapping etc. Documentation & comments Explain “why”, not just “what”.

Google C++ Style Guide Google Java Style Guide Google Python Style Guide.

Logging Use appropriate log levels, include context. Exception Handling Don’t swallow exceptions, use meaningful messages. Use of Constants & Configuration Replace magic numbers Store in properties/env variables. Avoid Deprecated APIs Always prefer supported alternatives Organize Code Effectively.

Logging: Use appropriate log levels, include context. Why? Structured, levelled, timestamped records for troubleshooting configurable per environment supports aggregation/monitoring (E.g. ELK Stack).

Best Practices for Implementation.

Exception Handling: Don’t just throw exceptions, handle them properly..

Use of Constants & Configuration This is bad because, Magic Numbers – arbitrary numbers with no meaning ("0.12") scatters configuration across code makes updates error‑prone prevents environment‑specific overrides.

A math equation with numbers and symbols AI-generated content may be incorrect..

Avoid Deprecated APIs Always prefer supported alternatives.

Create Utility/ Helper classes for reusable logic Read this: Java Helper vs. Utility Classes Follow Single Responsibility Principle One class, one responsibility Group related functionality logically in packages/modules. Aim for High Cohesion, Low Coupling Avoid bloated Utilities A code smell – God Class Keep utility classes focused..

Requirements evolve (features, scale, compliance) The original design no longer is adequate Problem Domain Understanding improves models, names, and boundaries must be reshaped to match the domain. Software entropy many small clean changes still create coupling and duplication over time. Style ≠ architecture conventions ensure readability, not good architecture. Delivery trade-offs create technical debt (due to code smells) Refactoring is how you address these problems safely..

Code smells are indicators of deeper problems not bugs, but warnings. Smells make code harder to maintain and extend. Refactoring removes smells and restores design integrity. Examples: Long Method → Extract Method Large Class → Extract Class Switch Chains → Replace with Polymorphism.

Refactoring is “a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior.” – Martin Fowler..

Goals Improve design make code easier to understand help find bugs enable faster development Small Steps Principle Incremental changes reduce risk.