DEV Community: Chandru

JavaScript `async` and `await`

Chandru — Wed, 16 Sep 2026 09:21:58 +0000

When working with APIs or other asynchronous operations in JavaScript, you'll often use async and await.

They make asynchronous code easier to read and understand.

`async`

The async keyword makes a function return a Promise.

async function getMessage() {
  return "Hello World";
}

Because it's an async function, the result is a Promise.

`await`

await waits for a Promise to finish before continuing.

async function getData() {
  const response = await fetch("https://api.example.com/users");
  const data = await response.json();

  console.log(data);
}

Instead of writing:

fetch(url)
  .then(response => response.json())
  .then(data => console.log(data));

we can use async/await, which is usually easier to read.

Error handling

Use try...catch to handle errors:

async function getData() {
  try {
    const response = await fetch(url);
    const data = await response.json();

    console.log(data);
  } catch (error) {
    console.error(error);
  }
}

Simple rule to remember

async → makes a function return a Promise
await → waits for a Promise
try/catch → handles errors

That's the basic idea behind async and await in JavaScript.

Callback Function in JavaScript

Chandru — Wed, 09 Sep 2026 05:59:33 +0000

A callback function is a function that is passed as an argument to another function and is called later when needed.

Here is a simple example:

function greet(name) {
  console.log("Hello " + name);
}

function processUser(callback) {
  callback("John");
}

processUser(greet);

Output:

Hello John

Here, greet is the callback function because we pass it to processUser().

The processUser() function then calls it using callback("John").

In simple words:

A callback is a function passed to another function to be executed later.

JavaScript Constructors and Arrays: What I Learned

Chandru — Tue, 08 Sep 2026 06:33:48 +0000

While learning JavaScript objects, I came across constructors and arrays.

Both sounded a little confusing at first, but after using them, they became much easier to understand.

Constructors

A constructor is useful when we want to create multiple objects with the same structure.

For example, if we want to create multiple users, we don't have to write the same object again and again.

function User(name, age) {
  this.name = name;
  this.age = age;
}

Now we can create users using new.

const user1 = new User("John", 22);

We can create more users using the same constructor.

In modern JavaScript, we can also use a class with a constructor:

class User {
  constructor(name) {
    this.name = name;
  }
}

The basic idea is simple: constructors help us create similar objects easily.

Arrays

Arrays are used when we want to store multiple values in one place.

const fruits = ["Apple", "Mango", "Orange"];

Array indexes start from 0, so fruits[0] gives us "Apple".

There are many array methods in JavaScript. Here are some basic ones I found useful.

length

length tells us how many items are in the array.

console.log(fruits.length);

toString()

It converts the array into a string.

console.log(fruits.toString());

at()

It returns an item at a particular position.

console.log(fruits.at(1));

join()

It joins the array elements using the separator we provide.

console.log(fruits.join(" - "));

push()

It adds an item to the end of the array.

fruits.push("Banana");

pop()

It removes the last item.

fruits.pop();

shift()

It removes the first item.

fruits.shift();

unshift()

It adds an item to the beginning.

fruits.unshift("Grapes");

concat()

It can be used to combine arrays.

let more = fruits.concat(["Kiwi"]);

slice()

It returns a part of an array without changing the original array.

let result = fruits.slice(0, 2);

splice()

It can be used to add, remove, or replace items in an array.

fruits.splice(1, 1);

flat()

It is useful when an array contains other arrays and we want to flatten them.

let nums = [1, [2, 3]];
console.log(nums.flat());

isArray()

It checks whether a value is actually an array.

console.log(Array.isArray(fruits));

There are many more array methods in JavaScript, but these are some good ones to start with.

The ones I use most often are probably push(), pop(), shift(), unshift(), slice(), splice(), and concat().

JavaScript Objects: What I Learned

Chandru — Sun, 06 Sep 2026 06:30:40 +0000

After learning strings and functions, the next topic I came across was objects.

An object is a way to keep related information together. Instead of creating separate variables for a person's name, age, and city, we can put them inside one object.

const person = {
  name: "John",
  age: 22
};

Here, name and age are called properties.

We can access a property using a dot.

console.log(person.name);

We can also change the value later.

person.age = 23;

