DEV Community: Animesh

Building a local-first multi-JSON workspace in the browser

Animesh — Tue, 31 Mar 2026 19:41:56 +0000

Most JSON formatters I’ve used only handle one JSON at a time.
That becomes painful when you're working with multiple API responses or trying to compare payloads.

I wanted something closer to a workspace, not just a formatter — so I explored a local-first approach where everything runs entirely in the browser (no network calls).

What I focused on

Working with multiple JSONs simultaneously (like tabs)
Keeping everything private and offline
Adding a diff view for comparing objects
Handling large JSON files without freezing the UI

Challenges I ran into

1. Large JSON performance

Rendering deeply nested objects can easily block the main thread.
I had to be careful with parsing, virtualization, and avoiding unnecessary re-renders.

2. Diffing nested structures

Simple diff algorithms break down with large or deeply nested JSON.
Balancing accuracy vs performance was tricky.

3. Local storage limits

Managing multiple JSONs locally isn’t trivial — especially when users paste large payloads.

Curious about others’ approaches

How do you handle diffing large JSON objects efficiently?
Any patterns for multi-document workflows in the browser?
Better ways to manage large data in local-first apps?

Would love to hear how others are solving these problems.

My tool - https://www.multijson.com

C++ Removed Features

Animesh — Fri, 02 Jul 2021 17:15:44 +0000

With the new version of C++17 many new functions introduced but some features are removed or deprecated.😊

These are listed below :

Removal of deprecated operator ++
Removal of registers
Removal of auto_ptr
Trigraphs
throw(typeid)
Allocator support in std::function
std::pointer_to_unary_function and std::pointer_to_binary_function
std::binder1st and std::binder2nd
std::bind1st and std::bind2nd
Other functions

1. REMOVAL OF DEPRECATED OPERATOR ++

Postfix and prefix Increment (++) expressions are now not valid for bool operands, since pre-fix and post-fix operator++ was overloaded for type bool but In both cases, the return value for a bool argument is true. The bool type does not support the full set of arithmetic types. Since from the launch of C++98 this change was much awaiting. In new version of C++17 it is no longer considered an arithmetic type and these operators have been deprecated.

Alternatives :
std::exchange can be used as alternative for this, but only where post-fix operator has valid uses. Exchange function replaces the value of object with new value and returns the old value of object.

2. REMOVAL OF REGISTERS

Long back, in C++11 register keyword was deprecated. Register keyword specifies or gives a hint to compiler that the variable can be put in a register for fast access or these variables might be heavily used so that it can do optimization by storing it in a CPU register. But compiler implicit do optimizations and hint was rarely used. Therefore in new version register keyword is removed, although keyword is still reserved for future versions.

syntax :

register string s="Bye Bye register :)"

Alternatives :

There is no alternative for register as compiler does the same work automatically.

3. REMOVAL OF AUTO_PTR

auto_ptr was used to create a smart pointer to handle an object’s lifetime. It is owner of the object to which it refers, when an object gets destroyed auto_ptr also gets destroyed automatically. This smart pointer quietly steals ownership of the managed object in its copy constructor and copy assignment from the right-hand argument. As a result, the copy is not the same as the original smart pointer object. Because of these copy semantics, auto_ptr not works as CopyConstructible, and therefore it is deprecated.

Alternatives :
auto_ptr can easily replaced by unique_ptr which is also a smart pointer with similar working but with improved security. It was introduced in C++11 as direct replacement of auto_ptr as it provide new features (deleters) and support for arrays moreover it allows only one owner of the referencing pointer. So, while using unique_ptr there can only be at most one unique_ptr for one resource and when it is destroyed, the resource is automatically claimed. If we try to make a copy of unique_ptr will cause a compile-time error.

Example :

 unique_ptr<T> p1 (new T);
 unique_ptr<T> p2 = p1; 
 // Error: can't copy unique_ptr

4. TRIGRAPHS

Trigraphs are group of three character basically, it is special character sequence which is used as alternative for some characters. Represented with two question marks.

example : ??- produces ~ ??= produces # ??/ produces \ ??’ produces ^ ??( produces [ ??) produces ] ??! produces | ??< produces { ??> produces }

But they produce much confusion as they are parsed before comments and therefor removed in the latest version.

Alternatives :
C++17 not provide any alternatives for Trigraphs, as modern keyboards have all this features moreover it produces a lot of bugs in code.

5. throw(typeid)

If a function is declared with type T listed in its exception specification, the function may throw exceptions of that type or a type derived from it. This is the non-throwing version of the dynamic exception specification hat has been deprecated and now removed. It has been replaced with noexcept which has more clear meaning.

Syntax : throw(typeid, typeid, ...) example :

void throwsInt(int x) throw(int) 
{  
    cout<<"throw function replaced with noexcept :)";  
    if (x == 0) 
    { 
      throw 1;  
    }
}

Alternatives :
As mentioned above, throw can have better alternative with noexcept. It specifies whether function could throw exceptions or not without specifying their type. But use it only when invocation of the function cannot throw any error, otherwise program will terminate.

