Forem: Lalit Kumawat

The Future of Web Development: Predictions and Possibilities

Lalit Kumawat — Sat, 05 Aug 2023 14:55:39 +0000

Current State of Web Development
Web improvement is constantly developing, driven by progressions in innovation and the changing necessities of clients. Web developers currently use different innovations like HTML, CSS, JavaScript, and structures like Respond, Rakish, or Vue.js to fabricate dynamic and responsive sites. Nonetheless, they face difficulties connected with cross-program similarity, security weaknesses, and the requirement for quicker stacking pages.

Predictions for the Future of Web Development
AI and Machine Learning in Web Development
As computer-based intelligence and AI advancements progress, they are supposed to alter web improvement. Artificial intelligence-controlled apparatuses can robotize tedious undertakings, distinguish messes, and streamline site execution, prompting more proficient advancement processes.

Progressive Web Apps (PWAs)
PWAs offer another way to deal with web advancement, consolidating the best of web and versatile applications. They furnish clients with application-like encounters, including disconnected admittance, message pop-ups, and quicker stacking times, while being effectively discoverable through web search tools.

Voice User Interface (VUI) Integration
With the ascent of remote helpers and brilliant speakers, voice search and orders are becoming more predominant. Web developers should streamline sites for voice communication, guaranteeing consistent client encounters through the VUI mix.

Photo by Micheal Ogungbe on Unsplash

Augmented Reality (AR) and Virtual Reality (VR) on the Web
AR and VR advancements are tracking down their direction into the web, empowering vivid encounters for clients. Web designers will investigate ways of incorporating AR and VR components into sites, offering intelligence and drawing in satisfaction.

Photo by Shubham Dhage on Unsplash

Blockchain and Web Development
Blockchain innovation’s decentralized nature gives improved security and straightforwardness. Web designers might use blockchain for secure validation, information on the board, and decentralized applications (DApps).

Internet of Things (IoT) Impact on Web Development
As IoT gadgets become more broad, web developer should oblige their cooperation with sites and applications. This could incorporate streamlining UIs for more modest screens and guaranteeing consistent correspondence among gadgets and the web.

Possibilities in Web Development
Enhanced User Experience
The eventual fate of web advancement vows to convey unrivaled client encounters. Sites will be more natural, outwardly engaging, and versatile to individual inclinations, bringing about higher client fulfillment and commitment.

Personalization and Customization
Web developers will zero in on personalization by utilizing client information to offer customized content and encounters. Customization choices for UIs and functionalities will become more regular, permitting clients to have a customized venture through sites.

Faster Loading Times and Performance
As web speeds improve, web designers will focus on enhancing stacking times and, by and large, site execution. Clients can anticipate quicker access should data and smoother routes.

Enhanced Security Measures
With rising digital dangers, web developers will embrace vigorous safety efforts to safeguard clients’ information and security. Encryption and secure conventions will become standard practice in web advancement.

Integration of Real-time Features
Web designers will investigate continuous elements, empowering live communications, like cooperative altering, ongoing visits, and warnings. This will improve correspondence and efficiency on sites and web applications.

The Role of Web Developers in the Future
Evolving Skillsets and Knowledge
Web developers should remain refreshed with recent advances and patterns to stay applicable in the high-speed computerized scene. Constant learning and upskilling will be crucial for satisfying the needs representing things to come.

Collaboration with AI and Automation
Artificial intelligence-fueled instruments will help web designers. However, human imagination and critical thinking abilities will stay crucial. Joint efforts among people and artificial intelligence will prompt more creative and productive web improvement processes.

Focus on Accessibility and Inclusivity
Web developers will focus on openness to guarantee that everyone uses sites equally. Inclusivity in the plan will become a standard work, elevating equivalent admittance to data and administrations on the web.

Addressing Environmental Sustainability
Web developers will be aware of natural effects as the advanced impression develops. They will investigate eco-accommodating facilitating arrangements and improve sites to lessen energy utilization.

Conclusion
The eventual fate of web improvement holds energizing prospects, driven by headways in artificial intelligence, AR, VR, IoT, and other advancements. As web designers adjust to these changes, clients can anticipate upgraded encounters, consistent collaborations, and a more customized internet-based climate. The vital lies in finding harmony between robotization and human imagination to shape a web scene that takes special care of the requirements, everything being equal.

I am currently building a newsletter to share informative articles and news, covering ai, startups 🚀, tech 📱, and programming 💻! my progress in becoming Software Developer with little experience, and how you can learn from my experience.

Please subscribe via this link.

Also published here.

A simple guide to JavaScript concurrency in Node.js and a few traps that come with it

Lalit Kumawat — Sat, 05 Aug 2023 14:46:29 +0000

Why Are Two Similar Objects Not Equal in JavaScript?

Lalit Kumawat — Sun, 30 Jul 2023 13:41:11 +0000

In JavaScript, two objects may not be equal even though they appear to be similar. Why is that the case? 🤔 Let's understand why.

For example:

const obj1 = {
name: "Dillion"
}
const obj2 = {
name: "Dillion"
}

console.log(obj1 === obj2)
// false
As you can see here, obj1 and obj2 look similar. They both have the property of name with a value of "Dillion". But comparing them--obj1 === obj2--returns false. 🤔

The same thing applies to arrays:

let arr1 = [1, 2, 3]
let arr2 = [1, 2, 3]

console.log(arr1 === arr2)
// false
To understand why this is the case, you have to understand what primitive and reference values are in JavaScript.

