Beginner Programmers Research Articles

COverlap: a Fiji toolset for the 3D co-localization of two fluorescent nuclear markers in confocal images

With the increasing complexity and throughput of microscopy experiments, it has become essential for biologists to navigate computational means of analysis to produce automated and reproducible workflows. Bioimage analysis workflows being largely underreported in method sections of articles, it is however quite difficult to find practical examples of documented scripts to support beginner programmers in biology. Here, we introduce COverlap, a Fiji toolset composed of four macros, for the 3D segmentation and co-localization of fluorescent nuclear markers in confocal images. The toolset accepts batches of multichannel z-stack images, segments objects in two channels of interest, and outputs object counts and labels, as well as co-localization results based on the physical overlap of objects. The first macro is a preparatory step that produces maximum intensity projections of images for visualization purposes. The second macro assists users in selecting batch-suitable segmentation parameters by testing them on small portions of the images. The third macro performs automated segmentation and co-localization analysis, and saves the parameters used, the results table, the 3D regions of interest (ROIs) of co-localizing objects, and two types of verification images with segmentation and co-localization masks for each image of the batch. The fourth macro allows users to review the verification images displaying segmentation masks and the location of co-localization events, and to perform corrections such as ROI adjustment, z-stack reslicing, and volume estimation correction in an automatically documented manner. To illustrate how COverlap operates, we present an experiment in which we identified rare endothelial proliferation events in adult rat brain slices on more than 350 large tiled z-stacks. We conclude by discussing the reproducibility and generalizability of the toolset, its limitations for different datasets, and its potential use as a template that is adaptable to other types of analyses.

Improving CS1 Programming Learning with Visual Execution Environments

Students in their first year of computer science (CS1) at universities typically struggle to grasp fundamental programming concepts. This paper discusses research carried out using a Java-based visual execution environment (VEE) to introduce fundamental programming concepts to CS1 students. The VEE guides beginner programmers through the fundamentals of programming, utilizing visual metaphors to explain and direct interactive tasks implemented in Java. The study’s goal was to determine if the use of the VEE in the instruction of a group of 63 CS1 students from four different groups enrolled in two academic institutions (based in Madrid, Spain and Galway, Ireland) results in an improvement in their grasp of fundamental programming concepts. The programming concepts covered included those typically found in an introductory programming course, e.g., input and output, conditionals, loops, functions, arrays, recursion, and files. A secondary goal of this research was to examine if the use of the VEE enhances students’ understanding of particular concepts more than others, i.e., whether there exists a topic-dependent benefit to the use of the VEE. The results of the study found that use of the VEE in the instruction of these students resulted in a significant improvement in their grasp of fundamental programming concepts compared with a control group who received instruction without the use of the VEE. The study also found a pronounced improvement in the students’ grasp of particular concepts (e.g., operators, conditionals, and loops), suggesting the presence of a topic-dependent benefit to the use of the VEE.

Sandwich Robot for Computational Thinking: Reflections from testing with high school pupils

Our study discusses results from testing and co-designing Sandwich Robot, a game on algorithmic thinking targeting beginner programmers. The player composes code from a minimal set of blocks, to make a robotic character gather ingredients for a sandwich, following a specific order; the gameplay is similar to other Computational Thinking (CT) games like Karel the Robot or LightBot. The latest prototype of the game has been tested with three classes of 15-20 pupils from a technical high school in Denmark. The test was conducted in collaboration with their teacher in the subject Informatik, which focuses on CT and basic programming, and ended with a co-design workshop.
 Our results shows that pupils were interest in the basic concept behind our game, they generally described our game as “fun”. Pupils and their teacher saw learning potential in the game, as a tool for understanding algorithmic thinking, but also for refining their learning at later stages. This expanded the role we envisioned for our game, leading us to rethink its relation to the pupils’ learning process. On-going and future work involves addressing pupils’ feedback and providing a level editor to allow Kahoot-style challenges. Our main contribution provides an exemplar of how the thinking behind algorithmic problem-solving can be transposed into game mechanics, embodied in a casual game, and how a non-technical narrative can support beginners learning CT.

DIY liquid handling robots for integrated STEM education and life science research.

Automation has played a key role in improving the safety, accuracy, and efficiency of manufacturing and industrial processes and has the potential to greatly increase throughput in the life sciences. However, the lack of accessible entry-point automation hardware in life science research and STEM education hinders its widespread adoption and development for life science applications. Here we investigate the design of a low-cost (~$150) open-source DIY Arduino-controlled liquid handling robot (LHR) featuring plastic laser-cut parts. The robot moves in three axes with 0.5 mm accuracy and reliably dispenses liquid down to 20 μL. The open source, modular design allows for flexibility and easy modification. A block-based programming interface (Snap4Arduino) further extends the accessibility of this robot, encouraging adaptation and use by educators, hobbyists and beginner programmers. This robot was co-designed with teachers, and we detail the teachers' feedback in the context of a qualitative study. We conclude that affordable and accessible LHRs similar to this one could provide a useful educational tool to be deployed in classrooms, and LHR-based curricula may encourage interest in STEM and effectively introduce automation technology to life science enthusiasts.