6. ALLOCATOR SUPPORT IN std::function :

Several constructors allow to specify an allocator used for allocating internal memory. std::function also have constructors that take an allocator argument, but the semantics are unclear, and there are technical glitch with storing an allocator in a type-erased context and then recovering that allocator later for any allocations needed during copy assignment. Therefore, these constructor overloads were removed in C++17.

Alternatives :
No such features is present in C++ which replaces allocator.

7. std::pointer_to_unary_function, std::pointer_to_binary_function :

std::pointer_to_unary_function, std::pointer_to_binary_function function objects that act as wrappers around unary or binary functions. These functions contains constructor which constructs a new pointer_to_unary_function object with the supplied function and operator() which calls the stored function.

Alternatives :
These two functions std::function and std::ref replaces std::pointer_to_unary_function, std::pointer_to_binary_function.

8. std::binder1st and std::binder2nd :

These are function object that binds an argument to a binary function.
The value of the parameter is passed to the object at the construction time and stored within the object. Whenever the function object is invoked though operator(), the stored value is passed as one of the arguments, the other argument is passed as an argument of operator(). The resulting function object is an unary function.

1) binder1st : Binds the first parameter to the value value given at the construction of the object.

2) binder2nd : Binds the second parameter to the value value given at the construction of the object.

Alternatives :

Lambdas, std::bind are two features which can be alternatives for binder1st and binder2nd.

9. std::bind1st and std::bind2nd :

These are Helper functions that create instances of std::binder1st or std::binder2nd, which binds a given argument to a first or second parameter of a given binary function object. But these become no use with the introduction of lambdas in C++11, therefor they were deprecated.

10 Other functions :

std::mem_fun_t
std::mem_fun1_t
std::const_mem_fun_t
std::const_mem_fun1_t
std::mem_fun_ref_t
std::mem_fun1_ref_t
std::const_mem_fun_ref_t
std::const_mem_fun1_ref_t

These are function objects that wrap a pointer to a member function with no parameters or one parameter. The class instance whose member function to call is passed as a pointer to the operator() ie, the object whose member function to call is passed by pointer to the call operator for the latter, it is passed as a reference. They are deprecated because they are limited to member functions with either none or just one argument and you need different functions and function objects for handling pointers or references to the class instance.

Alternatives :
Alternative to above functions is std::mem_fn which can handle member functions with any number of variables and not only references or pointers to objects but also smart pointers.

Conclusion :

C++ is simple, much clear and provide faster programming. Improving such language with latest versions and removing old buggy features is necessary. Thousands of proposals were put forward for updating the features in C++17. And it's time to say bye to some old features. 😎

Connect
LinkedIn
Twitter

C++ Rocks!😄

ECMAScript 2021 New Updates

Animesh — Tue, 29 Jun 2021 11:01:17 +0000

INTRODUCTION😎

ECMAScript is a part of JavaScript language which is mostly used in web technology, building websites or web apps. ECMAScript is growing as one of the world's most widely used general-purpose programming languages. It is majorly used in embedding with web browsers and also adopted for server and embedded applications.

New updates to ECMAScript will release out this July. The new improvements are introduced to make JavaScript more powerful and also make working easy for developers. It provides new functions, simple ways to do complex works and much more.

NEW UPDATES🤩

The new JavaScript features in ECMAScript 2021 are:
1. Logical assignment operators
And & Equals (&&=)
OR & Equals (||=)
Nullish Coalescing & Equals (??=)
2. Numeric Separators
3. String replaceAll
4. Promise.any
5. Private class methods
6. Private Getters and setters

1. Logical assignment operators
Logical assignment operators introduce new operators which combine logical operators and assignment expressions.

And & Equals (&&=)
It assigns when the value is truthy.

let x = 1;
if(x){
  x = 10;
}
// Output: x = 10

New :

let x = 1;
x &&= 10
// Output: x = 10

OR & Equals (||=)
It assigns when the value is falsy.

let x = 0;
x = x || 10;
// Output: x = 10

New :

let x = 0;
x ||= 10
// Output: x = 10

Explanation the assignment operation happens only if x is a falsy value. if x contains 1 which is a truthy value, assignment does not happen. Here x contains 0 therefore assignment happens.

Nullish Coalescing & Equals (??=)
Symbol ?? is Nullish Coalescing operator in JavaScript. It checks if a value is null or undefined.

let x;
let y = 10;
x ??= y;

Value of x is undefined, therefor the right hand side expression is evaluated and sets x to 10.

2. Numeric Separators
To improve readability and to separate groups of digits, numeric literals use underscores as separators.

// A billion dollar that I want to earn
const money = 1_000_000_000;
const money = 1_000_000_000.00;
// Also can be used for Binary, Hex, Octal bases

3. String replaceAll
If we want to replace all instances of a substring in string than this new method replaceAll is very useful.

const s = "You are reading JavaScript 2021 new updates.";
console.log(s.replaceAll("JavaScript", "ECMAScript"));
// output : You are reading ECMAScript 2021 new updates.

