Let there be "Hello world!"

Society and programming has something fundamental in common; the stack.

In software we say that the front end is dependent on logic layers and a back end and data base.

In society our justice system runds on the legal institutions, which run on people, which make stuff with language, and that language is implemented in the logic and database architectures of the brain - the wetware.

But the towers of logic and interconnection has to be programmed, implemented and built. It doesn't come from nothing. Todays article is about the very mechanism that makes it all possible; and how we can use it to do natural language programming.

I give you:

The declaration

Declarative: A sentence that speaks something into being by saying it is so.

-Congratulations, you now have a PhD.

-This is a receipt of your purchase

-A counts as B in this context

let willYou = (answer) => {
if (answer === ‘marry me’) {
return ‘Together, for eternity.’;
} return ‘The heart waits, ever hopeful.’;
}

Limits to life
There are some fundamental limits to life; a limit to how much stuff one can have, how much one can move and change, a limit to our energy, and lastly a limit to how much we can compute and think.

Each of these limits have been overcome to some extent in various revolutions, like the industrial revolution, where our ability to use energy and put stuff together was multiplied tenfold from learning how to harness steam to make machines. It was the intelligentsia of that time, the engineers who really benefited form this transformation — for normal people much of that wealth was inaccessible.

Now we are part of our own revolution. The information revolution, where it is the computation and thinking that has been put into the logic of the hardware. There have been some attempts at making the power of computation available to more people, but still for the most part the power of definition, of declaring new pieces of logic into reality, has been reserved the priesthood of the mathematically minded coder. The encoder of the logic, the programmer.

It is normal, I declare…
But speaking, and making things up, is not something that is generally reserved for a small group of people. Just like we kan still knit by hand, even though there are machines that do it much faster, programming is part of a human experience that everyone can have — but instead of making a computer program, we write letters, make deals, define relationships and the like. Programming, or making social and written reality is part of who we are.

A large part of the reason why it was difficult to program before, was that there was not much incentive for the programmers to make powerful interfaces for non- programmers. Interfaces that would in any case be more domain specific and more limited than the tools they themselves use. The most powerful example is “Hypercard”, a program that for a long time was part of every mac, where cards could be hyperlinked to make small programs.

Of course now, there is a proliferation of no code tools, and these have hitherto had some success — but has not been seen, perhaps, as “real coding.”

No coding tools float at the top of the “stack” but without robustly connecting to what is below — it is not real coding. It is my impression that to truly connect, we need a text layer to be at the top too.

The text interface
As an affordance generative artificial intelligence systems have the ability to accept declaratives as an input, while at the same time speaking in a natural language to the user. This means that the task of programming, of putting logic into a computer system as is, has been lifted out of the realm of being merely an expert system, and is now accessible to a lot more people.

There is still a barrier to programming expert systems. This is because programming intrinsically is a hard skill. We recognise this because learning to speak and think in itself is hard — formulating complete ideas, and saying what is needed is indeed hard. Therefore, no matter how easy programming will become, we will still never be free of the demand to express what we actually want to happen — and for that reason we will still need professional programmers.

Generativity itself
Generativity is the ability of a combinatorial system to produce novel outputs or meanings based on known elements. To understand this we can contrast marbles and lego. No matter how how many ways you recombine your marbles, they will not make a box for your pencils. They have combinatoriality, but their effects will not change much. However, with lego you can make new and useful structures, even though you are only recombining old elements again and again. This is the difference between generativity and mere combinatoriality.

Programming and natural language are both generative systems. The input of building these systems is the declarative for both, and then there is the grammar or logic of combining these. However, there are other uses that are somewhere in between making a program and making something happen.

Smaller ideas for things to happen with
This is something we can see with the “advanced data analysis” tool that comes with openAI. With this you can ask it do to calculations for you, or explore in depth something that can only be done with some computation. For instance, if you have an xlsx file, a spreadsheet, it can go through it to do statistical analysis, alphabetise and sort, or make graphical representations of the data.

But is this programming? Yes, in the sense that you are providing a language input, that is then turned into an artificial logical structure, capable of producing novel inputs.

Traditionally programs are larger structures, systems of interdependent logical operations — but with the advent of, so to speak, just in time programming, we could have a more nuanced idea of what programming can be for us.

Not new, but new.
Has not declaratives been part of our interfaces before? In domain specific instances, there can be examples, such as with calculator or calendar functionality, where you as the user do some defining of your own. But these systems have not been generative, they cannot combine elements in a meaningful way.

I think it is impossible to say where this will take us. We already start seeing that generative programs have started cropping up. Some of these are image makers, some make GUI, and others music — but we have yet to see the truly robust companion that elevates your mental tasks to the next levels, and lets you define programs that work on your behalf to make your life easier.

Educate, elevate.
As we make these systems, we will need to educate the user in how to use them.

For now, let us only stop to ask “What kinds of things must a user learn to make use of generative text interfaces that accept declaratives as an input?”. An interesting answer to this was provided to us by the computer engineer, programming language author and physicist Stephen Wolfram on his fourth appearance on the Lex Fridman podcast.

Wolfram made the point that a general user might not know how to do things, but rather more that it could be done, and also what the output was. For instance, a user might have some data on the profile of their customers, and also have their purchasing information. Given this, what kind of analysis would produce a better understanding of targeted marketing? Maybe… regression analysis?

“Can’t we just ask the llm analysis tool what to do?” Sure, it might provide some answers, but this is only a second order approximation of what you want to do. Without knowing what kinds of computational tasks might be performed, it will be hard to both come up with the idea to use the tool, and also to robustly understand the results.

While not everyone will have the same needs for using computation like this in their everyday life, those who have this competency in computation, and those who lack, will create a class distinction — a new computer literacy gap.