Learning Performance in Adaptive Learning Systems: A Case Study of Web Programming Learning Recommendations.

Students often face challenges while learning computer programming because programming languages’ logic and visual presentations differ from human thought processes. If the course content does not closely match learners’ skill level, the learner cannot follow the learning process, resulting in frustration, low learning motivation, or abandonment. This research proposes a web programming learning recommendation system to provide students with personalized guidance and step-by-step learning planning. The system contains front-end and back-end web development instructions. It can create personalized learning paths to help learners achieve a sense of accomplishment. The system can help learners build self-confidence and improve learning effectiveness. In study 1, the recommendation system was developed based on the personal data and feedback of 41 professional web design engineers. The system uses C4.5 decision tree methods to develop a programming learning recommendation model to provide appropriate learning recommendations and establish personalized learning paths. The test group included 13 beginner programmers. After 4 weeks’ programming instructions in front-end and back-end web development, the learners were interviewed to understand their preferences and learning effectiveness. The results show that the effectiveness of the recommendation system is acceptable. In study 2, online real-time feedback and adaptive instruction platform is developed, which is different from the past adaptive curriculums mainly using the Internet platform and only the submitted assignments to determine the newly recommended learning process for students. The study found that the students’ learning performance in the adaptive instruction group is better than those in the fixed instruction group.

A modern approach to supporting program visualization: from a 2D notation to 3D representations using augmented reality

The visualization of programs and algorithms has been demonstrated to be essential when learning to program. Nevertheless, existing graphic representations require a high level of abstraction that most beginner programmers cannot understand. Current state-of-the-art approaches provide promising alternatives, but a significant part leaves the advantages of graphic representation in the background. These advantages include abstracting the source code by means of symbols that make them easier to understand without previous training. This work introduces the evolution of a 2-D graphic notation to a 3-D environment, which represents an improvement to a complete platform for collaborative programming learning through problem solving, named COLLECE-2.0. This improvement provides the platform with capabilities to visualize programs through augmented reality by using a new set of graphic representations, which are based on roads and traffic signs in the context of programming learning. These visual models have been evaluated by Computer Science students to know whether the proposed notation is intuitive and useful. The obtained results show that the proposed notation is suitable for representing programming concepts and easy to understand. We also present a series of improvements, integrated as a new subsystem in the aforementioned platform, which allows the automatic construction of 3-D visualizations on an augmented reality environment. These visualizations use the proposed notation and leverage the scalability and architecture of COLLECE-2.0.

Finding Structure in Time: Visualizing and Analyzing Behavioral Time Series.

The temporal structure of behavior contains a rich source of information about its dynamic organization, origins, and development. Today, advances in sensing and data storage allow researchers to collect multiple dimensions of behavioral data at a fine temporal scale both in and out of the laboratory, leading to the curation of massive multimodal corpora of behavior. However, along with these new opportunities come new challenges. Theories are often underspecified as to the exact nature of these unfolding interactions, and psychologists have limited ready-to-use methods and training for quantifying structures and patterns in behavioral time series. In this paper, we will introduce four techniques to interpret and analyze high-density multi-modal behavior data, namely, to: (1) visualize the raw time series, (2) describe the overall distributional structure of temporal events (Burstiness calculation), (3) characterize the non-linear dynamics over multiple timescales with Chromatic and Anisotropic Cross-Recurrence Quantification Analysis (CRQA), (4) and quantify the directional relations among a set of interdependent multimodal behavioral variables with Granger Causality. Each technique is introduced in a module with conceptual background, sample data drawn from empirical studies and ready-to-use Matlab scripts. The code modules showcase each technique’s application with detailed documentation to allow more advanced users to adapt them to their own datasets. Additionally, to make our modules more accessible to beginner programmers, we provide a “Programming Basics” module that introduces common functions for working with behavioral timeseries data in Matlab. Together, the materials provide a practical introduction to a range of analyses that psychologists can use to discover temporal structure in high-density behavioral data.

Concept–based Analysis of Java Programming Errors among Low, Average and High Achieving Novice Programmers

