On some end-user programming constructs and their understandability
Introduction
For many years there has been a shortage of computer experts, including programmers. According to some sources, in the US the annual growth in available jobs is almost three times higher than the rate of students graduating with bachelor’s degrees in Computer Science (Partovi, 2014). In the Netherlands a shortage of programmers is expected to be the main factor driving up wages (Bouman, 2016). Globally, IT vacancies (i.e. programmers, database experts, etc.) are the second hardest to fill (ManpowerGroup, 2016).
When there is a shortage of a resource, the question arises whether the resource is used rationally and whether there exists any substitute. As regards programmers, one can consider hobbyists and end users as potential substitutes for professional software developers. A worldwide study performed by IDC (2014) shows that in addition to 11 million professional software developers there are about 7.5 million hobbyists. According to other data (Scaffidi et al., 2005), in the US the ratio of professional programmers to end-user programmers is 3 to 55.
There are many problems that do not require deep programming skills but do require deep domain knowledge. In such a context an end-user programmer (a person who creates programs for herself (Ko et al., 2011)) could be the right choice. This is especially true in the area of management information, where it is common to make use of MS Excel, which combines the power of a data grid interface with the possibility of programming macros in Visual Basic for Applications (VBA). These features make spreadsheet applications extremely popular. For instance, as reported by Panko and Port (2012), a single bank can have about 9 million MS Excel files in use (!). Unfortunately, spreadsheets have their weaknesses too. According to Business Insider (2013), JP Morgan has lost US$6 billion due to bugs in their Value-at-Risk model implemented with spreadsheets. One could blame end users and their carelessness, but the real culprit may be the gap between the very easy-to-use data grid interface and the hard-to-program macros in Visual Basic. In many cases, they would prefer to use complex formulae and copy-pasting instead of writing a macro which might fail when some modifications to the calculations are introduced.
Shortage of professional programmers and problems of financial experts with spreadsheets are not the only motivations for working on improving languages and environments for end-user programming. This approach gives users empowerment and can lead to better use of their domain knowledge. More usage contexts for end-user programming can be found, for instance, in Ko et al. (2011).
To be more effective, domain experts would need programming constructs that are both easy to use and supportive in writing business utilities, i.e. small programs that are useful in the business environment of a given domain expert (e.g. value-at-risk models). MS Excel is a solution, but far from an ideal one. Some attempts to improve the situation have already been made (e.g. Jones et al. (2003), Sestoft and Sørensen (2013)), but it seems that there is still plenty of space for improvement, and it is worthwhile to consider new ideas.
In this paper, four end-user programming constructs are proposed and examined. They form an end-user programming paradigm which we call Board Programming. It is based on the metaphor of spreadsheets. As a consequence, Board Programming offers to the programmer exemplary computations and—to facilitate understanding—it does not allow to overwrite data (that approach is known as single assignment). Moreover, it uses so-called index arrays instead of loops (that is typical for spreadsheet-like computations) and allows to use colours to select data (it is a kind of complement to conditional formatting which is available in Excel). Board Programming is designed to be useful for end-user programmers (more precisely, junior managers) working in the area of management information.
The main topic of the paper is to validate the understandability of the proposed constructs experimentally. Following the rapid prototyping approach (Myers et al., 2016), we want to gather early feedback and made a decision based on evidence (Stefik and Hanenberg, 2017) which of them should be included in the designed language.
The paper is organised in the following way. Firstly, in Section 2, the notion of understandability is defined, and a set of performance indicators is proposed. As the evaluation of the proposed programming constructs was performed by a series of very similar experiments, in Section 3 the experimental framework (the common part of all of the experiments) is described. Because of this, the experimental parts of the subsequent sections are quite short and mainly present the results. The proposed programming constructs are discussed in Sections 4–7. Each of the sections contains a description of the programming construct, an example, a short overview of related work, and the results of the experimental evaluation (i.e. performance indicators). Finally, Section 8 presents several acceptance indicators of the proposed paradigm, obtained from the participants in the experiments (these data show how far the they are willing to use a programming language based on the proposed constructs), as well as conclusions and future work.
Section snippets
Understandability and its indicators
In the context of programming constructs, understandability can be defined as follows. Definition 1 The understandability of a set of programming constructs is the degree of ease of predicting the results of computations defined by means of those constructs. JUSTIFICATION The proposed definition appears similar to the definitions of understandability given by Grubb and Takang (2003): Program understandability is the ease with which the program can be understood—that is, the ability to determine what a program does and how
Evaluation framework
The programming constructs discussed in the subsequent sections were evaluated experimentally with the following goal in mind (here we used the goal description template proposed in the Goal Question Metric approach, van Solingen et al. (2002)): Goal 1 The purpose of the programming experiments was to evaluate the understandability of the proposed end-user programming constructs (i.e. single assignment with exemplary computations, data-driven indices, selection by colours, and read-write heads) in
Observation
It is widely accepted that examples help to understand various kinds of formulae, including program code. For instance, exemplary computations lie at the heart of the concept of live programming (Hancock, 2003, Hermans, van der Storm, 2016, Schuster, Flanagan, 2015): a combination of input data and a live programming environment provides programmers with immediate and continuous feedback about how their modifications to the code affect program execution (McDirmid, 2007).
However, pure examples
Observation
A single-assignment program (see e.g. Fig. 3a), although easier to understand (as suggested by Conjecture 1), still seems far-removed from what would be expected by end-user programmers. Above all, it lacks visualisation. Even though exemplary computations present intermediate results, there is no explicit connection between the output data and the code used to calculate it, i.e. which cell was written by which statement. End-user programmers have to make an effort to analyse the code and
Observation
In the examples presented so far, only single variables and sequences (represented as columns) have been used. Obviously, one can also represent a sequence as a row (i.e. horizontally) if that might increase understandability.
One more data structure which is useful and fits well with the spreadsheet metaphor (Abraham et al., 2007) is the matrix. Each matrix is treated as a sequence of rows and a sequence of columns. When there is a separate column associated with a matrix, then each item of
Observation
In the programs presented so far, we have used the dollar symbol ($) to represent the value of the previous item in an array (see Fig. 8, for example). Unfortunately, in some cases, it is not that simple—to compute the value of the current item of an array or matrix one needs to refer to items other than the immediate predecessor. Here is a simple example of function which cannot be programmed just by using the ’$’ symbol: Function 5 Fibonacci For given n calculate the n-th element of the Fibonacci sequence (see
Conclusions
The area of end-user programming is of growing importance. However, existing general-purpose programming languages seem unsuitable for this type of programmers, and there is a need to look for new programming paradigms. In this paper, we have examined a set of programming constructs, called Board Programming, that could form a basis for an end-user programming language. The set comprises the following mechanisms:
- •
Single assignment with exemplary computations: To date, exemplary computations have
Acknowledgements
We would like to thank Prof. Magdalena Wyrwicka (Dean of the Faculty of Management Engineering, PUT) and Prof. Stefan Trzcieliński (Head of the Chair of Management and Computing Systems, PUT) for allowing us to perform our experiments at the Faculty of Management Engineering. Special thanks are due to Alina Gościniak (Adam Mickiewicz High School in Poznań) and Dr. Aleksander Jurga for their great help with the organisation of the experiments. Moreover, we thank the IFIP WG 2.4 and IFIP TC-2
Michał Ma ćkowiak is a PhD student at Poznan University of Technology. His main research interests lie in the fields of programming languages, end-user programming and software architecture.
References (48)
- et al.
Spreadsheet Programming
(2007) - et al.
Visual specifications of correct spreadsheets
2005 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC’05)
(2005) SSA is functional programming
ACM SIGPLAN Notices
(1998)- et al.
Learning computer programming: Implementing a fractal in a Turing machine
Comput. Educ.
(2010) - et al.
A spreadsheet-based user interface for managing plural relationships in structured data
Proceedings of the 2011 annual conference on Human factors in computing systems - CHI 11
(2011) - Bouman, M., 2016. Shortage of programmers and engineers will push up...
Turingal — the language for teaching the principles of programming
The 3rd European Logo Conference, Parma, Italy
(1991)- et al.
Forms/3: a first-order visual language to explore the boundaries of the spreadsheet paradigm
J. Funct. Program.
(2001) - Business Insider, 2013. How the London whale debacle is partly the result of an error using...
- et al.
Using and exploring hierarchical data in spreadsheets
Proceedings of the 2016 CHI Conference on Human Factors in Computing Systems - CHI’16
(2016)
Ordinal Methods for Behavioral Data Analysis
ClassSheets: Automatic generation of spreadsheet applications from object-oriented specifications
Proceedings of the 20th IEEE/ACM international Conference on Automated software engineering - ASE ’05
G*Power 3: a flexible statistical power analysis program for the social, behavioral, and biomedical sciences
Behav. Res. Methods
On the interpretation of χ 2 from contingency tables, and the calculation of p
J. R. Stat. Soc.
Pict: An interactive graphical programming environment
Comput. (Long Beach Calif)
Software Maintenance: Concepts and Practice
Elements of Software Science (Operating and Programming Systems Series)
Real-time Programming and the Big Ideas of Computational Literacy
TrueGrid: Code the table, tabulate the data
Software Technologies: Applications and Foundations
Design science in information systems research
MIS Q.
A user-centred approach to functions in Excel
Proceedings of the Eighth ACM SIGPLAN International Conference on Functional Programming - ICFP ’03
On effect size.
Psychol. Methods
Cited by (0)
Michał Ma ćkowiak is a PhD student at Poznan University of Technology. His main research interests lie in the fields of programming languages, end-user programming and software architecture.
Jerzy Nawrocki he works as a professor and vice director in the Institute of Computing Science at the Poznan University of Technology. He is a member of IFIP board. His research interests concern Software Engineering and Project Management.
Mirosław Ochodek holds Ph.D. degree and works as an assistant professor in the Institute of Computing Science at the Poznan University of Technology. His main research interests lie in the fields of requirements engineering, software metrics, functional size measurement, and software effort estimation.