DEV Community: Vaishnavi M

Create react app vs Vite

Vaishnavi M — Wed, 25 Sep 2024 15:04:03 +0000

I have always relied on the npm command create-react-app to create the starter files for any React.js project. It does what it says on the tin, and creates all my starter template files, setups a local dev server and dev environment. Over the years I have become a little impatient because it takes around 3-4 minutes to setup a basic barebones app. Recently I have come to know about a faster way to setup React apps, which also gives you all the useful features that create-react-app gives you too. It is using a tool called Vite. Vite is another build tool like Webpack (create-react-app uses Webpack under the hood, read more here).

In this post I will take you through the steps on how to install React.js app using Vite and point out some differences too. You can also see a video on the comparison of the two installation methods. In the Video below, You will discover that the installation time, plus time to run local server is astonishingly fast for Vite.

So how do we start the ball rolling
You can refer to the Vite docs, From there, you can choose from a few methods to start off your installation. We are going to use the template method. In their docs, the listed methods are:

#npm 6.x
npm init vite@latest my-vue-app --template vue

#npm 7+, extra double-dash is needed:
npm init vite@latest my-vue-app -- --template vue

#yarn
yarn create vite my-vue-app --template vue

But these commands are for installing Vue.js, just as side note, Vite was originally developed for Vue.js but has been modified to use with other frameworks including React.js. For our case, all we need to do is replace the keyword after '--template', from vue to react. And dont forget to replace the app name to your choosing. So assuming that we are running npm version 6.x, we will run the following command:

npm init vite@latest my-react-app --template react

Then we will cd into our directory and install the remainder of the starter files and run the dev server:

cd my-react-app
npm install
npm run dev

If you goto the browser. You should see a React logo with a counter and a button, as below.

Directory structure of the our newly created app

The thing to note here is that, main.js is the root file that imports/loads App.js. There is also a new file called vite.config.js, this is circled in the above image. This file is used to turn on and set new features for your build process. I will come to this file in the next section below.

One last thing about importing files...

I have noticed that out the box this setup does not allow for absolute paths. With create-react-app, you can do

import x from 'components/x'

. With Vite, you have to do the relative pathing, like

import x from '../../../'

To fix this we need to change the vite.config.js file, which looks like this:

import { defineConfig } from 'vite'
import reactRefresh from '@vitejs/plugin-react-refresh'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [reactRefresh()]
})

we need to add an extra setting to resolve the path, this change will go after the "plugins" settings. It will end up looking like this after the change:

import { defineConfig } from 'vite'
import reactRefresh from '@vitejs/plugin-react-refresh'
import path from 'path'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [reactRefresh()],
  resolve: {
    alias: {
      '@': path.resolve(__dirname, './src'),
    },
  },
})

and this will allow us to refer to paths as

import x from '@/component/x'

!IMPORTATNT to prefix with '@' in path.

conclusion

I did find Vite impressingly fast. It took me 55 secs to install and run on local server. I have not done much heavy development using Vite but it looks promising. It is too early for me to say if I will use it on any bigger projects in the future. There are other methods of installing React.js using Vite, these methods are maintained by other communities. Check out other community maintained templates here, you can also find one with Tailwind. Please leave comments on your experiences too.

Note: Vite has templates to build apps in the following frameworks

vanilla
vanilla-ts
vue
vue-ts
react
react-ts
preact
preact-ts
lit-element
lit-element-ts
svelte
svelte-ts

so to create a build in react typescript , just change the last bit to "react-ts" after the "--template" , so it becomes:

npm init vite@latest my-react-app --template react-ts

Git Rebase vs Git Merge: A Comprehensive Guide

Vaishnavi M — Mon, 16 Sep 2024 09:41:00 +0000

Git, a distributed version control system, offers a variety of ways developers can integrate changes from one branch into another: git merge and git rebase being two of the most commonly used strategies. Understanding the differences, benefits, and best practices of both can greatly enhance your Git workflow efficiency.

Understanding Git Merge

Think of git merge as a handshake between two branches. The git merge command integrates changes from one branch into another. It takes the contents of a source branch and integrates it with the target branch. If the histories of both branches have diverged, Git creates a new merge commit to combine the histories, preserving the history as it happened.

Consider two branches, feature and master:

A---B---C feature
 /
D---E---F---G master

Merging feature into master would result in:

