DEV Community: Bhargab B

The Frontend UI Library Landscape Explained for Developers

Bhargab B — Tue, 09 Jun 2026 11:42:39 +0000

The frontend ecosystem has evolved far beyond writing plain CSS files. Today, developers can choose from a variety of UI libraries and frameworks, each solving different problems.

If you're new to frontend development or wondering why there are so many UI libraries, here's a simple breakdown.

Raw CSS: The Original Approach

Raw CSS is where everything starts.

It gives you:

Complete control over styling
Unlimited customization
A deeper understanding of how the web works

The downside? As projects grow, managing CSS can become messy and difficult. That's why most production applications use some form of abstraction on top of CSS.

Tailwind CSS: CSS, But Better

Tailwind doesn't give you components—it gives you utility classes that make styling faster and more maintainable.

<button class="bg-blue-500 text-white px-4 py-2 rounded">
  Click Me
</button>

You're still working with native HTML elements, but without constantly jumping between CSS files.

Why Developers Like Tailwind

Uses native HTML elements
Keeps styles close to components
Highly customizable
Doesn't impose a design system

Think of Tailwind as an unopinionated layer on top of CSS.

Material UI (MUI): Pre-Built Components

MUI takes the opposite approach.

Instead of styling everything yourself, it provides ready-made React components:

<Button variant="contained">
  Submit
</Button>

This speeds up development significantly, but customization can sometimes feel restrictive.

Pros

Fast development
Consistent UI
Large component ecosystem
Accessibility built in

Cons

Highly opinionated
Custom designs may require additional styling solutions like Emotion

Think of MUI as a highly opinionated UI framework that prioritizes productivity.

Radix UI: Logic Without Design

Some UI components are difficult to build correctly.

Examples include:

Modals
Dropdowns
Tooltips
Accordions

These components require:

Accessibility support
Keyboard navigation
Focus management
Complex interaction logic

Radix handles all of that for you while leaving the styling completely up to you.

What Makes Radix Different?

No built-in styling
Accessibility-first
Focuses only on component behavior

Radix handles the functionality, not the appearance.

Chakra UI: The Middle Ground

Chakra UI sits somewhere between Tailwind and MUI.

It provides:

Pre-built components
Accessibility by default
Easier customization than MUI

If MUI feels too restrictive and Tailwind feels too low-level, Chakra often strikes a nice balance.

Think of Chakra as a flexible component library with sensible defaults.

Bootstrap: The OG Framework

Before Tailwind became popular, Bootstrap dominated frontend development.

It made building responsive websites much easier through:

Components
Grid systems
Utility classes

Why Bootstrap Was So Popular

Developers could quickly create polished interfaces without writing much CSS.

Why It's Less Common Today

Modern applications often require more customization, while Bootstrap tends to produce similar-looking UIs out of the box.

Still, it's a solid choice for:

Prototypes
Internal tools
Legacy applications

Shadcn: The Modern Approach

Shadcn has quickly become one of the most popular choices in the React ecosystem.

What's interesting is that it's not really a component library.

Instead, it combines:

Radix UI for behavior
Tailwind CSS for styling

And copies the component source code directly into your project.

Why Developers Love Shadcn

Full ownership of component code
No vendor lock-in
Easy customization
Production-ready patterns

A simple way to think about it:

Shadcn = Radix + Tailwind + Full Ownership

Quick Comparison

Library	What It Solves
Raw CSS	Complete control
Tailwind	Cleaner CSS workflow
MUI	Fast development with pre-built components
Radix	Accessible component logic
Chakra UI	Flexible pre-built components
Bootstrap	Rapid UI development
Shadcn	Modern, customizable component system

Final Thoughts

The biggest mistake developers make is comparing all UI libraries as if they solve the same problem.

Each tool serves a different purpose:

Tailwind helps you write CSS more efficiently.
MUI and Chakra UI provide pre-built components.
Radix UI provides accessibility and interaction logic.
Bootstrap offers a complete UI framework.
Shadcn combines Radix and Tailwind into a modern development experience.

Once you understand the problem each library solves, choosing the right one becomes much easier.

What is Execution Context In JavaScript?

Bhargab B — Sat, 08 Jun 2024 08:02:38 +0000

JavaScript Execution Context - Internal Working of JS

In Simple Terms

In simple terms when you run a JavaScript program, the whole program runs inside a container or box, and remember this:

"Everything in JavaScript happens inside an Execution Content"

Look at the diagram again! Yes, execution context in javascript has two components: memory; and code component.

Let's understand both components and then we can at last we will combine all these pieces and we will be able to understand JavaScript Execution Context.

Memory Component
This is the section where all the variables and functions we declare in our program are stored. These variables are stored as key-value pairs i.e., key: value. This memory component is also known as the variable environment

Code Component
This is the section where the codes are executed line by line (one line at a time). There is a fancy name for it Thread of Execution

Phases of the JavaScript Execution Context

When you execute a JS code, it goes through 2 phases in order:

