Computer programming is an art, because it applies accumulated knowledge to the world, because it requires skill and ingenuity, and especially because it produces objects of beauty. A programmer who subconsciously views himself as an artist will enjoy what he does and will do it better. (Donald Knuth)
(If you don’t recognize the name, nothing you’ll read here will be even remotely as interesting as looking him up and his work, so you should probably do that instead.)
Building AIs is a form of getting computers to do things they couldn’t do before. It’s a relatively new, or at least up to recently relatively infrequent, way of programming, but it doesn’t mean it’s not programming. This isn’t, I think, a controversial statement.
What’s perhaps less recognized is that when a programmer builds an AI, the code they use to train it isn’t the program: the AI is the program. That it’s opaque, hard to debug, and poorly understood — that we are more often pushed to add features than allowed to make it robust, that documentation is next to non-existent and that “debugging by printf” is still the default, are all-too-familiar signs of an impatient industry and an immature discipline, not philosophically deep and structurally unavoidable features of AI.
In short: most contemporary AIs — not the training libraries, the AIs built with them — are powerful, buggy, intriguing, and ugly. They are by and large badly engineered: not because there’s a lack of talent or money in the field, but because they are new and the competitive urgency lies elsewhere (something that often kills companies and sometimes people; as much as computer engineering in the wild has lagged behind what we know is possible in terms of robustness and elegance, contemporary AI makes COBOL bank systems look like something written by Dijkstra (another name that, if new to you, you should definitely look up).
This isn’t a plea to renounce the contemporary AI push: it’s allowing us to do things we couldn’t before. It’s a notice that it’s in its very early stages, and that it won’t continue forever the way it is. Future AI will have a richer conceptual structure and a deeper algorithmic understanding of what it’s doing — not just how it was trained — and will require programming skills different in detail from current ones but conceptually the same.
Good software is almost always beautiful; it’s a programmer’s sort of beauty, just like a chemical engineer can see the beauty in a synthetic route, or a musician appreciates a technical gesture. My view — you can certainly disagree — it that most AI right now isn’t beautiful in that sense. That’s a very optimistic view, because it tells me that the most interesting times are ahead, and that instead of the “obsolescence of programming” — a prediction that more often than not betrays a shallow understanding of what programmers do, as if it were little more than typing code — we are right now grappling with the problem of building new conceptual frameworks for the next phase of this art we love.
(Beyond the money, besides the spotlight, before the IPOs and far away from the blog posts – there’s always love.)