# Responsibly Abandoning Open Source Projects - Jason Turner - NDC Copenhagen 2026

## Executive summary

This talk outlines best practices for developing and maintaining open-source projects to ensure they can be responsibly abandoned or handed off years later without becoming 'legacy' or 'abandoned.' The core focus is on achieving a state of 'completeness' by implementing rigorous automation across the entire development lifecycle—from static analysis and comprehensive testing (including path coverage, fuzzing, and mutation testing) to simplified build processes. Key recommendations include automating all quality gates within CI/CD pipelines and minimizing technical debt related to tooling complexity.

## Key takeaways

- Achieve 'Completed,' Not 'Abandoned': When concluding work on a project, aim for the status of 'completed' rather than 'abandoned.' This requires proactive measures like maintaining clear documentation and ensuring continuous automation.
- Automate All Quality Gates: Implement automated checks for every possible tool (static analysis, dynamic analysis, formatting) to ensure consistency and reduce friction for future maintainers. This should be fully integrated into the build process.
- Prioritize Strong Typing: Adopting strongly typed systems (e.g., using type hints in Python or dedicated types like `Point` and `Color`) makes code less prone to order-of-operations errors, significantly improving robustness.
- Minimize Build Setup Friction: A new contributor should be able to set up the development environment and run all tests/analysis in a minimal number of steps (ideally five lines or less).

## Technical details

- Code Quality & Analysis: Implement static analysis tools (e.g., Sonar, Clang-Tidy) and ensure warnings are treated as errors during the build process to enforce high code quality.
- Testing Depth & Coverage: Move beyond simple line coverage (100%) by measuring branch coverage and path coverage. Path coverage is highly valuable but computationally expensive; it should be targeted function-by-function.
- Advanced Testing Techniques: Utilize fuzz testing (generating pseudo-random inputs to find unexpected memory errors) and mutation testing (swapping operations in code to ensure the test suite is comprehensive enough to detect subtle bugs).
- Build System Automation: The build process must be fully automated via CI/CD tools (e.g., GitHub Actions) and should enforce passing tests for all merges into the main branch.
- Code Formatting & History: Use automatic code formatters (like `rustfmt` or Black) to eliminate style arguments during pull requests. Maintain a clean history by using squash and merge judiciously.

## Practical implications

- Integrate all possible quality checks (static analysis, fuzz testing, mutation testing) into the mandatory CI pipeline.
- Treat warnings from compilers and linters as build-breaking errors to enforce strict code standards.
- Simplify project setup documentation and build commands to minimize onboarding friction for new developers.
- Adopt strongly typed structures in languages that support them to prevent runtime type errors.

## Topics

Open Source Development, Software Reliability Engineering, Build Automation, Code Quality, Testing Methodologies, Clang-Tidy, Sonar, Black / Prettier, GitHub Actions

Source: https://www.youtube.com/watch?v=drPP5Yyzxp8