These are not official terminology, I am using them to make you understand Execution Context In JavaScript.

Scanning Phase: In this phase, the JS engine creates the container that we discussed earlier (Execution Context). It allocates memory for the variables and functions in the memory component. The variables are assigned the value of undefined and the functions are directly copied from the code to the memory component.
Execution phase: In this phase, the magic happens and the JS engine executes the code one line at a time. You remember in the scanning phase it assigns the value of undefined to the variables, and in the execution phase the undefined is replaced with the value that is declared in our code.

Let's understand with the help of a simple program:

 let a = 10;

 function addOne(num) {
   return num + 1;
}

In the scanning phase:

In the execution phase:
That undefined is replaced with the actual value, which we assign in our code 10.

This as a whole is known as the Execution Context In JavaScript.
I hope you understand it clearly, but if not then below is a real-life example that will help you understand it even more!

JavaScript Execution Context With Real Life Example

Imagine You're at a Restaurant

Think of JS as a restaurant, where different chefs (functions) are preparing meals (executing code).

The Execution Context is like the kitchen workspace that each chef uses to prepare their meal.

When the restaurant opens, the head chef (JavaScript engine) sets up the Global Execution Context. This is the main kitchen workspace where everything starts.

Ingredients (variables and functions) that are available to all chefs.
Utensils (methods and objects) that everyone can use.
Recipes (global functions) that any chef can follow.

function makeSalad(ingredient) {
  var dressing = "Olive Oil";
  console.log("Using ingredient: " + ingredient + " with " + dressing);
}
makeSalad("Lettuce");

When the function makeSalad("Lettuce") is called, the following happens:

Creation
- The workspace (Execution Context) is set up.
- Local ingredients (variables and functions) are declared.
- ingredient is set to "Lettuce".
- dressing is declared but not yet defined.
Execution Phase:
- Local ingredients are assigned values.
- The function's code runs using these local items.

Conclusion

Execution Context (EC) is created by js engine whenever a code is run
EC contains two phases: creation, and execution phase
When a variable is declared or a function is created, and completely new EC is created inside the global EC.
The EC is the chef's workspace.
The Global Execution Context is the main kitchen setup.
Each Function Execution Context is a new chef's workspace, created and stacked as needed.

Pseudocode: Everything you need to know

Bhargab B — Sun, 02 Jun 2024 10:00:33 +0000

The Ultimate Pseudocode Guide | How to use it effectively

Before understanding how to use pseudocode, you must understand what it is and its importance. Let's get right onto it.

Introduction

Pseudocode is a way of describing how a computer program should work using a human-readable language, generally English. In other words, it's a simplified version of programming code written in plain English before implementing it in a specific programming language. Think of it as a bridge between how humans think and how computers operate.

Pseudocode can also be referred to as a syntactical representation of a program and lacks strict syntax since it only represents the programmer's thinking process.

Importance of Pseudcode

Here are the points why pseudocode is important

Language Agnostic: Pseudocode helps programmers understand and write code because it is language agnostic and allows them to focus on solving the problem at hand without getting bogged down in the exact syntax of a programming language.
Visualization: It also enables visualization of the entire solution to an algorithmic problem and helps break down large problems into smaller, manageable pieces.
Simplicity: It uses simple, everyday words and phrases, avoiding the complex syntax and strict rules of programming languages.

How to use pseudocode effectively?

Here is the step-by-step guide for using pseudocode effectively:

Understand the Problem in Depth: Ensure you thoroughly understand the problem without worrying about edge cases initially.
Identify the Approach for Solving It: Plan your approach and outline the steps needed to solve the problem.
Start Writing: Focus on the logic rather than syntax. Write down the steps in plain English.
Use Consistent Formatting: Maintain a consistent format throughout your pseudocode. Avoid using technical jargon.
Iterate and Refine: Review your pseudocode, refine it, and check for potential bugs.

Examples

Example 1: Making a Cup of Tea

Imagine you want to write a program that makes a cup of tea. Here’s how you might write the pseudocode for that:

1. Boil water
2. Place a tea bag in a cup
3. Pour the boiling water into the cup
4. Let the tea steep for a few minutes
5. Remove the tea bag
6. Add sugar or milk if desired
7. Stir the tea
8. Serve the tea

Example 2: Finding the Largest Number in a List

Imagine you want to write a program that finds the largest number in a list of numbers. Here’s how you might write the pseudocode for that:

1. Start with an empty list of numbers
2. Initialize a variable 'largest' to be the first number in the list
3. For each number in the list:
    a. If the current number is greater than 'largest':
        i. Update 'largest' to be the current number
4. After checking all the numbers, 'largest' will hold the largest number in the list
5. Print or return 'largest'

Conclusion

Pseudocode is a valuable tool for programmers to understand, write, and solve coding problems. By following suggested guidelines for writing pseudocode and practicing regularly, programmers can develop a personalized style that makes sense to them and improves their overall programming skills.