This Work-in-Progress paper presents WebTA, a code critiquer developed using Java, currently being expanded to MATLAB for first-year engineering students. It outlines the modification process of the existing WebTA software for MATLAB and shares the results of three beta tests conducted with 52 students. The paper highlights the significance of providing an automated tool that helps students identify and improve coding errors is highlighted (addressing the gap between computer science and engineering education). WebTA's feedback-on-demand feature addresses the challenge of providing timely and personalized feedback to a large number of students, contributing to the enhancement of first-year engineering education.

This research is part of a larger development project that is working on a multi-programming language code critiquer called WebTA. The WebTA code-critiquing software is designed to be used in courses for novice programmers, e.g., CS1 a first engineering course. The authors report on a component of the project that makes initial steps towards a automating the identification of common student mistakes, or antipatterns in code. Antipatterns can be errors, inefficiencies, or incorrect style choices in the code. This works is aimed at Python and uses the machine learning algorithm, Random Forests, to identify a stylistic antipattern of crowded operators.

Several rule-based code critiquing systems have been developed to support programmers. However, these systems often are targeted toward experienced learners. Novice learners often lack self-efficacy in programming [1]-code critiquers targeted at novice programmers to promote student learning and enrich the overall education system are essential. Students' self-efficacy for programming is the perception of students' competence concerning programming [2], an essential attribute of computer science education. This paper examines existing literature on the impact of self-efficacy on students in programming. This work focuses on empirical work in programming education that independently addresses and develops theories specific to student programming-at the same time, addressing the existing gap in understanding the impact of code critiquers on student self-efficacy. The systematic review followed guidelines proposed by Kitchenham methodology. Findings revealed various factors that improve self-efficacy and provide evidence of significant sources of self-efficacy in programming. Moreover, the investigation guides further research in designing code critiquers to enhance the self-efficacy of novice learners. This work is part of a more significant effort to investigate the use of antipatterns (common programming mistakes) in novice programmers' coding. This sub-project aims to determine if the use of a code critiquer by first-year engineering students will improve student self-efficacy regarding programming.

Expanding autocritiquers to other languages requires the difficult task of obtaining and representing antipat-terns. Under the current framework, each language requires a unique Abstract Syntax Tree (AST) and error solution such that both the resulting AST and error summaries can be searched and presented to students. Often similar antipatterns arise that have to be rewritten in each language's own context. This paper proposes the creation of a generalized AST structure for an auto-critiquer under development, that can unify common code structures across similar languages while capturing differences in the languages. This work also proposes a standard for error message representation that can capture similar errors across language specific error messages. There are two motivations to standardizing AST and error message formats. Firstly, our solution allows for a standardized User Interface (UI) and easy integration of new languages with an identical on-boarding process for both professors and students. Secondly, reuse of antipatterns will allow us to skip the time-consuming step of constructing near-identical structural and logical antipattern queries as well as unifying novice based error feedback.

Modeling is commonly employed in school settings to help students develop an understanding of biological systems [3]. By inspecting and modifying the inner workings of their models, students become familiar with causal factors and how they impact the properties of the model. We believe that allowing students to tinker with computational models involves developing the same skills used in computational thinking, such as abstraction, decomposition, analysis, automation, and generalization. In this poster, we discuss the design and implementation of a simulation that models the growth and spread of a hypothetical disease. The goal is to help middle school students develop computational thinking skills while learning how a virus spreads through the human population.

