I am very interested in programming tools that non-experts can use. I.e. people that didn’t learn to program initially but want or need to sometimes. Last week I have discussed with someone that could be interested in this kind of tool. And during the discussion about her use case, something appeared very clearly. In her journey in using programming, there are good chances that at one point she will need help from more experienced people. My feeling after that discussion is that this will be very common and that it is very important to take this into account early in the vision and the design of such tools or in the building of the community around it. I.e. creating tools that allow non-experts to program, make them feel it is normal to not know everything, making it really easy for them to find some help, and make it easy for a more experienced programmer to give help for the programming task. I guess I had this idea/feeling for some time, but I really feel its importance after that discussion. What do you think of that? Do you have examples of tools/communities where this is taken very seriously? Or any research work on this? Be it for end-user programming or not (in fact even experts need help from “more” experts).

This year's Convivial Computing Salon discussed this a fair bit. In particular, Philip Tchernavskij's response to Jun Kato's talk had a lot of pointers to prior work. I can't find the slides, but watch the video at https://junkato.jp/programming-as-communication

Thanks a lot Kartrik. In fact I have seen it live, but forgot about it, a sign that the subject wasn't important for me at that time. I know recall I liked Jun Kato's talk a lot. I will definitely rewatch it.

Some keywords from my notes of the talk, that were used in papers in the '90s: * participatory design * customizable/tailorable/personalizable/adaptable software Some notes I made of papers: * Maclean et al., 1990 * MacKay 1990 (DIY community) Just in case this is useful 🙂 Mostly this is an excuse for me to transcribe analog notes to a digital, searchable form.

This is, I think, an excellent book on end-user programming. https://www.amazon.com/Small-Matter-Programming-Perspectives-Computing/dp/026228040X It includes a significant discussion of the role of peer support

Indeed. Searching http://history.futureofcoding.org for 'nardi' brings up some good past threads.

Here's a way to put it... If you're making sufficiently rich software (from the end-user perspective), they are going to need help using it. You can choose to assist them in getting help, or you can hope that users will self-organize a forum for helping each other. Either way, help will be needed in order to get the most out of your software.

This is a frequent situation in computational science as well. It's not quite end-user programming, but a mixture of next-to-end-user and end-plus-next-to-end-user programming. Typically collaboration of a domain expert with some computing knowledge and a software professional with some domain knowledge.

I think there are increasing levels of end-user programmability: • adjusting an app's configurations and settings, customising in your settings • simple rules: email filters, IFTTT • spreadsheet formulae; box-n-wire dataflow through function boxes • copying someone else's code and changing the obvious parameters, etc • doing lots of the above and realising it's become a massive program, then panic! So I think we're talking about the latter here? Where an EUP system is very easy to get into, but then as a result it's very easy to create a huge blob of dense, opaque programming? I think it's important that the EUP system offers a model that is structured from the start, and where the normie programmer can draw on the work of others in a structured way, not just copy-pasting. They should be able to build a complex system incrementally and safely because the structure enables them to see how both their own constructions come alive and also how the work of others operates, and to see the effects of their changes immediately.

Thanks @Duncan Cragg for your comment! You are right: an important thing I want to address is how to design a system that can manage the "panic" step. And you point that one way to do it, is to try to propose tools that limit the risk of occurrence of the panic, by offering a safe environment where complexity doesn't "hit" the programmer to late.

Well that is perhaps leading to an idea of a distributed, semantic (AST not text) IDE?

It's also worth noting that decreasing scope can often reduce essential complexity; for example we could probably write some crazy huge language that can compile to all other languages but it'd likely be more useless than any of the others too. In the past I've seen a simple core, with pattern-based replacement for "optimization" work well, though the replacements often carry inexpressible constraints (leaky abstractions) and can increase complexity :/

Here's a doc on my site talking about this: http://object.network/onex-app.html