Primitive and Reference Values
Think of a primitive value as one value (static, fixed) and a reference value as a group of multiple values or (dynamic) value.

Primitive values are of the types string, number, boolean, null, undefined, symbol, and BigInt. These values are fixed and stored on the stack, for example:

let name = "Dillion"
let age = 60
let isRaining = true
image-71
Reference values are of the object types which includes objects, arrays and functions. These values are dynamic (can contain multiple values, properties, and can be modified over time) and are stored on the heap, with a reference value in the stack, for example:

let array = [1, 2, 3]
let obj = { name: "Dillion" }
function print() {
console.log('hello')
}
image-72
The reference value is an address that points to the location of the data in the memory.

Here's an article where I explained the difference in more detail: Primitive and Reference Values Simplified

Comparing Primitive and Reference Values
When you compare primitive values, you are comparing static values, which have a fixed size on the stack:

let name = "Dillion"
let name2 = "Dillion"

console.log(name === name2)
// true
Here, we compare name and name2 if they are equal. What happens here is that JavaScript checks for the name and name2 variables in the stack, and then it sees that they have equal values, so it's true--they are equal.

In the case of objects, you are comparing the references (the addresses) and not the exact values. Here's what I mean.

If you have two arrays like this:

let array = [1, 2, 3]
let array2 = [1, 2, 3]
Here's what it would look like on the stack and heap:

image-73
As you can see here, for array, [1, 2, 3] is not stored on the stack. It is stored on the heap, and the memory location of that data is stored on the stack as a reference.

The same thing for array2; [1, 2, 3] is not stored on the stack. It is stored on the heap, in a different memory location and the reference is stored on the stack.

When you compare both arrays like array === array2, you're not exactly comparing [1, 2, 3] === [1, 2, 3] but you're actually comparing refForArray === refForArray2 (ref is short for reference).

As we saw in the heap illustration, array and array2 have different memory locations, which means they have different references, which then means the variable array is not equal to the variable array2.

The only way array and array2 can be equal, is if you have something like:

let array = [1, 2, 3]
let array2 = array

console.log(array === array2)
// true
By assigning array to array2, you are assigning the reference that array holds in the stack, to array2:

image-74
Therefore, array and array2 now have the same value--the same reference.

How to compare objects
We've seen that in our attempt to compare two object values, we are actually comparing the reference and not the object data. So how do we correctly compare the object data?

There are a couple of ways you can do this but I will share two of them.

Compare objects using _.isEqual from Lodash
You can write a function that does an equality check between two objects, but it could become complicated when you have to compare deeply nested objects which can have different values, including objects.

A faster approach is using the isEqual method from Lodash which is an effective solution that handles deep comparison between two values:

const _ = require('lodash');

const array = [1, 2, 3]
const object = { name: "Dillion" }

const array2 = [1, 2, 3]
const object2 = { name: "Dillion" }

console.log(_.isEqual(array, array2))
// true

console.log(_.isEqual(object, object2))
/ true
Compare objects using JSON.stringify()
Say you don't want to use Lodash, you can use JSON.stringify which recursively stringifies an object or array to a string:

const array = [1, 2, 3]
const object = { name: "Dillion" }

const array2 = [1, 2, 3]
const object2 = { name: "Dillion" }

console.log(
JSON.stringify(array)
===
JSON.stringify(array2)
)
// true

console.log(
JSON.stringify(object)
===
JSON.stringify(object2)
)
// true
Since the stringified version is a primitive type (static), the data of both values can be compared. But here is a limitation with JSON.stringify().

JSON.stringify can return different results if the order or properties in an object are different. For example:

const object = {
name: "Dillion",
age: 50
}

const object2 = {
age: 50,
name: "Dillion"
}

console.log(
JSON.stringify(object)
===
JSON.stringify(object2)
)
// false
In object, we have name coming before age, but in object2, we have age coming before name. This means their stringified representations would be different and as a result, their data are not equal.

Wrap up
Primitive and Reference values are fundamental concepts to understand when working with data in JavaScript. And as we have seen in this article, comparing primitive values is easier, but comparing reference values can be trickier because when you think you are comparing the data, you may not realize that you are actually comparing the reference.

Please subscribe via this link.

Also published here.

I hope this article answers the question of "Why are two similar objects not equal in JavaScript?". If it does, please give this article a share 🙏🏾

Node.js Development: All You Need to Know

Lalit Kumawat — Thu, 20 Jul 2023 10:04:01 +0000

Node.js is a robust runtime environment that has revolutionized how developers build server-side applications. It allows developers to use JavaScript on both the frontend and backend, making it the perfect choice for building scalable, high-performance applications.

According to the Stack Overflow Developer Survey 2022, Node.js was the most used web technology among professional developers, with more than 46% of votes, and it ranked 8th in the most loved technologies list. Therefore, Node.js can be considered a future-proof technology that every developer should know.

This article will provide an in-depth overview of Node.js, including its features, use cases, advantages, disadvantages, step-by-step guides for setting up Node.js with different operating systems, and answers to some of the most frequently asked questions about Node.js.

What is Node.js?

Node.js is one of the most popular runtime environments for JavaScript, web servers, and other network applications in general. It is open-source, cross-platform, and known for its single-threaded asynchronous event-driven concurrency model. It was introduced in 2009 and revolutionalized the development world since it allowed developers to run JavaScript outside web browsers.

