Programming novices often struggle when solving exercises, slowing down progress and causing a dependency on external aid such as a teacher, a more experienced person, or online resources. We present Jinter, a tool to generate hints to solve small exercises involving Java methods. The hints are produced taking into account the current state of an exercise and a backing model solution. The aid may refer to spotting errors or missing parts to achieve the desired outcome while taking into account behavioral equivalences of programming constructs (e.g., loop structures, forms of assignment, boolean expressions, etc). We evaluated the approach by surveying 8 programming instructors, finding that about two-thirds of the automated hints either match or are related to those given by instructors.

Conventionally, merging code files is performed using generic line-based merging algorithms (e.g., diff3) that are unaware of the syntax and semantics of the programming language, outputting conflicts that could be avoided. Structured and semistructured merging techniques are capable of reducing conflicts, but they still suffer from false positives (conflicts that could be avoided) and false negatives (conflicts that go undetected). We propose a merging technique that combines semistructured and transformation-based strategies, where conflict detection is aware of semantic aspects of the programming language. We extract transformations of two branches and apply a merging process that analyzes incompatible transformations, avoiding false positives and false negatives that occur in existing approaches. We developed Jaid, a prototype merging tool for Java based on the assumption that structural code elements evolve with attached UUIDs (representing identity). We performed an early experiment with 63 merge scenarios from two open-source projects to test the technique and assess its feasibility.

We present Jask, a system capable of generating questions about a learner's code written in Java. Given Java code as input, Jask provides a set of meaningful questions formulated in terms of the actual code (using its constructs and identifiers) and the corresponding correct answers. We integrated Jask in a web-based system where students submit their code (e.g., from lab exercises), answer questions about it, and obtain immediate formative feedback with the correct answers. An initial study involving 123 distinct introductory programming students providing 2274 answers revealed that questions pertaining to program dynamics tend to register low scores, possibly evidencing fragile comprehension of programming constructs. Participants were surveyed, revealing a positive view towards the usefulness of Jask, especially with respect to consolidating terminology.

Knowledge about misconceptions is an important element of pedagogical content knowledge. The computing education research community collected a large body of research on misconceptions, using a diverse set of definitions and approaches. Inspired by this prior work, we present an actionable definition of misconceptions, focused on the area most commonly studied: programming and programming languages. We then introduce an organizational structure for collections of programming language misconceptions. We study how existing collections fit our organization, and we present a curated inventory of programming language misconceptions that aims to follow our definition and structure. Our inventory goes beyond traditional programming misconception collections. It connects misconceptions to the authoritative specifications of languages, to places they may be triggered in textbooks, to research papers that discuss them, and it provides support for integrating programming language misconceptions into educational platforms.

Students sometimes produce code that works but that its author does not comprehend. For example, a student may apply a poorly-understood code template, stumble upon a working solution through trial and error, or plagiarize. Similarly, passing an automated functional assessment does not guarantee that the student understands their code. One way to tackle these issues is to probe students' comprehension by asking them questions about their own programs. We propose an approach to automatically generate questions about student-written program code. We moreover propose a use case for such questions in the context of automatic assessment systems: after a student's program passes unit tests, the system poses questions to the student about the code. We suggest that these questions can enhance assessment systems, deepen student learning by acting as self-explanation prompts, and provide a window into students' program comprehension. This discussion paper sets an agenda for future technical development and empirical research on the topic.

Summary Plugin‐based systems are typically realized with resort to a component framework that offers an infrastructure for assembling plugin components, which can be composed to form system variants. Feature models have been proposed as an abstraction to manage software variability, where feature configurations describe variants of a software system. In this paper, we propose an automated approach to map the artifacts of plugin‐based component frameworks to feature models. We describe a methodology for structuring the architecture of a plugin‐based system, so that the variability space and variants are reflected in a feature model and its configurations. We materialized the proposed approach for the Eclipse Equinox component framework in a tool to visualize the variability of plugin‐based systems in feature diagrams, which can be used to generate system variants. We carried out an experiment where we developed a small plugin‐based product line on top of Equinox in the context of an advanced software development course. Copyright © 2016 John Wiley & Sons, Ltd.

ABSTRACT A significant part of a developer's activity is spent on maintenance tasks, which might involve dealing with unfamiliar code. Especially in these cases, a maintenance task is likely to imply a considerable amount of time locating the relevant source code that needs to be changed, a problem often referred to as feature location. This paper proposes a navigation mechanism for tracing user interface elements of a running program to their representation in the source code. The mechanism realization relies on instrumenting the program in order to enable navigation from user interface elements to locations in the source code. We developed a prototype implementation of the proposed mechanism that implies an acceptable instrumentation overhead, suitable for being used on industrial‐scale programs. We performed a user study and observed that the proposed mechanism enables fast code location and that the time spent to accomplish similar tasks does not change significantly as program size increases. Copyright © 2014 John Wiley & Sons, Ltd.

