DEV Community: Himanshu Jangid, हिमांशु जाँगिड़

The programming passion is melting

Himanshu Jangid, हिमांशु जाँगिड़ — Thu, 19 Mar 2026 09:47:18 +0000

I have two important things to say:

I don't enjoy programming anymore

Every day, these AI agents get better and better. They are present in nearly every IDE and in all parts of the IDE. It all started with Copilot, which would only suggest a few lines when you left a comment.

I remember turning it off because I wanted to write some code myself, and it was getting in the way. A small part of code completion wouldn't have helped me at all. But things are changing now. It's not just finishing a line anymore; it's finishing a whole project with just a few prompts.

I adopted this technology because I thought I would stay behind in the community, and to some extent I was right, but I don't enjoy programming anymore. We used to get stuck on a problem for hours and then work hard for a long time to figure it out. That made us happy. We always spent a lot of time making games, game engines, and compilers because they were the noble things to do.

But now they're only a few prompts away. You have an idea, a PRD, and a few prompts. That's it. You don't have to write code anymore. And you don't have any fun anymore.

There don't seem to be any juniors or seniors anymore.

Life for software engineers was very different just two or three years ago. We had tools and learned how to use them well. One thing we learned took a lot of time, but it helped us grow as engineers. This is how the idea of Senior and Junior engineers came about.

It seems like new people don't have to spend a lot of time learning how to code. They can just write one prompt and get code like a pro. These AI models are getting better every day, and people who worked hard to improve their skills are being challenged by people who are just starting out. I think that people who spend more time improving their skills over the years are still better engineers and can make better software, even when using AI tools. But does that even matter now?

I know this post went in a negative direction, and I'd like to hear what you think. What do you think?

Thanks for taking the time to read.

Yield Keyword JavaScript - With Real life use-cases

Himanshu Jangid, हिमांशु जाँगिड़ — Wed, 18 Mar 2026 23:03:52 +0000

The yield keyword in JavaScript is primarily associated with generators, which are a special type of function that can be paused and resumed. Generators are useful for working with sequences of data, asynchronous programming, and creating iterators. Here are some real-life use cases and examples:

Lazy Evaluation and Infinite Sequences:

Generators allow for lazy evaluation, meaning they produce values on-demand rather than generating them all at once. This is particularly useful when working with infinite sequences.

function* infiniteSequence() {
  let i = 0;
  while (true) {
    yield i++;
  }
}

const sequence = infiniteSequence();
console.log(sequence.next().value); // 0
console.log(sequence.next().value); // 1

Asynchronous Programming:

Generators can be used with asynchronous code to simplify complex asynchronous flows. This is often seen in combination with promises.

function fetchData(url) {
  return fetch(url)
    .then(response => response.json())
    .then(data => data);
}

function* fetchDataGenerator() {
  const data1 = yield fetchData('https://api.example.com/data1');
  const data2 = yield fetchData('https://api.example.com/data2');
  console.log(data1, data2);
}

const generator = fetchDataGenerator();
const { value: result1 } = generator.next();

result1.then(data => {
  const { value: result2 } = generator.next(data);
  result2.then(data => generator.next(data));
});

Custom Iterators:

Generators can be used to create custom iterators, allowing you to define how a loop should iterate over a custom data structure.

const myObject = {
  *iterator() {
    yield 'a';
    yield 'b';
    yield 'c';
  }
};

for (const value of myObject.iterator()) {
console.log(value);
}

Recursive Algorithms:

Generators can be used to implement recursive algorithms with a more iterative style, avoiding maximum call stack size errors.

function* recursiveGenerator(n) {
  if (n > 0) {
    yield* recursiveGenerator(n - 1);
    yield n;
  }
}

for (const value of recursiveGenerator(5)) {
  console.log(value);
}

The yield keyword, in these examples, is essential for pausing the execution of the generator function and passing values in and out of the generator, enabling more readable and manageable asynchronous and iterative code.

Boost your productivity with TMUX

Himanshu Jangid, हिमांशु जाँगिड़ — Wed, 11 Mar 2026 19:53:47 +0000

Hello engineers,

What do you think I came up with today? Indeed, I have been following the 100 things principle to this day; I know what is good for me, and I am doing it.

Tmux

This is definitely what I learned today.

What? The answer to the question "What" is that it is a terminal multiplexer, which means that you can have the feel of multiple terminals in just one.

How? It's simple; we just need to install the cli tool. In my case because I am an Arch user

I use arch btw

I simply install it with the command pacman -S tmux.

