Dave Bryant Copeland - Quantifying the Carrying Cost
Oct 3, 2023
auto_awesome
Dave Bryant Copeland, Senior Software Engineer and speaker, discusses challenges in retrofitting software with more testing, navigating design decisions, understanding personal biases, and a disappointing experience with frontend in Angular.
Maintainable software requires comprehensive testing to ensure functionality and confident changes.
Adding tests to legacy projects can be time-consuming, but it is essential for maintainability.
Consider the complexity, testability, and value of new features to strike a balance and ensure functionality.
Deep dives
Characteristics of Maintainable Software
Maintainable software is characterized by being well-understood, allowing for confident changes and modifications. This is often achieved through the inclusion of tests, ensuring that the software behaves as intended. Ensuring a good balance between unit, integration, and acceptance testing is crucial for maintaining confidence in the software's functionality.
Challenges of Testing in Legacy Projects
When entering a project where testing has not been emphasized enough, or where initial attempts at testing have been abandoned, challenges arise. Lack of comprehensive testing, such as integration and acceptance tests, can lead to uncertainty regarding the software's functionality. Adding tests to legacy projects can be time-consuming, but it is essential to ensure maintainability.
Overcoming Challenges in Integration Testing
Integration tests can be challenging to write and maintain, particularly in situations where an application undergoes significant changes or redesigns. The introduction of new technologies, such as JavaScript frameworks, can complicate testing efforts. To address this, it is crucial to clearly define the reasons for conducting integration tests and find simpler ways to test complex functionality, ensuring confidence in the system.
Balancing Complexity and Testability
When introducing new features or making design changes that affect the front-end experience, it is essential to consider the complexity and testability of those changes. The value of a feature should be evaluated against the cost of maintaining and testing it. Communicating the need to test and ensure functionality to designers and stakeholders can help strike a balance between complex features and testability.
Contextualizing Technical Advice
When seeking advice, it is important to consider the context and experience of the person giving it. Understanding the expertise and real-world experience of an individual can help evaluate the relevance of their advice. Different work environments, such as consultants versus product companies, may require different approaches, and it is crucial to consider the specific context when making decisions and seeking guidance.
Robby has a chat with the Author of Sustainable Web Development with Ruby on Rails, Dave Bryant Copeland (he/him/his). Dave is a Senior Software Engineer and speaker. Reflecting on his experience, Dave believes that well-maintained software is software that people understand what it does, how it works, and that it can be changed. He starts off by highlighting the challenges that developers face when trying to retrofit software with more testing.
He also shares his expert insights on how software engineers can navigate design decisions while ensuring that they speak up if a proposed feature is difficult to build, test, and maintain. When it comes to software engineers getting advice from experienced practitioners, Dave says that the engineers should make sure they understand their own context and biases. He introduces us to his book and shares a very interesting story about the disappointment he got after building and releasing a frontend in Angular. Stay tuned for more!