DEV Community: Himanshu_Sharma

AI, Companies, and the Shrinking Role of People.

Himanshu_Sharma — Sun, 15 Feb 2026 17:51:10 +0000

The End of Institutional Memory: When Knowledge Becomes Infrastructure

For decades, companies survived on memory stored inside people.

The senior employee who knew why a product was built a certain way. The manager who remembered the failed launch nobody talks about anymore. The engineer who understood the fragile system everyone else was afraid to touch.

When those people left, something real left with them.

Knowledge transfer was fragile. Experience was power. Loyalty mattered because memory mattered.

That era is ending.

When Memory Becomes Infrastructure

Artificial intelligence can now track a company’s entire growth timeline.

It can retain product history, operational decisions, internal documentation, performance data, customer behavior patterns, and strategic shifts.

It does not forget. It does not resign. It does not burn out.

Institutional memory no longer needs to live inside a person. It can live inside infrastructure.

When knowledge becomes embedded in systems instead of individuals, companies stop being vulnerable to employee exits. The risk of losing experience shrinks. The hierarchy built around “who knows what” starts to flatten.

From a purely operational perspective, this is efficient.

No leaves.
No internal drama.
No emotional instability disrupting output.
No dependency on one person holding critical context.

Work continues. Problems get solved. Systems operate.

Results Over People

At the end of the day, companies do not reward effort. They reward results.

Most customers do not care who solved the issue. They care that it works.

Nobody asks how their phone processes data. They expect it to function. If it breaks, they want it fixed. The mechanism is irrelevant.

Organizations operate the same way.

If AI can execute bulk work, retain knowledge, coordinate processes, and optimize decisions, then hiring becomes a choice rather than a necessity.

Entire layers of operational roles begin to look optional.

The Compression of Control

With enough automation, a single individual at the top, supported by AI systems and a small coordinating team, could oversee a company worth billions.

Execution moves into machines. Oversight compresses upward.

One human. Massive leverage.

The bottleneck stops being labor. It becomes decision-making.

This is not just about job replacement. It is about control.

When knowledge belongs to infrastructure instead of people, bargaining power changes. When systems hold context, humans become operators of tools rather than carriers of memory.

“The future of work isn’t arriving with noise, it’s arriving with fewer seats at the table.”

The Rise of the Black Box

At the same time, society grows comfortable with black boxes.

People rarely question how complex systems work as long as they deliver results. Output becomes the only visible metric. Process disappears. Trust shifts from human experience to algorithmic performance.

The more AI integrates into corporate systems, the less visible human thought becomes.

It gets converted into models. Encoded into workflows. Abstracted into dashboards.

Convenience increases. Efficiency increases. Human presence decreases.

Companies may gradually stop asking, “Who did this?” and start asking only, “Did it work?”

The Quiet Transition

If infrastructure can handle cognitive labor at scale, hiring slows. Roles compress. Influence concentrates at the top.

The future may not be a dramatic takeover.

It may be something quieter.

A steady transition from people-centered organizations to system-centered ones.

No mass announcement. No visible collapse.

Just fewer humans needed to keep the machine running.

And eventually, fewer humans inside the machine at all.

In the next piece, we go deeper into what this shift really means for people.

Abstraction in Object Oriented Programming- Explained using Java

Himanshu_Sharma — Sun, 04 Sep 2022 06:44:45 +0000

Abstraction is one of the 4 pillars of object-oriented programming. The main purpose of abstraction is to hide implementation details and show only the required/essential information. In simple words, it reduces complexity for normal users. It is mainly used to solve the issues at the design level, mostly the conceptual part.

Abstraction can be achieved via Abstract classes and Interfaces. Through abstract classes, java can’t achieve true abstraction, but by the use of interfaces, it can achieve 100% abstraction. Let’s see how.

In this Article, I will discuss Interfaces.

Multiple inheritance is not allowed in java, meaning one class cannot extend multiple classes because if such a case happened then the child class cannot differ which method came from which parent class. In such a scenario we can use Interfaces to enjoy the benefits of multiple inheritance and here is how.

Interfaces: An Interface is a set of specifications that a class must implement. By default, interfaces are public and abstract, so there is no need of defining them explicitly. Let us take an example.

In the below code, an interface named Engineer is created which means any class that implements Engineer must have to use its defined methods. If you see inside interface PracticeEngineering, it is neither defined public nor abstract implying that by default methods inside interfaces are public and abstract, there is no harm if you define also.

package Interfaces;

public interface Engineer {

void PracticeEngineering();//by default abstract and public

}

We have one more interface called Doctor.

package Interfaces;

public interface Doctor{

void performSurgery();
void beomceDoctor(); //by default abstract and public

}