Why? There is no doubt as to why I will use it in the future. It simply saves me a significant amount of time. That concludes it. I've recently started using Lunar Vim. Just another neovim configuration, which is, of course, a vim configuration using lua and vimscript.

Okay, back to the point. I just like what tmux is doing. There are only about 5-10 simple commands to learn. You will save at least half an hour per day, and more importantly, you will save yourself and your mind from being frustrated every time you go back and forth in the terminal with the mouse. Because even Ctrl + Tab does not work in my case, I had to come up with another solution.

Okay, let's get started. I am assuming you have already figured out how to install Tmux on your system, whether it is deb, rpm, or something else. (I use Arch, by the way).

Creating a session A session is simply a collection of terminal sessions. You can combine multiple terminals into a single session. To do this, use the following command: tmux new -s <session name>. You will be instantly sent to that session and will see a status bar. To exit the session, press Ctrl B, then d. This command will detach the session.
Creating a new window: To create a new window in a session, press Ctrl + B now. Press, then c. You will have a new Windows that is ready for use.
Close a window: by pressing x and then y, or n to cancel your decision.
Switching sessions: Press + s; you'll know what to do.
Switching windows: Press +w, you will see the list, and you can toggle from there.

Other commands

n to the next window + l to toggle the window (not sure about it)

I think that's all I have to say about T-mux; you can look up the rest on Google.

#Linux #TMux

By Himanshu Jangid

check out, LFC, my open-source contributors finding tool: https://lookingforcontributors.web.app/

The Hundred Things Principle

Himanshu Jangid, हिमांशु जाँगिड़ — Tue, 10 Mar 2026 10:13:34 +0000

Abstract

The aim of this document is to present the Hundred Things Principle. Humans accumulate and retain a lot of knowledge over the course of a lifetime. We are built by nature in such a way that our memory never runs out, at least it has not yet been confirmed in any research. The hundred things principle is based on the idea that what is the minimum number of things a new human being should learn each day to accomplish great achievement. This method has not yet been applied or experimented on any human being but now after this has been written, I hope some people will try it on themselves and share their feedback. All the facts and knowledge stated in this document do not have any scientific support and are only based on personal experiences. So, one should only take it as an opinion.

Related Definitions

Thing - A thing can be an object, task, knowledge, fact, field, discussion, technology or anything that adds up in our brain and fills brain storage. It may or may not consist of subparts. The subparts can be standalone things if they are big enough to fill some space in our brain otherwise they will be included in the parent thing itself and will not be treated as separate. A thing should not take more than 2 to 5 minutes to be learnt.

Himanshu Jangid

What should we count as a thing?

This is the most obvious question to be asked by a person who wants to adopt this principle as his/her daily routine. What should be counted as a thing and what should not be? Is it okay to count something as a thing and its subparts as different things? What should be the minimum criteria for something to be called a thing?

It has already been specified what should be counted as a thing in the definitions section in the first section of the document. We will focus on the minimum criteria of a thing to be a thing.

There are many cases that are raised during the specification of what should fit into the thing category. It depends on various criteria

Type of the thing
Size of the thing
Number of sub things
Relative knowledge

Based on type of thing A thing can be of various types

Fact
Topic
Subject
Video or Movie
Article
Observation
Podcast or Recorded session

Now these types can be directly associated with the possibility of a thing to be called a thing.

If it is a fact then it should be big enough to be recorded. One line facts should not be considered as a thing instead a group of many facts should be.

If it is a topic then it should be at least a paragraph big, and should contain meaningful data.

A subject can not be called a thing if it is too big; instead its subtopics can be individual things.

Videos and movies can be called a thing directly and you can break it into many things.

Articles are the best examples of what should be called a thing, they contain facts, data, knowledge and meaningful information. They have a good size and enough knowledge to fill some part of the brain.

Observation is something that we observe during our work or sometimes simply sit and look. An observation can be called a thing if you associate some additional knowledgeable information with it.

Podcasts and recorded sessions are also proper things and can be broken down into things.

Based on size of thing A thing should be not more than 2-5 minutes long to be learnt less than or more than it should not be considered as a standalone thing.

Based on number of sub things If a something is small and it has more than 2 sub things then it is a thing otherwise it is not. If something is big then it can be broken in subparts. And if something already has subparts and they are also big then they can be broken too.

Based on Relative knowledge If something is not big enough but something else is related to it then the combination of both of those can be considered as a thing.

What is not a thing?

Clearing up the misunderstanding

What we think a thing is