Teaching programming in context, i.e. having students learning how to program by manipulating artifacts of a familiar domain (e.g. images, card games), has demonstrated convincing results in terms of raising student retention and interest in CS. This paper presents a pedagogical environment for teaching Java in context that is extensible with respect to the domains it supports. Instructors model domains and develop visualization widgets for rendering their objects. In turn, students use the environment to visualize and manipulate objects of the domain when solving exercises. The advantage and originality of the proposed environment is that it embodies an open-ended platform for creating diverse contexts at a low cost, standing as an enabler for widening the spectrum of abstractions for programming in context.

Teaching programming in context, i.e. having exercises dealing with artifacts of a familiar domain (e.g. images, card games), has demonstrated convincing results in terms of raising student retention and interest in CS. This session addresses the development of contexts for Java by means of AGUIA/J plugins.

A significant part of a developer's activity is spent on maintenance tasks, which might involve dealing with unfamiliar code. Especially in these cases, a maintenance task is likely to imply a considerable amount of time locating the relevant source code that needs to be changed. This paper proposes a navigation mechanism for tracing UI elements of a running program to their representation in the source code. The technique relies on instrumenting the program in order to enable navigation from UI elements to locations in the source code. We have developed a prototype implementing the proposed mechanism and performed a user study where programmers were asked to perform maintenance tasks on programs of different sizes. We observed that the proposed mechanism enables fast code location, and that the time spent to accomplish similar tasks does not change significantly as program size increases.

Locating code within large systems, especially when the code is unfamiliar to a developer, may consist of an expensive activity. The GUITA Toolkit1consists of a set of Java instrumentation components, which can be woven into an application, in order to supply the developer with program comprehension mechanisms that can be activated at runtime by interacting with the application. This demonstration covers two of these mechanisms, which can be used in combination: (a) GUI-driven code tracing, which enables UI widgets to be traced to their representation in the source code at runtime, and (b) feature-driven code tracing, which enables code fragments to be located by demonstrating a feature on the executing application.

Learning and teaching object-oriented programming are still perceived as being difficult tasks. This paper presents AGUIA/J, a pedagogical tool for interactive experimentation and visualization of object-oriented Java programs. The approach is based on having a graphical environment for experimenting a set of user-developed classes where objects of such classes can be created and controlled interactively. The main innovative aspects of the tool comprise the visualization of objects in widgets that take different forms according to their classes and state, a mechanism to address the query-command separation principle, and the capability of runtime adaptation of the objects in the workbench to new versions of their classes. An experiment using AGUIA/J as courseware in pilot lab classes has resulted in higher approval rates for the involved students, as well as significantly lower drop-out rates.

Abstract In the current trend of software engineering, patterns and profiles lend themselves as two powerful complementary mechanisms for documenting and enforcing design rules. In this paper, we study how unified tool support can be achieved for patterns and profiles by interpreting them as role‐based structural descriptions and exploiting existing tool support for role modeling. The approach is realized using so‐called design profiles, which allow both validation and generation of models according to rules expressed in the patterns and profiles. A prototypical tool environment supporting the approach has been developed. The practical applicability of the approach is demonstrated by specifying design rules of the enterprise Java beans (EJB) platform and by producing an environment for designing EJB‐based applications. We also discuss possible usage scenarios in the context of this case study. Copyright © 2008 John Wiley & Sons, Ltd.

The adoption of Domain-Specific Modeling Languages (DSMLs) for generating framework-based applications has proved to be an effective way of enforcing the correct use of frameworks and improve the productivity of application developers. However, the development of the code generator of a DSML is typically a laborious task with difficulties in what concerns complexity, understandability, and maintainability. In this paper, we address this problem with a new approach for developing DSMLs for frameworks that allows to eliminate the need of implementing code generators. The approach relies on the extension of frameworks with an additional layer based on aspect-oriented programming that encodes a DSML. By means of a generic language workbench, framework-based applications can be generated from application models described in that DSML. The proposed language workbench was implemented in a prototype tool and a case study on the Eclipse Rich Client Platform was performed.

Learning complex software platforms is a challenging task. This paper studies the problem of platform learning from the viewpoint of multidimensional separation of concerns in software systems. In this approach, concerns are used to identify and specify the kinds of learning tasks and interactions that should be supported by a learning environment for software platforms. The approach has been applied to build a concern-based learning environment for a Nokia GUI platform. A generic concern management tool has been used to build the r environment.