Introductory programming: a systematic literature review

As computing becomes a mainstream discipline embedded in the school curriculum and acts as an enabler for an increasing range of academic disciplines in higher education, the literature on introductory programming is growing. Although there have been several reviews that focus on specific aspects of introductory programming, there has been no broad overview of the literature exploring recent trends across the breadth of introductory programming. This paper is the report of an ITiCSE working group that conducted a systematic review in order to gain an overview of the introductory programming literature. Partitioning the literature into papers addressing the student, teaching, the curriculum, and assessment, we explore trends, highlight advances in knowledge over the past 15 years, and indicate possible directions for future research

The development of design guidelines for educational programming environments

Introductory programming courses at university are currently experiencing a significant dropout and failure rate. Whilst several reasons have been attributed to these numbers by researchers, such as cognitive factors and aptitude, it is still unclear why programming is a natural skill for some students and a cause of struggle for others. Most of the research in the computer science literature suggests that methods of teaching programming and students’ learning styles as reasons behind this trend. In addition to the choice of the first programming language taught. With the popularity of virtual learning environments and online courses, several instructors are incorporating these e-learning tools in their lectures in an attempt to increase engagement and achievement. However, many of these strategies fail as they do not use effective teaching practices or recognise the learning preferences exhibited by a diverse student population. Therefore this research proposes that combining multiple teaching methods to accommodate different learners' preferences will significantly improve performance in programming. To test the hypothesis, an interactive web based learning tool to teach Python programming language (PILeT) was developed. The tool’s novel contribution is that it offers a combination of pedagogical methods to support student’s learning style based on the Felder-Silverman model. First, PILeT was evaluated by both expert and representative users to detect any usability or interface design issues that might interfere with students’ learning. Once the problems were detected and fixed, PILeT was evaluated again to measure the learning outcomes that resulted from its use. The experimental results show that PILeT has a positive impact on students learning programming

Designing and Evaluating Accessible E-Learning for Students with Visual Impairments in K-12 Computing Education

This dissertation explores the pathways for making K-12 computing education more accessible for blind or visually impaired (BVI) learners. As computer science (CS) expands into K-12 education, more concerted efforts are required to ensure all students have equitable access to opportunities to pursue a career in computing. To determine their viability with BVI learners, I conducted three studies to assess current accessibility in CS curricula, materials, and learning environments. Study one was interviews with visually impaired developers; study two was interviews with K-12 teachers of visually impaired students; study three was a remote observation within a computer science course. My exploration revealed that most of CS education lacks the necessary accommodations for BVI students to learn at an equitable pace with sighted students. However, electronic learning (e-learning) was a theme that showed to provide the most accessible learning experience for BVI students, although even there, usability and accessibility challenges were present in online learning platforms. My dissertation engaged in a human-centered approach across three studies towards designing, developing, and evaluating an online learning management system (LMS) with the critical design elements to improve navigation and interaction with BVI users. Study one was a survey exploring the perception of readiness for taking online courses between sighted and visually impaired students. The findings from the survey fueled study two, which employed participatory design with storytelling with K-12 teachers and BVI students to learn more about their experiences using LMSs and how they imagine such systems to be more accessible. The findings led to developing the accessible learning content management system (ALCMS), a web-based platform for managing courses, course content, and course roster, evaluated in study three with high school students, both sighted and visually impaired, to determine its usability and accessibility. This research contributes with recommendations for including features and design elements to improve accessibility in existing LMSs and building new ones

Live Docker Containers

