[ TOPIC ]
backwards-compatibility
49 real merged PRs across 20 projects, ordered easiest to hardest. Read them in order to see how backwards-compatibility shows up in production code, then go deeper with the free papers and talks below.
[ 01 // REAL PRs ]
Next (mid) · 43
♻️ Update internal annotation usage for compatibilty with Pydantic 2.11
This PR teaches how subtle changes in a dependency's internal API (Pydantic) can break integration in a framework (FastAPI), and how to adapt internal usage and testing to maintain compatibility across versions.
fix: [3.0] gate nested HYBRID high-cardinality STL_SORT on scalar index version
This PR teaches how to gate new index build strategies on versioning to ensure backward compatibility and safe rollbacks in distributed systems.
gh-155694: Scope HTTPPasswordMgr credentials by URL scheme
This PR teaches how to scope sensitive credentials by URL scheme to prevent credential leakage between HTTP and HTTPS, illustrating secure API design and careful backwards compatibility in a widely used standard library.
gh-152204: Validate date and time fields in `_pydatetime.date{time}.fromisoformat`
This PR teaches how to robustly validate and parse fixed-format date/time strings, ensuring consistent error handling and input validation between Python and C implementations, and how to extend tests to cover subtle malformed cases.
tty: add raw-vt and io raw modes
This PR teaches how to extend a public API with new, explicit modes while preserving backwards compatibility and ensuring robust cross-platform testing.
Fix Environment.GetCommandLineArgs()[0] to report the host invocation name
This PR teaches how to evolve a public API to more accurately reflect platform semantics (argv[0]), while preserving backwards compatibility, handling edge cases, and updating tests to verify nuanced behavior.
GH-50993: [CI][Integration] Add extension-wrapped union to integration data
This PR teaches how to design robust cross-implementation integration tests for extension types wrapping unions, and how to ensure correct type registration and buffer layout handling across serialization boundaries.
Avoid rooting cryptography through ZipArchive on browser
This PR teaches how to conditionally remove a security-related dependency for specific platforms (browser/WASM) to reduce binary size, while maintaining platform-appropriate fallbacks and ensuring that unsupported features fail clearly.
Fix LOGICAL_ERROR in DatabaseReplicatedDDLWorker with max_replication_lag_to_enqueue=0
This PR teaches how to enforce configuration invariants at parse time, handle backward compatibility for persisted settings, and write regression tests for subtle logic errors in distributed systems.
Fix ILLEGAL_TYPE_OF_ARGUMENT on nullable MySQL spatial columns
This PR teaches how to robustly map between differing database type systems, handle type system invariants, and write regression tests for subtle schema inference bugs.
GH-50312: [Python] Fix UUID extension type round-trip to pandas returning bytes
This PR demonstrates how to add a native conversion path for a custom extension type (UUID) from Arrow to pandas, including C++/Python interop, careful API design, and comprehensive regression testing for round-trip data fidelity.
Treat a leading CSV null as the first Tuple element
This PR teaches how to correctly handle ambiguous NULL values during CSV deserialization for tuple types, balancing per-element and whole-column defaults, and demonstrates robust test-driven bug fixing for serialization edge cases.
Fix wrong access type for SYSTEM CLEANUP and VIRTUAL PARTS UPDATE ON CLUSTER
This PR teaches how to correctly align privilege checks for distributed SQL commands, ensuring RBAC consistency and writing regression tests for access control changes.
Make `preserve_identifier_case` a three-state setting
This PR teaches how to evolve a configuration setting from a boolean to an enum for extensibility, while preserving backward compatibility and improving code clarity.
Refactored docs for `std::fs::set_permissions_nofollow` + fix BSD-based systems to use fchmodat with AT_SYMLINK_NOFOLLOW flag
This PR teaches how to handle platform-specific system call differences and errors, including fallbacks and documentation updates, to ensure correct and portable file permission APIs.
📝 Update `tutorial/security/oauth2-jwt/` to use `pwdlib` with Argon2 instead of `passlib`
This PR teaches how to migrate a Python project's password hashing from an outdated library (passlib/bcrypt) to a modern, secure, and future-proof alternative (pwdlib/Argon2), including code, documentation, and dependency updates.
fix(runtime-vapor): preserve vdom props normalization in interop
This PR demonstrates how to preserve prop normalization and defaulting when bridging between two component systems, with a focused regression test to ensure correct inherited prop handling and attribute filtering.
custom_response: allow LocalResponsePolicy to preserve or set response_code_details
This PR demonstrates how to extend an API with new configuration options while preserving backwards compatibility and updating tests and documentation accordingly.
gh-118150: difflib: expose autojunk flag from SequenceMatcher to public methods and functions
This PR teaches how to expose a previously internal configuration parameter ('autojunk') to a module's public API while maintaining backward compatibility and updating documentation.
fix(runtime-vapor): respect inheritAttrs ownership for component roots
This PR teaches how to correctly handle attribute inheritance and fallthrough in a component framework, including how to write regression tests for subtle API contract changes.
fix(apply): Warn users when `apply` is passed plan options -target, -destroy and -refresh-only if they disagree with the saved plan in use.
This PR teaches how to handle user error and flag misuse in CLI tools while preserving backwards compatibility, including adding targeted warnings and robust tests.
[release/11.0] [System.Management] Make generated WMI wrappers disposable
This PR teaches how to safely expose resource cleanup in generated types by implementing IDisposable, and highlights the API and compatibility considerations of such a change.
Do not require recursive nameservers propagation by default for the DNS-01 challenge
This PR teaches how to handle backwards-incompatible upstream changes by restoring previous default behaviors and clarifying configuration management to avoid breaking users in patch releases.
[compiler]: add `useWindowVirtualizer` to known incompatible libraries
This PR teaches how to maintain compatibility and safety in a compiler by explicitly marking third-party APIs as incompatible with certain optimizations due to their internal mutability patterns.
[NVPTX] Restrict NVVM bf16 intrinsic upgrades to integer storage types
This PR teaches how to safely upgrade legacy intrinsic function signatures while preserving backward compatibility and ensuring invalid cases are properly rejected and tested.
[HLSL][Driver][SPIRV] Add -fspv-use-legacy-buffer-matrix-order flag
This PR demonstrates how to introduce a compiler flag for backwards compatibility, propagate it through a large codebase, and refactor built-in handling to support conditional behavior in a type-generic way.
[mlir][LLVM] Preserve !associated and !absolute_symbol on llvm.mlir.global
This PR demonstrates how to extend an IR dialect and its import/export logic to preserve new metadata fields, including validation and round-trip translation between representations.
worker: add ref/unref to web workers
This PR teaches how to extend a standard API with Node.js-specific behavior using symbol-based protocols to maintain compatibility and avoid polluting the standard interface.
rustdoc: Take into account edition information for keyword highlighting
This PR demonstrates how to thread contextual information (like language edition) through a codebase to ensure correct feature handling and syntax highlighting, with attention to backwards compatibility and robust testing.
feat: accept repository-style Azure keys in repo-creds (#29414)
This PR demonstrates how to add backwards-compatible support for multiple key aliases in configuration parsing, including precedence rules and thorough unit testing.
gh-129382: Match venv API symlink defaults to the CLI
This PR demonstrates how to align API defaults with CLI behavior in a standard library module while maintaining backwards compatibility and clear documentation.
Stop generating v2 snapshot files, nor loading v2 snapshot files
This PR demonstrates how to safely remove legacy snapshot file support while considering backwards compatibility and upgrade/downgrade paths in a distributed system.
fix(compiler-vapor): keep the space after a quoted attribute value
This PR demonstrates how small details in code generation and serialization (like whitespace between HTML attributes) can affect standards compliance and interoperability in compilers.
Rename `#[unroll]` => `#[rustc_unroll]` to mitigate nameres ambiguity
This PR teaches how to mitigate name resolution ambiguities and accidental breakage in language attribute design by renaming unstable features for backwards compatibility.
quic: convert incoming :status header to number
This PR demonstrates how to align API behavior across protocols (HTTP/2 and HTTP/3) for consistency, including updating tests and documentation to reflect subtle type changes in header handling.
[react-dom] Include all Node.js APIs in Bun entrypoint for `/server`
This PR demonstrates how to align and extend platform-specific module exports to maintain API compatibility across different JavaScript runtimes like Node.js and Bun.
[SPIRV] Implement bare bones lowering for G_PREFETCH
This PR demonstrates how to conditionally lower an IR instruction to a target-specific operation or drop it based on target capabilities and extension support, illustrating careful API mapping and compatibility handling.
Revert "Add rustc_test_entrypoint_marker"
This PR teaches how to safely revert a feature that caused regressions, including handling test fallout and discussing alternative designs for attribute macros.
[libc++] Implement P3798R1: The unexpected in `std::expected`
This PR demonstrates how to add a new API method to a standard library type in a backwards-compatible way, update feature test macros, and write comprehensive tests for the change.
make -Ctarget-feature warnings more explicitly FCWs
This PR demonstrates how to implement and communicate future compatibility warnings in a compiler, showing the process of phasing out previously accepted features.
Remove experimental `--env-set` option
This PR demonstrates how to safely remove an unstable compiler flag and its supporting code, including documentation and tests, while considering ecosystem impact and backwards compatibility.
Remove flag `--max-snapshots` and `--v2-deprecation`
This PR demonstrates how to safely remove deprecated configuration flags and related code after a feature is fully removed, highlighting considerations for backwards compatibility and codebase cleanup.
remove feature gate ServiceAccountTokenPodNodeInfo
This PR demonstrates the process and considerations involved in removing a deprecated feature gate from a large codebase, including updating feature lists and cleaning up conditional logic.
Go deep (senior) · 5
fix(ext/node): do not resume client TLS sessions unless requested
This PR teaches how to faithfully emulate Node.js TLS session resumption semantics in a Rust+JS polyfill, including subtle protocol compatibility, session cache gating, and cross-language state management.
Store the names of `Fn` trait parameters in the AST, fix rustfmt bug
This PR demonstrates how to evolve a language's AST and parser to preserve more semantic information (parameter names in Fn traits), coordinating changes across the compiler, tooling, and tests while maintaining backward compatibility.
Allow associated const equality constraints with GCA
This PR teaches how Rust's type system and compiler internals evolve to support new features (generic const arguments) while carefully managing backwards compatibility and trait object constraints.
stabilize `c_variadic_naked_functions`
This PR teaches how language features are stabilized in a compiler, including the process of expanding ABI support for naked c-variadic functions and the careful coordination of feature gating, documentation, and backwards compatibility.
Partially support building and locating wasm proc-macros
This PR demonstrates how to extend a compiler's configuration and artifact discovery logic to support a new target (wasm proc-macros), including CLI flag design and conditional logic for experimental features.
[ 02 // MUST-READ PAPERS ]
Free to read, ranked by citations.
- Semantic Versioning versus Breaking Changes: A Study of the Maven RepositorySteven Raemaekers, Arie Van Deursen A, Joost Visser · IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM) · 2014142 citationsfree PDF
- Why and how Java developers break APIsAline Brito, Laerte Xavier, André Hora · IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) · 201864 citationsfree PDF
[ 03 // FREE VIDEOS & TALKS ]
Ranked by views.
other topics