 project and I ran into the following error while setting the Yarn version to berry.

rajat@Rajats-MacBook-Air yarn-berry % yarn set version berry
info There appears to be trouble with your network connection. Retrying...

Upon some digging around, I discovered that Yarn was unable to reach 

rajat@Rajats-MacBook-Air yarn-berry % yarn set version berry --network-timeout 10000000 --verbose
verbose 0.088904291 Checking for configuration file "/Users/rajat/dev/throw-away/yarn-berry/.npmrc".
verbose 0.089522125 Checking for configuration file "/Users/rajat/.npmrc".
verbose 0.089589916 Found configuration file "/Users/rajat/.npmrc".
verbose 0.089890333 Checking for configuration file "/Users/rajat/.nvm/versions/node/v18.2.0/etc/npmrc".
verbose 0.089955208 Checking for configuration file "/Users/rajat/dev/throw-away/yarn-berry/.npmrc".
verbose 0.090007041 Checking for configuration file "/Users/rajat/dev/throw-away/.npmrc".
verbose 0.090125666 Checking for configuration file "/Users/rajat/dev/.npmrc".
verbose 0.0901665 Checking for configuration file "/Users/rajat/.npmrc".
verbose 0.090290833 Found configuration file "/Users/rajat/.npmrc".
verbose 0.090437375 Checking for configuration file "/Users/.npmrc".
verbose 0.091147083 Checking for configuration file "/Users/rajat/dev/throw-away/yarn-berry/.yarnrc".
verbose 0.091224125 Checking for configuration file "/Users/rajat/.yarnrc".
verbose 0.091271625 Found configuration file "/Users/rajat/.yarnrc".
verbose 0.09142775 Checking for configuration file "/Users/rajat/.nvm/versions/node/v18.2.0/etc/yarnrc".
verbose 0.091464458 Checking for configuration file "/Users/rajat/dev/throw-away/yarn-berry/.yarnrc".
verbose 0.091497208 Checking for configuration file "/Users/rajat/dev/throw-away/.yarnrc".
verbose 0.091585875 Checking for configuration file "/Users/rajat/dev/.yarnrc".
verbose 0.091625208 Checking for configuration file "/Users/rajat/.yarnrc".
verbose 0.091660708 Found configuration file "/Users/rajat/.yarnrc".
verbose 0.091760625 Checking for configuration file "/Users/.yarnrc".
verbose 0.092885916 current time: 2022-12-10T08:45:51.427Z
verbose 0.099392166 Performing "GET" request to "https://github.com/yarnpkg/berry/raw/master/packages/yarnpkg-cli/bin/yarn.js".
info There appears to be trouble with your network connection. Retrying...

Turns out, I needed to enable corepack for it to work as listed in the Yarn's official 

After the above command, I was able to set the Yarn version properly. Hope it was helpful

Resolving Network Connection Error In Yarn

Prompt engineering is an emerging field within natural language processing (NLP) that has the potential to revolutionize certain aspects of software development. At its core, prompt engineering involves creating NLP models that can generate text based on certain prompts or inputs. These models can be used to automate tasks that previously required human intervention, such as generating news articles, customer service responses, and even software code.

One of the key applications of prompt engineering is the generation of code based on specific prompts or inputs. This has the potential to significantly speed up the development process, allowing developers to focus on more complex tasks such as software architecture and design. It could also potentially reduce the number of junior developer positions as prompt engineers could ask the right questions to the AI to generate production-quality code which can be readily used.

While prompt engineering is still in its early stages, it has the potential to impact software development jobs in several ways. 

First, it could lead to the creation of new roles focused specifically on prompt engineering. As more companies adopt this technology, they will need skilled professionals who can create and maintain NLP models and ensure that they are being used effectively.

Second, prompt engineering could potentially automate certain aspects of software development, such as generating code for routine tasks or performing automated testing. This could reduce the need for certain roles within software development teams, although it is important to note that it is unlikely to replace software developers entirely.

Third, prompt engineering could potentially increase the speed and efficiency of the software development process, allowing companies to deliver products more quickly and efficiently. This could lead to increased demand for software development services and potentially create new job opportunities.

It is important to note that prompt engineering is still in its early stages, and its impact on software development jobs is not yet fully understood. While it has the potential to revolutionise certain aspects of the industry, it is unlikely to completely replace human developers. 