Aim/Purpose: The study examined types of errors made by novice programmers in different Java concepts with students of different ability levels in programming as well as the perceived causes of such errors. Background: To improve code writing and debugging skills, efforts have been made to taxonomize programming errors and their causes. However, most of the studies employed omnibus approaches, i.e. without consideration of different programing concepts and ability levels of the trainee programmers. Such concepts and ability specific errors identification and classifications are needed to advance appropriate intervention strategy. Methodology: A sequential exploratory mixed method design was adopted. The sample was an intact class of 124 Computer Science and Engineering undergraduate students grouped into three achievement levels based on first semester performance in a Java programming course. The submitted codes in the course of second semester exercises were analyzed for possible errors, categorized and grouped across achievement level. The resulting data were analyzed using descriptive statistics as well as Pearson product correlation coefficient. Qualitative analyses through interviews and focused group discussion (FGD) were also employed to identify reasons for the committed errors. Contribution:The study provides a useful concept-based and achievement level specific error log for the teaching of Java programming for beginners. Findings: The results identified 598 errors with Missing symbols (33%) and Invalid symbols (12%) constituting the highest and least committed errors respec-tively. Method and Classes concept houses the highest number of errors (36%) followed by Other Object Concepts (34%), Decision Making (29%), and Looping (10%). Similar error types were found across ability levels. A significant relationship was found between missing symbols and each of Invalid symbols and Inappropriate Naming. Errors made in Methods and Classes were also found to significantly predict that of Other Object concepts. Recommendations for Practitioners: To promote better classroom practice in the teaching of Java programming, findings for the study suggests instructions to students should be based on achievement level. In addition to this, learning Java programming should be done with an unintelligent editor. Recommendations for Researchers: Research could examine logic or semantic errors among novice programmers as the errors analyzed in this study focus mainly on syntactic ones. Impact on Society: The digital age is code-driven, thus error analysis in programming instruction will enhance programming ability, which will ultimately transform novice programmers into experts, particularly in developing countries where most of the software in use is imported. Future Research: Researchers could look beyond novice or beginner programmers as codes written by intermediate or even advanced programmers are still not often completely error free.

Automated Grading Systems for Programming Assignments: A Literature Review

Automated grading for programming assignments is becoming more and more important nowadays especially with the emergence of the Massive Open Online Courses. Many techniques and systems are being used nowadays for automated grading in educational institutions. This article provides a literature review of the many automated grading systems and techniques that are being used currently. It focuses on highlighting the differences between these systems and techniques and addressing issues, advantages and disadvantages. The review shows that these systems have limitations due to difficulty in usage by students as noticed by some course instructors. Some of these problems stem from UI/UX difficulties while other problems were due to beginner syntax errors and language barriers. Finally, it shows the need to fill the gap by building new systems that are friendlier towards beginner programmers, has better localization and easier user experience.

A hybrid approach for using programming exercises in introductory physics

Incorporating computer programming exercises into introductory physics is a delicate task that involves a number of choices that may have an effect on student learning. We present a “hybrid” approach that speaks to a number of common concerns regarding cognitive load which arise when using programming exercises in introductory physics classes where many students are absolute beginner programmers. This “hybrid” approach provides the student with a highly interactive web-based visualization, not unlike a PhET or Physlet interactive, but importantly the student is shown only the subset of the code where the initial conditions are set and the system variables are evolved. We highlight results from a coding activity that resembles the classic game Asteroids. The goals of this activity are to show how a simple 1D code can be modified into a 2D code, and to reinforce ideas about the relationship between force, velocity, and acceleration vectors. Survey results from four semesters of introductory physics classes at the Ohio State University's Marion campus, in which a high percentage of the students are weak or absolute beginner programmers, provide evidence that most students can complete coding tasks without severe difficulty. Other survey results are promising for future work where conceptual learning will be assessed in a direct way using metrics like the Animated Force Concept Inventory [Dancy and Beichner, Phys. Rev. Spec. Top. Phys. Educ. 2, 010104 (2006)]. The exercise highlighted here and others from our group are available for general use at http://compadre.org/PICUP.

A Method for Quality Evaluation of Supervision Software Using Fuzzy Concepts and the International Standard ISO/IEC 25000

Supervision software is an important part of supervisory control and data acquisition systems. It is ubiquitous in industrial applications and there is an increasing need for management methods to evaluate this software. In this paper, we describe a new method to evaluate supervision software using fuzzy logic and ISO/IEC 25000 standards which, together, are able to organize the evaluation phases and to indicate the quality degree of the software product. The method aggregates the opinion of experts in a preferential voting system, in which the opinion is weighted by the expert experience and agreement with the majority. The method defines the quality degree of each software requirement in a quality index, which is obtained by comparing the results of the evaluation with the quality standard developed for this specific problem. A 1.5-year-long experiment with beginner programmers illustrates the application of the method, and the results show the improvements that must be made in the software developed by them. With this new way of evaluating supervision software, programmers can identify problems in requirements, evaluate software and propose efficient solutions.