Full Paper. Research. We discuss possible ways to direct students to right level of introductory programming. While many schools offer college preparatory or advanced placement courses in computing, there is still, unfortunately, a large part of the "college-ready" population that has no opportunity to learn computing at all before they arrive. Regulation of CS education at the state/province or national level is still rare (but growing). Thus incoming students possess a wide range of skills and knowledge. When coupled with increasing enrollments, this diversity of experience can result in courses having large numbers of both absolute beginners and seasoned coders. Such courses are difficult to teach, intimidate novice students, and bore those with more experience. This can result in low engagement and retention.Unlike mathematics and language arts, introductory courses in CS vary widely from one institution to another in both conceptual material and programming language used. A standard point of entry to college mathematics is a calculus course, with some students instead starting earlier with pre-calculus or an algebra refresher, and others starting out in the second-term calculus course. There is rarely a concern about student skill being hidden by notational or other language differences, because the language of mathematics is close to universal. Similarly, freshman language arts courses in reading and/or writing assume a certain level of skill and maturity of comprehension and expressiveness in the target language; otherwise remedial courses are provided.We investigate placement of incoming first year students into appropriate introductory computer science courses at higher education institutions where there is more than one choice of first course. The goal is to determine the best way to decide which first course would be the most helpful for each student.

Conference presentations usually focus on successful innovations: new ideas that yield significant improvements to current practice. Yet educators know that we often learn more from failure than from success. In this panel, we present four case studies of "good ideas" for improving CS education that resulted in failures. Each contributor will describe their "good idea", the failure that resulted, and wider lessons for the CS community.

This position paper discusses the need for greater inclusion of context in papers describing computer science education research. This inspiration arose from our efforts to compare our experiences with pair programming in an introductory computer science course with experiences described in the literature. We quickly observed that the behaviors associated with the term "pair programming" and the contexts can differ greatly between universities and yet the phrase pair programming is often used with no further explanation.

We propose a working group to investigate methods of proper placement of university entrance-level students into introductory computer science courses. The main issues are the following. The ability to predict skill in the absence of prior experience The value of programming language neutrality in an assessment instrument Stigma and other perception issues associated with students' performance, especially among groups underrepresented in computer science The impact or potential impact on underrepresented populations (minorities, those with lower socioeconomic status) The outcomes/satisfaction/retention metrics in the major of the paced/tracked students compared to those in one-size-fits-all introductory classes

This poster presents MATLAB Critiquer, a system that examines code submissions and provides feedback to first year engineering students who are learning to program in MATLAB. Code Critiquers act as substitute mentors, when instructors are not available, and give students experience with interactive, test-driven development. Students using our critiquer are engaged in communication by proxy with the instructor. This communication does not replace instructor feedback; rather, it codifies common feedback scenarios to assist the instructor in reaching students just when the student is engaged in problem solving and learning. Our critiquer uses the MATLAB Java API; connecting to the MATLAB Engine that parses and executes student code submissions. We process error messages that are returned using regular expressions, then use these results to craft feedback for the students. Static code analysis is used to provide feedback on style. The critique covers code structure, shakedown test results, and programming style in a manner appropriate for novice coders.

Programming is becoming skill required by a wide range of students, not just CS majors. Furthermore, not only are non-CS majors learning to program, but many non-CS faculty find themselves teaching programming courses. Introducing these faculty and students to the craft of programming is accompanied by a number of unique challenges. How can non-CS faculty position themselves as programming experts, given they are not CS people? How can we convince non-CS students that coding is a necessary skill? Often our non-computing majors are reluctant, stating "Programming isn't what I signed up for!" Many non-CS students are not receptive to learning new programming languages due to a lack of intrinsic motivation coupled with technological anxiety. These factors often result in low-self efficacy, which must be overcome in order to explore, play, and learn. This Birds of a Feather discussion brings together instructors from diverse disciplines to discuss the teaching of programming to a range of students, the barriers that exist for non-computing students, and the interventions that attempt to mitigate these issues.

The introductory programming lab, with small cycles of teaching, coding, testing, and critique from instructors, is an extraordinarily productive learning experience for novice programmers. We wish to extend the availability of such critique through automation, capturing the essence of interaction between student and instructor as closely as possible. Integrated Development Environments and Automated Grading Systems provide constant feedback through static analysis and unit testing. But we also wish to tailor automated feedback to acknowledge commonly recurring issues with novice programmers, in keeping with the practice of a human instructor. We argue that the kinds of mistakes that novice programmers make, and the way they are reported to the novices, deserve special care. In this paper we provide examples of early programming antipatterns that have arisen from our teaching experience, and describe different ways of identifying and dealing with them automatically through our tool WebTA. Novice students may produce code that is close to a correct solution but contains syntactic errors; WebTA attempts to salvage the promising portions of the student's submission and suggest repairs that are more meaningful than typical compiler error messages. Alternatively, a student misunderstanding may result in well-formed code that passes unit tests yet contains clear design flaws; through additional analysis, WebTA can identify and flag them. Finally, certain types of antipattern can be anticipated and flagged by the instructor, based on the context of the course and the programming exercise; WebTA allows for customizable critique triggers and messages.

