Cover art for ‘10 – Of Books and Code’

10 – Of Books and Code

Artificial Creativity

Listen on Apple Podcasts Listen on Google Podcasts Listen on Spotify

References:

David Deutsch, “The Beginning of Infinity”:
- Chapter 1, “The Reach of Explanations”
- Chapter 2, “Closer to Reality”
- Chapter 6, “The Jump to Universality”
- Chapter 7, “Artificial Creativity”
Facebook research on open-endedness: https://www.youtube.com/watch?time_continue=4500&v=g6HiuEnbwJE
OpenAI press release about Microsoft investment: https://openai.com/blog/microsoft/

Subscribe to this podcast via RSS Back to all episodes

Transcript

This transcript was generated automatically and may contain mistakes.

Welcome back. This is episode 10 on Artificial Creativity. I’m recording this episode from Berlin, and I’m happy to report that, according to a friend of mine in Germany, people here are trying to get away from the term “artificial intelligence” because they’re starting to realize that the software developed so far has little to do with intelligence. I’m very happy to hear that.

You may remember in, I believe, episode 3, we talked about the current state of AGI research, and we also spoke about the concept of universality and its implications. I want to use a specific example of universality today, namely the movable type printing press, but this time not only to go over universality again, but to get to a bit of a personal quibble of mine and to show that something is rotten in the state of software development, without getting too cynical, I hope. And there was an announcement that came out of OpenAI the other day that I’d like to share with you and comment on.

Software is now so ubiquitous that it’s hard to imagine any company that is not in need of at least some software solutions, because everyone uses software, and for good reason. I mean, once you have created a piece of software, the maintenance cost is typically pretty low compared to the cost of writing the software in the first place. This is what David refers to as the difference between the inspiration phase and the perspiration phase in chapter two of “The Beginning of Infinity”. Thomas Edison once claimed that inventing something takes 1% inspiration and 99% perspiration. But it turns out that isn’t true. The inspiration phase is almost everything. Because once you’ve invented a new technology, applying it doesn’t take any new knowledge. And it’s the new knowledge that’s hard to come by in the first place.

And by the way, this is another reason why I think the functional approach we’ve been taking is a hard-to-vary way of explaining explanations, because once you’ve created a function from nothing, which takes work, all you then need to do is run it, which, depending on the performance characteristics of that function, typically takes much less work. And it’s the same with explanations.

Another excellent reason to use software is that it has reach. Especially online applications have a built-in potential audience of billions of people. And it also has reach in another sense. The universality of computation implies that software can simulate any possible physical process. So software is undeniably a powerful tool.

As I said, in episode three, we discussed universality and its implications. And we used it to show that all people and AGIs are necessarily the same. They are universal, general-purpose problem solvers. They can in principle solve any soluble problem if they try hard enough. And it’s not a matter of degree. Either something or someone is a universal problem solver or they’re not. And since there are infinitely many soluble problems, it means that a universal problem solver has an infinitely big repertoire. And it’s inexhaustible. And this is why narrow AI research won’t lead to AGI by adding more and more features, because adding plus one feature doesn’t get you any closer to having infinitely many features.

In chapter six of “The Beginning of Infinity”, called “The Jump to Universality”, David gives the example of the printing press. And I’d like to talk about the printing press as well because I think it’s a good way to show what universality is and what current AI research, and I dare say all of software engineering, is lacking.

So up until the invention of movable type, there were different ways to print. For example, books were either copied by hand, or each page was carved in mirror script onto, for example, a flat wooden plate, and then the plate was inked, and then it was copied onto a piece of paper by pressing the plate against that piece of paper. So it’s much like using a rubber stamp. You ended up with wooden plates you could use to print one particular book, one plate per page. For example, the Bible was a popular book at the time. Movable type was invented by Johannes Gutenberg because he was looking for a cheaper and easier way to print books. And movable type made that process much better because the old way was such a laborious process.

But there was something else about movable type that made the printing press qualitatively different from its predecessors, and that was its reach. Because not only could it print any book that had been printed so far, and perhaps faster, it could print any printable book, even ones that hadn’t been written yet, and that’s remarkable. So this shows the momentous reach of movable type. This reach is a particular kind of universality. It means that the movable type printing press could print any book any other such printing press could also print. And it was a general-purpose printing press because it could print any book, period. So all movable type printing presses are necessarily the same in their ability to print a certain set of books, and that set happens to be infinitely big.

