scholarly journals EzUnit: A Framework for Associating Failed Unit Tests with Potential Programming Errors

2007 ◽  
pp. 101-104 ◽  
Author(s):  
Philipp Bouillon ◽  
Jens Krinke ◽  
Nils Meyer ◽  
Friedrich Steimann
Keyword(s):  
Unit Tests ◽  
Programming Errors

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

10.28945/4246 ◽  
2019 ◽  
Keyword(s):  
Undergraduate Students ◽  
Classroom Practice ◽  
Group Discussion ◽  
Intervention Strategy ◽  
Practice Volume ◽  
Future Research ◽  
Achievement Level ◽  
Java Programming ◽  
Ability Levels ◽  
Programming Errors

[This Proceedings paper was revised and published in the 2019 issue of the Journal of Information Technology Education: Innovations in Practice, Volume 18.] 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.

scholarly journals Programming errors contribute to death from patient-controlled analgesia: case report and estimate of probability

2003 ◽  
Vol 50 (4) ◽  
pp. 328-332 ◽  
Author(s):  
Kim J. Vicente ◽  
Karima Kada-Bekhaled ◽  
Gillian Hillel ◽  
Andrea Cassano ◽  
Beverley A. Orser
Keyword(s):  
Case Report ◽  
Patient Controlled Analgesia ◽  
Programming Errors

scholarly journals User documentation and training at Belle II*

2020 ◽  
Vol 245 ◽  
pp. 08008
Author(s):  
Sam Cunliffe ◽  
Ilya Komarov ◽  
Thomas Kuhr ◽  
Martin Ritter ◽  
Francesco Tenchini
Keyword(s):  
Software Development ◽  
Development Team ◽  
User Support ◽  
Question And Answer ◽  
Metasearch Engine ◽  
Belle Ii ◽  
Different Sources ◽  
And Training ◽  
Unit Tests

Belle II is a rapidly growing collaboration with members from one hundred and nineteen institutes spread around the globe. The software development team of the experiment, as well as the software users, are very much decentralised. Together with the active development of the software, such decentralisation makes the adoption of the latest software releases by users an essential, but quite challenging task. To ensure the relevance of the documentation, we adopted the policy of in-code documentation and configured a website that allows us to tie the documentation to given releases. To prevent tutorials from becoming outdated, we covered them by unit-tests. For the user support, we use a question and answer service that not only reduces repetition of the same questions but also turned out to be a place for discussions among the experts. A prototype of a metasearch engine for the different sources of documentation has been developed. For training of the new users, we organise centralised StarterKit workshops attached to the collaboration meetings. The materials of the workshops are later used for self-education and organisation of local training sessions.

scholarly journals Extending Racer with Thread is Alive Mechanism

2012 ◽  
pp. 256-258
Author(s):  
GC Dinesh ◽  
Dr. B. Eswara Reddy ◽  
A. P. Sivakumar
Keyword(s):  
Concurrent Programming ◽  
Aspect Oriented Programming ◽  
Data Races ◽  
Programming Errors

We know that detecting concurrent programming errors such as live locks, data races, starvation and deadlocks is mainly headed problem in day to today programming. Several algorithms have been developed in order to find the concurrency related bugs, among such type of algorithms the efficient one is RACER algorithm. Previously in racer algorithm RACER only uses events acquiring and releasing locks, as well as calls to Thread.start. So here in this work, we extend racer algorithm by making calls to thread is alive method. We use aspect oriented programming AspectJ. The purpose of extension racer algorithm is, in order to increase the performance of an algorithm. We applied this extension of racer algorithm to two small programs. The experiments state that extension of racer increases the efficiency of racer algorithm.

scholarly journals Results from an ethnographically-informed study in the context of test-driven development

2016 ◽  
Author(s):  
Simone Romano ◽  
Davide Davide Fucci ◽  
Giuseppe Scanniello ◽  
Burak Turhan ◽  
Natalia Juristo
Keyword(s):  
Work Experience ◽  
Software Developers ◽  
Test Driven Development ◽  
Is Implementation ◽  
Production Code ◽  
Field Notes ◽  
New Feature ◽  
Iterative Software ◽  
The University ◽  
Unit Tests

Background: Test-driven development (TDD) is an iterative software development technique where unit-tests are defined before production code. Previous studies fail to analyze the values, beliefs, and assumptions that inform and shape TDD. Aim: We designed and conducted a qualitative study to understand the values, beliefs, and assumptions of TDD. In particular, we sought to understand how novice and professional software developers, arranged in pairs (a driver and a pointer), perceive and apply TDD. Method: 14 novice software developers, i.e., graduate students in Computer Science at the University of Basilicata, and six professional software developers with work one to 10 years work experience participated in our ethnographically-informed study. We asked the participants to implement a new feature for an existing software written in Java. We immersed ourselves in the context of the study, and collected data by means of contemporaneous field notes, audio recordings, and other artifacts. Results: A number of insights emerge from our analysis of the collected data, the main ones being: (i) refactoring (one of the phases of TDD) is not performed as often as the process requires and it is considered less important than other phases, (ii) the most important phase is implementation, (iii) unit tests for unimplemented functionalities or behaviors are almost never up-to-date, (iv) participants first build a sort of mental model of the source code to be implemented and only then write test cases on the basis of this model; and (v) apart from minor differences, professional developers and students applied TDD in a similar fashion. Conclusions: Developers write quick-and-dirty production code to pass the tests and ignore refactoring.

Sign in / Sign up

Export Citation Format

Share Document