The use of containerization technologies for software development, such as Docker, is now widespread, with over 70000 Dockerfiles being found in projects from the GitHub platform as of October 2016. The use of these technologies has a few advantages, providing a secure, portable and efficient environment where applications can be executed. Currently, the usual workflow of a developer configuring a Docker environment consists of writing a Dockerfile, building the Dockerfile into a Docker image, instantiating that Docker image in a Docker container and verifying if the container is working as expected (using a tool or the command-line). If the container is not behaving as expected, then the developer has to make changes to the Dockerfile and repeat the process, until the desired behaviour is achieved. This process is often slow, based on trial-and-error, and therefore time consuming and frustrating for developers, as observed in a survey performed with students with some Docker experience. As such, reducing the temporal distance between editing a Dockerfile and observing the consequences of those changes on the containers that can be built from that Dockerfile (i.e. tightening the feedback loop) can reduce the debugging efforts required by the programmer. Live programming refers to the ability to obtain continuous feedback on a program while that program is being developed. Since software is usually developed on text editors/IDEs, live feedback is usually provided within these tools. The level of liveness in IDEs is related to the type and update frequency of the feedback provided. The existing tools that can help a developer working with Dockerfiles can be split into several categories: container status, performance monitoring, container management, infrastructure testing, static analysis and image build optimization. However, currently the only tools which provide live feedback are some static analysis tools. Therefore, the developer is restricted to the development workflow mentioned above, with little liveness in his environment. Providing more live dynamic feedback in the developer's environment is expected to lead to an increased efficiency of developers working on Dockerfiles. This can be achieved through the implementation of an IDE plugin which automatically builds, instantiates and extracts information from a Docker container while the developer writes the respective Dockerfile, providing continuous feedback on changes that the developer makes. In order to quantify the influence of providing more live dynamic feedback on the efficiency of developers, a user study was conducted

Intelligent Tutoring System Authoring Tools for Non-Programmers

An intelligent tutoring system (ITS) is a software application that tries to replicate the performance of a human tutor by supporting the theory of learning by doing . ITSs have been shown to improve the performance of a student in wide range of domains. Despite their benefits, ITSs have not seen widespread use due to the complexity involved in their development. Developing an ITS from scratch requires expertise in several fields including computer science, cognitive psychology and artificial intelligence. In order to decrease the skill threshold required to build ITSs, several authoring tools have been developed. In this thesis, I document several contributions to the field of intelligent tutoring in the form of extensions to an existing ITS authoring tool, research studies on authoring tool paradigms and the design of authoring tools for non-programmers in two complex domains - natural language processing and 3D game environments. The Extensible Problem Specific Tutor (xPST) is an authoring tool that helps rapidly develop model-tracing like tutors on existing interfaces such as webpages. xPST\u27s language was made more expressive with the introduction of new checktypes required for answer checking in problems belonging to domains such as geometry and statistics. A web-based authoring (WAT) tool was developed for the purpose of tutor management and deployment and to promote non-programmer authoring of ITSs. The WAT was used in a comparison study between two authoring tool paradigms - GUI based and text based, in two different problem domains - statistics and geometry. User-programming of natural language processing (NLP) in ITSs is not common with authoring toolkits. Existing NLP techniques do not offer sufficient power to non-programmers and the NLP is left to expert developers or machine learning algorithms. We attempted to address this challenge by developing a domain-independent authoring tool, ConceptGrid that is intended to help non-programmers develop ITSs that perform natural language processing. ConceptGrid has been integrated into xPST. When templates created using ConceptGrid were tested, they approached the accuracy of human instructors in scoring student responses. 3D game environments belong to another domain for which authoring tools are uncommon. Authoring game-based tutors is challenging due to the inherent domain complexity and dynamic nature of the environment. We attempt to address this challenge through the design of authoring tool that is intended to help non-programmers develop game-based ITSs

Interaction-aware development environments: recording, mining, and leveraging IDE interactions to analyze and support the development flow