Multiple studies have shown that when novice and experienced programmers are enrolled in the same introductory programming course, the novice programmers are negatively impacted. We have two entry points into our course sequence for majors. One course is intended for students with little or no programming experience, while the alternate course is intended for students who have had previous programming experience. In 2015 we discovered that many students with programming experience were enrolling in the course for novice programmers. A change in our placement strategy in 2016 resulted in a greater portion of the students with programming experience actually enrolled in the course intended for students with programming experience. Last year we reported on the impact this change had on the courses and the students enrolled in these introductory courses. Although student performance improved only slightly, many fewer students with little or no previous programming experience reported that their first programming course was unreasonably difficult in 2016. In this paper we examine how this change in placement strategy and resulting changes in the courses is impacting student persistence in the major. Initial indications are that a greater percentage of students with little or no previous programming experience are persisting in their computing major when these students begin in an introductory course that does not also include students who have substantial programming experience.

The need for K-12 students to engage in Computer Science has been acknowledged in the White House call for "Computer Science for All" and supported through a variety of institutions. Implicit in many initiatives, and explicit in Google's CS4HS initiative, is the notion of a "Community of Practice" involving K-12 teachers. Communities of Practice are mutually supportive groups to assist newcomers as they find their way in a new endeavor. Teachers can support one another at multiple levels: technical, pedagogical, political, and emotional. Maintaining a Community of Practice for CS teachers, however, can be challenging. Demands on teacher time, lack of institutional buy-in, physical isolation, and lack of appropriate peer institutions are some confounding factors. A true community of practice requires maintenance: ways to identify newcomers or other participants in need, and ways to identify and share the resources that can help others. In this BoF, educators who are working to expand CS within K-12 education will discuss the challenges in the Community of Practice approach and share proven ways of addressing them.

We present a demonstration of our WebTA tool, which facilitates the teaching of programming by providing automatic critique and grading of student source code. Programming is in fact a complex set of interconnected activities. Learning to design, analyze, implement, test, and revise software is crucial for student success, not just for computer science students but for a broad and growing body of students in other disciplines as well. Our approach is to teach students agile development methods through small cycles of teaching, coding integrated with testing, and immediate feedback. WebTA facilitates our teaching approach by providing automatic critique of student source code. WebTA provides immediate feedback to students and gives them experience with interactive, test-driven development. Students using WebTA are engaged in communication-by-proxy with the instructor. This communication does not replace instructor feedback; rather, it codifies common feedback scenarios, triggered by errors, warnings, or textual code analysis, to assist the instructor in reaching students just when the student is engaged in problem solving and learning. This prompts the student to reflect and refactor in an iterative design process. WebTA compiles student code and executes it over a series of shakedown tests. It also analyzes student performance and generates preliminary grading reports. Students are coached through code critiques and suggestions that prompt them to reflect and refactor. The demonstration consists of a walkthrough of two use-case scenarios: Student use of WebTA as a code snippet critiquer and its use by faculty as an automated grading system.

Studies have shown that novice programmers face unnecessary obstacles when they are enrolled in an introductory course alongside students with previous programming experience. Thus a recommended best practice is to have separate courses or separate sections for novice and experienced students in introductory programming courses. At Michigan Tech we have two starting points for our introductory sequence with one aimed at novice programmers and a second aimed at students with some programming experience. We, therefore, assumed that the curriculum was in alignment with this best practice. A survey of our incoming students indicated that students were not enrolling in the courses consistent with our expectations. By changing the timing and means of offering an assessment to determine student placement in the introductory sequence, we were able to substantially impact the make-up of our introductory courses. The change did have the desired positive impact on students in the course for novice programmers. In this paper, we will also discuss some of the other issues we uncovered with this change.

