Common Programming Assignment Mistakes Students Make

Programming assignments measure many valuable skills. Students must analyze given requirements, determine an appropriate approach, and plan and test a program. Students must organize their source code and provide a description of their approach. Students tend to make errors when they start coding without a plan or when they leave the testing for the last moment. A missing test case, incorrect condition, or typo can adversely affect the program output.

For UK University students specializing in computer science or software engineering, code that is accurate and readable and adheres to good programming practices and is structured to fulfill the assignment is usually considered good code. Identifying and understanding common programming assignment mistakes will help students to better understand programming concepts and write good quality code.

Why Do Students Make Programming Assignment Mistakes?

Mistakes in completing programming assignments often occur before a student writes the first line of code. Not understanding the requirements or selecting an approach that does not solve the problem can cause obstacles later in the process.

Developing the ability to identify common coding mistakes helps students to develop better problem-solving ability and computational thinking.

1. Starting Without Understanding the Task

One of the largest coding mistakes students make is beginning the development of an application before analyzing the requirement.

First, read the entire assignment brief, identify the required/expected input and output, the required programming language (and version if applicable), functions and algorithms, required data structures, coding standards, required documentation, and the method of submission.

Creating some pseudocode prior to opening your IDE (Integrated Development Environment) would also be helpful to some students. It would help students develop a control flow, variables, functions, loops, conditional logic, and the return value of the functions they will eventually implement.

Good planning greatly decreases the frequency of errors and reduces the overall length/complexity of code that needs to be written.

2. Ignoring Syntax Errors

Syntax errors are some of the most common mistakes programming students make. Incorrect matching of brackets, improperly formatted code, misspelled functions, misplaced punctuation, etc. can all lead to a program crashing.

Compilers/Interpreters (depending on the programming language) provide error messages which infer the location and nature of the problem. Students should not guess and change code, but instead should understand the error message.

Understanding syntax, semantics, data types, parameters, arrays, objects, classes, and methods (among others) help answer why the code does not work.

Incremental practice with the various programming concepts will greatly decrease a student’s frustration with syntax errors.

3. Writing Poorly Structured Code

One of the most common mistakes made with programming assignments is development of code that does not have a clear structure.

For example, to solve a complex problem, some students will place hundreds of lines of code to solve the problem in a single function. This solution may work, but adds various challenges to the code such as maintenance and testing of the code.

An alternative approach would be to break down a complex solution into smaller responsibilities and separating the solution into different functions, classes, etc.

Using the following tips during development is helpful for making code readable and reducing time needed to perform code maintenance and future code changes: expressive variable names, correct indentation, meaningful comments, and good practice code-formatting.

Coding Errors That Affect Program Output

Not every programming error stops code from running. Many student programmer errors occur when code runs, but with incorrect results.

4. Confusing Logical and Syntax Errors

A syntax error is a mistake writing code in a programming language. A logical error, however, occurs when the code produces the wrong answer, and the program can run as expected.

Consider a loop which executes too many times, a conditional statement using the wrong operator, or a function returning a wrong value.

Some programming errors can take time to identify and debug.

One technique is to debug in an IDE step by step and view the variables to determine where the logic breaks. Examine the actual output of the program in comparison to the expected output to determine the break in logic.

Students have found that algorithmic thinking helps them isolate and identify gaps in logic much faster.

5. Forgetting About Runtime Errors

Runtime errors happen during program execution. They can happen when a program runs with incorrect input, tries to use an invalid array position, divides by zero, or tries to use a non-existing file.

Errors which cause an entire programming assignment to fail can be prevented by effective error handling.

Data input should be validated. Exception handling should be used when unexpected situations occur.

A large part of software development is understanding how a program should behave, even when the input is not ideal.

6. Testing Only One Scenario

Insufficient testing is another common programming assignment error to avoid.

Just because a program produces the correct answer once, it does not mean it will produce correct answers in all cases. In many cases, assignment mistakes are hidden waiting to be found. Test cases should consider usual, unusual, extreme, irrelevant values, empty, and edge case values. This can be made easier with a unit testing framework. Test-driven development (TDD) is also a good practice to explain the functionality of a program and to ensure the development of a unit.

