I think this is a sad vision of the future not because a lot of programmers will be forced to do something else, but because it seems like this represents a fundamental failure for formal methods. We're hurtling towards a world where we automatically generate low-quality, buggy code, produced by stochastic parrots who mimic code written in possibly a different era by humans tackling different problems.
Forget about being employed producing software in a world where these are the norms, I don't think I'd want to be a software _user_.
I'd love for programming to be higher level and accessible, but I wish the process were:
- write a _specification_ that describes functionality, invariants, etc
- generate signatures compatible with that specification
- interactively seek implementation-relevant information from the designer, e.g.
- "I see Users can have an unbounded collection of Bars, which can each reference an unbounded number of Wugs. How many Bars do you suppose a typical User would have? How many Wugs per Bar and how many Bars will reference each Wug? How large is a Wug typically?"
- "Which of these DB queries do you expect to be run most/least frequently?"
- "This API method allows for pagination. How often do you expect a user to page beyond k?"
- generate tests
- generate code aligning with signatures, _and which cause tests to pass_ (i.e. program synthesis from examples)
- static analysis / abstract interpretation / model checking to confirm that some invariants are respected
- explicitly reporting which invariants or properties were not able to be confirmed automatically which a human may need to confirm via an ad-hoc analysis
Software is one of the domains where we can actually do a lot of sophisticated automated reasoning, but the current trend of ML code generation as text completion ignores basically all of that, and this seems like a giant waste.