Programming as interaction: A new perspective for programming language research(tomasp.net)

119 pointsby jgamman8 anni fa12 comments

Programming as interaction: A new perspective for programming language research

http://tomasp.net/blog/2018/programming-interaction/

4 comments

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.

wcrichton8 anni fa

Some specific resources for the interested:

- Cognitive Dimensions of Notations (Green 1989) http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.128...

- Programmers Are Users Too: Human-Centered Methods for Improving Programming Tools (Myers et al. 2016) http://faculty.washington.edu/ajko/papers/Myers2016Programme...

- Programmer Interrupted (Parnin 2013) http://blog.ninlabs.com/2013/01/programmer-interrupted/

- Empirical analysis of programming language adoption (Meyerovich and Rabkin 2013) https://dl.acm.org/citation.cfm?id=2509515

- Learnable Programming (Victor 2012) http://worrydream.com/LearnableProgramming/

- Usability of Programming Languages working group at CHI'16 https://docs.google.com/document/d/1-GUt5oVPpi7rlObbU1WbA5V1...

azhenley8 anni fa

All great examples! Here are some other great researchers/groups that do research in this area:

- Brad Myer's Natural Programming Project at CMU (tons of novel tools!): http://www.cs.cmu.edu/~NatProg/index.html

- Andy Ko's work on debugging and learning to code: http://faculty.washington.edu/ajko/publications

- Emerson Murphy-Hill's work on the usability of dev tools, especially refactoring tools: https://people.engr.ncsu.edu/ermurph3/pubs.html

- Chris Parnin's studies on the cognitive aspects of coding: http://chrisparnin.me/

- Chrsitian Bird's empirical studies of developers: http://www.cabird.com/wp/publications/

- Thomas LaToza's work on the collaborative aspects of development: https://cs.gmu.edu/~tlatoza/papers.html

- Bjorn Hartmann's help support in code editors and tutorial generation: https://people.eecs.berkeley.edu/~bjoern/

- Philip Guo's tools to support novices with coding: http://www.pgbovine.net/publications.htm

- My dissertation "Human-Centric Tools for Navigating Code": http://web.eecs.utk.edu/~azh/publications.html

- Margaret Burnett's work on how people forage for information in code: http://web.engr.oregonstate.edu/~burnett/reprints.html

tpetricek8 anni fa

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.

no_identd8 anni fa

You also aware of the following?

First:

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.455... The Interactive Nature of Computing: Refuting the Strong Church-Turing Thesis

And related research, such as the one pointed out in this hacker news comments thread:

https://news.ycombinator.com/item?id=17292935

(Full comments for that submission, "Are real numbers really real?" here: https://news.ycombinator.com/item?id=17291752)

For more, albeit more peripherally related, see also here:

https://arxiv.org/abs/0806.3972 Short note on additive sequences and on recursive processes;

from where I'll quote:

"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:

http://drops.dagstuhl.de/opus/volltexte/2017/7276/pdf/LIPIcs...

Which points out that one can do certain forms of recursion, specifically, https://en.wikipedia.org/wiki/Bounded_quantification#F-bound..., via recursive self-types, without turing completeness.

]

nikofeyn8 anni fa

> This is not new at all. There have been people studying this (myself only for the last 6 years) for quite some time...

the author is aware.

https://twitter.com/tomaspetricek/status/1024984269972819968

tpetricek8 anni fa

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...

Fellshard8 anni fa

The Dynabook / Smalltalk ideals, too.

asprouse8 anni fa

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.

Something12348 anni fa

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.

mettamage8 anni fa

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.

qaq8 anni fa

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.