Syntax highlighting as an influencing factor when reading and comprehending source code

Syntax highlighting or syntax colouring, plays a vital role in programming development environments by colour-coding various code elements differently. The supposition is that this syntax highlighting assists programmers when reading and analysing code. However, academic text books are largely only available in black-and-white which could influence the comprehension of novice and beginner programmers. This study investigated whether student programmers experience more difficulty in reading and comprehending source code when it is presented without syntax highlighting. Number of fixations, fixation durations and regressions were all higher for black-and-white code than for colour code but not significantly so. Subjectively students indicated that the colour code snippets were easier to read and more aesthetically pleasing. Based on the analysis it could be concluded that students do not experience significantly more difficulty when reading code in black-and-white as printed in text books.

Studying the Binomial Distribution Using LabVIEW

This undergraduate physical chemistry laboratory exercise introduces students to the study of probability distributions both experimentally and using computer simulations. Students perform the classic coin toss experiment individually and then pool all of their data together to study the effect of experimental sample size on the binomial distribution. Simulations of the coin toss experiment are also performed using the software package LabVIEW. LabVIEW facilitates the creation of complex computer programs in a short period of time, even by beginner programmers. Histograms in LabVIEW are displayed in real time with students adjusting the number of simulated coin tosses on the fly using a virtual knob or a slider, up to 1 million individual trials. This allows the students to see firsthand the evolution of the binomial distribution into the Gaussian distribution with a large sample size.

Competing Dichotomies in Teaching Computer Programming to Beginner-Students

The goal in teaching computer programming is to develop in students the capabilities required of a professional software developer. Beginner programmers suffer from a wide range of difficulties and deficits. Several studies suggest that undertaking computer programming for meeting a real industry application is still a challenge for many students even after studying for a year or two. The purpose of this paper is to investigate the challenges in teaching computer programming to beginner-students and to initiate a dialog in the information and communication technology teaching community on how to teach and assess computer programming courses effectively. We undertake an extensive literature review to identify four major programming dichotomies in teaching computer programming: knowledge versus application, comprehension versus generation, procedural versus object oriented and functional versus imperative. Further, based on our teaching experience, we propose a practical approach to teaching computer programming to beginner-students. The paper discusses the implications to ICT teaching community and how teaching and assessments can be made effective to achieve the goal of making beginner programmer learn not only knowledge but also relevant application skills. We believe that the study would contribute to making ICT teaching more practical and effective in achieving their educational goals.

Implementation of SQLite database support in program gama-local

The program gama-local is a part of GNU Gama project and allows adjustment of local geodetic networks. Before realization of this project the program gama-local supported only XML as an input. I designed and implemented support for the SQLite database and thanks to this extension gama-local can read input data from the SQLite database. This article is focused on the specifics of the use of callback functions in C++ using the native SQLite C/C++ Application Programming Interface. The article provides solution to safe calling of callback functions written in C++. Callback functions are called from C library and C library itself is used by C++ program. Provided solution combines several programing techniques which are described in detail, so this article can serve as a cookbook even for beginner programmers. This project was accomplished within my bachelor thesis.

Programming by discovery

Abstract The concept of Programming by Discovery refers to the process of designing programming environments and systems which use various visualisation, programming and interaction technologies in an effective way to help users, especially beginner programmers, in writing computer programs, understanding their dynamic behaviour, detecting any misconceptions and bugs associated with them, and seeing the effect of these programs on the underlying machine. A system for programming by discovery encourages a user to become an active learner by allowing him to form his own hypotheses, explore his own questions, and draw his own conclusions. This paper reports on the design and evaluation of a system for programming by discovery which embodies the principles outlined above. To assess the usefulness of the design framework presented in this paper, a pilot empirical evaluation was conducted. The results provided a number of interesting insights into the implication of incorporating visualisation and immediacy features along with graphical notional machine and algorithm‐like language into the design of programming systems.

Knowledge organization and skill differences in computer programmers

Like experts in other fields, expert computer programmers can recall at a glance far more information relevant to their field than novices can. One explanation for this difference is that experts not only have more information, they have it better organized into meaningful chunks. In this paper, we infer the details of individual programmers' chunks of key programming concepts using the Reitman—Rueter ( Cognitive Psychology, 1980, 12(4), 554–581.) technique for inferring tree structures from recall orders. Differences in organizations accompany skill-level differences. Beginner programmers' organizations show a rich variety of common-language associations to these programming concepts; Intermediate programmers show mixtures of programming and common-language associations; and Experts show remarkably similar, but not identical, organizations based clearly on programming knowledge.