However, a lot of junior developer positions are probably going to be filled by prompt engineers. 

Instead, it is more likely to augment their capabilities and allow them to focus on more complex and creative aspects of software development. As with any emerging technology, it is important to approach prompt engineering with caution and consider its potential impact on the workforce and society as a whole.

What Is Prompt Engineering And How Is It Going To Affect Software Development Jobs

While it is easier to assume that all technical folks who work at the IT companies are hardcore coders, it is actually not true. There are many fields in the IT industry where one does not have to know coding. Let's see what those fields are.

In some companies these are also known as the Customer Success Executives and they are responsible for helping out the users in using the product. These people work very closely with the engineering and product teams so you will not be coding but you will be dealing with a lot of technical stuff. This is a great role for someone who is trying to break into IT from any other career.

These folks are responsible for designing the over all user interface and user experience for the product(s) the company is working upon. While you are not expected to churn out code, you should be proficient at concepts of color theory, accessibility, UI designing with tools like Adobe Photoshop and Illustrator etc.

Software developers require servers to host their development code upon. Someone has to configure those servers and take care of things like network access, disaster recovery and security of these servers. Although these profiles include almost no coding, you are expected to deal with configuration files from time to time. By âdealingâ, I meant moving a few lines of code around.

Consider this role as âLinux/Network Admin on steroidsâ. You are not only required to configure the servers and software,  but also to build the entire development and production servers stack from the ground up. This will include writing configuration files from scratch by going through the documentation of the software/hardware the company has provided you.

In this role, you are required to design ingenious algorithms to dig out key information about the business. This will include scouring through a lot of data (in the form of database records, files etc.), perform the calculation and presenting the data in an easy to assimilate report. The company acts of such reports to fine-tune its business and processes.

These people train computers to learn new skills and patterns. This sort of training helps the computers in making automated decisions in the future. In this role, you will be required to work with a lot of data and algorithms. You need to have some interest in mathematics so that you can grasp the machine learning algorithms with ease.

I hope you might have found something you are particularly interested in from the list above, even if coding is not your forte or interest. If you have further queries, please write to me at 

Don't Like Coding But Still Interested In Joining IT? Here Are Some Alternatives

When JavaScript was created some twenty years ago, modularity was not something that was supported out of the box. 

When people started building complex and bigger project with JavaScript, they started craving for a way to modularise their code by breaking down their code into various files or modules. That requirement gave birth to all these module systems which we are going to learn about in this post.

Following are major module systems in the JavaScript ecosystem.

Let's learn about each of these in detail.

If you have used Node.js, you probably have seen this module system in action. Although Node.js' implementation is only 

 by CJS, it resembles CJS specs quite a lot. Using this system, you can export symbols from a file (module) using the 

 object. In order to import symbols from other modules, you need to 

CJS is synchronous in nature, which means that execution is blocked until a module is imported successfully.

AMD was created as a result of a disagreement between a few members of the CJS developer group. The members who were not happy with the direction CJS was heading in parted ways and created AMD.

AMD embraces browsers' way of working with modules hence it support asynchronicity. AMD uses 

 keyword and a factory function to provide the module loading functionality.

 are two frameworks which support outputting AMD compatible code. AMD supports loader plugins which means you can load different types of resources as dependencies.

ESM is developed by ECMA, the committee behind ECMAScript which is the specification JavaScript is based on. You use 

 keyword to export symbols from a module and 

 for importing symbols into the module from other modules. Since ESM is a part of the specification, it is natively supported by browsers (not all of them at the time of this writing) and Node.js.

The code using ESM is tree-shakable i.e. unused code can be eliminated by the static analysers and will not be included in the final build.

The only downside of using ESM I was able to find out was that it is not yet supported by all the browsers out there.

That's it for this comparison. I hope I was able to explain the why and how of these module systems. If you have queries regarding this post, come ask in our 

Understanding CJS, EMS and UMD

MongoDB is a Document database used by companies like Forbes, Toyota etc. 

 (CodeLit’s own LMS) also uses MongoDB as a database.

All the database operations are going to use the following data. It is a list of hotels.

To obtain a connection string of your MongoDB Atlas instance, go 

db.hotels.insertOne({ 
	"name": "Blue Royal",
	"price": 200,
	"amenities": ["tv", "geyser", "wifi"],
	"address": {
		"city": "Mumbai"
	}
});

