Towards the Humanisation of Programming Tool Interactions

Program analysis tools, from simple static semantic analysis by a compiler, to complex dynamic analyses of data flow and security, have become commonplace in modern day programming. Many of the simpler analyses, such as the afore- mentioned compiler checking or linters designed to enforce code style, may even go unnoticed or unconsidered by most users, ubiquitous as they are. Despite this, and despite the obvious utility that such programming tools can provide, many warnings provided by them go unheeded by programmers most of the time.There are several reasons for this phenomenon: the propensity to produce false positives undermines confidence in the validity of warnings, the tools do not in- tegrate well into the normal workflow of the developer, sometimes the warning message is simply too esoteric for most users to understand, and so on. A com- mon theme can be drawn from these reasons for ignoring the often-times very useful information given by a programming tool: the tool itself is difficult to use.In this thesis, we consider ways in which we can bridge this gap between users and tools. To do this, we draw from observations about the way in which we interact with each other in the most basic human-to-human context. Applying these lessons to a human-tool interaction allow us to examine ways in which tools may be deficient, and investigate methods for making the interaction more natural and human-like.We explore this issue by framing the interaction as a "conversation" between a human and their development environment. We then present a new programming tool, Progger, built using design principles driven by the "conversational lens" which we use to look at these interactions. After this, we present a user study using a novel low-cost methodology, aimed at evaluating the efficacy of the Progger tool. From the results of this user study, we present a new, more streamlined version of Progger, and finally investigate the way in which it can be used to direct the users attention when conducting a code comprehension exercise

Examining the effects of enhanced compilers on student productivity

Programs written by novices programmers often contain errors. Previous work shows students struggle when compiler error messages are inaccurate, misleading, or both. Loss of productivity caused by poor error messages has not been thoroughly explored in the literature. This thesis examines how enhanced compilers improve the experiences of those learning to program. The thesis follows fifty non-CS majors with little programming experience through a one-semester CS1-like course at the University of Northern British Columbia, a small western Canadian university. Half of the participants used the enhanced compiler for Java named Decaf while the other half used the standard Java compiler. The evidence shows that Decaf is beneficial with regards to the number and types of errors generated, productivity, frustration, and confidence in programming ability, and compares results with the literature.enhanced compilersstudent productivityJav

Designing graphical interface programming languages for the end user

This thesis sets out to answer three simple questions: What tools are available for novice programmers to program GUIs? Are those tools fulfilling their role? Can anything be done to make better tools? Despite being simple questions, the answers are not so easily constructed. In answering the first question, it was necessary to examine the range of tools available and decide upon criteria which could be used to identify tools aimed specifically at the novice programmer (there being no currently agreed criteria for their identification). Having identified these tools, it was then necessary to construct a framework within which they could be sensibly compared. The answering of the second question required an investigation of what were the successful features of current tools and which features were less successful. Success or failure of given features was determined by research in both programming language design and studies of programmer satisfaction. Having discovered what should be retained and discarded from current systems, the answering of the third question required the construction of new systems through blending elements from visual languages, program editors and fourth generation languages. These final prototypes illustrate a new way of thinking about and constructing the next generation of GUI programming languages for the novice

Refining ChatGPT-Generated Code: Characterizing and Mitigating Code Quality Issues

In this paper, we systematically study the quality of 4,066 ChatGPT-generated code implemented in two popular programming languages, i.e., Java and Python, for 2,033 programming tasks. The goal of this work is three folds. First, we analyze the correctness of ChatGPT on code generation tasks and uncover the factors that influence its effectiveness, including task difficulty, programming language, time that tasks are introduced, and program size. Second, we identify and characterize potential issues with the quality of ChatGPT-generated code. Last, we provide insights into how these issues can be mitigated. Experiments highlight that out of 4,066 programs generated by ChatGPT, 2,757 programs are deemed correct, 1,081 programs provide wrong outputs, and 177 programs contain compilation or runtime errors. Additionally, we further analyze other characteristics of the generated code through static analysis tools, such as code style and maintainability, and find that 1,933 ChatGPT-generated code snippets suffer from maintainability issues. Subsequently, we investigate ChatGPT's self-debugging ability and its interaction with static analysis tools to fix the errors uncovered in the previous step. Experiments suggest that ChatGPT can partially address these challenges, improving code quality by more than 20%, but there are still limitations and opportunities for improvement. Overall, our study provides valuable insights into the current limitations of ChatGPT and offers a roadmap for future research and development efforts to enhance the code generation capabilities of AI models like ChatGPT

