Skip to content
1. Immediate Payoff and Rapid Success2. Task‑Specific Focus3. Compact Expression4. Error Visibility and Repair5. Low Cognitive Load (Semantic Focus)6. Simple, Legible Control Structures7. Progressive Disclosure8. No Requirement for Low‑Level Mechanisms9. Composability Without Mastery10. Continuous Update / No Deferred Execution
End-User Programming
Below are a list of 10 heuristics for evaluating End-User Programming systems based on Bonnie A. Nardi’s “A Small Matter of Programming” (Chapter 3, 1993). End-User Programming includes low-code platforms, spreadsheets, and other systems that use formula languages.
To conduct your own evaluation, tap on the Open Form button to send in your evaluation. You may do evaluations for any low-code platform or system that uses a formula language that you are familiar with. You can find the results on the page, but it is best to review the results after you have sent in your evaluation. Thank you for participating!
End-User Programming Heuristics
Feedback | Expression | Abstraction
End users should be able to build something meaningful very quickly, without extended setup or prerequisite knowledge.
Task‑specific functions allow users to develop quick facility with a program and to build a real application, however simple, in a short time. The motivational barrier is thus breached as users achieve rapid success. - p50
The language or system should be shaped around the user’s domain tasks, not around general‑purpose computation.
The formula language provides a limited set of carefully chosen high‑level task‑specific operations that are sufficient for building applications within a restricted domain and a set of simple but useful control structures. - p49
Users should be able to express ideas succinctly, without verbose or rule‑heavy syntax.
Textual languages are compact, efficient, and can be developed in less time than graphical languages. These are significant advantages that should be considered in the development of end‑user programming languages. - p49
Errors should be immediately visible, localised, and easy to repair; malformed expressions should be prevented where possible.
Users noted that in any case, most such errors are immediately caught by the spreadsheet itself, which will not permit poorly formed formulas. Proper syntax checking appears to be sufficient to enable users to cope with syntax errors. - p49
The system should manage low-level complexity—especially dependency maintenance—so that users can focus cognitive resources on high-level meaning and domain problems.
Where there is complexity, as in managing dependencies, the system should do as much as possible, leaving users only the task of understanding dependencies at a high semantic level. Spreadsheet control structures enable users to capture complex domain relationships expressed through conditions, iteration, and constraints, but at a low programming cost. - p48
As users continue to use a program, they are not constantly faced with the job of stringing together low‑level functions as they work but can concentrate on the actual problem solving itself. - p50
Control structures should be minimal, readable, and directly related to the task domain.
Spreadsheet control structures enable users to capture complex domain relationships expressed through conditions, iteration, and constraints, but at a low programming cost. - p49
Users should be able to perform useful work with a small initial investment of learning, and gradually incorporate more advanced concepts as they are ready.
Spreadsheets allow users to perform useful work with a small investment of time and then go on to more advanced levels of understanding as they are ready. p48
Users can begin by building simple cell relations and move on to more elaborate models as their knowledge expands. p48
Users should not need to manage memory, data structures, imports, or infrastructure to solve meaningful problems.
The operations and control constructs in spreadsheets are ready-to-hand; they do not require lower-level programming chores such as memory allocation, but are available at the highest level, so that users map them directly to their tasks. - p49-50
Users should be able to combine existing elements into new behaviours without full conceptual mastery of the system.
Users do not have to learn every feature of a programming system in such a short time…, but they must be able to get some real work done and attain a sense of accomplishment and success. - p45
The system should continuously update results and dependencies without requiring an explicit execution step, so that changes take immediate effect and users are never out of sync with the system.
In spreadsheets the mechanics of managing cell dependencies and their updates are completely taken care of by the spreadsheet itself—no programming effort at all is required on the part of the user. - p48
Want to print your doc?
This is not the way.
This is not the way.
Try clicking the ··· in the right corner or using a keyboard shortcut (
CtrlP
) instead.