Node.js is written in C, C++, and JavaScript. The core components of Node.js - the V8 engine and the libuv library - are written in C++ and C, respectively, since these languages provide low-level access to system resources, making them well-suited for building high-performance and efficient applications. JavaScript is mainly used to write the application logic.

How Node.js Works

When you run a JavaScript program in Node.js, the V8 engine will first parse the code to build an Abstract Syntax Tree - AST. The interpreter takes the AST generated by the V8 parser and generates bytecode from the AST. Lastly, the compiler compiles the bytecode into binary machine code that matches the CPU architecture of the running host.

Although Node.js is single-threaded, it uses an event-driven, non-blocking I/O model to handle multiple requests simultaneously without blocking others. This behavior is achieved through the event loop.

As the name implies, the event loop is a loop that runs continuously and waits for events to occur. When an event occurs, the event loop will add the event to an event queue. If there are no other pending events in the queue, the event loop will execute the event and remove it from the event queue. If there are any other events in the queue, they will be processed one at a time in a non-blocking manner.

For example, consider the below example with two setTimeout functions:

console.log('Starting');

setTimeout(function() {
console.log('Timer 1 finished');
}, 3000);

setTimeout(function() {
console.log('Timer 2 finished');
}, 2000);

console.log('Stopping');

Let's break down the execution of the above example into steps to understand better how the event loop works.

The script will start and log "Starting" in the console.

The first setTimeout function is called, and it will schedule the execution of the function passed to it after a delay of 3 seconds.

The second setTimeout function will then be called and schedule the execution of the function passed to it after a delay of 2 seconds.

The script will log "Stopping" in the console.

Once the main thread execution finishes, Node.js starts processing the event loop and checks if there are any pending callbacks in the event queue. In this case, two callbacks are pending in the queue with timer events.

The event loop runs the callback for the second setTimeout function, logs "Timer 2 finished" in the console, and removes the event from the queue.

The event loop then runs the callback for the first setTimeout function, logs "Timer 1 finished" to the console, and removes the event from the queue. -Once the event queue is empty, the event loop will again start waiting for new events to add to the event queue.

The event loop will constantly check the event queue for completed events. When an event's delay time has passed, it is moved from the event queue to the call stack for execution. In this case, the second setTimeout function has a shorter delay time than the first. So, it will be moved from the event queue to the call stack before the first setTimeout function. That's why the output of the example will look like the below:

Starting
Stopping
Timer 2 finished
Timer 1 finished

What Are the Features of Node.js?

Asynchronous I/O - Node.js uses an event-driven, non-blocking I/O model to handle multiple requests simultaneously without blocking the execution of other requests.

Cross-platform - Supports Windows, macOS, and Linux operating systems.

Fast startup time - Unlike other runtime environments, Node.js has a fast startup time. So developers can quickly test and iterate on their code.

Web socket support - Built-in support for web sockets, allowing bi-directional communication.

Large ecosystem - Many open-source modules and packages are available in NPM.

No buffering - Node.js does not buffer data. Data is processed as soon as received, resulting in faster response times and reduced latency.

What is Node.js used for?

Node.js is a multi-purpose runtime environment that developers can use in a variety of ways:

APIs - Highly scalable and performance-oriented APIs for web and mobile applications.

Real-time applications - Ideal for real-time applications like chat apps and online gaming platforms.

Microservice - Developers can easily design microservice architectures with Node.js. Furthermore, they can use tools to generate fully functional services based on Typescript and Node.js with popular technologies such as (but not limited to) NestJS, Prisma, PostgreSQL, GraphQL, and MongoDB.

Cross-platform application development - Can be used for desktop application development with Electron.

IoT - Perfect for building applications requiring real-time communications.

Single page applications - Works well with frontend frameworks like Angular, React, and Vue.js.

Pros of Node.js Development

Node.js is excellent for high-performance applications since it is built on the V8 JavaScript engine.

Highly scalable since its event-loop mechanism helps to process requests non-blocking.

Simplifies web development by allowing developers to use JavaScript for both frontend and backend development.

Huge active user community.

Cost-effective since Node.js is open-source.

Easy integrations with other development tools and technologies like Express, AWS, Socket IO, MongoDB, etc.

Cons of Node.js Development

Using too many callbacks to write asynchronous code can cause callback hell.

Node.js is not designed to handle CPU-intensive tasks like video encoding, data encryption, or scientific computing.

Developers need to take extra measures to increase the security of their applications.

There are difficulties in debugging due to asynchronous control flow.

NPM dependencies are hard to manage - some packages are not stable or not well documented or might have security issues. In addition, project size grows unexpectedly with nested dependencies.

How to Install Node.js

Installing Node.js is simple and one of the first things developers should do when setting up their machines.

Step 1 - Download the latest LTS Node.js version from their webpage. Make sure to select the appropriate installer based on your operating system.

Step 2 - Run the installer file and follow the installation wizard.

Step 3 - After the wizard completes, open the CMD and type node -v to verify the installation. It will log the Node.js version you installed. (e.g., v18.12.0)

FAQs

Q1: What is the difference between Node.js and Angular/AngularJS?

Angular is a JavaScript-based frontend development framework, and AngularJs is the predecessor of Angular. On the other hand, Node.js is a server-side runtime environment that allows developers to run JavaScript code on the server side.

So, Angular/AngularJS is used to build client-side applications, while Node.js is for server-side development.

Q2: Why is Node.js popular?

Node.js is one of the most popular web technologies among developers. The use of JavaScript for server-side development, handling high concurrency, support for building highly scalable and efficient applications, and non-blocking I/O are some of the key reasons behind the popularity of Node.js.

