Refactoring & technical debt
23 moments from 21 videos · 1:16:29 total
This playlist provides developers with actionable strategies for refactoring legacy systems and managing technical debt without breaking existing functionality.
Balancing technical debt and clean code practices
Dedicating specific days in the release cycle to refactoring prevents the buildup of unmanageable legacy code.
Identifying signs of overly complex application authorization logic
Frequent code churn and massive repository diffs directly indicate a necessity to adopt decoupled access architectures.
Balancing technical debt reduction with feature delivery
Applying continuous refactoring and the strangler fig pattern to improve code health without halting business priorities.
Combating technical debt and anti-modularity forces
Day-to-day workarounds and deferred refactoring actively degrade application architecture over time by accumulating unstructured dependencies.
Strategic use of technical debt for fast prototyping
Engineering teams optimize for speed by deliberately introducing technical debt into initial releases and aggressively refining the architecture in subsequent iterations.
Managing subjective micro challenges and codebase complexity zones
Steering developers away from dangerously freakish implementations preserves codebase simplicity and long-term team maintenance.
Managing technical debt for future team success
Proactively tracking and resolving technical debt accelerates new engineer onboarding and preserves system maintainability.
Challenges of applying test automation to legacy code
Complex dependencies and code resistance make traditional testing methodologies risky in existing codebases.
Managing technical debt in legacy web applications
Why organizations benefit from making incremental maintainability improvements across aging codebases instead of pursuing rewrites.
Managing technical debt and the long-term cost of shortcuts
Delivering the marketplace successfully through extreme procedural shortcuts advertently creates systemic dependencies on unscalable architectures that eventually require major refactoring investments.
Securing enterprise funding to refactor unscalable procedural shortcuts
Transparent communication of deliberate technical debt upfront builds organizational trust and subsequent support for funding robust infrastructural operations.
Managing software technical debt and risky code coverups
Updating neglected frontend libraries often unravels nested dependencies that vastly exceed initial development budget estimates.
Prioritizing internal code quality to prevent complete systemic rewrites
Investing engineering effort early to construct well-designed software avoids the expensive trap of compounded technical debt.
Applying targeted practices to reduce waste and technical debt
Structuring dedicated time for collaborative code katas, extensive planning, and continuous refactoring fundamentally improves project health.
Managing technical debt accumulation and unpredicted feature delivery delays
Accumulating technical debt requires paying continuous system interest through slower development cycles before architectural progression becomes impossible.
Identifying accumulated architectural debt in a modern codebase
Manual deployments, tight navigation coupling, and locked dependencies created a fragile development environment.
Balancing urgent feature deadlines with ongoing refactoring needs
Navigating management pressure requires establishing a functional testing baseline and clearly communicating the systemic risks of continued technical debt.
Five team approaches to handling engineering refactoring work
Strategies for integrating code cleanup range from strict roadmap allocation to complete avoidance.
Navigating legacy projects lacking existing unit tests
The absence of automated test suites prevents safe refactoring and accelerates the deterioration of codebases.
Defining code smells and identifying deeper system problems
Setting the scope of code smells as surface-level indicators of bad design helps teams communicate efficiently and maintain testable code.
How fragile and slow tests compound technical debt
Fragile tests that break on minor code movements discourage test creation and ultimately reduce development velocity.
Final benefits of relying on strict domain models
Aligning software processes directly with the physical domain limits downstream code breakage when underlying infrastructure changes.
Managing code bloat and architectural waste
Automated code generation often leaves abandoned imports and redundant functions behind when switching developmental approaches.
Your mix. Instantly.
More mixes
AI & Machine Learning
AI coding agents
AI & Machine Learning
MCP (Model Context Protocol)
AI & Machine Learning
RAG
Languages & Frameworks
TypeScript
Languages & Frameworks
React
Languages & Frameworks
Java
Cloud, Platform & Data
Platform engineering
Cloud, Platform & Data
Observability
Cloud, Platform & Data
Infrastructure as code
Architecture, Quality & Security
System architecture
Architecture, Quality & Security
Code review
Architecture, Quality & Security
Software supply chain security
Leadership, Career & Community
Engineering strategy
Leadership, Career & Community
Developer experience
Leadership, Career & Community