Though it is already clear from the above section “What should we count as a thing” that whatever that is not being counted as a thing is also not a thing. But it’s more complex than you think. We might say it when your father tells you something and it is big enough than it is also a thing. Or you can also say that you are in your school or college and you discuss something with them, this can also be a thing.

What a thing actually is

In reality things are different in The Hundred Things Principle. When you walk around and get some knowledge, it may teach you something, it may even fill some space in your brain. But according to the principle, It will be only a thing when you know exactly that you are going to learn something. Because then you can keep a record of it. This principle is all about documentation. You must have a record of what you have learnt over a period of time. So the best way to learn according to this principle is that you sit somewhere or just walk with a particular frequency, you keep a book, a laptop, a mobile or any knowledge resource in your hands and learn them. And continuously keep a record of it. You store the names and a little description about the things you learnt with a reference so that you can revise it again if needed.

Now you know exactly what it is and you can easily categorise “thing” and “not a thing”.

How should we find new things?

The common issues raised while learning are - What should you learn? Where should you learn from? How should you find new things to learn from?

Solutions

Join a community

The best and quick solution to this problem is to join communities. Communities have people of similar fields and knowledge with level. Someone might have more knowledge than others. This is a simple hierarchical structure and in this kind of system you can see people above you about what they have learnt or have been learning. You can ask them where to find solutions? and what are the things you should try? It is the same as keeping a meteor. A community guides people throughout their journey. But there is a special case of what to do if you are the root node in this hierarchy, this means you are the top level member of the community. In that case you can join a bigger community or you can join other relative or non relative communities where you are not a root node. This is the best suitable method for most people.

Become an explorer

Though the above method is suitable for most people, the most recommended method for a person is to become an explorer. An explorer is someone who is not dependent on a single source for his growth rather he always keeps exploring for new alternatives and mentors. During this process an explorer learns most things on his own rather than from specific sources. An explorer does not trust anyone; he always tries to find the best solution by looking at more than one source's views.

The advantages for an explorer The advantages of becoming an explorer is that you always have better knowledge than others who followed a specific structure. An explorer learns everything on his own; this makes his character more solid and makes himself a good teacher. An explorer has more potential, he is more creative and artistic, he is a critical thinker and picks the most isolated parts of the topic that everyone ignores.

The disadvantages for an explorer The fact that an explorer does not trust anyone gives him a doubting nature. This makes himself isolated, people don’t usually like these kinds of people. Explorer focuses more on learning than living that makes him unhealthy. He does not like people who do not think like him, this makes others almost hate him. He might be bad at focusing as his habit is to look at multiple things at a time.

What should you actually do

In simple words rather than becoming either a community member or explorer; you should become both. This will help you to be both friendly in nature and good at knowledge and different opinions.

How many things should we learn?

Now comes the best and most crucial part. How many things should you learn each day to become wise?

Let’s go step by step : (For going from one step to another. A time gap of at least 10 days should be there)

Start with 5 things per day (each taking 2-5 minutes). In the worst case it takes 50 minutes of your day. Now 50 minutes per day is not something that can make you fast, wise and productive. So we have to go one step further.
Now do 10 things per day (each taking 2-5 minutes) in the worst case it takes 100 minutes. This is not the end, let's move further.
Now do 20 things per day. Now it takes 200 minutes. It is still a manageable time. Let’s go a step further.
Now do 40 things per day. It takes 400 minutes. There is a problem now. We know that we don’t have this much time left after all day of working, eating, attending meetings, classes in colleges or schools, doing off campus work like homework or refactoring of code (if you are a programmer). We can’t avoid these issues, but we can borrow some extra time from other tasks. Let’s say 10 minutes from lunch, taking less sleep (6-7hr per day is enough) etc. If we somehow borrow 30 minutes and we reduce the size of things from worst case 5 minutes to best case 2 or 3 minutes. You can now manage things for the 40 things case.
Now let’s move directly to our actual target that comes from the heading. We are not at 100 things a day in the worst case it is 500 minutes that means at least the straight 8 hours a day. To be at this level, you have to be so efficient with your time management skills. One has to finish his office work in time and then focus on learning things to get to this level. One will at least need 4-6months to be truly at this stage of learning.

Extra tips

For learning we need to have dedication, focus and mental strength. To get these powers one should practice yoga and meditation, and should maintain good health for keeping the mental strength at a higher level. Keep in mind that everything takes time. You might feel exhausted or tired but doing this multiple times and focusing only on things will make you almost addicted to them. Then, your golden period will start. You will have better and sharper knowledge than others. You will be confident with your words and beliefs. You will think more deeply and critically, looking at all the aspects of any problem. So these were some extra tips that you can follow to make yourself better at “The Hundred things principle”.