Suppose a person class named “Student” want to become an engineer as well as a doctor. Now, there is no hierarchy between Engineer and Doctor, both the professions differ from each other, meaning neither engineer can become sub-class of doctor nor doctor can become sub-class of engineer; both of them are at the same level. Such cases come under multiple inheritance that is solved using interfaces.

A class can implement multiple interfaces in order to acquire both of their benefits.

package Interfaces;
public class Student implements Engineer, Doctor{

  public static void main(String[] args) {
       Person obj = new Person();
       obj.PracticeEngineering();
       obj.performSurgery();
       obj.beomceDoctor();
  }

@Override
public void performSurgery() {
System.out.println("Person is performing surgery");
}

@Override
public void PracticeEngineering() {
System.out.println("Person is pursuing Engineering");
}

@Override
public void beomceDoctor() {
System.out.println("Person is pursuing MBBS");
}

}

NOTE

A child class can extend only one parent class in java ( multiple inheritance is not allowed in java)

One interface can extend multiple interfaces Ex: Interface “VideoEditing” can extends two Interfaces EditVideo and UploadVideo.

interface EditVideo {
   void videoEditor();
}

interface UploadVideo {
   void videoUploader()
}

public interface VideoEditing extends  EditVideo, UploadVideo {
   void StudyConcept();
}

When a class implements an interface it must include implementation for all its methods.

Ex: If a class “Blogger” implements a VideoEditing interface then it should include methods videoEditor() and videoUploader().

public class Blogger implements VideoEditing {

  @Override
  void StudyConcept() {
  System.out.println("Blogger is Studing concept");
  }

  @Override
  void videoEditor() {
  System.out.println("Blogger is editing video");
  }

  @Override
  void videoUploader() {
  System.out.println("Blogger is uploading video");
  }
}

Thanks for spending your valuable time reading this article, I am sure you learned something today.😄

3 Dev hacks of JS ...spread Operator for Arrays

Himanshu_Sharma — Sat, 20 Aug 2022 15:08:40 +0000

Being a software Engineer, it's always learning new things, and implementing them on a loop😉. This post is about the JavaScript ES6 ...spread operator, to make your life easier, and code like a pro.😎

What is Spread Operator?

How MDN defines it?

In simple words, it's just 3 dots(...) which can be applied to iterable, such as Arrays, Sets to combine/copy the elements. When applied to objects, it helps in updating/adding key-value pairs.

Let's understand how it's applied to arrays by a story.

Scene 1: You are working on a feature and you got 2 arrays with different elements to combine, how will you do it.

cosnt array1 = ["JS", "REACT", "GIT"]
const array2 = ["Node", "Mongo"]

Is this the approach you are following?

const newArray = array1.concat(array2);

console.log(newArray)
// output -> ["JS", "REACT", "GIT", "Node", "Mongo"]

If yes, then start using the below one, it's recommended, understandable, and more transparent.

const mergedArray = [...array1, ...array2];

console.log(mergedArray)
// output -> ["JS", "REACT", "GIT", "Node", "Mongo"]

Just for sake of understanding consider spread as "remove bracket and get all the elements inside them"😜

Scene 2: Let's say you have mergedArray, and now you want to clone it and perform some operations.

// we now have mergedArray= ["JS", "REACT", "GIT", "Node", "Mongo"]

Let's clone the array, it's super easy. Just an assignment.

const cloneArray = mergedArray;

clonedArray[0] = "Python";

conosle.log(clonedArray) 
// ["Python", "REACT", "GIT", "Node", "Mongo"]😎

console.log(mergedArray) 
// ["Python", "REACT", "GIT", "Node", "Mongo"]😲

Woo! you did not expect that to happen. Remember, an array is a reference type, when assigned to a variable, it will store the reference, not the actual value. So when you cloned merged array via "=" assignment operator, it stored the address, not the value. So the change made in cloned array, mutated actual array.

Then how to do it, don't worry spread operator to the rescue.✨

const clonedArray = [...mergedArray];

clonedArray[0] = "Python";

conosle.log(clonedArray) 
// ["Python", "REACT", "GIT", "Node", "Mongo"]😎

console.log(mergedArray) 
// ["JS", "REACT", "GIT", "Node", "Mongo"]😃

Here spread operator is not referring to the address of mergedArray, instead it's copying the array at a new address, so that changes made on clonedArray does not mutate mergedArray.

Scene 3: Let's say you have an number array, how to get the max and min element from the array. Believe in ...spread😂

const numberArray = [22, 58, 46, 20, 5]

console.log(Math.max(...numberArray)) // -> 58
console.log(Math.min(...numberArray)) // -> 5

Thank you for spending valuable time reading this post, I am sure you learned something today.😄