I think there could be good ideas in here but it would need to be about 75% shorter for me to figure out where they are. I read a lot at the beginning but it was mostly talking generally about how learning works, and I wanted the meat, so I tried to skim, but skimming seemed to make me just miss the meat.
I enjoyed the start/problem statement, but failed to grasp the connection between the rule rewriting paradigm and the complexity swamp we’re currently in.
It’s a bit muddled. I think the claim is that the particular flavor of multiset rewriting that they’ve implemented (or more vaguely, the entire family of rewriting logics?) is a more “intuitive” basis for learning and reasoning about computation in general, and could serve as an escape route of some sort, a dry patch of ground for people who want to build radically simpler systems. (Of course, that doesn’t actually solve the swamp problem!)
It’s using a pretty badly strained metaphor of mountainous wilderness to describe what you call a swamp. And it’s making a lot of the same rhetorical moves as Alan Kay or Bret Victor. Unfortunately, while it blames “historical inertia” for this swampy state of affairs, it doesn’t point out any specific historical phenomena or even prior art. I guess it’s not that kind of talk?
This idea of rewriting-as-computation seems interesting, and it fits against other interesting ideas I’ve come across in the past, like “event sourcing”/Out of the Tar Pit and certain kinds of adventure games - this is almost the entire game engine of Fallen London, and recently I’ve been been playing with Inform 7 writing code like “instead of taking something from the cigar case in the presence of Mrs. Whitworth: say ‘Mrs. Whitworth lunges at you and grabs the cigar case!’; now the cigar case is held by Mrs. Whitworth.” which I think looks a bit like a rewrite rule if you squint.
I am intrigued, but I don’t immediately see any way to make use of these ideas. I’ll be interested to see what develops in future.
I’m curious, how does Vera handle a couple of basic issues with multiset rewriting systems:
Nondeterminism?
|| a b c
| a b | o
| b c | o
Exponential blowup?
|| o
| o | o o
I haven’t run these examples through any of the implementations, but I’m less interested in how they currently behave than in how you’re thinking about these issues.
Nondeterminism is resolved by having rules be checked in order of definition. This is also how checking for empty counters and/or the decision side of Turing completeness is managed. Your example would end up with c :: 1, o :: 1
Exponential blowup is a way to quickly saturate counters, and do infinite loops, ultimately it’s about as interesting as an infinite loop.
Speaking of, infinite loops -are- an intentional part of how Vera works,
| game loop | check inputs, update, render, next frame
| check inputs | ( poll inputs )
| update | ( logic )
| render | ( rendering calls )
| next frame | game loop
There’s some logic missing for timing the end of a frame, but that’s a basic game loop.
So the rules are always ordered linearly? No partial order like with parser precedence levels? I suppose that takes care of incoherent rule sets too:
|| a
| a | b
| a | c
I can understand why infinite loops are useful, but I wasn’t asking about that. What do you mean by “saturate counters”? Is a counter some fixed-width integer type? Can it roll over? Does it have an “infinity” value or something? Do you consider counter saturation to be an error condition?
What a counter does is currently implementation dependent, but what generally makes sense is either to have a saturation point or have counters be backed by bignums of some variety. In theory, you can assume unbounded counters, and use encoding to store state and achieve Turing completeness. In practice, there are more practical ways to implement memory and storage.
That being said, Very Large Counters are -generally- mostly interesting as a way of acting as catalysts . Beyond that usecase, at least in our current awareness of Vera’s semantics and use, they probably indicate an error condition.
The linear ordering was chosen for it’s intuitive nature.
Another thing about that priority ordering: It allows you to redefine what -any- rule in an existing program does if you put in a higher priority rule that matches on the same counters.
COMEFROM, but not as a joke, and we’ve already had some fun experiments in that direction. Time will tell how much it is an asset vs a liability when it comes to building programs.
I see on the wiki that most of the effort is going into the lower-level Vera layer. Is there some particular goal or benchmark you’re looking to achive before getting back to the next-level Mira layer?
What does “the success of the Nova project” look like to you? A portable and widely-used interpreter, like Python or Ruby? A library that other projects incorporate, like Lua or Tcl? A bunch of different, interoperable implementations designed for different contexts, like JavaScript? A bunch of different, incompatible implementations built on similar ideas, like Lisp or Forth?
We’ve achieved enough with Vera that some work is going into building a Mira to Vera compiler.
The thing is, that for now, Vera is a lot easier to build and modify in the spare time that’s currently fueling this project. We don’t have anyone working on Nova full time yet.
The other thing is that Vera has a -lot- more capability than one might think at first glance. I’ve got plans for using it to power a JavaScript UI toolkit, and writing that in a way where the code for it -actually- can run on the front or back end, for example.
As far as success goes, there’s a decently long gradient, this is -very- much a Shoot for the Moon and land among the stars situation. I very strongly believe that Nova’s ideas are going to turn the software industry upside down in the next 10 years, but to quote myself:
The ideas of Nova already turn heads when presented to professional developers. We cannot rest on this laurel. Nova needs to demonstrate the ability to manage complexity at scale.
We should be impressive like Erlang, readily documenting engineering concerns and limitations, not merely hyping ourselves up.
As much as I think it’s going to change things, it can only do that -if- we actually respond to the feedback and face the problems that are in front of us as they come. So, like, skepticism and attempts to find gaps are welcome! I recognize that I’m making extraordinary claims, and that those require great evidence. I intend to go -make- that evidence by using Nova to solve problems, as I have time.
The first goal with Nova is to have a bunch of different, interoperable implementations. A Vera implementation can be spun up in an afternoon or two (we’ve got one in Lua, another in Python, another in C, two targeting uxn, and I’m working on a JS implementation right now). We’re working on defining as much as we can of the Nova system in Vera over time, as well, so a basic Vera implementation can act as a sort of base layer and opt you into a lot of the ecosystem up front.
The second goal is to build a Nova system that runs on bare metal, so that we can run Nova on extant hardware. The Atari 2600 is a planned Vera target, for example. Compiling Vera to C or Assembly is actually surprisingly easy.
That being said, Nova also works quite naturally as a library incorporated into other projects, for two reasons:
It’s a small thing to build/add, useful at smaller code-footprint sizes than a Lisp or a Forth
It fills a role largely orthogonal to most existing languages, of being a way to organize the edges between parts of a program, rather than leaving them diffused throughout a web of function calls. Nova fits into a missing quadrant of software development, IMO.
That being said, if we don’t end up changing things as much as I expect, then Nova becomes a secret weapon for a few hundred to few thousand programmers.
There’s a great depth and breadth of research into rewriting systems that the linked talk doesn’t mention, but I would hope the author is aware of. For example https://maude.cs.illinois.edu/wiki/Rewriting_Logic
Maude has definitely come up in community discussions around this work, so although it’s not mentioned in this talk, I’m confident that the author is aware of it. They mentioned survey the history of this space for quite some time. Perhaps in the future they may more explicitly relate their work to what has come before.
I do agree that software these days is more complex than it was 30 years ago, but by the same token, I’ve seen the same hand wringing over democratizing software for the past 30 years! Perhaps the problem isn’t that software is too hard to use, perhaps it’s most people don’t want to use computers? Or perhaps the question to answer is: what does it mean to be “computer literate?” [1]
[1] And in my opinion, it’s not “being able to use Microsoft Word.
Or perhaps the question to answer is: what does it mean to be “computer literate?” [1]
[1] And in my opinion, it’s not “being able to use Microsoft Word.
Pfff, you know, I feel like that’s not even a valid question anymore. As a tech nerd who’s been programming since age 12, uses tiling window managers, TUI tools with vi keybindings and Emacs, I struggle a lot with “modern” technology. For example, the other day I spent 5 to 10 minutes trying to find the “search” in Apple’s email program on my wife’s iPhone (turns out you have to swipe upwards on the overview page to make it appear, WTF). Also, to this day I still have no idea if there’s even a “search in this document” function (a la Ctrl+F) in iOS.
There have been plenty of other such moments where I felt like an absolute tool trying to use some popular commonly used program. I feel like the cultural gulf between “technologists’ tools” and “mainstream tools” is just too wide. I guess this is what it must feel like to be old and left behind by digitization.
The way to search the emails is discoverable by searching the web.
There is no universal ctrl+f type shortcut in iOS. You can search pages in Safari, but it’s hidden in the share menu for some reason (swipe the share menu up for more options).
In Safari on iOS, you just type in the URL bar, and one of the “search” options that come up (at the very bottom, usually hidden by the page length and/or the onscreen keyboard) is an option to “search this page”. I’m not a fan, but it does have the option.
For some interpretation of “use”, too: I saw text that was right-aligned by putting lots of spaces in a line in 1994, and I thought that the ability to let the computer take care of alignment is a feature some may take longer to get used to.
I still see it in 2024, both by people who had those 30 years to adapt and didn’t bother as well as people who are much younger than that and barely know that machines without that ability even exist.
So yes, it seems many people don’t want to use computers. They want to solve some problem of theirs with the least amount of thought spent on that. More power to them, but it’s difficult to democratize software for such folks.
Maybe some people are better served with pen + paper, plus a bunch of index cards. (Even though I, the tech nerd supreme in my social circles, am the only one to carry index cards in daily life.)
This reminded me so much of prolog toward the end that I was surprised it was never mentioned. Either nobody remembers prolog anymore, or my memory of it (bag of facts, rules for matching & rewriting) is glitched. Still, pretty interesting.
I think there could be good ideas in here but it would need to be about 75% shorter for me to figure out where they are. I read a lot at the beginning but it was mostly talking generally about how learning works, and I wanted the meat, so I tried to skim, but skimming seemed to make me just miss the meat.
Yesh, too long and definitely leaning too hard on “scrollytelling”
It’s the script of a 1-hour talk, it seems unfair to expect anything else.
I enjoyed the start/problem statement, but failed to grasp the connection between the rule rewriting paradigm and the complexity swamp we’re currently in.
It’s a bit muddled. I think the claim is that the particular flavor of multiset rewriting that they’ve implemented (or more vaguely, the entire family of rewriting logics?) is a more “intuitive” basis for learning and reasoning about computation in general, and could serve as an escape route of some sort, a dry patch of ground for people who want to build radically simpler systems. (Of course, that doesn’t actually solve the swamp problem!)
It’s using a pretty badly strained metaphor of mountainous wilderness to describe what you call a swamp. And it’s making a lot of the same rhetorical moves as Alan Kay or Bret Victor. Unfortunately, while it blames “historical inertia” for this swampy state of affairs, it doesn’t point out any specific historical phenomena or even prior art. I guess it’s not that kind of talk?
This idea of rewriting-as-computation seems interesting, and it fits against other interesting ideas I’ve come across in the past, like “event sourcing”/Out of the Tar Pit and certain kinds of adventure games - this is almost the entire game engine of Fallen London, and recently I’ve been been playing with Inform 7 writing code like “instead of taking something from the cigar case in the presence of Mrs. Whitworth: say ‘Mrs. Whitworth lunges at you and grabs the cigar case!’; now the cigar case is held by Mrs. Whitworth.” which I think looks a bit like a rewrite rule if you squint.
I am intrigued, but I don’t immediately see any way to make use of these ideas. I’ll be interested to see what develops in future.
The way I like to describe it is that Nova programs have a built-in universal test seam.
(also, hi, I’m one of the Nova core devs, and am happy to answer questions if folks have them)
I’m curious, how does Vera handle a couple of basic issues with multiset rewriting systems:
Nondeterminism?
Exponential blowup?
I haven’t run these examples through any of the implementations, but I’m less interested in how they currently behave than in how you’re thinking about these issues.
Nondeterminism is resolved by having rules be checked in order of definition. This is also how checking for empty counters and/or the decision side of Turing completeness is managed. Your example would end up with
c :: 1, o :: 1Exponential blowup is a way to quickly saturate counters, and do infinite loops, ultimately it’s about as interesting as an infinite loop.
Speaking of, infinite loops -are- an intentional part of how Vera works,
There’s some logic missing for timing the end of a frame, but that’s a basic game loop.
So the rules are always ordered linearly? No partial order like with parser precedence levels? I suppose that takes care of incoherent rule sets too:
I can understand why infinite loops are useful, but I wasn’t asking about that. What do you mean by “saturate counters”? Is a counter some fixed-width integer type? Can it roll over? Does it have an “infinity” value or something? Do you consider counter saturation to be an error condition?
What a counter does is currently implementation dependent, but what generally makes sense is either to have a saturation point or have counters be backed by bignums of some variety. In theory, you can assume unbounded counters, and use encoding to store state and achieve Turing completeness. In practice, there are more practical ways to implement memory and storage.
That being said, Very Large Counters are -generally- mostly interesting as a way of acting as catalysts . Beyond that usecase, at least in our current awareness of Vera’s semantics and use, they probably indicate an error condition.
The linear ordering was chosen for it’s intuitive nature.
Another thing about that priority ordering: It allows you to redefine what -any- rule in an existing program does if you put in a higher priority rule that matches on the same counters.
COMEFROM, but not as a joke, and we’ve already had some fun experiments in that direction. Time will tell how much it is an asset vs a liability when it comes to building programs.
It’s an interesting model, and I appreciate how you’ve prioritized simplicity as a design goal. I look forward to seeing how it scales up.
@wryl gets most of the credit for the focus on simplicity, heh.
I see on the wiki that most of the effort is going into the lower-level Vera layer. Is there some particular goal or benchmark you’re looking to achive before getting back to the next-level Mira layer?
What does “the success of the Nova project” look like to you? A portable and widely-used interpreter, like Python or Ruby? A library that other projects incorporate, like Lua or Tcl? A bunch of different, interoperable implementations designed for different contexts, like JavaScript? A bunch of different, incompatible implementations built on similar ideas, like Lisp or Forth?
We’ve achieved enough with Vera that some work is going into building a Mira to Vera compiler.
The thing is, that for now, Vera is a lot easier to build and modify in the spare time that’s currently fueling this project. We don’t have anyone working on Nova full time yet.
The other thing is that Vera has a -lot- more capability than one might think at first glance. I’ve got plans for using it to power a JavaScript UI toolkit, and writing that in a way where the code for it -actually- can run on the front or back end, for example.
As far as success goes, there’s a decently long gradient, this is -very- much a Shoot for the Moon and land among the stars situation. I very strongly believe that Nova’s ideas are going to turn the software industry upside down in the next 10 years, but to quote myself:
As much as I think it’s going to change things, it can only do that -if- we actually respond to the feedback and face the problems that are in front of us as they come. So, like, skepticism and attempts to find gaps are welcome! I recognize that I’m making extraordinary claims, and that those require great evidence. I intend to go -make- that evidence by using Nova to solve problems, as I have time.
The first goal with Nova is to have a bunch of different, interoperable implementations. A Vera implementation can be spun up in an afternoon or two (we’ve got one in Lua, another in Python, another in C, two targeting uxn, and I’m working on a JS implementation right now). We’re working on defining as much as we can of the Nova system in Vera over time, as well, so a basic Vera implementation can act as a sort of base layer and opt you into a lot of the ecosystem up front.
The second goal is to build a Nova system that runs on bare metal, so that we can run Nova on extant hardware. The Atari 2600 is a planned Vera target, for example. Compiling Vera to C or Assembly is actually surprisingly easy.
That being said, Nova also works quite naturally as a library incorporated into other projects, for two reasons:
That being said, if we don’t end up changing things as much as I expect, then Nova becomes a secret weapon for a few hundred to few thousand programmers.
There’s a great depth and breadth of research into rewriting systems that the linked talk doesn’t mention, but I would hope the author is aware of. For example https://maude.cs.illinois.edu/wiki/Rewriting_Logic
Maude has definitely come up in community discussions around this work, so although it’s not mentioned in this talk, I’m confident that the author is aware of it. They mentioned survey the history of this space for quite some time. Perhaps in the future they may more explicitly relate their work to what has come before.
I do agree that software these days is more complex than it was 30 years ago, but by the same token, I’ve seen the same hand wringing over democratizing software for the past 30 years! Perhaps the problem isn’t that software is too hard to use, perhaps it’s most people don’t want to use computers? Or perhaps the question to answer is: what does it mean to be “computer literate?” [1]
[1] And in my opinion, it’s not “being able to use Microsoft Word.
Pfff, you know, I feel like that’s not even a valid question anymore. As a tech nerd who’s been programming since age 12, uses tiling window managers, TUI tools with vi keybindings and Emacs, I struggle a lot with “modern” technology. For example, the other day I spent 5 to 10 minutes trying to find the “search” in Apple’s email program on my wife’s iPhone (turns out you have to swipe upwards on the overview page to make it appear, WTF). Also, to this day I still have no idea if there’s even a “search in this document” function (a la Ctrl+F) in iOS.
There have been plenty of other such moments where I felt like an absolute tool trying to use some popular commonly used program. I feel like the cultural gulf between “technologists’ tools” and “mainstream tools” is just too wide. I guess this is what it must feel like to be old and left behind by digitization.
The way to search the emails is discoverable by searching the web.
There is no universal ctrl+f type shortcut in iOS. You can search pages in Safari, but it’s hidden in the share menu for some reason (swipe the share menu up for more options).
In Safari on iOS, you just type in the URL bar, and one of the “search” options that come up (at the very bottom, usually hidden by the page length and/or the onscreen keyboard) is an option to “search this page”. I’m not a fan, but it does have the option.
For some interpretation of “use”, too: I saw text that was right-aligned by putting lots of spaces in a line in 1994, and I thought that the ability to let the computer take care of alignment is a feature some may take longer to get used to.
I still see it in 2024, both by people who had those 30 years to adapt and didn’t bother as well as people who are much younger than that and barely know that machines without that ability even exist.
So yes, it seems many people don’t want to use computers. They want to solve some problem of theirs with the least amount of thought spent on that. More power to them, but it’s difficult to democratize software for such folks.
Maybe some people are better served with pen + paper, plus a bunch of index cards. (Even though I, the tech nerd supreme in my social circles, am the only one to carry index cards in daily life.)
This reminded me so much of prolog toward the end that I was surprised it was never mentioned. Either nobody remembers prolog anymore, or my memory of it (bag of facts, rules for matching & rewriting) is glitched. Still, pretty interesting.
I’m curious how this handles things like trig or parsing JSON or whatever. Seems solid for text adventure games, which is not nothing.