Logic mistakes, coding assignment mistakes, runtime mistakes, and mistakes that produce surprises in the software are some of the mistakes that good quality software testing is designed to find.

The quality of programming assignments can be negatively decreased with different coding practices.

Coding Practices That Reduce Assignment Quality

Technically correct solutions can still become faulty if these solutions are mysterious with complicated logic and unclear names, functions, and classes with poor documentation.

7. Using Unclear Names

Names should be made clear for functions, variables, and classes to indicate their meaning and purpose. Names should be made clear for input and output parameters.

Documenting complex logic and making interesting trade off decisions should be done with simple, natural comments and should avoid obvious commenting.

Most of the computer programming mistakes are caused by students who take code they do not understand, whether it be from the internet in general, from forums, classmates, or from generated examples and insert it into their programming assignments.

8. Copying Code Without Understanding It

This external code can negatively impact the programming assignment with the unrelated algorithms, poor code security, unnecessary functions that are irrelevant to the purpose or goals of the assignment, and poor programming practices.

Students should have a clear understanding of the code they are submitting for their programming assignments.

If you don't understand how or why you are using a function, loop, method, algorithm, or data structure in your code, don't include it in your submission. It improves your programming skills and promotes academic integrity.

9. Choosing the Wrong Algorithm or Data Structure

Many beginner programmers choose inappropriate solutions to a problem because they are fast but inefficient.

A key factor in ensuring the best, most efficient, and effective solution is an appropriate analysis of the problem before choosing an algorithm and data structure.

Many Code problems have numerous solutions, including inefficient and over complex solutions. Avoid prematurely optimizing your code, especially if your solution is not understandable. Optimize only when efficiency is critical to the task.

How to Avoid Programming Assignment Errors

Such an organized workflow helps one to avoid the usual mistakes made in programming assignments.

Plan Before Coding

From the outset, you have to understand the requirements of the task. Analyze the task and envision how each part of the program will merge with the rest. Plan extensively and break the task down into smaller sub-tasks.

With a clear plan in mind, use pseudocodes and other planned routines to drive your program in the absence of the real instructions.

Debug While You Develop

You mustn't wait for programs to be complete before you begin to correct errors in the program. With a schedule of continuous programming and development, analyze errors with the debugger as they appear. Program with a step mode and use the debugging tools in your IDE to inspect the values of each variable at execution time.

Errors become difficult to find and correct when programming is done in massive bursts.

Use Version Control

A version control system, such as Git, helps students to track the changes made to their program.

With a version control system, development history becomes a useful source for finding the introduction of programming errors.

Programming with Git teaches students how to work effectively and efficiently with higher order programming jobs.

Review and Refactor

The main purpose of refactoring is to improve the logic and structure of the code without altering the functionality.

This involves extra variables, oversized functions, complicated control flow, functions and variables with unclear names, long functions.

Code refactoring also leads to improvement in readability and organizational structure and the overall maintenance of the code.

Programming Assignment Checklist Before Submission

Before submitting your programming assignment, be sure to review your program.

Be sure to verify that your program fulfills each requirement for the assignment and outputs the expected result. Run different types of testing, including edge case tests. Make sure that there are no errors that you have not resolved and that there are no unresolved compilation errors, syntax errors, logical errors, or errors which appear during the execution of the program.

Check the indentation and test the self-documentation and comments. Check the names of all variables, functions, classes, and methods. Check the error handling and the input validation.

Review the university's standards for coding, the requirements for submitted files, the rules of academic integrity, instructions for referencing, and the criteria for assessment.

Finally, be sure to test the version of the program that you submitted instead of assuming that the last changes that you made were correct.

Final Thoughts

Lastly, it is good to reflect on the process of programming. There are many things that characterize good programming. This reflects more than just coding. Programming can also be learned from viewing sample answers to programming assignments.