DEV Community: Souvik Kundu

Do Not Memorize C Keywords. There Is A Smart Way To Learn Them.

Souvik Kundu — Tue, 21 Oct 2025 14:24:02 +0000

If you’re learning C programming, you’ve probably seen the giant list of reserved keywords, words you can’t use as variable names because they’re already part of the language.
And if you’ve ever tried to memorize them all, you know how painful, and pointless it feels.

Don’t Memorize, Understand and Group
You don’t need to memorize keywords like a dictionary.
Instead, your brain learns better when you group and understand them in context. C keywords fall naturally into categories, and once you see the pattern, you’ll remember them automatically.

1. Data Type Keywords
Used to define what kind of data a variable holds.
Examples: int, float, double, char, short, long, void, signed, unsigned
Think: “I define what kind of box I’m using before I put something in it.”

2. Storage Class Keywords
They control where and how long a variable exists in memory.
Examples: auto, static, extern, register
Think: “Where does my box live, and when does it disappear?”

3. Type Qualifiers & Modifiers
They modify how variables behave or are accessed.
Examples: const, volatile, restrict, inline
Think: “Add rules to how my box can be used, read-only, change anytime, etc.”

4. Control Flow Keywords
These decide what happens next in your program.
Examples: if, else, switch, case, default, for, while, do, break, continue, goto, return
Think: “These are my decision-makers and loop controllers.”

5. Data Structuring Keywords
Used to build complex, custom data types.
Examples: struct, union, enum, typedef
Think: “Blueprints for building your own data structures.”

6. Modern & Advanced Keywords (C99, C11)
These are advanced tools for multithreading, atomic operations, generics, etc.
Examples: _Bool, _Complex, _Imaginary, _Atomic, _Generic, _Static_assert, _Thread_local, _Alignas, _Alignof, _Noreturn
Think: “Power tools, not for beginners, but good to know they exist.”

Learn by Usage, Not by List
When you learn loops, work with data types, and write functions, each keyword becomes memorable when you use it.

C Programming: A Short and Simple Guide To break, continue, and switch

Souvik Kundu — Thu, 31 Oct 2024 13:02:59 +0000

This quick and simple post delves into more advanced control flow mechanisms in C, providing programmers with the tools to write more efficient and readable code.

break and continue

These keywords allow us to manipulate loop execution.

break: Terminates the loop entirely.

for (int i = 0; i < 10; i++) {
  if (i == 5) {
    break; 
  }
  printf("%d ", i);
}
// Output: 0 1 2 3 4

continue: Skips the current iteration and proceeds to the next.

for (int i = 0; i < 5; i++) {
  if (i == 2) {
    continue; 
  }
  printf("%d ", i);
}
// Output: 0 1 3 4

switch: A cleaner alternative to multiple if-else statements when dealing with a single variable.

int day = 3;
switch (day) {
  case 1:
    printf("Monday\n");
    break;
  case 2:
    printf("Tuesday\n");
    break;
  case 3:
    printf("Wednesday\n");
    break;
  default:
    printf("Other day\n");
}
// Output: Wednesday

break statements are crucial in switch blocks to prevent fall-through behavior.

Conditional Operator (?:)
A concise way to express simple conditional logic.

int a = 10, b = 20;
int max = (a > b) ? a : b; // max will be 20

This is equivalent to:

int a = 10, b = 20;
int max;
if (a > b) {
  max = a;
} else {
  max = b;
}

The conditional operator (?:) enhances code readability when used appropriately.

C programmers can write organized, efficient, and maintainable code by mastering control flow mechanisms. These constructs allow for flexible program execution.

Loops in C: A Simple Guide with Examples

Souvik Kundu — Thu, 31 Oct 2024 10:38:37 +0000

Loops are essential tools in programming that allow us to execute a block of code repeatedly. They can perform a variety of tasks, from simple calculations to complex data processing.

In C programming, we have three main types of loops: for, while, and do-while. Let's explore each of them with examples.

The for Loop

The for loop is the default choice when we know exactly how many times we want to repeat a block of code. It's like setting a timer for our code to run a specific number of times.

// syntax

