Software Quality and Maintenance

Software engineering doesn’t end when the code is deployed. In fact, for most successful systems, the Maintenance phase accounts for 60-80% of the total software lifecycle cost.

Software Quality Attributes (ISO 25010)

Quality is not just “lack of bugs.” The ISO 25010 standard defines a quality model with several key attributes:

1. Functional Suitability: Does it do what the user needs?
2. Performance Efficiency: How fast is it? How many resources does it use?
3. Compatibility: Can it exchange information with other systems?
4. Usability: How easy is it for users to learn and use?
5. Reliability: How often does it fail? Can it recover?
6. Security: How well does it protect data and resist attacks?
7. Maintainability: How easy is it to modify, test, and improve?
8. Portability: How easy is it to move to a different environment?

Technical Debt

Technical debt is a metaphor for the eventual consequences of poor system design, software architecture, or software development within a codebase.

• Causes: Pressure to meet deadlines, lack of knowledge, poor documentation, or evolving requirements.
• The Interest: The extra effort required to add new features because of the mess in the existing code.
• Managing Debt: Use tools like SonarQube to track “debt” in hours. Schedule dedicated “refactoring sprints” or allocate 20% of every sprint to paying down debt.

Types of Software Maintenance

1. Corrective Maintenance: Fixing bugs reported by users.
2. Adaptive Maintenance: Modifying software to work in a new or changed environment (e.g., a new OS version).
3. Perfective Maintenance: Improving performance or maintainability (e.g., refactoring).
4. Preventive Maintenance: Making changes to prevent future problems (e.g., updating a library before its support ends).

Legacy Systems

A legacy system is an old method, technology, computer system, or application program that is still in use.

• The Challenge: They often lack tests, documentation, and the original developers have left.
• Strategy: Don’t rewrite the whole thing at once. Use the Strangler Fig Pattern: gradually replace parts of the system with new services until the old system is “strangled” and can be retired.

Course Conclusion: Software Engineering & OOAD

Congratulations on completing the Software Engineering & Object-Oriented Analysis and Design course!

Over the past 30 lessons, we have traveled from the basic building blocks of objects and classes to the complex ecosystems of DevOps and software maintenance.

Key Takeaways:

1. Abstraction is Power: Mastering the ability to hide complexity behind interfaces and abstract classes is the core of good design.
2. SOLID Principles are North Stars: They guide you toward code that is flexible enough to handle the only constant in software: Change.
3. Patterns, not Recipes: Design patterns are tools in your toolbox. Don’t force them into every problem; use them when the context fits.
4. Testing is Part of Coding: You haven’t finished the feature until you’ve written the tests that prove it works and won’t break later.
5. Focus on People: Software is built by people, for people. Clean code, documentation, and DevOps cultures are all about improving the human experience of building and using software.

What’s Next?

• Build something: Apply these patterns to a real-world side project.
• Read the Classics: Explore Design Patterns (Gang of Four) and Clean Code (Robert C. Martin).
• Keep Learning: The field of software engineering is always evolving. Stay curious!

Happy Coding!