Objects can contain different types of data too. We can have strings, numbers, arrays, and even functions inside an object.

When a function is inside an object, we usually call it a method.

const person = {
  greet() {
    console.log("Hello!");
  }
};

Then we can call it using person.greet().

Objects are used a lot in JavaScript. You'll see them when working with users, products, API responses, settings, and many other things.

The main thing I learned is that objects are a simple way to organize related data in one place.

At first, objects can feel a little confusing, but after using them in a few examples, they start to feel much more natural.

JavaScript Strings: The Basics I Learned

Chandru — Fri, 04 Sep 2026 09:04:14 +0000

Strings are one of the first things we use when learning JavaScript.

Simply put, a string is just text.

There are three common ways to create strings in JavaScript.

1. Single Quotes

We can use single quotes to create a string.

let name = 'John';

2. Double Quotes

We can also use double quotes.

let name = "John";

Both single and double quotes work in a similar way. It's mostly a matter of which style you prefer or what the project uses.

3. Template Literals

Template literals use backticks instead of quotes.

let message = `Hello ${name}`;

I find template literals especially useful when we need to include variables inside a string.

For example, instead of joining strings with +, we can directly put the variable inside ${}.

Some Useful String Methods

JavaScript has many built-in methods for working with strings.

We can change text to uppercase:

let text = "hello";
text.toUpperCase();

Or lowercase:

text.toLowerCase();

We can also check how many characters are in a string:

text.length;

Another useful one is includes(), which checks whether a string contains some text.

text.includes("he");

Final Thoughts

Strings may seem very basic, but we use them everywhere in JavaScript — names, messages, search boxes, URLs, API data, and much more.

The main thing to remember is:

Single quotes → 'Hello'

Double quotes → "Hello"

Template literals → `Hello ${name}`

Types of Functions in JavaScript

Chandru — Thu, 03 Sep 2026 06:25:14 +0000

After learning what functions are in JavaScript, I came across different ways of writing them.

At first, I thought they were all completely different. But after trying them out, I realized the main difference is just how we write and use them.

Function Declaration

This is the normal way of creating a function.

function greet() {
  console.log("Hello!");
}

Then we can call it whenever we need it.

greet();

This is probably the easiest one to understand when you're starting out.

Function Expression

Here, we assign a function to a variable.

const greet = function() {
  console.log("Hello!");
};

It works like a normal function, but the function is stored inside the variable.

Arrow Function

Arrow functions are a shorter way of writing functions.

const greet = () => {
  console.log("Hello!");
};

You'll see these a lot in modern JavaScript, especially when working with arrays and frameworks.

Anonymous Function

An anonymous function is simply a function that doesn't have a name.

For example:

setTimeout(function() {
  console.log("Hello!");
}, 1000);

Here, the function is passed directly to setTimeout, so we don't need to give it a name.

IIFE

IIFE stands for Immediately Invoked Function Expression.

The name sounds complicated, but the idea is simple. The function runs immediately after it is created.

(function() {
  console.log("Hello!");
})();

You may not use IIFE very often in modern JavaScript, but it's still good to know what it means when you see it in existing code.

What I take from this

There are several ways to write functions, but I don't think you need to memorize all of them at once.

Start with function declarations and arrow functions. Once you're comfortable with those, the other types will be much easier to understand.

The more JavaScript you write, the more naturally you'll know which one to use.

JavaScript Functions: A Simple Explanation

Chandru — Wed, 02 Sep 2026 05:34:39 +0000

While learning JavaScript, one topic that I found really important was functions.

A function is basically a block of code that we can write once and use whenever we need it.

For example:

function greet() {
console.log("Hello!");
}

We can run the function by calling it:

greet();

Functions with Parameters

Sometimes we want to give some information to a function. That's where parameters come in.

function greet(name) {
console.log("Hello " + name);
}

Now we can pass different names when calling the function.

Return

A function can also give a value back using return.

function add(a, b) {
return a + b;
}

We can then store the result in a variable and use it wherever we need.

Why are functions useful?

Without functions, we might end up writing the same code again and again.

Functions help us:

Reuse code
Keep code organized
Avoid repetition
Make programs easier to understand