Nowadays, software development is largely carried out using Integrated Development Environments, or IDEs. An IDE is a collection of tools and facilities to support the most diverse software engineering activities, such as writing code, debugging, and program understanding. The fact that they are integrated enables developers to find all the tools needed for the development in the same place. Each activity is composed of many basic events, such as clicking on a menu item in the IDE, opening a new user interface to browse the source code of a method, or adding a new statement in the body of a method. While working, developers generate thousands of these interactions, that we call fine-grained IDE interaction data. We believe this data is a valuable source of information that can be leveraged to enable better analyses and to offer novel support to developers. However, this data is largely neglected by modern IDEs. In this dissertation we propose the concept of "Interaction-Aware Development Environments": IDEs that collect, mine, and leverage the interactions of developers to support and simplify their workflow. We formulate our thesis as follows: Interaction-Aware Development Environments enable novel and in- depth analyses of the behavior of software developers and set the ground to provide developers with effective and actionable support for their activities inside the IDE. For example, by monitoring how developers navigate source code, the IDE could suggest the program entities that are potentially relevant for a particular task. Our research focuses on three main directions: 1. Modeling and Persisting Interaction Data. The first step to make IDEs aware of interaction data is to overcome its ephemeral nature. To do so we have to model this new source of data and to persist it, making it available for further use. 2. Interpreting Interaction Data. One of the biggest challenges of our research is making sense of the millions of interactions generated by developers. We propose several models to interpret this data, for example, by reconstructing high-level development activities from interaction histories or measure the navigation efficiency of developers. 3. Supporting Developers with Interaction Data. Novel IDEs can use the potential of interaction data to support software development. For example, they can identify the UI components that are potentially unnecessary for the future and suggest developers to close them, reducing the visual cluttering of the IDE

Source Code Interaction on Touchscreens

Direct interaction with touchscreens has become a primary way of using a device. This work seeks to devise interaction methods for editing textual source code on touch-enabled devices. With the advent of the “Post-PC Era”, touch-centric interaction has received considerable attention in both research and development. However, various limitations have impeded widespread adoption of programming environments on modern platforms. Previous attempts have mainly been successful by simplifying or constraining conventional programming but have only insufficiently supported source code written in mainstream programming languages. This work includes the design, development, and evaluation of techniques for editing, selecting, and creating source code on touchscreens. The results contribute to text editing and entry methods by taking the syntax and structure of programming languages into account while exploiting the advantages of gesture-driven control. Furthermore, this work presents the design and software architecture of a mobile development environment incorporating touch-enabled modules for typical software development tasks

A hint generation system for introductory programming exercises in Java

Teaching and learning programming is a real challenge for teachers and students. Students starting to code for the first time, feeling stuck when trying to solve a programming exercise is normal, and teachers should support them in this case. The student who works autonomously can create a proactive attitude towards his education. With the current evolution of technology and world events, the remote environment for education is a reality, so tools that can help students, guiding them when they need it, can be important to give them the necessary autonomy.This dissertation proposes a recommendation system that can be integrated into any exercise platform to recognize a partially written code and generate reliable and useful tips (combined with positive feedback) whenever the student needs support, based on a solution previously set by the teacher. This dissertation describes the implementation of such a recommendation system, based on abstract syntax trees and tree editing distance. A system prototype composed of a REST API and a Web frontend was developed as a materialization of the proposed approach.Ensinar e aprender programação é um verdadeiro desafio para professores e alunos. É normal os alunos que começam a codificar pela primeira vez sentirem-se bloqueados ao tentar resolver um exercício de programação, ficando dependentes de ajuda de professores ou alguém mais experiente para progredir. Porém, o aluno que trabalha de forma autónoma pode desenvolver uma atitude proativa em relação à sua educação. Com a atual evolução da tecnologia e os acontecimentos mundiais, o ambiente remoto para educação é uma realidade, e logo, ferramentas que possam auxiliar os alunos, orientando-os quando precisam, podem ser importantes para dar-lhes a autonomia necessária. Esta dissertação propõe um sistema de recomendação que pode ser integrado em qualquer plataforma de exercícios para reconhecer um código parcialmente escrito e gerar dicas confiáveis e úteis (combinadas com feedback positivo) para ajudar no progresso sempre que o aluno precisar de apoio. As dicas são geradas com base numa solução previamente definida pelo professor. Esta dissertação descreve a implementação de tal sistema de recomendação, baseado em árvores de sintaxe abstrata e distância de edição das mesmas. Foi desenvolvido um protótipo de sistema composto por uma API REST e um frontend Web como materialização da abordagem proposta