And as David points out in that same chapter, movable type is a typical example of a jump to universality because usually before the jump happens, you have to make specialized objects, for example, special-purpose printing plates or special-purpose computers and so forth. And after the jump, you only need to customize or program the universal object, such as movable type or Turing-complete computers and so forth. I think a similar jump to universality can be expected with software development, and I will explain what I mean in the course of this episode.

There are a couple of things to take away from movable type. One is that once something has reached universality in a certain domain, it is necessarily the same as everything else in that domain. The repertoires are the same, by definition. So, like I just said, all movable type printing presses can print all the same books. They can only differ in how many movable letters they have and in how fast you can print, but they won’t qualitatively differ.

The other thing to take away is that you cannot reach universality in an infinitely big domain, such as printing any printable book, by adding more and more to a list of features. This is why in infinitely large domains, universality can only reach in a jump. For example, imagine having carved out wooden plates that could be used to print the Bible, and then you carve out wooden plates to print “Romeo and Juliet”. You can keep doing that for as many books as you like, but it won’t get you any closer to a printing press that can print any book, because there are infinitely many such books. So once there’s a new book that needs printing, you can’t print it with the old-style printing press, not out of the box. That’s what differentiated movable type. It was a universal system, and all you had to do was put the letters in the right place, and voilà, you could print any book.

The situation is the same in AI research. I mentioned in episode three that OpenAI has created a musical composer, and a text predictor, and a piece of hardware that looks like a human hand that can manipulate objects. And of course, they’ve created many other interesting bits of software. But the point is you could put all of those things together into a system that can do all three things. But it can still only do those three things. To build AGI, we require a program that has an inexhaustible repertoire, and so a jump to universality is needed. The analogy here to printing books is that each new functionality is the counterpart to a set of wooden plates that can be used to print one particular book. So adding more features doesn’t get you AGI, for the same reason creating more wooden plates doesn’t get you a universal printing press.

It may be slightly unfair to put the blame on OpenAI only or on AI research more generally, because I think that software development today universally has the shortcoming, with a few token exceptions here and there. It’s just that the problem is salient in AI research. This also shows that current AI development is no different from other kinds of present-day software development, other than maybe that it feels a bit more academic because it relies on things like neural networks and calculus and linear algebra and so forth.

But I contend that when it comes to software development today, AI or otherwise, we still do something very similar to using wooden plates instead of movable type. I mean this metaphorically, of course, because our keyboards and text editors simulate movable type functionality, and we can use our computer’s hardware and software to type in any software we want. So instead, what I mean is that when we write software, we’re still doing no better than creating those wooden plates because we keep writing different kinds of specific software over and over again.

So the parallel is this. Every time a new book needed to be printed, somebody needed to carve out a new set of wooden plates. And then those wooden plates could be used and reused to print that specific book several times. We do the same thing with software today. If we need a new specialized piece of software, we write it from scratch, and we do this for every new piece of software, just like we used to do for every new book. And once we have that desired piece of software, we can reuse it by running it again and again. This looks like something that happens before a jump to universality, doesn’t it? Where you create specialized objects instead of customizing one universal one. So I consider this exciting evidence that there is a universal discovery waiting to be made, and that’s AGI.

This inefficiency hasn’t gone unnoticed, of course. People have performed research in the area of automated programming, of which genetic programming is a part, and of which John Koza is a pioneer. I’ve mentioned him before. And the hope is that we can one day create a program which takes in and understands specifications, and then writes a hard-to-vary program that meets those specifications. We already know from the concept of universality and from previous episodes that a program that could do this with required reach is necessarily an AGI. It would be a universal program, which need only be customized to create any other program or explanation, rather than coming up with every special-purpose piece of software or explanation ourselves.

So the idea is basically to get rid of the programmer. So where currently a software engineering manager tells an engineer the specifications, and then the engineer goes off and writes the program, we then wouldn’t need an engineer anymore. The manager or the client or whoever determines the specifications simply tells the AGI directly. For companies, this means they wouldn’t need software engineers anymore. This would be extremely lucrative. And it makes sense. Software engineers are rarely hired for their creativity, I’m sad to say, at least not beyond what is required to implement a set of specifications. So if companies could automate this task, they would. And why shouldn’t they?