for (initialization; condition; increment/decrement) {
  // Code to be executed in each iteration
}

// example

#include <stdio.h>

int main() {
  for (int i = 1; i <= 5; i++) {
    printf("%d ", i);
  }
  printf("\n"); // Output: 1 2 3 4 5
  return 0;
}

In this example, the for loop prints the numbers from 1 to 5 . The initialization ( int i = 1; ) sets the starting value of the counter variable i . The condition ( i <= 5; ) specifies that the loop should continue as long as i is less than or equal to 5 . The increment ( i++ ) increases the value of i by 1 after each iteration.

The while Loop

The while loop is like a conditional loop. It keeps spinning (executing the code block) as long as the condition remains true.

// syntax
while (condition) {
  // Code to be executed repeatedly
}

// example
#include <stdio.h>

int main() {
  int i = 1;
  while (i <= 5) {
    printf("%d ", i);
    i++;
  }
  printf("\n"); // Output: 1 2 3 4 5
  return 0;
}

This while loop achieves the same result as the for loop above. It prints the numbers from 1 to 5 , but the counter variable i is initialized and incremented outside the loop structure.

The do-while Loop

The do-while loop insists on executing the code block at least once, even if the condition is initially false.

// syntax
do {
  // Code to be executed repeatedly
} while (condition);

// example
#include <stdio.h>

int main() {
  int i = 6; // Notice i is initialized to 6
  do {
    printf("%d ", i);
    i++;
  } while (i <= 5);
  printf("\n"); // Output: 6
  return 0;
}

Even though the condition i <= 5 is false from the start, the do-while loop still executes the code block once, printing the value of i (which is 6).

Applications of Loops

Loops are incredibly versatile and have a wide range of applications in programming:

Repeating tasks: Automating repetitive actions like printing a series of numbers, processing data in an array, or reading input from the user until a specific condition is met.
Iterating through data structures: Accessing and manipulating elements in arrays, lists, or other data structures.
Implementing algorithms: Loops are fundamental building blocks in many algorithms, such as sorting, searching, and graph traversal.
Creating simulations and games: Simulating real-world scenarios or creating game logic that involves repetitive actions or events.

Lastly, since loops are fundamental in programming, understanding them in C will prepare you to learn other languages like Python, JavaScript, and Java.

Float vs. Double in Java: Choosing the Right Tool for the Job

Souvik Kundu — Thu, 31 Oct 2024 08:46:34 +0000

When working with decimal numbers in Java, you have two main options: float and double. While both represent floating-point values, they differ in precision, memory usage, and ideal use cases.

The Differences

Precision: Float offers approximately 7 decimal digits of precision, while double provides around 15 decimal digits.
Memory Usage: Float takes up 4 bytes of memory, while double occupies 8 bytes.
Speed: Float calculations are slightly faster than double, but this difference is often negligible on modern hardware.
Range of Values: Double can represent a much wider range of values than float.

When to Use float

Choose float when:

Memory is a Concern: If you're dealing with a large amount of floating-point data (e.g., in scientific simulations or 3D graphics), using float can save significant memory.
Precision Isn't Critical: When you don't need extreme accuracy, float is often sufficient. Use it for representing pixel coordinates in graphics, approximate measurements in simulations, or temperatures where minor rounding errors are acceptable.

Example of float

float temperatureCelsius = 25.5f;  
float gravityMetersPerSecondSquared = 9.8f;

When to Use double

Choose double when:

Precision Matters: For calculations where accuracy is paramount, double is the way to go. It's suitable for financial calculations, scientific simulations requiring high precision, and any situation where rounding errors can lead to significant problems.
Large Range of Values: If you need to represent extremely large or small numbers, double offers a wider range than float.

Example of double

double pi = 3.14159265358979323846;  
double avogadrosNumber = 6.02214076e23;

Rule of Thumb

If you're unsure, err on the side of using double. Its increased precision and range will often be more beneficial than the slight memory savings offered by float.

Key Takeaway:
The choice between float and double boils down to balancing precision and memory usage. By understanding their strengths and weaknesses, you can make informed decisions for your specific applications.