db.hotels.insertMany([
	{
		"name": "Panama Lagoon",
		"price": 300,
		"amenities": ["tv", "wifi"],
		"address": {
			"city": "Bangalore"
		}
	}, 
	{
		"name": "Ibis Luxuries",
		"price": 650,
		"amenities": ["tv", "geyser", "wifi", "meals"],
		"address": {
			"city": "Mumbai"
		}
	}, 
	{
		"name": "Paris Knight",
		"price": 450,
		"amenities": ["tv", "meals"],
		"address": {
			"city": "New Delhi"
		}
	}, 
	{
		"name": "Citrus Hotel",
		"price": 150,
		"amenities": [],
		"address": {
			"city": "New Delhi"
		}
	}
])

List all records but only the “name” property

db.hotels.find({}, {name: 1})

// skip _id field as well
db.hotels.find({}, {name: 1, _id: 0})

// Get only one record
db.hotels.find().limit(1)

// Sort by price 'low to high'
db.hotels.find().sort({price: 1})

db.hotels.find({"address.city": "Mumbai"})

db.hotels.find({"address.city": {$in: ["New Delhi", "Mumbai"]}})

db.hotels.find({amenities: {$all: ["tv", "geyser"]}})

List all hotels with a tv and a geyser with price more than $200/night

db.hotels.find({amenities: {$all: ["tv", "wifi"]}, price: {$gt: 200}})

Change the price of hotel “Blue Royal”

db.hotels.updateOne(
	{name: "Blue Royal"}, 
	{$set: {price: 250}}
);

db.hotels.update(
	{name: "Ibis Luxuries"},
	{$set: {"address.country": "india"}}
)

db.hotels.updateOne(
	{name: "Ibis Luxuries"},
	{$addToSet: {amenities: "spa"}}
);

db.hotels.updateOne(
	{name: "Ibis Luxuries"},
	{$pull: {amenities: "spa"}}
);

db.hotels.update(
	{name: "Ibis Luxuries"},
	{$unset: {"address.country": ""}}
)

db.hotels.updateMany({}, {$inc: {price: 20}})

If a matching record is not found, it will be inserted instead.

db.hotels.update(
	{name: "Gloria Paradise"},
	{$set: {price: 350, amenities: ["tv"]}},
	{upsert: true}
)

db.hotels.deleteOne({name: 'Gloria Paradise'})

db.hotels.deleteMany({"address.city": "New Delhi"})

MongoDB Quickstart

Type conversion (also known as coercion) in JavaScript confuses a lot of developers and makes a significant chunk of interview questions and general trivia/gotchas. In this post, we will learn the basic building blocks to coercion and see how to apply those to actual real world problems.

Type coercion is JavaScript's attempt to be fault-tolerant and forgiving. It will try to convert the data types of the variables you are performing an operation upon so that the operation does not error out.

Let's establish the first building block.

1. Everything gets converted to either a number or a string ultimately.

JavaScript will apply a few rule and ultimately all the operands will be converted to either of these values.

1.1. How does JavaScript decide if it should convert an operand to a string or a number?

Glad that you asked! There are certain operations which prefer numbers and others which prefer strings. Let's see a few examples.

*       // multiply

%       // modulo

++      // prefix (or postfix) operators

`${}`         // string templates

String()      // creating an string object

Then there are operations which are neutral like, 

 (==). We will learn more about those in 

So how does JavaScript convert any value to number/string? For that, we are going to establish the second building block.

2. JavaScript uses a function to convert anything to either number or string

 which converts any input to a primitive value. If the input is already a primitive, it is returned as is. Otherwise, it is first converted into a primitive value and then returned.

JavaScript calls ToPrimitive function automatically when the type conversion happens.  While calling this function, JavaScript also sends the preference i.e. whether it would like to convert that value into a string or a number, as an input. This input is called 

Following is the over-simplified pseudo-code of 

Please keep in mind I have glossed over non-essential stuff and we will follow the same pattern in all of such examples.

ToPrimitive (input, hint: string|number|default = default):
    if input is an object:
        if input has a function called toPrimitive:
            result = toPrimitive(input, hint)
            if result is not an object:
                return result
            else:
                throw error

        if hint == default:
            hint = number

        return OrdinaryToPrimitive(input, hint)

    // already a primitive
    return input