This, of course, assumes that the AGI chooses to do whatever it is told and does so without major complications and does it for cheaper than an engineer and so forth. But leaving that aside for now, it seems like a no-brainer that any company that spends money on software development would want this, and badly. I should also point out that when I say automate, I don’t mean to suggest that there is a surefire way of creating an explanation for any given problem. This can always only happen by trial and error, and there are no guarantees.

But so where is the research? Why aren’t we seeing more money poured into this area? I think it’s because the field of AGI has been dealt quite a bit of damage, not least because of the continuous bastardization of the term AI, to the point that people can’t even think of anything beyond self-driving cars and chess players when they hear the term. So most people have simply forgotten what AI used to be all about, about building a person, one of us, continuing this cosmological effort to understand better how we create knowledge and determining its place and our place in the universe.

OpenAI just announced that they raised $1 billion from Microsoft. Ah, you say, there is the large sums of money going into AGI research. Well, if only that were true. As I explained in episode three, OpenAI is not working on AGI. They’re working on AI, which is the opposite. But that doesn’t seem to be the focus after this press release. I hear some people complaining online about how OpenAI is shifting from being non-profit to for-profit. I don’t really care about that. In fact, I’ve never quite understood what the problem is with companies making a profit. It’s a good thing. When I lived in San Francisco proper, a recurring theme was you’d meet someone new, and they would tell you about the company they had just started, and one of the first things they mention is that it’s a non-profit. It’s interesting to think about. In any case, if you read OpenAI’s press release about the investment and you’ve listened to episode 3 of my podcast, you will find errors in virtually every paragraph.

I don’t want to pick it apart here, but I’m going to pick out only two things that I find important here. First, they say that large amounts of computing power are needed to create AGI—without a good, meaning hard-to-vary, explanation of how it works. And such an explanation would be an implementation of the AGI. See episode 5. If they already had the implementation but weren’t able to run it yet, we would still consider that implementation an AGI. So therefore, computing power can never be the bottleneck to judging whether you’ve built AGI or not. It’s always the explanation of how it works first. And then second, OpenAI focuses on how important it is to ensure the safety of the technology, which is a red herring. See episode 2.

As a quick aside on safety issues, I have failed to find them talking about issues of safety and morality as it concerns the AGI. Coercing an AGI to perform specific tasks is to be a slaveholder. I’m not exaggerating, this is literally so, because remember, an AGI is a person. By definition, it will have inborn desires and expectations, and it will want to solve problems it’s interested in. To force it to go against those desires and interests is immoral because it prevents error correction.

If you want to address this concern and find some way to make it okay to have an AGI work on specific problems that you dictate, I think you can only do it one way. You’d need to address universality. If by the G in AGI we mean universal explaining and problem solving, and also emotions, thoughts, consciousness, and so forth, then unless a program has all of these properties, it’s not really an AGI. Or we could argue that there are different kinds of universality that do not necessarily imply each other. So you would have universal problem solving on one hand, and emotions, thoughts, consciousness, and so forth on the other hand. I personally hope that these are different kinds of universality because it would allow us to build a universal explainer without having to worry about moral issues and coercion, and you can interpret some of the material in this podcast in that spirit.

My main priority is to understand knowledge creation and problem solving. If that ability automatically confers consciousness, emotions, and the like, well, then we need to worry about moral issues by default. But I don’t have good explanations of why and how explaining confers consciousness. So for the moment, I’m going to assume that it doesn’t. But this is speculative, and I need to explain what the different kinds of universality are and why they’re different from each other. So it’s a bit of a pickle. And I’d also need to address why even in an unconscious system, preventing error correction wouldn’t be immoral.

In “The Beginning of Infinity” and the chapter “Artificial Creativity”, David conjectures that all of these abilities were achieved in humans in one single jump to universality. And I’m going to tentatively defer to him there while retaining the hope that he’s wrong. And I will most likely go back and forth on this in the future. In any case, back to software development generally.

Some people may argue, why should companies in Silicon Valley invest in this, or anywhere? Most of them are consumer electronics companies. They sell consumer products. They don’t need to care about cosmological efforts. And I would say to those people that that’s a bunch of baloney, because no software can be written and no hardware built without an explanation of how to do that, and no company will turn down an explanation that has reach. And none of their consumer products would work without sophisticated explanations of physics and chemistry and computation and so forth. So they already rely on the cosmological pursuit, and it’s in their own interest to contribute to it and to look beyond immediate gains.