In November 2014, Michigan Technological University's departments of computer science (CS) and electrical and computer engineering (ECE) were selected to participate in NCWIT's Extension Services for Undergraduate Programs (ES-UP). ES-UP, supported by NSF and Google, is designed to help departments develop strategies to recruit and retain women in computing and engineering majors. Both departments have enrolled a low number of women in their programs and have had lower retention rates than other departments on campus. As part of the ES-UP initiatives, we surveyed our first-year students in Fall 2015 and followed up with a second survey in January 2016. The goal of the initial survey was to learn what attracted students to their major while the second focused on their experiences during their first semester. Examination of the students across the four majors in the two departments in separate colleges provides a unique perspective on students' attraction to and persistence in computing-related majors.

Students in computing disciplines need a strong basis in the fundamentals of discrete mathematics. Traditional “offline” approaches to teaching this material provide limited opportunities for the kind of interactive learning that students experience in their programming assignments. We have been using the Alloy language and analysis tool to teach concepts in discrete structures and logic in an exploratory, programming-intensive way. We report on our efforts to build scaffolded Alloy exercises for newcomers to discrete mathematics, and we report on some initial findings based on our experiences with students.

We introduce an interactive tool called WebTA that facilitates learning through automatic critique of student source code. Our tool provides immediate feedback to students and gives them experience with test-driven development. Students receive the benefits of cognitive apprenticeship through the feedback they receive in the tool. This facilitates tight, productive cycles of inquiry, critique and learning. WebTA compiles each student submission and executes it over a series of shakedown tests. Immediate feedback is given concerning errors and warnings, coupled with suggestions for debugging. The tool performs a textual analysis of the students source code and critiques programming style based on standard programming guidelines. To encourage inquiry through test-driven development, edge-case coverage, and API compliance, students develop and submit their own tests to be evaluated by the software. We report on use of WebTA in one first-year programming course and one second-year data structures course. Lab and assignment scores have improved with WebTA, and student comments attest to the effectiveness of the tool. Preliminary results indicate students receive higher grades with WebTA. One area with mixed results is WebTAs analysis of student developed JUnit tests; this feature improved API compliance but reduced edge-case testing. With these successful initial results, we offer suggestions for future development.

With the continued and alarming lack of involvement in computing among college students, attention has recently focused on engaging students at the middle and high school levels. Our "Copper Country Programmers" club began as a community outreach program to fill a gap left by the elimination of the computing curriculum in the local school district. In our club, university faculty and students provide curriculum, tools, and classroom tutoring for young novice programmers across the school district. Our curriculum teaches programming through a series of exercises involving HTML, BASIC, LOGO, and Processing (a graphics-oriented Java variant.) Contrary to some other approaches, we present students initially with a low level, bare bones programming model and development environment, then gradually increase the functionality and complexity. We find that students readily grasp the simple, transparent initial model, then experience first-hand the motivations for adding functionality (and complexity). Our cross-curricular programming topics include graphic design, interactive fiction, computer generated poetry, mathematical simulation, computational geometry, game physics, computer art, artificial intelligence, video game development, and critical thinking. We provide examples of our curriculum, student work, problems encountered, and how they were resolved.

Two trends in the developed world - the marked growth in the percentage of the population identified as “elderly”, and an increased reliance on computing technology - make it imperative that the high technology designers of tomorrow understand the challenges, capabilities and context of elderly users. Our graduate course on “software for senior citizens” provides a broad background of material from human-computer interaction, gerontology, literacy studies and cognitive and learning sciences. Students also gain first-hand experience through weekly tutoring sessions with local elderly residents. These sessions yield observations and generate contacts from which students generate research projects. This paper discusses our goals and motivations for the course, our experiences to date, and our plans for future iterations and opportunities for expansion.