4. Promise.any
The Promise.any() method returns a promise that will resolve as soon as one of the promises is resolved. It is opposite of Promise.all() method which waits for all promises to resolve before it resolves.

Wait, what will happen when all of the promises are rejected, Yes you get that, the method will throw an AggregateError exception with the rejection reason. We have to put the code inside try-catch block.

const promiseOne = new Promise((resolve, reject) => {
  setTimeout(() => reject(), 1000);
});
const promiseTwo = new Promise((resolve, reject) => {
  setTimeout(() => reject(), 2000);
});
const promiseThree = new Promise((resolve, reject) => {
  setTimeout(() => reject(), 3000);
});
try {
  const first = await Promise.any([
    promiseOne, promiseTwo, promiseThree
  ]);
  // If any of the promises was satisfied.
} catch (error) {
  console.log(error);
  // AggregateError: If all promises were rejected
}

5. Private class methods

Private method have scope inside the class only so outside the class they are not accessible, see this example

class Me{
  showMe() {
    console.log("I am a programmer")
  }
  #notShowMe() {
    console.log("Hidden information")
  }
}
const me = new Me()
me.showMe()
me.notShowMe()
//error

This code will throw an error that gfg.notShowMe is not a function. This is because #notShowMe() is now a private method inside the class GfG and can only be access via a public method inside the class.

New :

class Me {
  showMe() {
    console.log("I am a programmer");
  }
  #notShowMe() {
    console.log("Hidden information");
  }
  showAll() {
    this.showMe()
    this.#notShowMe();
  }
}
const me = new Me();
me.showAll();
//I am a programmer
//Hidden information

Now we create a new public method called showAll() inside the class Me from this public method we can access the private method #notShowMe() and since our new method is a public we get this output.

6. Private Getters and setters
Just like private methods, now we can make getters and setters as private so that they can only accessed inside class or by instance created.

class Me {
  get #Name() {
    return "Animesh"
  }
  get viewName() {
    return this.#Name
  }
}
let name = new Me();
console.log(name.viewName)
// Output: Animesh

Conclusion
JavaScript is one of the most popular language and these frequent updates of new features make it more awesome and development friendly. So Welcome all these new features..

Read
C++ Removed features

Connect
LinkedIn
Twitter

Updates Rocks! 😊

Microsoft Student Learn Ambassador Program

Animesh — Tue, 29 Jun 2021 03:47:53 +0000

Become a Student Ambassador
Finding your community is more important than ever as classes and social activities take place virtually. Amplify your impact and bring together your peers to learn new skills, solve real-world problems, and build communities across the globe.
Learn and get chance to work with Microsoft community.

Eligibility

To apply, you must be at least 16 years old, have valid identification and be actively enrolled in an accredited, higher education academic institution.
You must be a student from a university or college affiliated to some university.
All college students are eligible for this program.
You need to have proper valid identification papers.

How to apply

Microsoft Student Learn Ambassador program opens twice every year quarterly, you can apply both times.
You must have Microsoft account.
Visit official website of Microsoft Student Learn Ambassador or apply via given link. Apply Here
Click on Apply Now button and then login with your Microsoft account.
Now again click on Apply Now button.
You will see a form, fill the form completing all the necessary details and reading terms and conditions.

Benefits
As it turns out, earning these benefits involves doing some pretty fun things. Program have three milestones for Student Ambassadors:

1. Alpha- Complete a Microsoft Learn path and unlock Azure credits with your Visual Studio Enterprise subscription benefit. You’ll also receive a certification voucher, and a free domain name.

Benefits include:

LinkedIn Learning
VS CodeSpaces Subscription
VS Enterprise subscription
MTC voucher
Yourname.com domain for a year and maybe more

2. Beta - Host an event in your community to unlock event support and resource benefits. This effort could include an invitation to join our annual Microsoft Learn Student Ambassadors Summit.

Benefits include:

Microsoft swag kits and goodies like pens, backpacks, T-shirts, 2. pen drives and more
$150 worth of monthly Azure subscription
And all benefits below this stage

3. Gold - Get invited to the Gold milestone when you’ve gone above and beyond in earning your badges and serving your local community. You’ll become a Student Ambassadors Regional Leader, gain access to special events, and may be invited to become a Microsoft Most Valuable Professional (MVP).

Benefits include:

All benefits below this milestone
Chance to be a regional leader
Chance to be a Microsoft Most Valuable Professional(MVP)

The Student Ambassadors program prepares students for future careers through opportunities to build vibrant communities and share the latest in tech with their peers. Through exclusive access to Microsoft resources, such as Microsoft Learn, Visual Studio Code, and Azure credits, Student Ambassadors are equipped to build their technology skillset through hands-on learning.
In addition, you have the opportunity to develop your leadership and entrepreneurship skills through hosting events on your campus, networking with other students and Microsoft professionals, and building interdisciplinary skills, such as public speaking, and social media and personal branding.

Conclusion
Microsoft has largest tech community, joining and working with such big company will give a boom to your carrier. Also this will make your resume highly skilled apart from others.

Rock it!