Q3: Is Node.js a programming language?

No, Node.js is not a programming language. It is a runtime environment allowing developers to run JavaScript code outside the web browser.

Q4: Is Node.js a framework?

No, Node.js is not a framework. It is a runtime environment that provides an environment to run JavaScript code. Node.js is often mistaken as a framework since it includes several core libraries and APIs to help developers build web applications.

Conclusion

Node.js has become one of the most popular web technologies due to its excellent features like non-blocking I/O, event-driven nature, scalability, cross-platform support, and performance. It also has one of the largest developer communities and a wide range of third-party libraries to speed up development.

However, Node.js is not a silver bullet, and there are some limitations you need to understand. For example, Node.js is unsuitable for CPU-intensive tasks and requires knowledge of asynchronous programming. So, developers must identify their requirements before choosing Node.js as their runtime environment.

I hope this article provided a complete overview of Node.js, how it works, its features, and uses cases to help you decide when you should and should not use Node.js.

Please subscribe via this link

Also published here.

Software Deployment Best Practices in 2023

Lalit Kumawat — Sat, 15 Jul 2023 12:06:43 +0000

Deployment is the day when the software is finally released to the world.

Yet, as Stackify CEO Matt Watson said, organizations lack confidence in deployment. One of the greatest strengths of agile is the ability to deploy rapidly. However, moving too fast and without following the right processes, one can witness problems like downtime, errors, and poor user experience.

In addition, software deployment includes various activities like installing, configuring, testing, and monitoring the performance of newly deployed environments. For instance, there are a few practices for deploying software like A/B testing, Shadow Deployment, Grey Box Testing, Black Box Testing, White Box Testing, etc.

Here are the best practices that can assist you with an effective software deployment:

Separate Clusters for Non-Production and Production
Having an enormous cluster often creates problems for security and resource consumption. Therefore it is crucial to have two clusters at the minimum – one for production and another for non-production.

The Latest DZone Refcard

The Essentials of GitOps

Here is how you can separate clusters for production and non-production:

When using Kubernetes, use the K8 cluster for each environment.
Keep all the clusters in different namespaces.
Give access to the production cluster to fewer people.
Iterate faster to prevent production failure.
Carefully Collect Deployment Metrics
Kubernetes clusters have distributed services that support dynamic software. Therefore, it becomes crucial to have appropriate metrics to enable the applications to adapt to traffic. In addition, metrics can help measure the success of the deployment, enabling continuous monitoring of the performance of an application.

Follow these ways to collect Kubernetes clusters with ease:

Deploy Kubernetes cluster to run commands.
Use kubectl get to run commands against Kubernetes clusters and query the metrics API.
Retrieve compact metric snapshots.
Query resource allocations
Employ the Kubernetes dashboard to browse cluster objects.
Implement a Continuous Integration Server
A continuous integration server is software that centralizes all of your integration processes and provides a dependable building environment. In addition, it is highly adaptable and allows you to create different projects for various platforms.

The most critical consideration when utilizing a CI server is having a clean machine ready for installation. An environment free of excessive tools, environment variables, and other customizations is essential for running the CI server and overall process properly.

Here are the practices to run a continuous integration smoothly:

Frequently commit codes
Fix broken builds as soon as possible
Write unit tests
Ensure all tests must be passed
Avoid breaking code
Use of Deployment Checklist
Every task constituting multiple steps seems complex to accomplish unless you have a process. The same goes for deploying new software too. Preparing an app deployment checklist ensures that all the critical tasks are completed with utmost precision. Also, it is a must for one to be aware of the application's KPI.

Based on the above two parameters, you can make customized checklists for software deployment catered to your team's needs.

Consider Applying Resource Limits
If you are deploying your application to Kubernetes, there is no resource limiter by default. Without a limiter, your application can consume the entire cluster's resources, disrupting the production cluster's performance. That's why it is crucial to have resource limiters to avoid such circumstances.

When setting limits, it is important to consider potential traffic and load bursts. Although Kubernetes is known to provide resource elasticity, maintaining a balance is important. Setting the limit too low can lead to application crashes, and setting it too high can make the cluster becomes inefficient.

Automate Your Deployment Process
Manually deploying can work, but it is not the right way to do it. When a complex process like deployment is done by hand, it leaves too much room for human error. Automating deployment processes reduces errors and speeds up deployments making the process convenient for your team.

Automation can be deployed simply by using scripts to deploy specific actions in a specific environment. Many advanced CI/CD tools in the market support automated deployment.

Elon Musk launches his new company, xAI

Lalit Kumawat — Sat, 15 Jul 2023 11:44:02 +0000

Elon Musk on Friday said the purpose of his new artificial intelligence company, xAI, will be to "understand the universe."

In an often meandering 90-minute long Twitter Spaces audio chat, the billionaire discussed his vision for xAI for the first time while veering into topics such as the Earth's evolution and the fragility of civilization.

In seeking to deepen the understanding of the universe, Musk joked that xAI's mission statement would be "what the hell is really going on?"

Musk announced the formation of xAI on Wednesday after accusing companies like OpenAI and Google of developing the technology without considering risks to humans.

OpenAI and Google did not respond to request for comment.

He said xAI would seek to build a "good AGI," as an alternative to Microsoft, Google and OpenAI. AGI stands for artificial general intelligence and refers to AI that can solve problems like a human.

During the Spaces session, which had a delayed start as Twitter needed to "tweak the algorithm" to promote the chat to more users, Musk said xAI would work closely with his other companies, Twitter and Tesla.

