Topic

Software Modernization

All digests tagged Software Modernization

Meta's VR Codebase Nobody Wanted to Touch — Until This thumbnail

· 9:34

Meta's VR Codebase Nobody Wanted to Touch — Until This

This talk explores advanced strategies for modernizing legacy (brownfield) codebases using AI agents. Speakers argue that true modernization requires reverse-engineering the underlying business specifications and entity models, rather than simply performing 'lift-and-shift' migrations. Key architectural advice focuses on decoupling the system by ensuring the development process is not overly dependent on a single AI provider, model, or hardware environment, exemplified by the use of an MCP server to parallelize work across multiple on-demand environments.

Key takeaways

  1. Brownfield Code as a City, Not a Ball of Mud 0:21

    Legacy systems should be viewed as complex, functioning cities that have evolved over time, rather than a 'ball of mud.' The goal is to evolve the system into a more understandable, buildable structure, allowing for clear paths of development.

  2. Modernization Requires Specification Extraction 2:13

    True software modernization involves reverse-engineering the use case and entity model from existing code, tests, and documentation, and then generating new code based on that specification. Simply translating an old language (e.g., COBOL to Java) is considered 'lift and shift' and is insufficient.

  3. Decoupling the AI Stack (The Three Boxes) 4:23

    Architects must be wary of dependency on three uncontrolled components: the **harness** (interface), the **model host**, and the **model** itself. Building a digital product that can quickly switch between providers is critical for resilience.

  4. Parallelizing Refactoring with Agents 6:02

    AI agents can be taught specific refactoring patterns and then used to find similar patterns across a codebase, allowing multiple agents to work in parallel. This approach was used to move VR development off a single, powerful Windows machine.

Watch on YouTube Full article

What Is Legacy Code? How AI Is Modernizing Legacy Systems thumbnail

· 9:11

What Is Legacy Code? How AI Is Modernizing Legacy Systems

Legacy code, while functional, poses significant risks due to outdated languages (e.g., Cobol, Mainframe), lack of documentation, and deep, misunderstood domain-specific logic. Modernization is challenging due to retiring expert developers and compounding technical debt. Generative AI is emerging as a force multiplier, accelerating the modernization lifecycle by summarizing code, translating languages (e.g., Cobol to Java), and autonomously generating plans, tests, and documentation, allowing teams to focus on innovation rather than maintenance.

Key takeaways

  1. The Risk of Legacy Systems

    Legacy code is mission-critical software that is difficult to maintain, often lacking automated tests and documentation, and handling core infrastructure like financial transactions and healthcare data.

  2. Modernization Challenges

    The industry faces a widening skills gap as experts in old systems retire, and technical debt compounds, creating security vulnerabilities because systems don't receive modern security patches.

  3. AI's Role in Modernization 2:00

    AI accelerates the modernization process by allowing Large Language Models (LLMs) to read entire codebases, summarize module functions, and convert code between languages (e.g., C to Python) much faster than manual effort.

  4. Best Practices for Modernization 4:30

    Successful efforts focus on three areas: breaking monolithic applications into smaller, independent services (architecture); replacing aging infrastructure with modern, cloud-integrated platforms (technology); and implementing automated testing and continuous deployment (process).

Watch on YouTube Full article

Simon Martinelli - Lessons from Spec-driven Development - AI Native DevCon June 2026 thumbnail

· 31:39

Simon Martinelli - Lessons from Spec-driven Development - AI Native DevCon June 2026

The talk introduces the AI Unified Process, a spec-driven approach designed to combat code and specification drift in large, long-lived enterprise applications. Instead of treating code as the source of truth, this method uses system use cases (specifically SysML use cases) and domain/entity models as stable contracts. AI is leveraged not for full regeneration, but for generating and updating code and tests incrementally from these specifications, enabling modernization efforts that are more robust than simple 'lift and shift' migrations.

Key takeaways

  1. Spec-Driven Development (SDD) as the Source of Truth 21:33

    System use cases act as a stable contract for application behavior. Code is derived from these specs, ensuring that changes are managed through formal requirements updates rather than relying solely on code maintenance.

  2. Modernization via Specification Extraction 23:50

    For modernization projects (e.g., ERP systems), the process involves reverse-engineering use cases and entity models from existing documentation, code, and tests. This allows for feature integration without being limited to a simple technology migration.

  3. Architectural Shift: Self-Contained Systems 27:20

    To effectively use AI in large systems, the architecture should move away from overly distributed microservices (which create context management issues) toward 'Self-contained systems'—vertical splits that keep UI, business logic, and database within a single project or application.

Watch on YouTube Full article