The Many Ends of Programming - Ray Myers

Key Concepts

• AI Skepticism
• LLMs (Large Language Models) and Code Generation
• Future of Software Development
• Extreme Completion (AI-assisted Autocomplete)
• Dev Apocalypse (Elimination of Developer Roles)
• Abstraction Leap (Higher-Level Abstractions Replacing Code)
• Uncharted Waters (Non-Code-Like Future of Computation)
• Review Economy (Over-Reliance on AI-Generated Code Review)
• Infinite Pile of Garbage (Increased Tech Debt and Lower Quality)
• Domain Specific Languages (DSLs)
• Theory of Constraints

A Day in the Life of an AI Skeptic

Ray Meyers, Chief Architect at All Hands AAI, presents a talk focusing on empathy and listening in the context of AI's impact on software engineering, rather than a purely technical AI discussion. He frames the discussion around his experiences as an "AI skeptic," often challenging provocative statements about AI's capabilities.

• Example: Dario Amadei's statement about AI writing "essentially all the code" within 12 months.
• Meyers' response: A challenge to replace the software in one mainframe using AI tools.
• Key Point: LLMs often struggle with maintaining and editing existing code, a crucial aspect often overlooked.
• Reactions: Meyers notes that raising basic questions about AI limitations often elicits extreme reactions, including being called a "Luddite" or accused of "missing the big picture."
• Quote: "Resistance is futile" - Meyers critiques the use of this quote, associating it with the Borg from Star Trek and arguing that software engineers should resist harmful trends.

The Future of Software: Six Scenarios

Meyers identifies six potential scenarios for the future of software development in the age of AI:

1. Extreme Completion

• Description: AI-powered autocomplete tools (e.g., Cursor, GitHub Copilot) enhance coding speed and convenience.
• Impact: The fundamental role of software engineers remains largely unchanged.
• Example: Using Cursor IDE to generate a Haskell function based on a prompt.
• Example: Delegating a task via Slack to the Open Hands agent to add a log statement across multiple files.
• Technical Detail: Haskell's strong typing system is seen as a potential counterbalance to the uncertainty of LLM code generation.

2. Dev Apocalypse

• Description: AI becomes capable of fully automating software development, eliminating the need for human programmers.
• Perspective: While potentially beneficial for those who rely on software, it represents a job loss scenario for developers.
• Argument: If feasible, this scenario could be seen as the ultimate fulfillment of computer science's goals.
• Counter-Argument: Objections to this scenario are often dismissed as self-serving attempts to protect jobs.

3. Abstraction Leap

• Description: The level of abstraction in software development shifts, making traditional coding less relevant.
• Analogy: Current code becomes like assembly language, with specialized experts handling low-level details.
• Flavor 1: Prompts as Code: Natural language prompts replace source code as the primary human-facing artifact.
  • Challenge: The unpredictability of LLMs raises concerns about the stability and reliability of this approach.
  • Example: The PARCEL paper demonstrates generating a Lisp interpreter from structured text prompts.
• Flavor 2: Domain Specific Languages (DSLs): Specialized programming environments are created for specific business domains.
  • Examples: CSS, SQL, regular expressions, and even Excel.
  • Benefits: DSLs can improve reliability, quality, and productivity.
  • Tools: Language workbenches like JetBrains MPS, LionWeb, and Xtext facilitate DSL creation.
  • Argument: Language models can further improve the cost-effectiveness of creating DSLs.
  • Quote: "Year of DSLs" - Meyers declared this on his YouTube channel, Craft versus Craft.

4. Uncharted Waters

• Description: The future of computation is unlike anything seen before, potentially involving direct model inference or AI-invented programming paradigms.
• Speculation: LLMs could become the processors themselves, or super-intelligent AI could create entirely new programming methods.
• Challenge: This scenario requires further exploration and demonstration of practical applications.

5. Review Economy

• Description: AI tools generate code quickly, but human developers are still needed to review and approve the output, leading to an over-reliance on code review.
• Problem: The least enjoyable part of the job becomes the primary focus.
• Solution: Meyers suggests this is a sign of poorly managed bottlenecks and recommends applying the Theory of Constraints.
• Theory of Constraints: A body of knowledge that helps identify and address bottlenecks in processes.
• Strategies: Shifting further left (e.g., using type theory), reducing error rates, and prioritizing reviews.

6. Infinite Pile of Garbage

• Description: Coding assistance tools increase productivity but also lead to increased tech debt and lower code quality.
• Outcome: Products become worse over time, creating a cycle of technical problems.
• Research:
  • Uplevel found that developers using coding assistants had a higher bug rate.
  • GetClear reported that the percentage of code that was copy-pasted exceeded that which was moved in a refactoring in 2024.
• Counter-Evidence: GitHub found that their Copilot tool increased code quality in a controlled experiment.
• Conclusion: The impact of AI coding assistance on code quality is ambiguous and requires further investigation.

Interrelation of Scenarios

• Extreme completion could lead to the infinite pile of garbage if not managed properly.
• Combining abstraction leap with DSLs and extreme completion could create a powerful and ergonomic development environment.

Conclusion

Meyers emphasizes that the future of software development is not predetermined and that developers have a say in shaping it. He poses key questions:

• Do we want no programmers, or do we want everyone to be a programmer?
• Do we want better software, or just more software?
• How do we value and support developers whose skills are evolving?

He concludes by stating his desire for software that works well, provides value, and fosters positive relationships among those who build it.