A model for systematically investigating relationships between variables that affect the performance of novice programmers

This research was motivated by an interest in novices learning to program and a desire to understand the factors that affect their learning. The traditional approach to performing such an investigation has been to select factors which may be important and then perform statistical tests on a few potential relationships. A new research model is proposed and tested to ensure that a thorough and systematic investigation of the data is performed. This thesis describes the data, defines the model and explains the application and validation of the model. The research process is managed by a control algorithm that is the heart of the model. This algorithm is seeded by a hypothesis that connects two variables of interest and dictates the testing of a series of hypotheses; as it does this, it also delves deeper into the data to identify additional relationships. In this research the model was applied to investigate the relationships between: learning style and achievement; programming behaviour and achievement; and learning style and programming behaviour. Learning style was assessed using Kolb’s Learning Style Inventory, achievement was based on exam score and programming behaviour was extracted from a log of student activities using a programming tool. The largest number of significant relationships was found between aspects of behaviour and achievement. The model was validated by classifying the significant hypotheses based on the research model’s tree structure, the section of the programming tool in use and the literature. These three classification schemes provided a structure to explore their similarities and differences. The model was thus demonstrated to be robust and repeatable by comparing the results with those from both using a programming tool, and expert opinion. This research has revealed several attributes of the learning behaviour that affected the students’ results within this group, including aspects of timeliness and overall volume of activity. These are suitable targets for future investigations. The research model could be applied to other data sets where an in-depth investigation into pairwise data is required.

Issues, opportunities and concepts in the teaching of programming to novice programmers at the University of Lincoln : three approaches.

This thesis describes three small-scale, computer-based approaches developed and used by the author in her teaching of programming concepts to novice programmers, using Pascal as a first language, within a higher education context. The first approach was the development of a piece of tutorial CAL, the second was the development of an on-line help system and the third the development of a pattern language. For the first two, the author created the product. For the pattern language, she designed the template. These three approaches are described and the results obtained outlined. The work also looks at the kind of research methodologies and tools available to the author and present a rationale for her choices of method and tools. This work also briefly reviews some learning theories that could be used to underpin the design, use and evaluation of CAL. The thesis looks at a range of topics associated with the teaching of programming and the use of CAL. It looks at issues around the psychology and human aspects of learning to program, such as confirmatory bias and vision. It looks at other research efforts aimed at developing software to support inexperienced programmers, including new programming languages specifically designed to teach programming concepts and sophisticated programming support environments. The work briefly reviews various types of CAL and their uses. It also examines some key projects in CAL development from the 1960s onwards, with particular emphasis on UK projects from the early 1970s to the late 1990s. It looks at what conclusions can be drawn from examining some of the many CAL projects in the past. Finally, the work reviews the various strands of the author's research efforts and presents a brief overview and some initial suggestions for the teaching of programming to novice programmers

Development, implementation and evaluation of an interactive multimedia instructional model : A teaching and learning programming approach