The main thing I learned is that functions are not just about writing code in a different format. They help us break a bigger problem into smaller, reusable pieces.

4 JavaScript Things I Learned Recently

Chandru — Tue, 01 Sep 2026 05:56:35 +0000

While learning JavaScript, I came across a few things that I had seen before but didn't fully understand: ternary, switch, break, and continue.

After trying them with small examples, they started making more sense.

Ternary

The ternary operator is basically a short way of writing if-else.

For example:

let result = age >= 18 ? "Adult" : "Minor";

It is useful when the condition is simple and you want to keep the code short.

Switch

Switch is useful when you need to check one value against different options.

For example, if we want to check the day:

switch (day) {
case "Monday": console.log("Start");
}

We can add more cases depending on what we need.

Break

Break is used when we want to stop a loop.

For example:

if (i === 5) break;

When the condition is true, the loop stops there.

Continue

Continue is different from break.

It skips the current iteration but allows the loop to keep running.

if (i === 5) continue;

So, the way I remember them is:

Ternary → shorter if-else

Switch → different cases

Break → stop

Continue → skip and move on

These are small things, but understanding them makes JavaScript a little easier to work with.

I'm still learning, but I've found that writing small examples is much better than just reading about the syntax.

JavaScript Conditions and Loops: A Simple Explanation

Chandru — Mon, 31 Aug 2026 05:29:52 +0000

When I started learning JavaScript, conditions and loops were two topics I came across pretty early.

They may look confusing at first, but the idea is actually simple.

Conditions are used when we want JavaScript to make a decision. For example, if a user is logged in, we can show their profile. If not, we can ask them to log in.

if (isLoggedIn) {
console.log("Welcome!");
}

We can also use else when there are two possible situations.

Loops are used when we want to repeat something without writing the same code again and again.

For example, if we want to print numbers from 1 to 5:

for (let i = 1; i <= 5; i++) {
console.log(i);
}

There are different types of loops in JavaScript, like for and while. Which one we use depends on what we are trying to do.

The main thing I learned is that conditions help us make decisions, while loops help us repeat tasks.

Once you understand these two concepts, writing JavaScript becomes a lot easier because you'll use them in many real projects.

Agile Methodology Explained: A Beginner’s Guide to Agile

Chandru — Tue, 11 Aug 2026 11:43:22 +0000

Agile Methodology Explained in Simple Words

When I first heard the term Agile methodology, I thought it was just another technical word I had to remember.

But after understanding it, I realized the basic idea is actually pretty simple.

Agile is a way of developing software where you build things step by step, take feedback, and make changes along the way.

So, how does it work?

Let's say a team is building a food delivery app.

Instead of developing the whole application and showing it to the customer after a few months, the team breaks the work into smaller parts.

For example:

First, they work on login and registration.
Then they work on restaurant search.
After that, they add the cart and payment.
Finally, they work on order tracking and other features.

The team keeps testing and getting feedback throughout the process.

This is useful because requirements can change. Maybe the customer wants a different feature or the team finds a problem. With Agile, it is easier to adjust things instead of changing the whole project at the end.

What is a Sprint?

A Sprint is simply a short period where the team focuses on a particular set of tasks.

For example, in a two-week Sprint, the team might decide to complete the login system.

At the end of the Sprint, the team checks what was completed, what went wrong, and what needs to be done next.

You might also hear terms like Backlog, Daily Stand-up, Sprint Review, and Retrospective when working with Agile teams.

You don't need to memorize all of them immediately. Once you see how an Agile team works, these terms start making more sense.

Agile and Scrum are not the same.

This confused me at first too.

Agile is the overall approach, while Scrum is one of the frameworks used to follow Agile principles.

Why do companies use Agile?

The main reason is flexibility.

Software projects rarely go exactly according to the original plan. Requirements change, bugs appear, and users give new feedback.

Agile makes it easier to deal with these changes because the team works in smaller cycles instead of waiting until the very end.

Final thoughts

You don't need to know every Agile term to understand Agile.

The main idea is:

Build → Test → Get feedback → Improve → Repeat

That's pretty much Agile at its core.

If you're just starting out in software development, learning the basics of Agile is useful because you'll probably come across it in real-world projects and job descriptions.