The company will use public tweets to train its AI models and may also work with Tesla on AI software.

Such a relationship would have "mutual benefit" and could accelerate Tesla's work in self-driving capabilities, Musk said.

He also accused all AI companies of training their models using Twitter data in what he characterized as an illegal manner.

Musk, who has advocated for regulations in AI, said he has pushed for meetings with White House officials and has emphasized the importance of regulating AI in his recent meetings with top government officials in China.

Also published here.

How to Optimize your GitHub Repository for Open Source Development ?

Lalit Kumawat — Tue, 11 Jul 2023 08:22:02 +0000

Contributing to open source can be an awesome experience to help you learn, get job opportunities, network with people and also help others at the same time.

This article would give you tips to help prepare your GitHub repository for open-source contributions.

It is assumed that you have basic experience with markdown syntax to work with most of the files needed in this article.

Tips and Tricks
Creating your README
The README.md is the entry point to your project when people visit your repository. It should contain:

the description of the project.

why the project is useful.

how to get started.

relevant information on using the project etc.

Most projects with short documentation would have the README. I’d recommend the same except the documentation is huge, you need to have it somewhere else that can support search, pagination, etc.

**Writing your Contribution Guideline
**To create a contribution guideline, create a CONTRIBUTING.md at the root of your project and provide information that is necessary for new and old contributors to contribute to your project.

It can include information like:

the different ways contributors can contribute to the project.

how contributors can clone the repository on their local machine.

how contributors can set up the code on their machine for development.

how contributors can report bugs.

**Defining the Code of Conduct
**Working with people can be tasking in some cases and open-source projects are not protected from people with abusive intent. Creating a code of conduct sets a foundation for creating a positive environment for people to contribute without disruption by negative behaviors like sexual harassment, verbal abuse, etc.

Create a CODE_OF_CONDUCT.md at the root of your project. Using markdown syntax, the file can contain information about:

the project community pledge,

the project community standards,

enforcement guidelines.

You can adapt the guidelines provided here to create your guideline.

**Creating Status Checks
**To enforce good development, you can include a form of status check each time a pull request is made to your project. Status check let you know if commits meet the conditions set for the repository. The checks can include continuous integration like:

**units tests
**code coverage
code quality checks like DeepSource, SonarCloud, etc.
GitHub Actions is recommended to trigger jobs or workflow by certain events on your repository.

**Protect your Main Branch
**Using GitHub, you need to protect your main branch to enforce that certain requirements are met before pushing to the branch. Protecting the branch can also prevent deletion or force pushes to the branch.

To set up protection rules for the main/default branch, ensure you have admin access to the repository then click on Settings > Branches and click on Add branch protection rule:

Then you can configure or select the rules you want active:

To read more about GitHub branch protection rules, you can visit here.

**Create Pull Request Templates
**To set a foundation for code reviews, you can create a pull request template with sets of required information that you feel is necessary for code review.

To create the template, create a new directory, called .github, and create a new file in the directory called PULL_REQUEST_TEMPLATE.md.

A sample template could look like this:

Description

Issue closed #(issue)

Change Type

[ ] Bug fix
[ ] New feature
[ ] Breaking change
[ ] Minor changes in old functionality

Checklist

[ ] My changes are well-tested and commented
[ ] I reviewed my changes
[ ] My changes generate no new warnings

**Make Use of GitHub Labels
**You can utilize GitHub Labels to help create a standard workflow in a repository. You can use labels to categorize issues, pull requests, and discussions.

GitHub provides defaults labels with their description, some of which includes:

bug: indicates an unexpected problem or unintended behavior.
documentation: indicates a need for improvements or additions to documentation.
duplicate: indicates similar issues, pull requests, or discussions.
enhancement: indicates a new feature request.
good first issue: indicates a good issue for first-time contributors.
help wanted: indicates that a maintainer wants help on an issue or a pull request. etc

To read more about GitHub Labels, you can visit this documentation.

**Create Templates for Issues
**Once contributors start noticing and using your project, it is very likely for a number of issues to be created on your repository.

At the time of writing this article, Typescript has over 5000 issues in its repository.

Creating templates for issues is a great way to organize issues in your repository.

To create these templates, create a directory named, ISSUE_TEMPLATE, in the .github directory which is at the root of your project. Then create a new markdown file directly to create separate templates.

I will create a sample feature request template in a file called feature_template.md:

name: Feature Request
about: Suggest a new idea for this project

labels: enhancement

Viability Checklist

[ ] this wouldn't be breaking change in existing JavaScript
[ ] this will not change the runtime environment
[ ] this feature can be implemented with JavaScript

Suggestion

Use Case

Conclusion
Open source is not restricted to writing codes alone. You can help with documentation, help share and talk about the project with your friends, help with product designs, and many more. I hope this article is able to get some guidelines that can help you get started in your next open-source project.

I am currently building a newsletter to share informative articles and news, my progress in creating startups with little experience, and how you can learn from my experience.

Please subscribe via this link.

Also published here.

10 Advanced Git Commands

Lalit Kumawat — Tue, 11 Jul 2023 06:55:53 +0000

For many developers, truly harnessing the power of Git can be a daunting task. Git can seem intimidating when you first start using it. This is one of the reasons most developers limit themselves to using the standard push, pull, and merge commands.

However, over the years, Git has emerged as the standard tool for version control because of how powerful it is. So if you’re using Git on a regular basis, then you can vastly improve your workflow by learning some of these advanced features.