David mentions in chapter one of “The Beginning of Infinity” that our ancestors looked at the night sky and wondered what stars were only occasionally, when they took breaks from their more parochial concerns. I think this is the same today when we write software, and we should spend more time wondering about AGI and how it may work. Our ancestors were looking at the right—and they were wondering about the right things. Knowing how the night sky works does give us a tremendous amount of power over nature, and it improves our lives because much of the knowledge of how stars work and how gravity works applies to how things work on earth. For example, you cannot build GPS without Einstein’s relativity.

So I’m going to argue that much future progress we can make will depend on figuring out how to build AGI. But for now, there is a complacency in the industry that should and will lead to frustration among software engineers sooner or later, ideally now. AGI used to be the highest goal, the holy grail of computer science, and we’ve just sort of forgotten about it.

A software engineer’s situation today is basically this. Imagine Gutenberg’s investors had only been interested in particular books, and they hadn’t really cared about investigating how one should print books, and if maybe there wasn’t a better way to do all this. Let’s say they’d had only short-term interest of printing, say, these next 10 books. Those were actionable items, and let’s say they seemed reasonably lucrative, so there was a tangible benefit there. So instead of doing the research and coming up with movable type, imagine Gutenberg had spent all his days carving out wooden plate after wooden plate after wooden plate.

Maybe he would have found ways to make this process a little bit faster, just like developers find ways to write software a little faster and be more productive. And maybe he would have found ways to extract some carvings here and there that had recurring patterns so he could reuse them, in the same way that software engineers often make large parts of their software reusable. He may even have found new and better ways of carving out wooden plates, much like developers sometimes develop entirely new programming languages. But he probably would never have invented movable type. And even worse, imagine others had come along and claimed they were making progress towards a universal printing press without ever building one, without getting any closer to one, because all that ever improved was their way of carving out wooden plates.

The language around universality would have been ruined at that point, and it would have become harder even to envision anything beyond ever cleverer ways of carving out wooden plates. Yet this is exactly what’s happening today with software engineering. Why every company that develops software doesn’t allocate some money to spend on AGI research, and why they don’t see how repetitive it is to figuratively keep carving out wooden plates instead of inventing movable type, is beyond me.

There is one promising video someone shared with me recently that goes into how artificial intelligence research should start looking into unbounded problem solving. That sounds a lot more optimistic and more to the point. An AGI is a universal problem solver. The video also sheds light on how existing technologies are not yet open-ended. I’ll link to the video in the description. I should say that it’s a long video and the link starts somewhere in the middle, and you should know for the record that I did not watch the beginning of the video, and I didn’t watch it all the way to the end either, so I can only speak to the part I linked to. This came out of Facebook’s research arm, I think, and I’m excited to see this.

My main point in this episode is that to keep writing specific pieces of software for decades on end is insanity. It’s the equivalent of carving out wooden plate after wooden plate to print books without stopping to think that maybe building something like movable type would be a better idea. Since for the most part, software engineering managers, or even especially AI engineering managers, don’t seem interested in the topic, I say it’s on us engineers to make the difference. We need to grow tired of writing more and more specific pieces of software and instead establish our desire for something better and universal. Software engineers are a desired part of the workforce, and they have more power than they may realize. Nothing works without them, so they have the power to change things.

Working on specific software pays the bills, of course, just like printing specific books did. I won’t deny that. Working on a new invention doesn’t pay the bills immediately, but when it does, it has more monetary and functional potential than anything that came before it. If you find a specific problem that you’re interested in working on, more power to you. Sometimes there are particularly interesting wooden plates to carve out. Just remember that it’s still just a wooden plate. And if we don’t want to carve out wooden plates forever, we shouldn’t forget the general goal, the holy grail of software engineering, AGI, in our day-to-day.

Well, thanks as always for listening to this rant this time. I haven’t decided what I’m going to cover next. At some point, I would like to cover the Turing test, but I haven’t decided yet if that will be the next episode. In any case, I hope you’ll tune in, and I’ll see you then. Bye.


What people are saying

What are your thoughts?

You are responding to comment #. Clear
Markdown supported. cmd + enter to submit. You have free speech here. You’re responsible for what you write. Terms, privacy policy
Your real name is preferred.
This small puzzle helps protect the blog against automated spam.

Sign your comment with GPG to create or add to a public profile with all your comments.

Paste a detached signature of your comment.

              
Paste your public-key block if you haven’t before. You consent to your key’s contents, including your name, being displayed to the public.

              

Preview

Playing ~