What Are Comments In Programming – Complete Guide

Welcome to our comprehensive guide on one of the foundational best practices of programming: using comments in your code. Regardless of your familiarity with programming, understanding and leveraging comments is essential for success. Both new learners eager to grasp the basics of coding and seasoned developers looking to refine their skills will find this tutorial helpful. Comments may seem trivial, but they play a crucial role in writing clear, maintainable, and collaborative code. Let’s dive into the world of comments and discover why they should be an integral part of your programming toolset.

What Are Comments In Programming?

Comments in programming are annotations in the source code that are not executed by the compiler or interpreter. They are written and included by programmers to describe the functionality, purpose, or intricate logic of the code. Comments act as guideposts for anyone who reads the code, including the original author, especially when revisiting the code after some time.

What Are Comments Used For?

Comments serve various functions:

  • **Clarifying code**: They explain complex algorithms or coding logic.
  • **Marking sections**: Using comments to outline different sections or functionalities of the code.
  • **Debugging**: Temporarily disabling parts of code without deleting them.
  • **Providing metadata**: Such as the title of the program, author name, creation date, and more.

Why Should I Learn To Use Comments?

The practice of commenting is key for several reasons:

  • **Maintainability**: Comments help keep code readable for future maintenance and updates.
  • **Teamwork**: They facilitate collaboration among team members who work on the same codebase.
  • **Learning**: For beginners, dissecting commented code offers a path towards understanding programming concepts.
  • **Best Practices**: Seasoned developers often view thorough commenting as an indicator of professional and thoughtful coding.

Now that we’ve set the stage let’s dive into the intricacies of how to use comments effectively in your code.

CTA Small Image

Inline and Block Comments

There are two primary types of comments that you can use in programming: inline and block comments. Inline comments are single-line comments that explain a specific line of code, while block comments cover multiple lines, often explaining a section or method.

Single-Line Comments

Let’s begin with single-line, or inline, comments which are usually denoted by two forward slashes //. They’re ideal for brief notes right next to a line of code.

// Calculate the sum of two numbers
int sum = num1 + num2;
int total = a + b; // Add variables a and b

Notice how the comment can be placed before the code line or at the end of it, depending on what makes it clearer in the context.

Multi-Line Comments

Now let’s explore block or multi-line comments. These are surrounded by /* and */ and can span several lines. They are often used to explain more complex code or to temporarily disable large blocks of code during debugging.