In this article, I’ll discuss ten advanced Git commands every developer should know.

Top
Git Rebase
If you wanted to merge all your commits in a feature branch to the main branch, what probably comes to mind is using the git merge command. This will take all of the changes in the featured branch and stuff it into one merge commit and then put that merge commit into the main branch. After those changes are combined into that merge commit, it looks scattered, especially when you have a bunch of people working on the featured branch and pushing changes almost every time.

using git merge
The git rebase command can solve that for us. It takes all of your commits from a featured branch and moves them on top of the main commit.

git rebase
A great advantage is that it easily traces your commits inside the main branch.

_git rebase
You should use the git rebase command to consolidate into a single branch when you have multiple private branches. And it will display the commit history in a linear form. In a linear history, it’s easy to see the progression of changes because they are all applied one after the other, without any branches or merge commits. This can make it easier to understand how the code evolved over time.

Additionally, a linear history can make it easier to track down bugs because you can more easily see when a particular change was introduced. It can also make it easier to revert changes since you can simply revert a single commit rather than dealing with the complexity of merging branches.

Searching a Git Repo
Have you ever wanted to search for a string in your repository history? Well, you can do that now with the grep command, which helps you search for a specific string inside all the commits (the entire history of the project).

Git Grep
git grep is a useful tool for quickly searching through the codebase of a Git repository to find specific information searches through the tracked files in the current branch of a Git repository and returns a list of lines that match the specified pattern. It can be used to search for code snippets, function calls, or specific strings of text.

To search through files in your working directory (current project state) you can make use git grep :

_git grep STRING
Here’s an example of searching for the word “blockchain” in a web3 repository:

_git grep blockchain
Here’s the result:

searching for the word blockchain
Git Rev-List
You can also perform complex searches by adding the git rev-list. To understand how to do this, let’s take a brief look at the git rev-list

The git rev-list is a Git command used to list the revisions in a Git repository. It provides a list of all the commit objects in the repository, including the commit hash, author, date, and message, sorted in reverse chronological order. The output of the git rev-list command can be used to display the commit history, track the progression of a Git repository over time, or perform various operations on the commits.

_git rev-list [OPTIONS] []
Here,OPTIONS is a list of optional parameters that control the output of the git rev-list command, and is a list of revisions that you want to list.

For example, to list all the revisions in the repository, you can run:

_git rev-list --all
To list the revisions reachable from the current branch, you can run:

_git rev-list HEAD
To list the revisions between two branches, you can run:

_git rev-list branch1..branch2
You can use the git rev-list command in combination with other Git commands, such as xargs and git grep, to perform more complex searches.

_
git rev-list –all | xargs git grep -F ''
Using xargs is useful in this case because it takes the output of the git rev-list command, which is a list of all revisions in the Git repository, and passes each revision as an argument to the git grep command, so that the contents of each revision can be searched for the specified string.

You just have to replace the with the string you want to search for:

_
git rev-list --all | xargs git grep -F 'test'
This will search for the word ‘test’ and display the results.

Here’s the result:

searching the word ‘test’
Git Log
The git log command is one of the most useful Git commands you should be familiar with. When you need to look at your commit history, you use the git log command. The git log command displays the most recent commits as well as the current state of the HEAD.

_git log
In the images below, you can see a log or history of the commits made so far.

git log
Notice that each commit includes a unique sha-id created by the SHA algorithm. It also includes the date, time, author, and other information.

You can scroll through your log history by pressing the k key to move up and the j key to move down. Press q to exit.

You can also view your logs as a graph just by adding the --graph option:

_git log --graph

git log graph
Git Diff
Comparing changes you made between two files or branches before committing or pushing is helpful as it allows you to review your changes and make sure they are ready to be shared with others. This can help you catch mistakes or unintended changes before they are committed to the repository, which can save time and reduce the risk of introducing problems.

Thankfully, with git diff, you can do that. It lets you see what has changed between two branches, commits, and files.

Git Diff to Compare Files
To check the working directory against the local repository:

_git diff

git diff
This will show the differences between the file you are currently working on and the version in the last commit. The output will show a list of changes, with added or modified lines highlighted in green.

Git Diff to Compare Branches
To see the differences between two branches:

_git diff branch1 -- branch2

difference between two branches
This will show the differences between the two specified branches. The output will show a list of changes for each file that has differences between the two branches, with added or modified lines highlighted in green.

Git Diff to Compare Commits
To see the differences between two specific commits:

_git diff commit1 commit2

difference between two commits
This will show the differences between commit1 and commit2. The output will show a list of changes for each file that has differences between the two commits, with lines that were added or modified highlighted in green.

Git Reflog
Reflog is another simple but useful command. The term reflog refers to reference logs.

Git Log vs Git Reflog
Unlike the git log command which provides a history of the changes to the contents of the repository, the git reflog command provides a history of all updates to the references in a Git repository.

This command displays the most recent commits, pulls, resets, pushes, and so on your local machine. It allows you to return to any commit, even if a branch or tag doesn’t reference it.

The reflog retains information about the previous status of branches and allows them to be restored if necessary. This is an excellent method for tracking down any issues like lost commits, debugging problems, e.t.c that may have arisen and determining what you did to cause those issues.

_git reflog

git reflog
Git Revert
The revert command allows you to undo changes made to a repository’s commit history on the current branch.

To use git revert, Simply give the commit you wish to reverse to the command, and it will undo all modifications made since that commit.

