1,391 research outputs found
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
Natural Language Tutoring and the Novice Programmer
For beginning programmers, inadequate problem solving and planning skills are among the most salient of their weaknesses. Novices, by definition, lack much of the tacit knowledge that underlies effective programming. This dissertation examines the efficacy of natural language tutoring (NLT) to foster acquisition of this tacit knowledge. Coached Program Planning (CPP) is proposed as a solution to the problem of teaching the tacit knowledge of programming. The general aim is to cultivate the development of such knowledge by eliciting and scaffolding the problem solving and planning activities that novices are known to underestimate or bypass altogether. ProPL (pro-PELL), a dialogue-based intelligent tutoring system based on CPP, is also described. In an evaluation, the primary findings were that students who received tutoring from ProPL seemed to exhibit an improved ability compose plans and displayed behaviors suggestive of thinking at greater levels of abstraction than students in a read-only control group. The major finding is that NLT appears to be effective in teaching program composition skills
An Intelligent Debugging Tutor For Novice Computer Science Students
Debugging is a necessary aspect of computer science that can be difficult for novices and experienced programmers alike. This skill is mainly self-taught and is generally gained through trial and error, perhaps with some assistance from a professor or other expert figure. Novices encountering their first software defects may have few avenues open to them depending on the environment in which they are learning to program. The evident problem here is that the potential for a student to become stuck, frustrated, and/or losing confidence in their ability to pursue computer science is great. For a student to be successful when working professionally or progressing through academia they need to be able to function independently; trusting their own knowledge on par or above that of others so that their productivity does not rely on the knowledge of someone else. In order to solve this problem an Intelligent Tutoring System for teaching debugging skills to the novice utilizing Case Based Reasoning, Static Program Slicing, and the student\u27s preferred learning style was proposed. Case acquisition and automatic Exercise Generation were also explored. The system built for this research program was evaluated using novice students at the College and High School levels. Results of this evaluation produced statistically significant results at the p\u3c.05 and p\u3c.01 levels, with generated exercises exhibiting significance at the p\u3c.01 level. These results prove that the methodology chosen is a valid approach for the problem described, that the system does in fact teach students how to debug programs, and that the system is capable of successfully generating exercises on the fly
Contemporary developments in teaching and learning introductory programming: Towards a research proposal
The teaching and learning of introductory programming in tertiary institutions is problematic. Failure rates are high and the inability of students to complete small programming tasks at the completion of introductory units is not unusual. The literature on teaching programming contains many examples of changes in teaching strategies and curricula that have been implemented in an effort to reduce failure rates. This paper analyses contemporary research into the area, and summarises developments in the teaching of introductory programming. It also focuses on areas for future research which will potentially lead to improvements in both the teaching and learning of introductory programming. A graphical representation of the issues from the literature that are covered in the document is provided in the introduction
Recognising the design decisions in Prolog programs as a prelude to critiquing
This thesis presents an approach by which an automated teaching system can
analyse the design of novices' Prolog programs for tutorial critiquing. Existing
methodologies for tutorial analysis of programs focus on the kind of small proÂŹ
gramming examples that are used only in the early stages of teaching. If an
automated teaching system is to be widely useful, it must cover a substantial
amount of the teaching syllabus, and a critiquing system must be able to analyse
and critique programs written during the later stages of the syllabus.The work is motivated by a study of students' Prolog programs which were
written as assessed exercises towards the end of their course. These programs
all work (in some sense), yet they reveal a wide range of design (laws (bodges)
for which some form of tutoring would be useful. They present problems for any
automated analysis in terms of the size of the programs, the number of individual
decisions that must be made to create each program and the range of correct
and incorrect decisions that may be made in each case.This study identifies two areas in the analysis of students' program in which
further work is needed. Existing work has focussed only on the design and
implementation decisions that relate closely to the programming language. That
is not sufficient for these slightly more advanced programs, for which decisions in
the problem domain must also be recognised. Existing work has focussed on the
different ways to implement code, but in these programs the students also make
decisions about which data structures are to be used. These decisions must also
be part of an analysis.The thesis provides an approach which represents both decisions in the domain
of the problem being solved and decisions about how to implement them in
Prolog. Decisions in the problem domain are represented by tasks (for code)
and by domain objects (for data structures). Decisions that are specific to the
Prolog implementation are represented by prototypes which encapsulate standard
programming techniques (for code) and by a polymorphic data type language (for
data structures). Issues in devising these representations are discussed.An analysis-by synthesis approach is used for code recognition. This is augÂŹ
mented by a procedure called "clausal split" which isolates novel or poorly deÂŹ
signed parts of an implementation. Following an incomplete analysis of the
program by synthesis, the results of this analysis provide the basis for making
inferences about the parts of the program that have not been understood. For
analysing data structures, a type inference mechanism is combined with inference
about the parts of domain objects. Inferred data type information is also used
to limit search, both for synthesis and analysis.An architecture using this approach has been implemented. The success of the
architecture is assessed on student's programs. From this assessment it is clear
that much further work remains to be done, but the results are hopeful
System upgrade: realising the vision for UK education
A report summarising the findings of the TEL programme in the wider context of technology-enhanced learning and offering recommendations for future strategy in the area was launched on 13th June at the House of Lords to a group of policymakers, technologists and practitioners chaired by Lord Knight.
The report â a major outcome of the programme â is written by TEL director Professor Richard Noss and a team of experts in various fields of technology-enhanced learning. The report features the programmeâs 12 recommendations for using technology-enhanced learning to upgrade UK education
Online tools to support novice programming: A systematic review
Novice programming is a challenging subject to
both the students and the educators. A novice programmer
is required to acquire new knowledge to solve a problem
and propose a solution systematically. This is followed by
constructing the solution in a development environment that
they are unfamiliar with. This research looks at the challenges faced by a novice programmer and the online methods that are popular to assist the students. Online block programming is a popular option. One of the software that had been implemented in the various research project is Scratch. From the reviewed research, it shows that the trend is moving towards an intelligent tutoring system, where students can have personalized engagement for their learning experience. This paper presents a systematic review conducted using the keywords ânovice programmingâ, âintroductoryâ, âCS1â, âdifficultiesâ, âchallengesâ, and âthreshold conceptsâ. From the review conducted, it is observed that most of the work is carried out to ease the implementation of the solution through an integrated development environment, and block programming. On the support for instructors, the discussion on curriculum and challenges in CS1 tops the chart. This is followed by active learning through online tools
Is AI the better programming partner? Human-Human Pair Programming vs. Human-AI pAIr Programming
The emergence of large-language models (LLMs) that excel at code generation
and commercial products such as GitHub's Copilot has sparked interest in
human-AI pair programming (referred to as "pAIr programming") where an AI
system collaborates with a human programmer. While traditional pair programming
between humans has been extensively studied, it remains uncertain whether its
findings can be applied to human-AI pair programming. We compare human-human
and human-AI pair programming, exploring their similarities and differences in
interaction, measures, benefits, and challenges. We find that the effectiveness
of both approaches is mixed in the literature (though the measures used for
pAIr programming are not as comprehensive). We summarize moderating factors on
the success of human-human pair programming, which provides opportunities for
pAIr programming research. For example, mismatched expertise makes pair
programming less productive, therefore well-designed AI programming assistants
may adapt to differences in expertise levels.Comment: 8 pages (without references), 2 table
Recommended from our members
Facilitating teacher participation in intelligent computer tutor design : tools and design methods.
This work addresses the widening gap between research in intelligent tutoring systems (ITSs) and practical use of this technology by the educational community. In order to ensure that ITSs are effective, teachers must be involved in their design and evaluation. We have followed a user participatory design process to build a set of ITS knowledge acquisition tools that facilitate rapid prototyping and testing of curriculum, and are tailored for usability by teachers. The system (called KAFITS) also serves as a test-bed for experimentation with multiple tutoring strategies. The design includes novel methodologies for tutoring strategy representation (Parameterized Action Networks) and overlay student modeling (a layered student model), and incorporates considerations from instructional design theory. It also allows for considerable student control over the content and style of the information presented. Highly interactive graphics-based tools were built to facilitate design, inspection, and modification of curriculum and tutoring strategies, and to monitor the progress of the tutoring session. Evaluation of the system includes a sixteen-month case study of three educators (one being the domain expert) using the system to build a tutor for statics (forty topics representing about four hours of on-line instruction), testing the tutor on a dozen students, and using test results to iteratively improve the tutor. Detailed throughput analysis indicates that the amount of effort to build the statics tutor was, surprisingly, comparable to similar figures for building (non-intelligent) conventional computer aided instructional systems. Few ITS projects focus on educator participation and this work is the first to empirically study knowledge acquisition for ITSs. Results of the study also include: a recommended design process for building ITSs with educator participation; guidelines for training educators; recommendations for conducting knowledge acquisition sessions; and design tradeoffs for knowledge representation architectures and knowledge acquisition interfaces
Challenges to Transferring Western Field Research Materials and Methods to a Developing World Context
Much of the research currently undertaken in the area of intelligent tutoring systems hails from Western countries. To counteract any bias that this situation produces, to gain greater representation from the rest of the world, and to produce systems and publications that take cultural factors into account, experts recognize the need for more intercultural evaluations and collaborations. For these collaborations to be successful, though, methods and materials require modification. Field work methodologies used in developed countries have to be nuanced when transferred to developing world contexts. In specific, the paper describes five challenges that researchers must address in the transfer process: technology adoption, school support, infrastructure, student culture, and force majeure
- âŠ