Thanks

Thanks for reading this document. I hope that you will benefit from “The Hundred Things Principle”. You can even go further than 100 things, it totally depends on you. I have thought about almost all the aspects of this method and it seems to be good. I am trying this on myself too. Once again, Thanks for reading!

Please checkout my other blog: https://dev.to/himanshurajora/i-built-a-platform-to-help-developers-find-open-source-projects-that-need-contributors-2e54

Learn how to add markdown editor to your website

Himanshu Jangid, हिमांशु जाँगिड़ — Tue, 10 Mar 2026 10:02:01 +0000

I've got a new markdown editor for writing my blogs. It includes the following features:

Ordered lists
Bullets.
Code
Typography
Table
Various Text Styles
HTML Support
Links
Images and much more.

To make something like it for yourself in react, Follow these steps:

Install the markdown editor react component

npm install react-markdown-editor-lite --save also a markdown parser npm install markdown-it --save

Now add this to your react component

// import react, react-markdown-editor-lite, and a markdown parser you like
import React from 'react';
import * as ReactDOM from 'react-dom';
import MarkdownIt from 'markdown-it';
import MdEditor from 'react-markdown-editor-lite';
// import style manually
import 'react-markdown-editor-lite/lib/index.css';

// Register plugins if required
// MdEditor.use(YOUR_PLUGINS_HERE);

// Initialize a markdown parser
const mdParser = new MarkdownIt(/* Markdown-it options */);

// Finish!
function handleEditorChange({ html, text }) {
  console.log('handleEditorChange', html, text);
}
export default props => {
  return (
    <MdEditor style={{ height: '500px' }} renderHTML={text => mdParser.render(text)} onChange={handleEditorChange} />
  );
};

For using with Next JS

import dynamic from 'next/dynamic';
import 'react-markdown-editor-lite/lib/index.css';

const MdEditor = dynamic(() => import('react-markdown-editor-lite'), {
  ssr: false,
});

export default function() {
  return <MdEditor style={{ height: '500px' }} renderHTML={/* Render function */} />;
}

Click Here to Learn more https://www.npmjs.com/package/react-markdown-editor-lite

Why should you use a markdown editor

It is lighter than common WYSIWYG editors.
Based on Markdown language
Fast Blog editing without much thinking
HTML Support
Automatic linkify the links (make them clickable)

Thanks For Reading

react #markdown

Check out my open-source contributor finding tool at https://lookingforcontributors.web.app/.

I built a platform to help developers find open source projects that need contributors

Himanshu Jangid, हिमांशु जाँगिड़ — Mon, 09 Mar 2026 18:47:08 +0000

Many developers want to contribute to open source, but one of the biggest problems is figuring out where to start.

You might have experienced this before:

You want to contribute to open source
You search GitHub for projects
There are thousands of repositories
You don't know which ones actually need contributors

For beginners, this can be frustrating. Even experienced developers sometimes struggle to find projects that are actively looking for help.

So I decided to build a small platform to make this easier.

Introducing LookingForContributors

I built LookingForContributors, a platform where open source maintainers can share their projects and developers can discover projects that need contributors.

👉 https://lookingforcontributors.web.app/

The goal is simple:
connect developers who want to contribute with projects that need contributors.

What the platform helps with

With LookingForContributors you can:

Discover open source projects looking for contributors
Find projects based on skill level (beginner → advanced)
Help maintainers reach more contributors
Make it easier for students and new developers to start contributing

Many people want real-world development experience, and open source is one of the best ways to get it.

This platform tries to make that first step easier.

Why I built this

A lot of people in developer communities ask questions like:

How do I start contributing to open source?
Where can I find beginner-friendly projects?
Which projects actually need contributors?

Even though GitHub has millions of repositories, it's still difficult to discover the right projects.

So I wanted to create a place where maintainers can say:

“We’re looking for contributors.”

And developers can easily discover those opportunities.

Tech Stack

The project is built using:

React
TypeScript
TailwindCSS
Firebase

Feedback welcome

This project is still evolving, and I would really appreciate feedback from the developer community.

Things I'd love feedback on:

Features that would make this more useful
Better ways to discover projects
Ideas for GitHub integrations
Suggestions for improving the platform

You can check it out here:

👉 https://lookingforcontributors.web.app/

Thanks for reading!