_git revert
One thing to remember is that this only undoes changes from that specific commit. If you revert a month-old commit, it will not remove any modifications done since that point. It will only undo the changes made in that specific commit.

Another thing to remember is that using git revert does not truly erase the previous commit. Instead, it generates a new commit that undoes all of the modifications made in the previous commit. This is beneficial since it preserves the history of your repository.

You can also use this if you want to revert the latest commit:

_git revert HEAD
Git Prune
git prune removes stale or dormant objects from a git repository. Stale object can be a branch or tag that is deleted, or a commit that is amended or rebased. In Git, a stale object becomes unreferenced and unreachable.

Git prune acts as a trash can for unused data in the git repository history. This function is an offspring of the garbage collection command and is not immediately executed. The git garbage collection command (gc) is in charge of keeping a repository alive. It clears out all the clutter in a repository and keeps it clean.

_
git prune < --dry-run>| <-v> | <--progress> \
|<--expire |<-- > |…
--dry-run: doesn’t execute the prune but rather lists what it will remove
-v (--verbose): displays the output of pruned data and actions
--progress: displays output indicating the prune’s progress
--expire : specifies when the wasted objects will expire
…: specifies the options that are referenced from the commit’s head
Git Stash
git stash allows you to temporarily save changes that you have made to your working copy so that you can switch to a different branch, pull in upstream changes, and switch back to your original branch, at which point you can apply the saved changes.

It works by keeping or saving all of your uncommitted changes while also cleaning up your working tree. Stashing is helpful for you if you need to move away from what you are doing, say to fix an urgent bug, but aren’t quite ready to commit what you’ve done so far.

_git stash
This simple command saves all your code modifications but does not commit them. Instead, it saves them locally on your computer. When you’re ready to continue, you can pull your changes from the stash with this command below:

_git stash pop
Git Tag
Tags are references that point to specific commits. Tagging is generally used to capture a point in history that is used for a marked version release (i.e. v1.0.0). By default, tags are not transitive, meaning they don’t move when new commits are added. A Git tag is similar to a branch that won’t change, although, unlike branches, tags have no further history of commits after they are established.

_git tag
For example, if you want to create a new tag named v1.0.0, you can use the following command:

_git tag v1.0.0
This will create a new tag at the current commit. If you want to create a tag for a specific commit, you can specify the commit hash:

_git tag v1.0.0
You can also use the -a flag to annotate the tag with a message:

_git tag -a v1.0.0 -m "Release version 1.0.0"
To push the tags to a remote repository, you can use the git push command with the --tags flag:

_git push --tags
This will push all of your local tags to the remote repository. To view the list of tags you made in your repository:

_git tag --list

tag list
Git Clean
You can use the git clean command to deal with untracked files. It functions differently from the git checkout and git reset, which work on files that have already been added to the Git tracking index. This command removes all untracked files from your working directory.

_git clean
The git clean command requires you to use either the -f or -n flag when running it. If you don’t use either of these flags, the command will fail with an error message similar to “no f’s given”. For example, if you try to run git clean without any flags, you might see an error message like this:

error message
Let’s take a closer look at some of these flags used alongside git clean:

git clean -n
git clean -n: The -n flag is used to show a dry run of the command, which means it will display the files and directories that would be removed, but it won’t actually remove them.

Here’s an example, using the -n flag:

_git clean -n

git clean dry
As we can see, it is displaying the file that would be removed.

git clean -f
git clean -f: This flag is used to force the removal of untracked files and directories from your Git repository.