/* The following code block calculates the factorial
of a given number and prints the result. It uses a 
for loop to achieve the calculation. */
int factorial = 1;
for (int i = 1; i <= number; i++) {
    factorial *= i;
System.out.println("Factorial: " + factorial);

You can also use block comments to comment out code that you don’t want to execute without deleting it:

int temporary = 10;

With these basics, you can start adding useful notes to your code, making it much more understandable for anyone who might use it, including yourself in the future!

Using Comments Effectively

While knowing how to create comments is great, understanding how to use them effectively is just as essential. When writing comments, aim to provide context or explain the why behind the code, not just what the code is doing. The code tells you ‘what,’ and the comments should tell you ‘why’.

// Bad comment: Increment x

// Good comment: Increment x to track the number of iterations

Also, avoid stating the obvious. Comments should provide additional insight, not just reiterate what is already evident in the code.

// Unnecessary comment: Assign 5 to number
int number = 5;

// Better use of comments: Initialize number with the default value
int number = 5;

Remember that comments are there to help, not to clutter the code. Use them wisely, and they will be an invaluable asset in your programming toolkit.

It’s time to look at more nuanced ways in which comments can improve the readability and functionality of your code. Through a variety of examples, we’ll highlight the art of commenting effectively.

One important aspect of commenting is to highlight todo’s or areas requiring future work. This helps developers quickly identify parts that need attention, without searching through the entire codebase.

// TODO: Implement caching for better performance
function fetchData() {
    // code to fetch data from an API

Documenting known issues or bugs within comments can save time for anyone reviewing the code and helps to track the status of these issues directly within the source:

// FIXME: Fix the calculation when number is zero
int inverse(int number) {
    return 1 / number;

Explaining complex algorithms with comments can also be very beneficial. It allows other developers (or yourself in the future) to understand the reasoning behind specific decisions:

/* Using Dijkstra's algorithm to find the shortest path 
between two nodes in a graph. The paths and their weights
are stored in a map for O(1) lookups. */
Map shortestPaths = new HashMap();
// ...

Regulatory or compliance-related comments are crucial when coding for industries with strict guidelines. You might document the reasons for data handling procedures or the implementation of security features.

// GDPR Compliance: Only collect minimal data necessary for user profiles
class User {
    private String name;
    // other necessary fields

When working with tricky bits of code that could easily be misunderstood or misused, a cautionary comment can prevent future errors:

// CAUTION: This function alters the input array. Clone the array before using if original must be preserved.
function sortInPlace(array) {
    // sorting logic

Lastly, it’s important to keep your comments up to date. Outdated comments can be worse than no comments at all, as they can misguide the reader. Make sure that changes in code are reflected in the comments:

// Incorrect comment: the following line no longer adds 5, it was updated to add 10
// Add 5 to counter to avoid zero-index
counter += 10;

Proper comments can turn good code into great code, providing clarity and understanding where it’s needed most. Comment smartly, and your code will communicate as effectively as it functions.

As with all practices, the key is balance and relevance. Commenting on every single line is overkill and can be as unhelpful as having no comments at all. Use your judgement to guide when and where to add commentary, and your code will be more maintainable and accessible because of it.

We hope these examples help you see the potential of comments for improving the legibility and usability of your code. Smart use of comments is an essential skill for developers and is highly regarded in professional programming environments. Happy commenting!

Understanding the importance of comments and their effective use with examples is key in solidifying your coding practice. Now, let’s proceed with more code examples to reinforce what you’ve learned.

Consider a function that performs a calculation. The use of a descriptive comment explaining the function’s purpose can be crucial, often more helpful than naming conventions alone:

// Calculates the monthly payment based on the loan amount, term, and annual interest rate
function calculateMonthlyPayment(loanAmount, term, annualInterestRate) {
    // Mortgage calculation logic

When variables have constraints that are not immediately obvious, a comment can provide context and prevent misuse:

// radius must be non-negative
double radius = 5.0;

In team projects, it can be useful to include comments that give a hint about how to extend a section of the code without breaking existing functionality:

// To support more file types, add new cases to the switch statement
switch(fileExtension) {
    case 'txt':
        // process text file
    case 'csv':
        // process CSV file
    // case 'pdf': // Future implementation

When writing comments for loops, it’s important to not just describe what the loop does, but also its significance regarding the overall logic:

// Iterates over user data to find the user with the highest score
for (let user of users) {
    if (user.score > highestScore) {
        highestScore = user.score;
        highestScorer = user;

Perhaps your code includes a workaround or temporary fix for an issue. It’s essential to document these instances for context and future reference:

// Workaround for iOS Safari viewport bug in version 12.1
// Remove once upgrading to version 12.2 or higher is safe
if (navigator.userAgent.includes('AppleWebKit') && navigator.maxTouchPoints > 1) {
    // Specific fix logic

If you’re writing a complex regex, explaining it with comments can save others (and yourself) from a brain-ache later on:

// Matches ISO 8601 date format (yyyy-mm-dd)
const regex = /(\d{4})-(\d{2})-(\d{2})/;

Lastly, some comments can direct other developers to use the correct methodology or approach within a context, especially when a piece of code might suggest a tempting shortcut that should be avoided:

// Do not modify the state directly; use setState() to ensure the UI updates correctly
this.setState({ isLoading: true });

By examining these diverse examples, you can see how comments can serve not just as code descriptors, but as comprehensive guides for further development, maintenance, and collaboration efforts. Effective commenting practices contribute significantly to the long-term health and clarity of your projects, enabling both individual developers and teams to work more efficiently.

Apply these commenting strategies, and witness your coding quality steadily improve. Remember, a well-commented code is a sign of a considerate and deliberate programmer. Keep practicing, keep learning, and don’t forget to value the simple power of a well-placed comment!

Continue Your Coding Journey with Zenva

Mastering programming concepts such as commenting is just the beginning of your journey. If you’re looking to further expand your skill set, the Python Mini-Degree is an excellent next step. This comprehensive series of courses will guide you through not only the basics but also more advanced aspects of Python programming, from algorithms to game and app development. Whether you’re starting out or aiming to refine your skills, our Mini-Degree is designed to cater to all levels of experience.

For those who wish to explore a broader range of programming topics, our diverse array of Programming courses awaits you. Immerse yourself in a learning experience that can take you from novice to pro, with the flexibility of studying on your schedule and the satisfaction of building a robust portfolio of projects. Equip yourself with in-demand skills and earn certificates through our project-based approach.

Your journey doesn’t have to stop here. With over 250 courses, we at Zenva strive to offer content that empowers your ambitions, boosts your career, and turns your dreams into reality. So delve into our Python Mini-Degree or venture into our other programming courses and watch your proficiency and opportunities grow.


Incorporating comments into your programming routine is not just about making your code understandable; it’s about crafting a legacy that withstands the test of time and collaboration. As you continue applying the principles of effective commenting discussed in this tutorial, complement your learning with Zenva’s Python Mini-Degree to further solidify your coding techniques. With each step forward, you ensure that the code you write today remains clear and functional for the developers of tomorrow.

At Zenva, we believe that continuous learning is the key to success in the tech world. We’re committed to providing you with top-tier education that propels you into the future of development. Whether you aim to create the next hit game, build cutting-edge apps, or automate complex systems, embarking on this journey with us means choosing a path of endless possibilities. Sharpen your skills, embrace the discipline of commenting, and let’s code a brighter future together!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.