A---B---C feature
 /         \
D---E---F---G---H master

The master branch now includes a new commit H that represents the merge commit, preserving the history of both branches as they happened.

Understanding Git Rebase

git rebase is a command that allows you to integrate changes from one branch into another, similar to git merge. But it works in a different way. Let's consider git rebase as a painting process. Imagine the master branch as a wall and the feature branch as an artist. Initially, the master branch (the wall) is painted first. The feature branch (the artist) then comes in and adds their work on top of the master branch's work.

However, if the original painting (the master branch) is updated, the artist (the feature branch) would temporarily remove their painting, allow the wall to be updated, and then add their painting back on top of the updated wall. This is essentially what happens in git rebase.

git rebase takes the changes made in the feature branch and reapplies them onto the master branch, effectively creating a new base for the feature branch and rewriting history. This results in a more linear and clean commit history.

Consider again two branches, feature and master:

A---B---C feature
 /
D---E---F---G master

Rebasing feature onto master would give:

D---E---F---G master
             \
              A'---B'---C' feature

Commits A, B, and C are reapplied onto master, creating new commits A', B', and C'.

Comparing Git Merge and Git Rebase

Benefits and Use Cases

Preserving History: Git merge preserves history as it happened, including the time and order of all commits, while Git rebase can rewrite and clean up history, making it more linear and comprehensible. This can be beneficial when you want to understand the development process.

Conflict Resolution: When merging, conflicts need to be resolved once during the merge commit. However, during a rebase, you may have to resolve conflicts for each commit being reapplied. This can become tedious if many commits have similar conflicts.
Best Practices

Rebase for Local Cleanup: Rebase can be used to clean up local, in-progress features. By periodically performing an interactive rebase, you can ensure each commit in your feature is focused and meaningful.

Merge for Public Commits: Once you have shared your branch with others, it is best practice to use merge. Rebase could potentially rewrite the commit history and create confusion for other developers.
Avoid Rebasing Public Branches: Rebasing a public branch that others have based work on is a bad practice as it alters the commit history. This can cause confusion and further conflicts for other developers.

Conclusion

Both git merge and git rebase are powerful tools for integrating changes from one branch into another. They serve different purposes and are used in different scenarios. It's essential to understand the implications of each and choose the right tool for the right situation.

git merge is great for combining code from two different branches and preserving the exact historical timeline of commits. On the other hand, git rebase is excellent for making your feature branch up to date with the latest code from the master branch, keeping the history of your feature branch clean and making it appear as if the work happened sequentially.

In both cases, conflicts can arise and need to be resolved manually. But remember, once you've shared your branch with others, it's a best practice to use git merge to avoid rewriting public commit history.

Understanding Blockchain Technology: A Comprehensive Guide

Vaishnavi M — Mon, 16 Sep 2024 08:58:11 +0000

What is Blockchain ?
Blockchain is a distributed ledger technology that allows records of transactions across several computers in a safe and clear manner. As it does not require any central authority to tamper with the data, the block is immutable and tamper-proof. The generalized application of this technology is seen in cryptocurrencies, smart contracts, and other industries for safe data management.

How Blockchain Works ?
A blockchain stores data in blocks, which are collected together in a chronological chain. Each block contains a cryptographic hash of the previous block; hence, if any alteration is done in the previous block, it can be recognized easily due to the change in the hash. Transactions are validated by a decentralized network of computers, and hence the system is secure and resistant to the entry of malware.

Types of Blockchain

Public blockchain (e.g., Bitcoin, Ethereum)

Private blockchain (e.g., Hyperledger)

Consortium blockchain (e.g., Corda)

Hybrid blockchain

Applications of Blockchain Technology

Cryptocurrencies and Digital Payments (Bitcoin, Ethereum)
Supply Chain Management
Healthcare
Voting Systems
Real Estate
Smart Contracts
NFTs and Tokenization

Blockchain in Industry

Blockchain is transforming industries like,

Finance
Logistics
Government
Energy
Intellectual Property

Challenges and Limitations

Scalability issues
Energy consumption concerns
Regulatory and legal challenges
Security vulnerabilities

Future of Blockchain Technology

Trends in blockchain development (Layer 2 solutions, interoperability)
Role of blockchain in Web 3.0
Potential impact on the economy and society
Integrating blockchain with other technologies (AI, IoT)