Here’s an example, using the -f flag`:

_git clean -f
Here’s a screenshot of the result:

git clean force
The command forcibly removes the text.txt file

git clean -f -d
git clean -f -d: This combination of flags will forcefully remove untracked directories from your Git repository, but it will not remove any untracked files.

Here’s an example, using the -f -d flag:

_git clean -f -d

git clean force directories
The command forcefully removes the untracked directories in our example.

Conclusion
Git is a very powerful collaboration tool. If all you ever learn is push, pull, and merge, you can still go far. But mastering Git is worth the effort. It can increase your productivity and improve the quality of your collaborations with other developers.

The commands covered in this tutorial are just the start. There are many more. You might want to check out Git aliases and git bisect, and other interesting commands.

That’s it for today!
Do us a favor and let us know you made it this far with a like 💙 & Connect with us via newsletter - Lalit Kumawat Tech

Thanks for reading,

Lalit Kumawat

Why is GitHub not Open-Source?

Lalit Kumawat — Tue, 11 Jul 2023 06:01:56 +0000

GitHub, a widely popular platform for developers, has revolutionized the way code is shared, collaborated on, and managed. However, despite its commitment to open-source software, GitHub itself is not open-source. In a recent interview with Zach Holman, an engineer who worked at GitHub for five years and later advised GitLab, we gain insights into the factors that contributed to GitHub's success, its approach to building a developer community, and the decision to keep the platform closed-source. Let's explore the key takeaways from this conversation.

Timing and Building a Developer Community

One of the significant factors that played a crucial role in GitHub's success was timing. Zach Holman emphasizes the importance of seizing the right moment to launch a product. GitHub's founders had a deep understanding of the Ruby community, which allowed them to build a strong initial user base. By capturing the attention of influential developers and providing a valuable platform, GitHub started gaining traction organically.

Culture and Developer Evangelism

Zach Holman sheds light on the role of culture and developer evangelism in GitHub's growth. GitHub embraced an open-source approach internally, modeling itself after successful open-source projects. This approach fostered a culture of collaboration and transparency, resonating with developers worldwide. Zach Holman played a pivotal role in promoting this culture through conference talks and advocating for the open-source way of working.

Transitioning to a Larger Organization

As GitHub grew from a small team to a company of 250 employees, it faced unique challenges in maintaining its culture. The addition of managers and the need for more structured processes became inevitable. Zach acknowledges that scaling the company culture while maintaining productivity and innovation was a complex task. The transition from a managerless organization to one with a hierarchical structure required careful implementation and adjustments.

The Open-Source Dilemma

The decision to keep GitHub itself closed-source, despite its focus on open-source software, was a subject of ongoing discussion within the company. Zach Holman acknowledges the merits of both approaches. While open-sourcing aspects of the product can promote transparency and community collaboration, it also presents challenges in managing contributions, dealing with potential negativity, and maintaining a competitive advantage. GitHub's experience and exposure to various scenarios influenced the team's perspective on open-sourcing their entire product.

GitHub vs. GitLab: Differences and Perspectives

Having also advised GitLab, another prominent platform for developers, Zach Holman provides insights into the significant differences between the two companies. GitLab's strong commitment to open-source principles and its transparent decision-making processes set it apart. Zach acknowledges that GitLab's open-sourceness has a significant impact on its culture and product development pace. However, he emphasizes that both GitHub and GitLab have found success by employing different approaches, proving that there isn't a single correct path.

Transitioning from Engineering to Angel Investing

Zach Holman's journey from engineering at GitHub to angel investing brings a unique perspective to the discussion. He highlights the advantage of having technical knowledge when investing in tech companies. By advising and investing in different startups, Zach gained valuable insights into diverse industries, broadening his perspective. Investing became an extension of his advisory role, allowing him to leverage his experience to make informed decisions.

Wrapping up

The interview with Zach Holman provides valuable insights into the growth of GitHub, the challenges of scaling company culture, and the decision-making process behind keeping the platform closed-source. GitHub's success can be attributed to factors such as perfect timing, a strong developer community, and an open-source culture. While GitHub remains closed-source, the conversation also highlights the merits of open-sourcing aspects of a product. Ultimately, the success of platforms like GitHub and GitLab showcases that different approaches can lead to remarkable achievements in the developer community.

That’s it for today!
Do us a favor and let us know you made it this far with a like 💙 & Connect with us via newsletter - Lalit Kumawat Tech

Thanks for reading,

Lalit Kumawat

AI is Killing Remote Work

Lalit Kumawat — Sun, 09 Jul 2023 01:30:00 +0000

In 2020 and 2021, many a breathless think-piece was written about the Future of Work. The Old World was never coming back, and we all had to adapt to the reality forced upon us by COVID, or be left behind.

Visions tended to vary, but most agreed: Work from Home was here to stay. How could we ever go back to cubicles after a once-in-a-century plague forced us to take stock of work-life balance’s importance?

Oh how we were wrong. Amazon, Goldman Sachs, Disney, Dell… so many companies have asked employees to come back to the office over the past months that it may be easier to name the ones that haven’t done so (Airbnb? Coinbase?).

Employees have fought back, but the fight is not long for this world. They will all come back of their own volition. And the rise of General Artificial Intelligence is at fault.

As we witness AI becoming proficient in the ways of mundane corporate work (making presentations, helping clients, generating financial reports…), we get more anxious about our replaceability. We ask ourselves “What can I do that can’t be automated?” “How can I make sure I come out on top of this technological revolution?”

Sure, we crack jokes with our colleagues about the mistakes ChatGPT makes. We write sarcastic little Tweets saying “Our jobs are safe, fam”. But we’re all asking these same questions. We’re scared.

The smartest among us will have realized that the talents still unique to humanity are interpersonal and best exercised in-person. Collaboration. Leadership. Creativity. Brainstorming. All matters of soft skills. In fact, work that can’t be automated is the personality you bring to the office. No amount of technology seems to be able to replace this… because it can only happen organically.

And so, as white-collar jobs get increasingly automated, workers will willingly go back to the office, where they can show that they’re more than three ChatGPTs in a trench coat. And those people will be the ones to survive and get promoted; show me work you can produce alone at home and I will show you work that can be off-shored and/or automated.

Remote work was a zero-interest-rate phenomenon. That world is dead.

That’s not to say this is a positive. Work-from-home allowed flexibility that many benefited from. The ability to be at the office from 8 to 8 is, after all a privilege — in a twisted, capitalist way. But the world is changing, and togetherness is where the value is now.

As we experience the five stages of grief for a world some of us feel we no longer have a place in, there is still time to improve the corporate hellscape we are all going back to for fear of being left behind.

Instead of thriving for work-life balance, we can use AI and automation to make the “Work-Life Integration” concept come to life. Technological innovation can make some work happen anywhere, at any time, while other tasks can only be completed through in-person collaboration.

Allowing employees to desperately organize both types of work around their daily lives will be key to employee retention. That sounds a lot like “hybrid work”… but that concept does not go far enough. If teams want to meet at a restaurant or in a park at 9 pm (after spending quality family time) to brainstorm, let them!

This leads us to the concept of physical workspaces. They need to be reimagined. The cubicle is dead. Office towers are next. 15-minute cities have already been prophesied… and need to include 15-minute offices: spaces near the home where quality organic work can happen for a short while. And I don’t mean WeWorks. Those should remain buried.

Remote work is dead. It doesn’t mean the Old World is not equally so. We can evolve. We can do better.