Here is what the above pseudo-code is doing.

 function is not defined hence the responsibility lands on 

 function to convert an object into a primitive. 

Following is the implementation in over-simplified pseudo-code. 

OrdinaryToPrimitive(hint: string|number):
    if hint == "string"
        methods = ["toString", "valueOf"]
    else
        methods = ["valueOf", "toString"]

    loop over methods array:
        if method is callable:
            result = method()
            if result is not of object type:
                return result
            else
                throw error

So as you can see from above, JavaScript will call two methods i.e. 

 in a preferred sequence depending upon the hint.

2.1. Primitives will further converge to either string or number

We saw that ToPrimitive will return primitive values. These primitive values will be ultimately converted to string/number. JavaScript uses 

 for this. These methods define how values like null, undefined, symbol, bigint etc. are converted to numbers and strings respectively.

Let's see the above concepts in action. For that let's define a variable as follows.

let b = {
    valueOf: function () { return 1 },
    toString: function () { return 'bee' }
}

This is because the multiplication operator prefers the operands to be numbers. Hence JavaScript tried to convert the object 

Again, using the above logic and section 

There are operators which are neutral i.e. to don't prefer string over numbers and vice-versa. The following are a few such operators.

This class of operators leads to the most confusion around coercion in JavaScript. We will see how addition and loose equality works in this post. Less than is somewhat more complex than the other two so we will leave that out for now.

Again, let's look at the pseudo-code of how this is implemented.

Addition(x, y):
    convert operands to primitives
    if any operand is string:
        convert both operands to string
        concatenate the operands
        return result
    else:
        convert all operands to numbers
        if any operand is unconvertible (symbol, bigint):
            throw error
        else
            add both operands
            return result

'e' + 1 // prints 'e1'
1 + 2   // prints 3

let b = {
    valueOf: function () { return 1 },
    toString: function () { return 'bee' }
}

b + 1 // prints 2

 is an object and the other one is a number. JS will try to convert both of these to primitive (see Listing 8, line 2). To convert 

 (see Listing 3, line 10).  Hence b will be coerced to a number. So, 

Type Coercion In JavaScript: A Deep Dive

React JS is a popular JavaScript library that is used for building user interfaces. It is maintained by Facebook and a community of developers. With ReactJS, developers can create complex UI components that can be reused in different parts of an application. In this blog post, we will discuss the basics of ReactJS and its benefits.

ReactJS is a JavaScript library that is used for building user interfaces. It allows developers to create reusable UI components that can be used in different parts of an application. ReactJS was first released in 2013 and has since become one of the most popular JavaScript libraries.

ReactJS is a component-based library, which means that developers can create small, reusable components that can be combined to create larger, more complex UI components. ReactJS uses a virtual DOM (Document Object Model) to manage the state of components and update the UI efficiently.

There are many benefits to using ReactJS for building user interfaces. Here are some of the most significant benefits:

ReactJS allows developers to create reusable UI components. This means that a developer can create a component once and reuse it in different parts of an application. Reusability is essential because it reduces the amount of code that needs to be written and makes the application easier to maintain.

ReactJS uses a virtual DOM to manage the state of components and update the UI efficiently. This means that ReactJS can update the UI faster than other libraries or frameworks. ReactJS also uses a technique called "reconciliation" to update the UI only when necessary. This means that ReactJS can avoid unnecessary updates and improve performance.

ReactJS is scalable, which means that it can be used to build small or large applications. ReactJS is used by many large companies, including Facebook, Instagram, and Airbnb. These companies use ReactJS to build complex applications with millions of users.

ReactJS has a large community of developers who contribute to the library and create open-source tools and libraries. This means that developers can benefit from the work of others and find solutions to common problems.

To get started with ReactJS, you will need to have some knowledge of HTML, CSS, and JavaScript. You will also need to have Node.js installed on your computer.

Here are the steps to get started with ReactJS:

Once you have completed these steps, you can start building your first ReactJS component.

ReactJS is a popular JavaScript library that is used for building user interfaces. It allows developers to create reusable UI components that can be used in different parts of an application. ReactJS has many benefits, including reusability, performance, scalability, and a large community of developers. If you are interested in building user interfaces, ReactJS is a great library to learn.