This study sought to explore the outcomes from the use of a dynamic interactive visualisation tool among novice programmers in an introductory computer programming course. The proposed model, Dynamic Interactive Visualisation Tool in Teaching C (DIVTIC), was designed to use multimedia and visual imagery to provide learners with a step-by-step representation of program execution in the C language as a means of enhancing their understanding of programming structures and concepts. DIVTIC was designed to support constructivist learning principles and combined collaborative and visualisation learning strategies with use of the Internet and the World Wide Web to support the learning of programming. The feasibility and effectiveness of DIVTIC was explored among a cohort of 100 undergraduate engineering students, 50 in a control group and another 50 in an experimental group, studying an introductory programming course at Suranaree University of Technology (SUT) in Thailand, The study found that the use of DIVTIC was a successful complement to conventional teaching. The results clearly demonstrated the advantage of using DIVTIC among low achieving students. The students from this level in the experimental group significantly outscored their counterparts in the control group in the final test suggesting that DIVTIC was an important element in their learning process. Interestingly, these low achieving students used DIVTIC most and achieved highest grades. However, lower achieving students appeared to learn from simply viewing the animations rather than being highly interactive and stopping and starting them consistently. The study found that the visualisation process implemented in DIVTIC could be of considerable assistance to a particular group of students, those with a low GPA, in developing their understanding of difficult programming concepts

An integrated environment for problem solving and program development

A framework for an integrated problem solving and program development environment that addresses the needs of students learning programming is proposed. Several objectives have been accomplished: defining the tasks required for program development and a literature review to determine the actual difficulties involved in learning those tasks. A comprehensive Study of environments and tools developed to support the learning of problem solving and programming was then performed, covering programming environments, debugging aids, intelligent tutoring systems, and intelligent programming environments. This was followed by a careful analysis and critique of these systems, which uncovered the limitations that have prevented them from accomplishing their goals. Next, an extensive study of problem solving methodologies developed in this century was carried out and a common model for problem solving was produced. The tasks of program development were then integrated with the common model for problem solving. Then, the cognitive activities required for problem solving and program development were identified and also integrated with the common model to form a Dual Common Model for problem Solving and Program Development. This dual common model was then used to define the functional specifications for a problem solving and program development environment which was designed, implemented, tested, and integrated into the curriculum. The development of the new environment for learning problem solving and programming was followed by the planning of a cognitively oriented assessment method and the development of related instruments to evaluate the process and the product of problem solving. A detailed statistical experiment to study the effect of this environment on students\u27 problem solving and program development skills, including system testing by protocol analysis, and performance evaluation of students based on research hypotheses and questions, was also designed, implemented and the result reported

An investigation into student reactions towards rad versus traditional programming environments for novice developers

The traditional approach to programming using text editors is widely used in many institutions to teach introductory programming. These types of traditional programming environments provide fundamental programming concepts for learning, especially in the context of novice developers. In recent years, teaching institutions have seen a trend towards the introduction of visual drag-and-drop rapid application development (RAD) environments for teaching novice programmers. These \u27environments capture student interest in programming by allowing the construction of workable programs within a short time frame based on minimal pre-existing coding knowledge. However, some have argued that these visual RAD environments might not be suitable for providing fundamental programming concepts and syntax to novice developers. This research examines student perceptions towards visual RAD environments in comparison to traditional environments for learning programming for novice developers, mainly focusing on the novice developer\u27s first programming environment. To gather student reactions towards these programming environments, surveys, interviews and workshops were conducted with novice, intermediate and expert level student programmers. The results indicate that while visual RAD environments managed to capture the majority of the participants\u27 interest, the traditional approach was largely accepted as the most appropriate first environment for novice developers. Another finding from this research is the participants\u27 perceptions of the key aspects of learning programming, which also formed part of the deciding factors for the first environment. Understanding the underlying concepts, syntax and logic of the program seem to be the most important aspects followed by interest level and the ability to build workable programs quickly. The majority of participants perceived that traditional programming environments could help novice developers with understanding underlying concepts and syntax better than visual RAD environments. Although visual RAD environments do not require a traditional programming environment at the early stage of programming, the latter would become necessary as the program grows and more complex functions are required. Overall, the visual RAD environment was still the preferred environment for development despite the lack of pedagogical benefits compared with traditional environments