This is not new at all. There have been people studying this (myself only for the last 6 years) for quite some time, generally falling under the field of human-computer interaction. Even in the 70s researchers were studying how people read code.
In fact, there are niche conferences like VL/HCC (human-centric computing), ICPC (program comprehension), and PPIG (psychology of programming) that publish papers in this area each year. Bigger conferences, such as CHI, also publish a handful of papers on novel ways to interact with code each year too.
Author here. I'm aware of work in this area (though certainly not all of it) and I had the pleasure of attending last two PPIGs!
The idea I outlined in the blog post is absolutely inspired by all of this, but I think there is one fundamental difference (which perhaps is not as clearly explained as it should have been).
People in the HCI world study interactions that happen in programming and use that as a source of ideas for how to design languages. However, what I'm proposing is to make those "interactions" a part of the language definition. (HCI is a great source of ideas for understanding what those interactions are, but you can then study the resulting things in many ways, including formal methods - which is what I find interesting).
As far as I know, the related work that actually does what I'm describing is two things already mentioned in the blog post (Subtext, Inferential Programming) and one idea someone mentioned on Twitter is Programming by Example, which I think is close too.
tldr; I'm not talking about studying programming via the perspective of human computer interaction, but about making those first-class language constructs.
"It seems obvious that any ‘grammar’ that would engender the words – and only the words – of the above described recursive sequence has infinitely many rules (even if we can express them all in a finite number of English words) and as such does not belong to ‘formal’ grammars. Of course, the use of these new rules at every step of the process is limited, because it depends of the steps themselves. Nevertheless, it seems that the set of the generated words is not included in the outcome vocabulary of any formal grammar. Therefore it doesn’t correspond to any Turing Machine. Inasmuch it seems to be, in some sense, calculable and recursively enumerable, one can ask: how to build an automaton able to recognize them? How about the celebrated Church-Turing Thesis and the way it is understood or misunderstood?"
[
For EVEN MORE misunderstandings about Turing completeness, see also this Scala-related paper:
Haha, thanks for linking to this thread! This was definitely an idea that I've been thinking about for some time and this thread is a part of it. As pointed out in a comment elsewhere in the discussion, I think most of these do not quite do the same thing I'm interested in...
Back in 2003 my fundamentals of CS course heavily relied on the interactions window of DrScheme (now DrRacket https://racket-lang.org/). It was a extremely powerful educational tool. When I started doing web development I found myself frequently putting snippets like `javascript:alert('abc'.substr(1)` into the URL bar. With the advent of the Firebug console it became even easier to try out new snippets. Now a days the Chrome console tab even has autocomplete. I'd be interested to know how these simple interactions contributed to the widespread adoption of JS and other languages.
Better completion usually makes me more productive no matter how crap the language is. Looking at you Java with your ginormous standard library with poor docs, and poor completion in eclipse.
I always use a debugger, primarily to catch bugs, but I'm also realizing that because of that process, the debugger is a learning tool.
If I'd teach programming education, I'd teach them a language with great debugger support and preferably also support to single step through the machine language as well.
I suppose C is a good language for that. I wish JavaScript would show it's underlying machine code that you could single step through.
Sounds interesting from a practical side people might be worried that this info will be immediately streamed into some system used to derive some meaningless KPIs.
In fact, there are niche conferences like VL/HCC (human-centric computing), ICPC (program comprehension), and PPIG (psychology of programming) that publish papers in this area each year. Bigger conferences, such as CHI, also publish a handful of papers on novel ways to interact with code each year too.