**R**eact, the most popular front-end framework nowadays, and for good reasons, let alone its virtual DOM, one-way data binding, simplicity, and several other amazing features.



Preact, on the other hand, is a clever approach to come around with a tiny core-value proposition of React, having the same API composition, but way faster and easier than React.



>“The objective behind developing PreactJS is to offer memory efficiency, better performance, and closer compatibility with React.”



Over the course of a few years, a wide spectrum of websites from small open-source projects to the large MNCs have managed to switch to Preact, that includes Google, Uber, Pepsi, Financial Times, Tencent QQ, Housing.com, The New York Times, Dailymotion, Groupon, and the list goes on and on.

Here, we’ll discuss a few things about Preact-



## What is Preact??


Preact is a JavaScript library, known as _“Fast 3kb React Alternative with Same ES6 API” _or _‘Drop-in replacement for React’_, created by Jason Miller. The most interesting thing about this library is its small size. The particular ‘3kb alternative’ term is used to indicate its 3kb size.




Regardless of its smaller size, it claims to perform better than React. It is a React clone library that is identical to React in terms of modern API, Components & Virtual DOM. Swapping React with Preact is very easy and that too without worrying about performance attenuation.


## What Does Preact has In-Store for You?



You would be surprised to see how easy it is to use Preact. All you have to do is to install Preact and preact-compat and alias this preact-compat in your code with React. (Here, compat stands for compatibility)


>“preact-compat is a 2kb compatibility layer that allows you to leverage the many libraries of the React ecosystem and use them with Preact.”



This aliasing enables the React ecosystem to be used in your application. You can import and use react modules & libraries, as many as you want, in your Preact project. That’s incredible, isn’t it??



Here’s a small list of features that Preact has in-store for you-



- Similar React API & Patterns
- ES6 Class Components: Classes that expressively define stateful components.
- Higher-order Components: Return other components from render()
- Stateless Pure Functional Components: Functions that accept props as arguments and return JSX/VDOM
- Extensive React compatibility
- Virtual DOM Diffing: Preact’s diff is simple, effective, and extremely fast
- Supports all modern browsers and IE11+
- Highly Optimized Algorithm
- Seamless Server-Side Rendering
- Component and Element Recycling
- Transparent Asynchronous Rendering with a Pluggable Scheduler
- Instant Production-Grade App Setup with Preact CLI

## Features of Preact



Preact supports almost all the modern browsers nicely, such as- Chrome, Firefox, Safari, Edge, and IE11+.



Due to its plethora of plugins and add-ons, companies are taking a quick shift to it. It aims to deliver a few key goals, as given below-



- **Lightweight:** The feature that makes it highly popular is its considerably smaller size. To your surprise, the largest part of the application will be your code. That means, without stressing about keeping the framework under control, you’ll have a lot of time for coding only.
- **High Performance:** Preact is one of the fastest virtual DOM libraries. The qualities that make it faster is not just its tiny size but also the simple and predictable diff implementation that makes it faster.
- **Embeddable:** Preact can be embedded into a widget and by applying some tools, you can build an app without complex integration.
- **Instantly Productive:** Productivity increases many times when you don’t have to work on its size. Being lightweight, it spares your efforts and gets you productive instantly.
- **Ecosystem Compatible:** By aliasing React to Preact, you can make use of thousands of components from the vast React ecosystem.
- **Portability:** The virtual DOM component can easily be taken to other places, which could not be done otherwise.



## How Preact Differs from React??


While discussing ‘what makes Preact different from React’, the very first and most obvious difference is its size. When React weight 45kb (around), Preact is just 3kb.



However, there are some other reasons that add up to the differences. Though, many of them are either frivolous or can be removed completely by using the compatibility layer ‘preact-compat’.



Let’s see what are differences in this so-called replica of React-



- Instead of className, you can just use classfor CSS Classes.
- this.state and this.props have been passed to render().
- The h() function turn JSX into a ‘Preact-understandable’ structure.
- Element and component pooling is possible in Preact.
- setTimeout(1) for batching of DOM updates, debounced or collated.
- PropType is not available in Preact’s core, though supported in preact-compat.
- Preact components do not implement childContextTypes or contextTypes, receive all context entries from getChildContext()

## Starting Up with Preact CLI



Preact CLI is the Command-Line Interface that runs in the terminal of your system and helps you get started with building modern preact applications instantly, without any configuration. It is built upon the open-source tools such as Webpack, Terser, Babel, etc.



In order to get started with [Preact CLI](https://github.com/preactjs/preact-cli/), you don’t need any prior knowledge and this, the simplicity, makes it the most preferred way to use Preact above all. You’ll get everything, right from hot reloading to critical CSS inlining, organized here for you. You can expect excellent and amazing performance from Preact projects with it.



#### You can install it with a simple command-

Let’s move further and bring the out-of-box features of it in the limelight-



- Fully Automatic Code-Splitting
- Differential JavaScript Serving
- PRPL Pattern Support for Efficient Loading
- Pre-rendering for a fast Time to First Paint
- Support for Sass, Stylus, LESS and CSS Modules
- Hot Module Replacement
- Automatic App Mounting & Debug Helpers

## Switching from React to Preact



Preact is an exquisite choice to develop progressive and interactive web applications. The small size of Preact is preferable when you’re on a tight loading performance budget. The large bundles of JS lead to stretch the loading times, but by shorting down the library code by Preact, it loads quicker.



Switching to Preact from React can shave off multiple KBs in your project and makes it faster by enhancing the interactivity in one RTT.



There are basically two approaches to switch from React to Preact, that is-



- Setting up & aliasing preact-compat
- Switching imports to Preact and removing incompatible code


In your existing React app, you can try out Preact using the preact-compat compatibility layer. It lets you continue with your React/React DOM code with slight or no changes at all in the codebase.



This preact-compat package increases the bundle size by 2kb only and provides a major advantage by supporting the vast ecosystem of React modules. It enables you to work with Preact just like react and react-dom.


The process includes a few steps-

### #Installing & Setup

### #Aliasing React to Preact via Webpack


```
{
"resolve": {
  "alias": {
    "react": "preact-compat",
    "react-dom": "preact-compat"
    }
  }
}
```

## A Simple ‘Hello World’ App



Let’s make a simple ‘Hello World’ app. Our end goal here is to have an app that renders a text ‘Hello World’-




```
#With JSX
const App = <h1>Hello World!</h1>;      
#Without JSX
const App = h('h1', null, 'Hello World');
#Injecting the app into DOM
render(App, document.body);
```

Congrats, we’re done here. You’ve built your first Preact app.

## Upgrading to Preact X



Recently, Preact Team took a huge step by releasing the newest version, i.e., [Preact X](https://preactjs.com/guide/v10/whats-new), in the series after Preact 8.x. In a nutshell, it’s a tiny, complete and feature-rich package.



According to the team-


>“We’ve rethought every bit and byte of our code and added a plethora of major features in the process. The same goes for compatibility enhancements with the React ecosystem to support more third-party libraries.”



It brings a bunch of new and exciting features, some of them are mentioned here-

- **Fragments:** Special components that, without an extra wrapping DOM element, render children elements in line with the parent elements. Also, they allow returning multiple nodes from render.
- **Hooks:** Make logic-sharing within the components easier and can be imported via preact/hooks .
- **preact-compat** has moved to the core repository and now can be imported via preact/compat (note the slash).
- **componentDidCatch:** Enable catching and handling of errors within render.


There are so many other fixes in Preact 8.x, if you’ve filed to work with a library then give it a try with Preact X, I’m sure you won’t be disappointed.



Well, folks, I’ve tried to cover almost all the important matters (in-short) in this blog. Still, there’s so much more to know and learn about Preact. Whatever we learn can never be enough.

>“Knowledge is infinite and indestructible. It can never be destroyed and remains in this universe in one or other forms.”




## Final Words:


Are you confused about what to use, React or Preact?? Well, it completely depends upon your project requirements. Both of them have their own set of features and functionalities, though quite similar, but unlike enough.



You can use React for large scale apps, complex projects or other heavy stuff, whereas, the opposite is true in the case of Preact. It would work better for smaller and lighter apps. There is no point in building a complex application with Preact and importing several modules from the React ecosystem, wouldn’t it be better to just finish it with React??



Thanks for reading till the very end!! If you liked it then go further and reach out to our website [https://www.habilelabs.io/blog/ ](https://www.habilelabs.io/blog/ ) for more similar stuff.

medium_preact-a-clever-alternative-of-react.jpg

small_preact-a-clever-alternative-of-react.jpg

thumbnail_preact-a-clever-alternative-of-react.jpg

Preact- A Clever Alternative of React

Decorators are literally used to decorate the code with clean syntax. They are simple functions and placed immediately before the code that is being decorated.

## Overview About Decorators

- These Decorators dynamically change the functionality of property or function.
- They are identified with the symbol ‘@’ as prefixed before a method or a variable name.
- Whenever we want to use any decorator, we must need to explicitly import it from ‘lwc’ as shown below:


```
import {LightningElement, decoratorName} from 'lwc';
```

In Lightning Web Components, we are having three types of Decorators.

-  @api
-  @track
-  @wire


Here, we have shown in detail how to decorate a method or a property-

## Decoration with a Method


```
@decoratorName
getMethodName()
{
    return somevalue;
}
Ex: @track
getName()
{
return name;
}
```


```
@decoratorName propertyName='propertyValue';
Ex: @api name = ‘John’;
```

### @api:
- With @api, we can expose a public property.
- Public properties are reactive.
- If the value of public property changes, the component re-renders., so when a component is re-rendered, all the expressions used in the template are re-evaluated once again.


Import the @api decorator from lwc as shown below:


```
import { LightningElement, api } from 'lwc';
export default class TodoItem extends LightningElement     {
    @api name= 'John';
}
```

- Parent component can make use of the Public Property.
- A component that declares a public property can set only its default value.
- A parent component that uses the child component in its markup can set the child component’s public property value.


Let us understand @api decorator with the help of an example:

We have 2 components:

- api_example_child
- api_example_parent


#### api_example_child –
**In .html-**

![salesforce-decorators-in-lightning-web-components-1.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_1_1b3ae817b7.jpg)

**In .js-**

![salesforce-decorators-in-lightning-web-components-2.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_2_e0cd721ccc.jpg)

Here, we have a course as public property as it is decorated with the @api course. Now, parent components can make use of this Public Property course.

#### api_example_parent–
**In .html-**

![salesforce-decorators-in-lightning-web-components-3.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_3_c75e8671da.jpg)

Here, Course is the public property (i.e  @api) of the child component so its values can only be passed by parent components as shown above.

**In .js-**

![salesforce-decorators-in-lightning-web-components-4.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_4_5229d8ff07.jpg)

Final Output:

![salesforce-decorators-in-lightning-web-components-5.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_5_7d672a9d89.jpg)

### @track :

- With @track, we can expose a Private reactive property.
- Here, Reactive means if there is any change in JavaScript property, the component will re-render and all the expressions used in the template will be re-evaluated again.
- The properties, which must be used within the component where it’s been defined, are termed as Private Properties.
- When we use the @track decorator, we must import it explicitly from ‘lwc’ as shown below.


```
import { LightningElement, track } from 'lwc';
```

Example:

We have a component named as track_example–

**In .html-**

![salesforce-decorators-in-lightning-web-components-6.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_6_eb161ceaf4.jpg)

**In .js-**
![salesforce-decorators-in-lightning-web-components-7.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_7_21023462d7.jpg)

Here,

- Description is private reactive property as it is declared with @track. So, it can only be changed with-in the component where it is defined. (track_example).
- The default value for description is ‘Lightning Web Component Decorators’. So, when we click on the ‘Update Message’ button on the UI, the description property value is getting updated.

### Output

![salesforce-decorators-in-lightning-web-components-8.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_8_9ba135898c.jpg)
![salesforce-decorators-in-lightning-web-components-9.jpg](https://backend.habilelabs.io/uploads/salesforce_decorators_in_lightning_web_components_9_8095de060a.jpg)

Then, Click on ‘Update Message’ Button.

### @wire:


- By nature, it is reactive.
- When inside the Lightning web component, we need data from Salesforce, we go with @wire as it is used to read the salesforce data.
- When we use the @wire decorator, we must import it explicitly from ‘lwc’ as shown below.


```
import { LightningElement, wire} from 'lwc';
```

- While using the @wire to call the apex method from a class, the apex method must always be annotated with @AuraEnabled(cacheable=true).


```
public class wireFromLWC {
@auraEnabled(cacheable = true)
public static string retrunName(){
	return ‘John’;
}
}
```

- Those apex methods which are not ‘cacheable=true’ can’t be called via @wire decorator.
- The data returned by apex method can’t be modified within the .js file.
- The refreshApex functionality can only be used with @wire property or function.

## Conclusion:
In this blog, we have learned about the decorators used in the Lightning Web Components (LWC) that can add the functionality to a method or a property as per the business requirements.

All the above-mentioned decorators are unique to LWC. I hope that you find this information beneficial for your next project.

Thank You for reading!

Salesforce – Decorators in Lightning Web Components

medium_salesforce-decorators-in-lightning-web-components.jpg

small_salesforce-decorators-in-lightning-web-components.jpg

thumbnail_salesforce-decorators-in-lightning-web-components.jpg

I am working on a project where we have a React web app, React Native app, and another React Native app which is built using expo. All these three projects share a common backend, service layer, and redux logic.



There are some other common components as well that can be used across react native and expo app.



So, we needed an architecture to avoid duplicate code across the projects. I stopped for a moment and thought, what could be better than the monorepo architecture? It will also solve the problem stated above.



The Monorepo architecture provides the leverage to reuse much of the service layer, redux related code, and other shareable pieces of code across the components.



In the tutorial below, I will show step by step how can you use react web, react native, and react native Expo project in one monorepo.

Let’s check out what exactly is a Monorepo??



## Monorepo??


As stated by Wikipedia-

>A monorepo, syllabic abbreviation of monolithic repository, is a software development strategy where code for many projects is stored in the same repository.


![react-native-react-web_1.jpg](https://backend.habilelabs.io/uploads/react_native_react_web_1_e80c604f85.jpg)


In simple words, monorepo contains more than one project code, which allows us to share code between many projects. Each project can have its own build and deployment system or can share build systems.



Many companies, including Google, Twitter, Facebook, etc. follow this process.



Now, I will discuss all the things that we used, the challenges we faced, and resolved during this journey.



You can also take the help of the demo repository I created. (Link is given at the end of this tutorial).


## Getting Started with Monorepo for React and React-Native


We decided to use yarn-workspaces for our use-case. Lerna is an excellent tool to manage yarn workspaces.



As described on the Lerna website about itself -


>Lerna is a tool that optimize the workflow around managing multi-package repositories with git and npm.



To use Lerna, we will first need to install it. I am assuming you’ve already had Node.js and npm installed in your system.


```
#Installing Lerna 2.x
$ npm install --global lerna
#Creating project repository
$ git init lerna-repo && cd lerna-repo
#Turning folder into Lerna workspace
$ lerna init
```


```
lerna-repo/
  packages/
  package.json
  lerna.json
```

Now, you are ready with Lerna Workspace. Here, the packages, as per the name dictates, will contain different modules.

Let’s start adding a React js project into packages-



## Create React App into Monorepo


```
#Creating app in packages folder
$ npx create-react-app <app-name>
#Example
$ npx create-react-app web-app
```

Please note that NPX _supports only npm 5.2+ and higher versions, so if you have a lower version then you definitely need to upgrade it._



Once it is completed, go to the root folder of your repository and run-

All the required modules will be installed and hoisted to the root folder by this command.


To start the web application-


```
$ lerna --scope=web-app run start
```

Congrats!! You are done with your first package.

## Add React Native App Package


Go to the packages folder and run the following command-


```
$ npx react-native init <App name>
```


```
$ npx react-native init NativeApp
```

It will create all the folders and files required for the native app.



Once the process gets completed, go to the root folder and install packages again-

It will create React Native and other dependencies to root in npm_modules of monorepo. However, create-react-native-cli command expects react-native to be inside the package. If we still try to run it, there will be an error.



To fix this issue, we will use the yarn-workspaces [nohoist](https://classic.yarnpkg.com/blog/2018/02/15/nohoist/) feature.



In workspaces key of JSON package, we will add-


```
"nohoist": ["**/react-native", "**/react-native/**"]
```

Now, we’re gonna install packages again using yarn command.

Then we can start the apps using the following commands.


```
#Starting the android app
lerna --scope=NativeApp run android
#Start iOS app
lerna --scope=NativeApp run ios
```

Please note that an iOS app will work in MacBook only.



Well, now you have a repository that has both React web app and React Native mobile apps.



As we move further, we will try to add a React-Native expo project in this Monorepo as another package. If you don’t need an expo project, then you’re done here. You can stop right here!

## How to Make Expo Work with Monorepos??


1. Add expo-yarn workspaces as devDependency to the expo project, inside the ExpoApp folder.


```
$ yarn add --dev expo-yarn-workspaces
```

2. Add a postinstall script to package.json.

3. Add "postinstall": "expo-yarn-workspaces postinstall" under the "scripts" object in the app's package.json file.



>As per the documentation, expo-yarn-workspaces work only on macOS and UNIX based systems, Windows is not supported.



If we want it to work on Windows as well, then we need to make slight modifications to it.



Firstly, remove the postinstallscript from package.json and move it to the main package.json-


```
"postinstall": "cd ./packages/ExpoApp && expo-yarn-workspaces postinstall"
```

I tested the above workaround on macOS & Windows, and guess what?? It works like charm.



4. Now, define the entry module in the "main" field of package.json.



5. Specify "__generated__/AppEntry.js" as the value of the "main" field in package.json



Here is how the final package.json will look like-


```
{
  "name": "root",
  "private": true,
  "devDependencies": {
    "lerna": "^3.20.2"
  },
  "dependencies": {
    "metro-config": "^0.56.0"
  },
  "scripts": {
    "android": "lerna --scope=NativeApp run android --stream --",
    "ios": "lerna --scope=NativeApp run ios --stream --",
    "web": "lerna --scope=web-app run start --stream --",
    "expo": "lerna --scope=ExpoApp run start --stream --",
    "postinstall": "cd ./packages/ExpoApp && expo-yarn-workspaces postinstall"
  },
  "workspaces": {
    "packages": [
      "packages/*"
    ],
    "nohoist": ["**/react-native", "**/react-native/**", "**/expo", "**/expo/**"]
  }
}
```

6. Create metro.config.js in ExpoApp root folder with the following content-


```
const { createMetroConfiguration } = require('expo-yarn-workspaces');
module.exports = createMetroConfiguration(__dirname);
```

5. Reference metro.config.js in the app.json file inside the expo key.


```
"packagerOpts": {
  "config": "metro.config.js"
}
```

Now, go to the root folder and install packages again, using $ yarn .


```
#Start expo app
$ lerna --scope=ExpoApp run start
```

It will successfully start the expo app. But when you scan the app code on it, you will get an error as ‘react-native not found’.



As we said earlier that React Native should not be hoisted but the expo package is still hoisted. As a result, expo cannot find React-Native.



So, we need to update the hoisting of packages inside the _package.json_ file.


```
"nohoist": ["**/react-native", "**/react-native/**", "**/expo", "**/expo/**"]
```

After updating the package.json file with proper hoisting, we need to install the packages again using $ yarn .


Now try starting the expo project again-


```
$ lerna --scope=ExpoApp run start
```

Wow!! You’ll see that the Expo app has started working inside the monorepo environment.



Together with the expo project, you can run the React web app and React Native projects as well.



Here is the full folder structure-


![react-native-react-web_2.jpg](https://backend.habilelabs.io/uploads/react_native_react_web_2_45a9808e7e.jpg)

You will find the full code [example here](https://github.com/habilelabs/expo-react-react-native-monorepo-example).


All the code is quite simple and straightforward. I hope I’ve made every step very clear. Furthermore, if you have got any queries, feel free to reach out. If you are looking for a team for react or react-native then please contact us.



If you liked the blog then hit claps to it. Do you know that you can clap up to 50+ times??

medium_react-native-react-web_feature.jpg

small_react-native-react-web_feature.jpg

thumbnail_react-native-react-web_feature.jpg

React Native, React Web and Expo-Together in One Monorepo

Welcome to this journey to learn JMeter! Before discussing JMeter, we will learn about what’s Performance Testing.

It is important to ensure the effective performance of software application and therefore, Software Testing is required to ensure that the application runs smoothly without any fiascos.

## What is Performance Testing?
Performance Testing is a non-functional type of testing. It ensures software applications to perform well under their expected workload.

#### Attributes of Performance Testing:

- **Speed–** It checks the response time, rendering of data, and accessing.
- **Scalability –** It determines the maximum user load.
- **Stability –** It checks the stability of application under varying loads.
- **Reliability–** It determines whether the software product is secure or not.

## JMeter Basics:

JMeter is an open-source, pure Java platform software that is designed to load test functional behavior and measure performance. It can perform load and performance tests on Web Pages, Web Applications and static or dynamic resources Like Database, Rest Webservices, LDAP, Java Objects and more.

## How to Install JMeter –

- First of all, download JDK latest, and JMeter.
- Now install the prerequisites.
- Start the JMeter and follow the path.
- JMeter > go to bin folder > Double click on JMeter batch file & wait for few seconds to launch the JMeter GUI.

![how-to-test-performance-testing-using-jmeter-1.jpg](https://backend.habilelabs.io/uploads/how_to_test_performance_testing_using_jmeter_1_7864d510e1.jpg)

## Elements of JMeter:


JMeter consists of several components, known as Elements. These elements are designed in such a way that each one performs a specific task. Some of the main elements are:

- Thread Group
- Samplers
- Listeners
- Configuration


### Thread Group


It is a collection of threads. These threads simulate how the user interacts with the application, how the load is maintained and over what period of time.

![how-to-test-performance-testing-using-jmeter-2.jpg](https://backend.habilelabs.io/uploads/how_to_test_performance_testing_using_jmeter_2_1364f0ae8e.jpg)

For example, if you set no. of threads 100, JMeter will create and simulate 100 user requests to the server under test.

### Samplers
JMeter supports testing HTTP, FTP, JDBC, and many more protocols. Samplers help JMeter to send a request to the server and wait for the response. Each sampler generates one or more sample results.

![how-to-test-performance-testing-using-jmeter-3.jpg](https://backend.habilelabs.io/uploads/how_to_test_performance_testing_using_jmeter_3_23a24d5c8d.jpg)


- **FTP request:** An FTP request is made to do a performance test on the FTP server. Users can send an FTP ‘Download File’ or ‘Upload File’ to the FTP server.
- **HTTP request:** User can send an HTTP/HTTPS request to a web server.
- **JDBC request:** This sampler lets you execute Database Performance Testing. It sends a JDBC Request to a database.
- **BSF Sampler:** This sampler allows you to write a sampler using a BSF scripting language.
- **Access Log Sampler:** This sampler lets you read access logs and generate HTTP requests.
- **SMTP Sampler:** Used to send email messages using the SMTP protocol.

### Listeners
Listener is a component that shows the results of the test execution. These results can be shown in various different formats such as a tree, table, graph or log file.

![how-to-test-performance-testing-using-jmeter-4.jpg](https://backend.habilelabs.io/uploads/how_to_test_performance_testing_using_jmeter_4_fdcc54d586.jpg)

- Graph result listeners: It displays the server response time on a Graph.
- View Result Tree: It shows the result of the user request in basic HTML format.
- Table Result: It shows the summary of test results in the tabular format.
- Log: It shows the summary of test results in the text file.

### Configuration Elements
These elements are used to set up the defaults and variables for later use by samplers.

![how-to-test-performance-testing-using-jmeter-5.jpg](https://backend.habilelabs.io/uploads/how_to_test_performance_testing_using_jmeter_5_8af5855404.jpg)


- **CSV Data Set Config:** It allows us to read different parameters from the text file. Also, we can read lines from the file, and split them into variables.
- **HTTP Cookie Manager:** It has the same feature as a web browser. If an HTTP Request has made and the response contains a cookie, the Cookie Manager automatically stores that cookie to use it for all future requests.
- **HTTP request default:** This element lets you set default values that your HTTP Request controllers use.
- **Login Config Element:** The Login Config Element lets you add or override username and password settings in samplers.

## Conclusion:
As we discussed the JMeter performance, with the help of this open-source tool you can check the performance both on static and dynamic resources. It can be integrated with Bean Shell & Selenium for automated testing.Script Test.

I hope, this blog will help to better the performance testing results while using its element components & features in testing. You can also know that How to Create Maven Project in Eclipse for Selenium? for automation testing.

Feel free and ask me anything in the comment box related to “Test Performance Testing Using JMeter”, if you have some confusion.

Thanks for reading this blog!!

How to Test Performance Testing Using JMeter

medium_how-to-test-performance-testing-using-jmeter.jpg

small_how-to-test-performance-testing-using-jmeter.jpg

thumbnail_how-to-test-performance-testing-using-jmeter.jpg

How to Test Performance Testing Using JMeter?

**W**ondering what Docker is? Actually, it’s something worth wondering about. If you’re a Network Engineer or Software Developer, you would already be familiar with Docker- a fantastic tool for developing, shipping and deploying applications within “containers”.



It would be hard not to get attracted to it seeing its amazing ability of containerizing applications.



If you take a dive into the depths of the Internet you would find a whole stack of articles about it but only a few of them are beginner-friendly. Thus, I found myself coerced to write about docker for beginners.



Hopefully, this post will clear all your concepts about docker, and you’ll be able to create your first container.

## What is Docker??


Docker is a stateless server that packages software into standardized units called containers that have everything the software needs to run including libraries, system tools, code, and runtime.



>Docker is an open-source software platform that lets us build, test, run and deploy applications reliably and quickly. It was launched in the year 2013 by Docker Inc. Since then, it’s been the cause of attraction and excitement among developers across the IT world.



Some short-listed features that make it so popular, are-


- Compatibility with almost every programming language you’re familiar with.
- Easier Workflow
- Agility and Simplicity for Software Development
- Handy Application Encapsulation
- Easy Scaling and Monitoring
- Faster Development & Deployment



## Why Do We Need Docker ?



Almost every developer finds himself in such a situation, every so often, when their project works fine as long as its running on their laptop/machine. But, when it is moved onto production state, server or maybe another machine, it usually fails to work even close to fine (and It’s very annoying!). The efficiency, optimization, and performance with which it was working earlier get compromised critically.



You would be baffled to know how frequently these cases come out. The average rate is — about every 3 out of 4 projects.



Likewise, if you develop any website using any framework and move it onto the web server, you’ll definitely face some diminishes and uncertainties.



Docker is an ultimate solution to all these problems and a relief for the developer’s world. In fact, it’s been designed specifically to address and resolve such issues.


## Docker Terminology



Let’s understand a few important terms about Docker-



**Docker Engine:** Docker Engine is a key part of Docker. It is a client-server application, having a CLI (Command Line Interface), Rest API, and a server as its components. It creates and runs the containers from the Docker Image.


![docker_1.jpg](https://backend.habilelabs.io/uploads/docker_1_e8d89e56a5.jpg)



**Docker Container:** A docker container is a standardized, lightweight, stand-alone unit of software that contains entire software/application code, along with its configuration, dependencies, libraries, and tools, all wrapped up into a portable format, ready to run on any computing environments.



You can put these containers anywhere you like and the application will run exactly and absolutely like it was working on your machine.



>A docker container is a docker image brought to life.



Docker container is the running instance of the code that was stored in the form of a docker image.



Algorithm for a docker container looks like-


![docker_2.jpg](https://backend.habilelabs.io/uploads/docker_2_e206e2d605.jpg)

**Docker Image:**  By the term ‘Image’, you don’t need to suppose it to be a picture. The context of Docker Image goes beyond the physical images, they are more like blueprints of a software, holding together the code, libraries, Dockerfile and everything else that needed to run it.



A docker image is a set of stateless and immutable files containing the application code and environment required by an application to run. It’s a read-only file which means you cannot modify it. It will remain like that forever as nothing has ever changed.



## What are Virtual Machines (VMs)??


Before containerization entered into the picture, the job of isolating and organizing applications was done by Virtual Machines (VMs).



_A virtual machine is a software or virtual server that emulates the functionality of a hardware server. It makes it possible to run what appears to be multiple machines on hardware which actually is a single computer._



The virtual machines run many applications on the same hardware, this process is known as Virtualization.



Both containers and VMs pursue the same goal of isolating the applications and its dependencies in a self-contained unit that can run in any environment. While the VMs virtualize the hardware, containers virtualize the operating system.



So, which one is better??



Now, this is the tricky part. Both play a significant role, depending upon the requirement. While VMs are more secure, containers are still preferred as they are more portable, efficient, flexible, lightweight and, above all, consume fewer resources.



## Essential Functions of Docker



There is a long list of tasks that we can do with docker, which is quite impossible for me to explain in this single blog but we will definitely learn about some important ones -



- Client-side Application Program- You can pack up the whole software code along with its configuration, libraries and move it anywhere you like.
- It acts as a service and can be deployed on to any server.
- You can fix the bugs and redeploy the application in the development environment only.
- Acts as a social networking platform where you can share your work in the form of docker containers.

## Understanding Docker with ‘Hello World’ Example



You’re going to learn a lot form this very simple example (If you’re a beginner!!). If you’re a regular user of Docker then it’ll be like a nursery-class lecture.



Starting from the installation, I’ll go through every necessary step such as creating Dockerfile, building, and processing Docker Image, running the container, and a few additional things.



Keep up with me so that you don’t miss anything-


### Install Docker:


#### For Windows:


```
https://hub.docker.com/editions/community/docker-ce-desktop-windows/
```

#### For Linux:



Install some prerequisite packages under the following command-




```
#Installing some prerequisite packages
$ sudo apt install apt-transport-https ca-certificates curl software-properties-common
#Add the GPG key to the docker repository
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
#Add the docker repository to APT
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
#Update the database
$ sudo apt update
#Install Docker
$ sudo apt install docker-ce
```

### Create a Dockerfile and Index:



I’m sharing an example of creating a simple ‘Hello World’ container in here. Follow me step by step to learn the whole process of building and running a container-



After successfully installing Docker, we will create a Dockerfile-



- Create a text file named ‘Dockerfile’.
- Pull the Nginx docker image to serve your static webpage in the Dockerfile, as mentioned here-


```
FROM ubuntu
RUN apt-get update
RUN apt-get install nginx -y
COPY index.html /var/www/html/
EXPOSE 80
CMD ["nginx","-g","daemon off;"]
```

Add the commands for a simple web application of ‘Hello World’ in index.html file, like this-


```
<!DOCTYPE html>
<html>
<head>
<title>Page Title</title>
</head>
<body>
<h2>Hello World</h2>
<p>&copy; Welcome to Docker</p>
</body>
</html>
```

**Note:** The index.html and Dockerfile have to be saved in the same directory.

### Create a Docker Image:


To build the docker image, run the command-

Note: “_hello_world_ is the name of the docker image.”


### Run the Docker Container:



After the successful build of the docker image, run the container with the following command-


```
docker run -d -p 8080:80 hello_world
```

To check the running container or to render the docker container on the web browser you need to hit the URL-

#### Output goes here -


![docker_3.jpg](https://backend.habilelabs.io/uploads/docker_3_4fd77e46d6.jpg)


**Note:** The -p parameter represents the port number. Any web application is run on a browser with a specific port number.



For example-



_8080:80_ means all the requests hitting on port 80 will bind to 8080 port only.



**Additional:** 


```
#To check the status of your docker container
docker ps
#To enter into the docker container
docker exec -it <container ID> bash
#To check the logs of running container
docker logs <container ID>
```

Once you’re done by creating a Docker Image, you can share it on Docker Hub and make it public.

## Future with Docker/ Business Value of Docker



Do you have any rough guesses about what is the statistical condition of Docker in the marketplace?? Not even close?? That’s fine, let me break it to you that more than 15,000 companies are currently using Docker.



The pie-chart below will picturize the general usage of Docker in the international market-



![docker_4.jpg](https://backend.habilelabs.io/uploads/docker_4_d93bb2cc46.jpg)


With 40%, Software companies have occupied the majority of ratio. Then comes IT field with 17%, followed by HR & Recruiting industry with 10%.



The remaining proportion is covered by Telecommunications, Hardware, Consulting, Healthcare, Accounting, Socializing, and Retail industries. With every passing year, the pace of using Docker is increasing at a high rate, in each and every niche.



## Parting Words:



From the very moment when Docker was first introduced, it’s been easing the lives of developers. There have been a few misconceptions about Docker, such as, it’s not secure, requires Cloud, and all, but it has ruled them all out.



As a result, most of the companies have started shifting towards containers-driven environments.



The unbound flexibility and portability of Docker makes it a powerful tool. And who knows what the futuristic Docker has in store for us??



Thanks for reading this blog. Hopefully, you liked it. If it’s a yes, then stay connected with us.

Docker — Develop & Deploy Containerized Applications

medium_docker_feature.jpg

small_docker_feature.jpg

thumbnail_docker_feature.jpg

React is a JavaScript library, developed and maintained by Facebook, used to build user interfaces. It is a component-based architecture in which one can use two approaches, Class/Stateful Component, and Functional/Stateless Component. This architecture increases the reusability of the code.

In Class Components, we have all the lifecycle methods and can say like a game with complete control in our hands, while the same is not true in the case of Functional Components and we don’t have control over it. Therefore, in order to take control, React.js gives us the power of Hooks for the functional components. So, let’s start playing with this power of new controls.

## React Classes & Hooks

In React version <=16.7, if we are creating any component with state or which can access the react life cycle methods, it has to be a class component. We can create a class component by extending **React.Component** class of React and using **render()** function which will return HTML.

Hooks were introduced from >=React 16.8 versions. Basically, Hooks are the functions that provide us to write stateful logic, which was only possible in the Class component, but with the help of hooks, we can write the same logic separately and reuse that logic.

## Overview About React Hooks


Hooks are functions that let you “hook into” React state and lifecycle features from functional components. Hooks don’t work inside classes, instead, let you use React without classes.

By using hooks, we can remove the nesting, only left is our render function which is of pure rendering logic. We have some pre-built **hooks like- useState, useEffect, and useContext-**

![react-hooks-why-better-than-classes-1.jpg](https://backend.habilelabs.io/uploads/react_hooks_why_better_than_classes_1_f68747f320.jpg)

- **useEffect** stops it from being spread across three different lifecycle hooks. We can use the same hooks useEffect when we need to update something after every render, code won’t become increasingly nested.
- **useState** allows us to use the stateful logic in functional components. In the above example, we are using useState to maintain the key-p

## Use Cases:
Though hooks have some benefits over classes, it does not address all the features of classes. We can still use classes, let’s see in the example below-

![react-hooks-why-better-than-classes-2.jpg](https://backend.habilelabs.io/uploads/react_hooks_why_better_than_classes_2_5f7d262dd4.jpg)

There are some downsides as well, let’s have a look at them-

- If you need to use the same key pressed logic in some other component than we need to write the same code again and again.
- If you have more behavior like this code gets complicated.


Let’s review some of the ways we can use them-

### Mixins –
Using mixins we can group all lifecycle like-

![react-hooks-why-better-than-classes-3.jpg](https://backend.habilelabs.io/uploads/react_hooks_why_better_than_classes_3_dd53eda9bb.jpg)

Mixins allow you to mix some additional functionality into React components. Refactoring needs to be easy. These mixed-in behaviors need to be more obvious that they don’t belong to the component. They shouldn’t be using the internals of the component. ES6 classes do not support mixins to React. Instead, we have a HOC concept.

Mixins are not deprecated from React, you can still use mixins by using React.createClass to create React components.

## Higher-Order Components (HOC) –


The HOC is a technique of re-using react components all over again. HOC is a function that accepts a component and returns a new component. HOC commonly used by third-party libraries like Redux connect.

We can use the Higher-Order component by creating a container that passes in props. Let’s try the composition –

![react-hooks-why-better-than-classes-4.jpg](https://backend.habilelabs.io/uploads/react_hooks_why_better_than_classes_4_2fb0923003.jpg)

Now, we have all the benefits of MIXINS. We have a <KeyRender/> component that is not tightly coupled to the subscription behaviour. Do we always need to make a new component??

#### Rules to Remember-

While using hooks, there are some rules you need to remember-

- Hooks always call at the top level of the render function.


We can’t make conditional hooks and can’t reorder them on every render. If you want conditional effects, you should split your hooks into other components.

- Hooks can use only in React Function Components, and in Custom Hooks.
- There are not hook primitives for **componentDidCatch**
- Avoid using lifecycle methods like **componentDidMount, componentDidUpdate, componentWillUnmount**.


While using hooks, avoid lifecycle methods, instead, you can use hooks like useEffect or you can also create your own custom hooks.

## Wrap-Up


Using hooks will solve many of the problems which we often experience while using React Classes, but there are still some cases like we cannot access lifecycle methods while using hooks.
Again, this guide was not meant to convince you to use hooks or completely refactor the Classes to Hooks.
Just a friendly reminder that there are other options as well, available out there to experiment with!
Hooks don’t replace your knowledge of React concepts. If you are really interested in learning more about hooks, try to apply this concept to the new projects, you are assigned with.

Thank You!

medium_react-hooks-why-better-than-classes.jpg

small_react-hooks-why-better-than-classes.jpg

thumbnail_react-hooks-why-better-than-classes.jpg

React Hooks – Why Better than Classes?

**It**‘s been a year (almost!) since Google Cloud Platform (GCP) first announced this interesting serverless SaaS product, knows as ‘Cloud Run’. It was built with the idea to bring serverless computing to fully-managed container service.



>Cloud Run allows you to create dynamic web and mobile applications that automatically scale to meet traffic demands with a pay‐per‐use billing model.



That means you no longer have to pay for the times the application is not used and need not bear any hefty infrastructure costs.

## Serverless Agility for Containerized Apps



Cloud Run can be defined as the combination of two biggest trends of recent times i.e. Containerization and Serverless. Serverless means no infrastructure management, usage-based pricing, and easier auto-scaling while containerization stands for serving a project with stateless containers.



In its documentation, Google defined it in the best way possible-



>Run stateless HTTP containers on a fully managed environment or in your own GKE cluster.



Cloud Run was built around an open API, Knative, which enables the portability of your workloads and lets them run anywhere inside a stateless container. It allows you to store the docker images of the container with a web server within a specified memory specification/CPU resources and concurrency.



It is responsible for creating endpoints for serving over HTTP requests, routing to the container, and monitor the running container to handle the volume requests.


## Key Features of Cloud Run



Being fully serverless, Cloud Run portrays a different and better scenario of using web server infrastructure. Apart from that, Cloud Run also confers numerous other wonderful features, such as-



- Built-In Logging
- Fast Auto-Scaling
- HTTP URLs
- Supports All Languages, Libraries, and Binaries
- Monitoring Through Stackdriver
- Compatible with CI/CD tooling
- Stateless HTTP-Driven Containers
- Container Workflows and Standards
- Custom Domains
- Integration with Stackdriver Monitoring

## Install Cloud SDK



Cloud SDK is compatible with all of Linux, Windows, and macOS. It is a set of command-line tools used to get direct access to cloud storage, BigQuery, and other Google cloud services. Let’s check out its installation steps-


### For Linux User



Cloud SDK is available in package format for installation on Debian and Ubuntu systems. This package contains all gcloud commands for deployment over the command-line interface.



One can manually install the Cloud SDK by following the instructions below-


```
echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list
sudo apt-get install apt-transport-https ca-certificates gnupg
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key --keyring /usr/share/keyrings/cloud.google.gpg add –
sudo apt-get update && sudo apt-get install google-cloud-sdk
gcloud init
```

### Reduction of the Cloud SDK version



If one wants to go back to a specific version of Cloud SDK, where VERSION has the 123.0.0 module, run:


```
sudo apt-get update && sudo apt-get install google-cloud-sdk=123.0.0-0
```

### For Windows User



- Download gcloud sdk for [windows](https://dl.google.com/dl/cloudsdk/channels/rapid/GoogleCloudSDKInstaller.exe).
- Launch the installer and follow the prompts.
- Be vigilant for the following to be selected:
- Start Google Cloud SDK Shell
- Run ‘gcloud init’


## Troubleshooting Tips:



- If the Cloud SDK fails to run after installing version 274.0.0, refer to this [tracking bug](https://issuetracker.google.com/issues/146458519) for the latest workarounds.
- If your installation is unsuccessful due to the find command not being recognized, ensure that the PATH environment variable is set to include the folder containing find. Usually, this is C:\WINDOWS\system32;.
- If you have just uninstalled Cloud SDK, you will need to reboot your system before installing Cloud SDK again.


## Initialize the Cloud SDK


The gcloud init command is quite useful to perform various common SDK configuration tasks including authorization of the SDK tools, accessing Google Cloud platform, and configuring the default SDK settings.



To initialize the SDK, run the following at a command prompt:

To restrict the command from initiating a web browser, use instead-

To authorize without a web browser and in a non-interactive way, create a service account with appropriate scopes using google cloud console and **gcloud auth enable-service-account** with the corresponding JSON key file.

1. Sign in with your Google user account.

2. In the browser, log in to your Google user account.

3. If prompted, click ‘Allow’ to grant permission to access resources on the Google Cloud Platform.

4. At the command prompt, select a Cloud Platform project from the list, having Owner, Editor, or Viewer permissions.

5. In case of a single project, gcloud init will select it by default.

6. If you have the Google Compute Engine API enabled, gcloud init allows to choose a default Compute Engine zone.

7. It also ensures that you have completed the setup process successfully: Kudos, gcloud has now been configured!



## Connection to Cloud SQL from Cloud Run



Cloud SQL is a fully-managed database service that serves the configuration, maintenance, and administration of PostgreSQL and MySQL relational databases in the cloud.



To use this service in running state in an instance of Cloud Run to a Cloud SQL, one needs to have this service in the container and loaded into the container registry.


![cloud-run_1.jpg](https://backend.habilelabs.io/uploads/cloud_run_1_da450f07b5.jpg)


If you don’t have the container in _gcloud_ run then follow the below-given commands to build and push the docker image-


```
!/usr/bin/env bash
docker build -t image-name .
docker build -t gcr.io/$(gcloud config get-value project)/simple-example:latest .
docker push gcr.io/$(gcloud config get-value project)/simple-example
gcloud beta run deploy --image gcr.io/$(gcloud config get-value project)/simple-example:latest
```

## Connecting to Cloud SQL


Once you are done with configuring docker container correctly, the only way to connect Cloud SQL to cloud run is to use UNIX socket with cloud run instance (follow the below format for connection string):



**/cloudsql / INSTANCE_CONNECTION_NAME**



These connections are serviced to be automatically encrypted without any additional configuration.



Warning: Linux-based operating systems have a maximum socket path length of 107 characters. If the total path length exceeds this length, one cannot connect to a socket from Cloud Run (fully managed).



Cloud Run (fully managed) does not support connecting to the Cloud SQL instance via TCP. The code must not attempt to access the instance using an IP address such as 127.0.0.1 or 172.17.0.1. For example:


```
let variable;
const createVariable = async () => {
variable = await mysql.createVariable({
user: process.env.DB_USER, // e.g. 'my-db-user'
password: process.env.DB_PASS, // e.g. 'my-db-password'
database: process.env.DB_NAME, // e.g. 'my-database'
// If connecting via unix domain socket, specify the path
socketPath: `/cloudsql/${process.env.CLOUD_SQL_CONNECTION_NAME}`,
// If connecting via TCP, enter the IP and port instead
// host: 'localhost',
// port: 3306,
//...
});
};
createVariable();
```

That’s it folk!! I’ll wrap up here, hoping that this whole info about using cloud run services and connecting with google cloud database will be proved helpful for you, sooner or later. Stay tuned with us. 

Cloud Run- Bringing Serverless to Containers

medium_cloud-run_feature.jpg

small_cloud-run_feature.jpg

thumbnail_cloud-run_feature.jpg

The more technology is growing and getting advanced, the more likely people are tilting towards automation. They want everything automated. They expect to achieve fast and efficient results without putting much effort. In short, with low input, they want high output, which is completely fair and possible with the help of latest tools and technology.

The same is true with automation testing. Automation in regression testing spares a great deal of time and manual effort. There are so many tools available for automation testing and in this article, I’m going to describe one of them i.e. Cypress, along with its installation process briefly.

## About Cypress


Cypress is an automation tool for End to End testing. While it seems to be a very good competitor of Selenium, it is quite different both fundamentally and architecturally, at the same time. Firstly, it is not constrained by the same restrictions as Selenium. Also, it uses NPM Packages of Node JS. It’s like setting up a node project. Another, it enables you to write faster, easier and more reliable tests.


#### You can write the following tests in Cypress:



- End-to-end tests
- Integration tests
- Unit tests


Cypress can test anything that runs in a browser. It has its own test runner. A test runner uses two browsers for test, i.e.


- Chrome
- Electron (Headless Browser)


Cypress tests can also be recorded in the Cypress dashboard online. Cypress Dashboard is also useful for reporting. If you compare it with selenium then you would know that selenium doesn’t provide you the tools like Dashboard and Test Runner.


## Installation Process:


- First, [install the latest version of Node.js](https://nodejs.org/en/).
- Then create a folder in which the project will be installed. For example, the folder name is “Project”
- Open that folder & type CMD in its location.
- It will open Command Prompt in that folder.


```
 npm install cypress --save-dev 
```

This command will install cypress as a dev dependency.

![automation-using-cypress-end-to-end-testing-tool-1.jpg](https://backend.habilelabs.io/uploads/automation_using_cypress_end_to_end_testing_tool_1_fd1234c2ec.jpg)


Downloading, Unzipping & Installation will be started after executing the above command. See the below image>>

![automation-using-cypress-end-to-end-testing-tool-2.jpg](https://backend.habilelabs.io/uploads/automation_using_cypress_end_to_end_testing_tool_2_d3b803d251.jpg)

![automation-using-cypress-end-to-end-testing-tool-3.jpg](https://backend.habilelabs.io/uploads/automation_using_cypress_end_to_end_testing_tool_3_77eb8f0ee7.jpg)


Cypress has successfully been installed. See the above image, you’ll see that package.json is missing. If you want to create package.json, then run the command npm init. This package has all plugins & script information needed to execute a project.


This folder will look like this-


![automation-using-cypress-end-to-end-testing-tool-4.jpg](https://backend.habilelabs.io/uploads/automation_using_cypress_end_to_end_testing_tool_4_c7d10110ec.jpg)


## Cypress Test Runner:


To open the cypress test runner, run the command-


```
 node_modules\.bin\cypress open 
```

It shows the already created scripts. If you create your own then it will appear here. See the below image of test Runner-

![automation-using-cypress-end-to-end-testing-tool-5.jpg](https://backend.habilelabs.io/uploads/automation_using_cypress_end_to_end_testing_tool_5_e4fd5c6f3a.jpg)


## Script Execution:


Click on any script then it will be opened in the chrome browser. It looks in chrome like below image>>

![automation-using-cypress-end-to-end-testing-tool-6.jpg](https://backend.habilelabs.io/uploads/automation_using_cypress_end_to_end_testing_tool_6_bada070af7.jpg)


In the Chrome browser, it will show all test suit & test cases on the left-hand side. On the right side, it will show the visual execution of the script in browser. If you want to run the scripts in command line then run the command-

It will run the scripts in headless browser Electron.

## Cypress Dashboard:


If you want to use the cypress dashboard then open URL “https://dashboard.cypress.io/login” in the browser. Log in to the dashboard using your GitHub or Google account. After that, you can configure your project in the dashboard. It will show all recording, screenshots, videos & reporting of your Test execution (As shown in the image).


![automation-using-cypress-end-to-end-testing-tool-7.jpg](https://backend.habilelabs.io/uploads/automation_using_cypress_end_to_end_testing_tool_7_fb3f2eebdb.jpg)

## Conclusion:



Those who are new to automation and only know about the basics of coding, its an easy to use tools for them. The testers who are using selenium can also switch this tool. It shows script execution and bugs in browser as well. Even its dashboard provides full reporting of script execution.

Your feedback is most welcomed in the comments section.

Thanks for Reading!!

Automation Using Cypress End to End Testing Tool

medium_automation-using-cypress-end-to-end-testing-tool.jpg

small_automation-using-cypress-end-to-end-testing-tool.jpg

thumbnail_automation-using-cypress-end-to-end-testing-tool.jpg

Working with new technology can sometimes be too difficult and sometimes too easy. You watch too many tutorials to take opinions from other people. However, it’s up to you how you adapt to new technology.

I remember the first time, when I started learning React.JS, it was hard and a bit complex too. As I was new to JavaScript, I was limited to its basics only. If you are starting to learn React, first of all, you should learn to think in React then only your mindset will adapt to it.

In this blog, I’m sharing my personal experience with React in this article-

Let’s go!!

## #1. Stay Up to Date

The latest version of React has brought several new features, bug fixes, and new deprecation warnings to help prepare for future major releases. So, you need to keep aware of it and stay up to date. Some of the examples are-

#### Lifecycle Methods have changed-

- componentWillMount → UNSAFE_componentWillMount
- componentWillReceiveProps → UNSAFE_componentWillReceiveProps
- componentWillUpdate → UNSAFE_componentWillUpdate


You should adopt these changes because if you don’t, it will throw some warning which is not good for the project.

![important-lessons-i-have-learned-while-working-with-react-js-1.jpg](https://backend.habilelabs.io/uploads/important_lessons_i_have_learned_while_working_with_react_js_1_fc07ad7af6.jpg)

### Deprecating “Factory” Components
React had support for a “factory” component that returns an object with a render method:

![important-lessons-i-have-learned-while-working-with-react-js-2.jpg](https://backend.habilelabs.io/uploads/important_lessons_i_have_learned_while_working_with_react_js_2_4e7e23ce67.jpg)

This pattern was rarely used in the wild, thus, supporting it would cause React to be slightly larger and slower than necessary. If you rely on it, adding **FactoryComponent.prototype = React.Component.prototype** can serve as a workaround. Alternatively, you can convert it either to a class or to a function component.

Lately, so many new features have been introduced to React which we must have to be aware of and implement them in the projects.

## #2. Split Your Code into Smaller Chunks
React is all about the components. So, you have to split bigger pieces into smaller ones. Make it so that if a new person comes into your project, they won’t need days to learn how everything runs.

It’s all about the readability and scalability of your code. If the code has fewer code smells and duplicity, it’s a win-win situation for everyone.

![important-lessons-i-have-learned-while-working-with-react-js-3.jpg](https://backend.habilelabs.io/uploads/important_lessons_i_have_learned_while_working_with_react_js_3_0ee02e978c.jpg)

In the above example, the properties are static. So, we can have a pure component that is responsible for the website’s toaster message.

We can use it anywhere in code, using-


```
toasterInstance(‘Created Successfully’, 2);
```

Similarly, we can use it for others as well, like-

- Error Message
- Page Loader
- Input
- Button

## #3. Always Be Advanced
React is a very developing language, every day some new features and concepts are introduced in it. You must introduce these advanced features to your project.

Most of the people either don’t want to take the challenge or are not eager to put some extra effort to add these new concepts in their projects. But, you should not worry about it and always be ready to take the challenge.

#### There are many terms you can explore like-

- High Order component
- Error Boundaries
- Lazy Loading


Also, don’t be afraid to try something new at your work (within certain boundaries, of course!). Don’t just experiment on personal projects. People will argue, you just need to have a strong point to prove yourself.

#### Use lazy loading like this-

![important-lessons-i-have-learned-while-working-with-react-js-4.jpg](https://backend.habilelabs.io/uploads/important_lessons_i_have_learned_while_working_with_react_js_4_e8e5559ba3.jpg)
![important-lessons-i-have-learned-while-working-with-react-js-5.jpg](https://backend.habilelabs.io/uploads/important_lessons_i_have_learned_while_working_with_react_js_5_af9ebb432d.jpg)

## #4. Refactor Again and Again
People will criticize your work, as a result, you will have to change your code, many times. But it’s a natural process, code is never free of error. For this, we have to refactor again and again the same code.

The very important thing is never to forget to test your software. Do testing every time you make even a small change – don’t be shy of them.

## #5. Don’t Over-Complicate Things
Write code that is easy to understand and easy to use. If you don’t need Redux or something, and still using it because everyone uses it without understanding it’s true purpose, please don’t.

Sometimes you are using the latest technologies and writing complex code to show off, it’s really not needed, write code which is easy to read. Because in the end, you will understand that easier code which was written without showing off. Also, it’s easily understandable for others too.

When some other team members working on your code than for them it’s easy to complete that task without wasting too much time because code is reliable and not too complex. According to me, if your goal is to earn respect than improve your code for the team.

## Wrap Up:
React is a very developing language and if you enjoy working in React js you can learn many new topics, concepts and implement them in your projects.

Before JS, I was working in JAVA and it was difficult to adapt JS. But I was all full of excitement and after working with React js, the excitement is same. React is like every day you learn something new.

Therefore, I would recommend everyone to ask themselves: “Do you enjoy what you do?”

If not, then search for that special piece. Because we have to find that special piece. Success cannot be forced, it must be achieved.

HabileLabs worked on many ReactJS projects successfully and providing value-added ReactJS services for a long time.
Hope this information is useful for you. 

Thanks for Reading!!

Important Lessons I’ve Learned While Working with React.js

medium_important-lessons-i-have-learned-while-working-with-react-js.jpg

small_important-lessons-i-have-learned-while-working-with-react-js.jpg

thumbnail_important-lessons-i-have-learned-while-working-with-react-js.jpg

5 Important Lessons I’ve Learned While Working with React.js

**M**onorepository is a hot topic at the table. Though the concept first appeared about a decade ago, it took so many years for this tool to evolve at a large scale. You would be amazed to know that Google was among the very first companies that embraced this approach along with all its downsides.



>A monorepo is a repository that contains code for many projects and packages.



With monorepo, all you have to do is to manage one repository instead of struggling with multiple different repositories. Facebook and Google present themselves as perfect examples of using Monorepo.

In this blog, we will get a brief insight about monorepo-



## What is Monorepo??



>Monorepo is a combination of two syllabic abbreviations, i.e. mono and repo, where ‘mono’ refers to monolithic and ‘repo’ means repository.



In unison, we’re talking about the monolithic repository which can further be defined as- _A software development strategy to store all the isolated code parts from multiple projects, in a single repository_.



These projects in a monorepo don’t have to be related to each other, in one way or another. But they can still be connected via other means such as dependency management tools.



Monorepo has nothing to do with monolithic apps. Unlike monolithic apps, you can store as many logical apps inside it as you need, irrespective of whether they are website applications or iOS apps.



=> While Git is a version control system used to solve issues around various code versions, Monorepo is a source control pattern which somewhat performs a similar function but with several projects/codebases.


=> You may also compare it with your ‘office work’ folder containing several files, right from documents, packages, servers, applications, etc. In non-technical language, monorepo is nothing but a folder containing the code of several projects in different files (Well, not exactly but close!)


## Why Use Monorepo??



In the programming world, simplicity is everything. A good developer keeps his code as simple as he can. And monorepo is one such approach that helps you to keep your code as simple as possible.



It allows you to follow three basic rules of coding, described as-



- Keeping the code simple
- Reducing the code repetition- DRY Approach (Don’t Repeat Yourself) -
- Rule of composition — Separating out the simple objects and putting them together to form complex ones.


Other than maintaining the code-simplicity and keeping it clean & organized, it also carries some additional features, like-

- Simplified dependency management
- Changes can easily be coordinated across modules.
- Simplified organization of projects.
- Great Tools
- Easier Testing Process
- All-in-one process for lint, build, test, and release.
- Easy to make cross-project changes


Do you know that we can even use react web, react native, and react native Expo project in one monorepo!!

## Tools for Monorepo.



There are a few sets of tools that are excessively used nowadays to manage JavaScript projects having multiple packages in a monorepo. These tools follow the following approach-


![monorepo_1.jpg](https://backend.habilelabs.io/uploads/monorepo_1_a2ec9121dc.jpg)


### Lerna


![monorepo_2.jpg](https://backend.habilelabs.io/uploads/monorepo_2_8cb609bb69.jpg)


It’s a tool that splits up large and complex codebases into smaller and separate packages and publishes each of them on NPM independently. This whole fission is very useful and makes the code sharing process easier. It internally links all the dependencies through symlinking.



>Lerna is a tool that optimizes the workflow around managing multi-package repositories with git and npm. It can also reduce the time and space requirements for numerous copies of packages in development and build environments.

![monorepo_3.jpg](https://backend.habilelabs.io/uploads/monorepo_3_9a2bdb14ed.jpg)

Here is how you can install Lerna with npm-


```
$ git init lerna-repo && cd lerna-repo
```

Now, you can easily turn this repo into Lerna repository, using-

You’ve created a lerna.repo repository which should look like this now-


```
lerna-repo/
packages/
package.json
lerna.json
```

## Yarn Workspace

![monorepo_4.jpg](https://backend.habilelabs.io/uploads/monorepo_4_58c3a0adb4.jpg)


Another awesome JavaScript dependency management tool that manages monorepo across workspaces. It’s a tool to set up multiple packages, a single yarn install command, and all your project dependencies will be installed, all at once.



>Initially, yarn was not built to support monorepo but in new version, i.e. Yarn 1.0, the feature called ‘Workspaces’ was included.



It links the dependencies together which further makes your workspaces depend upon each other while using the available codes and it becomes easier to deal with them without much conflict.

## The How Part.


Once you get to know about how to implement Monorepo in your project, the further part about installing, running, and managing your code in it becomes too easy.


### Clone:



At first, you need to clone the full repository with the git clone command.



### Install:



Install it in the root folder, using-

### Run:


Now, run any of the code from the packages by any of the following commands -


```
yarn workspace your-package-name script-name
```

### Add npm Libraries:


To add a package (Here, react and react-dom)-


```
yarn workspace your-package-name add react react-dom — dev
```

### Remove npm Libraries:


To remove a package-


```
yarn workspace your-package-name remove react react-dom
```

### Test:


To call the test script for each workspace-

### Pros & Cons.



Everything has some pros as well as cons. The same is true in the case of monorepo. In fact, if you do some research you would find that it is facing quite a lot of criticism. Yes, there are a few downsides as well. Everything has. Flaws come complementary with everything.



#### Let’s have a look at its disadvantages-



- Security Issues- Allows read-access to all the stored projects which leads to security vulnerabilities.
- With the number of packages, increases the bootstrap time.
- Inconvenient for productive OSS collaboration and community building.
- Scalability challenges.


_It is not platonic or something. But it’s not unreasonable either. As a matter-of-fact, it would not wrong to say that that the individuals at Google, Facebook, and Twitter must have had some strong reasons to turn to Monorepos instead of going with thousands of smaller repositories._




Rather we should see so many positive sides of monorepo, like-



- Easier Code Sharing
- Deployment Flexibility
- Team Collaboration
- Atomic Commits
- Library creation is easy.
- Large-scale code refactoring.
- Seamless working between different packages.
- Reduces friction of local development.
- Simpler code review.


Etcetera, etcetera, and etcetera.



With so many advantages, one can easily spare some of the drawbacks. Actually, we can expect all these issues to be resolved in the near future.



Thanks for Reading!!



medium_monorepo_feature.jpg

small_monorepo_feature.jpg

thumbnail_monorepo_feature.jpg

A quick look at its what, why & how parts!!

Mono + Repo = Monorepo

According to the latest stats, Chrome is acquiring 60.98%, Internet Explorer by 12.18%, Firefox by 11.47% and Safari by 3.72% of total market shares in the browser uses. Different users use different versions of browsers to open a website as per their comfort levels. Imagine when your websites don’t provide the same user experience with different combinations of browsers and OS. It will be a major drawback for your business, and you do not want that to happen.

On different browsers, a website provides different user experiences. Cross-Browser testing is the procedure of comparing a site or web app’s design and functionality across different platforms and web browsers to make sure consistent functionality and behaviour for the end-user. With so many varieties of web browsers, operating systems and devices, obtainable today, cross-browser testing has become a critical part of software development.

## What to Test?


In this blog, we are going to discuss the role of cross-browser compatibly. With cross browser testing, we can test our website in all available browsers with different versions to provide same experience to our users everywhere.

- **Base Functionality:** Links, dialogs, menus etc.
- **Graphical User Interface:** Look and feel of the application.
- **Response:** How well the website provide response on user inputs.
- **Performance:** Loading of the pages within allowed the time frame.


## How to do Cross-Browser Testing?

![cross-browser-testing-using-selenium-1.jpg](https://backend.habilelabs.io/uploads/cross_browser_testing_make_your_website_universal_using_selenium_grid_1_15bc174a51.jpg)


There are two possible options available for cross browser testing as shown in the above image-

- **Manual:** Perform all test case manually on different combination of operating system and Web Browsers.
- **Automation:** Using Selenium Grid.


## Selenium Grid
Selenium Grid is a part of Selenium suite which is used for executing test scripts, or we can say test cases across different systems, operating systems and web browser in parallel process. Mainly, there are two versions of Selenium Grid-

- Newer Selenium Grid
- Older selenium Grid

## Advantages of Selenium Grid:

- Used to perform test scripts parallelly in distributed way.
- Can perform multi-browser testing.
- Reduces batch processing time.
- Can perform multi-operating system testing.


## Selenium Grid Architecture:


Selenium Grid works on the Hub-Node Principle. There is machine, or we can say a System that is called Hub, the centre part of the Selenium Grid. All the scripts will be executed from Hub. All the systems, where we want to execute our scripts, called NODE. These nodes are handled by the Hub remotely.

![cross-browser-testing-using-selenium-2.jpg](https://backend.habilelabs.io/uploads/cross_browser_testing_make_your_website_universal_using_selenium_grid_2_d0ae64a661.jpg)

## How to Set-up Selenium Grid??


For configuration of selenium grid, firstly, we have to download selenium Java client Driver, which is a Jar file. Currently, its stable version is 3.141.59. Like we have stated earlier, Grid is working on the principle of HUB-Node. Let’s assume here, machine A is hub and Machine B is Node.

- **Step 1–** Download Selenium Server:
Source:  [https://selenium.dev/downloads/](https://selenium.dev/downloads/)

Now, put this Jar file in C drive of the machine A and B.

- **Step 2–** Open the command prompt and navigate to the location where selenium server/jar file is placed.
- **Step 3–** Execute following Command on Command Prompt:
_java –jar selenium-server-standalone-2.43.1.jar –role hub_


The screen should now look something like this-

![cross-browser-testing-using-selenium-3.jpg](https://backend.habilelabs.io/uploads/cross_browser_testing_make_your_website_universal_using_selenium_grid_3_82deb8cf09.jpg)


- **Step 4-** We can also verify whether the hub is running, by using a browser. Selenium Grid generally use port number 4444 for running Grid. Simply open up a browser and go to: http://localhost:4444/grid/console
- **Step 5–** For now, the hub is set, now we have to launch a node. On the Machine B, open a Command prompt.

Move to Drive C and run the code given-below. Here, we have worked with the IP address 192.168.1.3 because our hub is processing from there only. We can use any port number as well. For Ex. We used 5566 here-

java -jar selenium-server-standalone-3.4.0.jar -role webdriver -hub http://192.168.1.3:4444/grid/register -port 5566

![cross-browser-testing-using-selenium-4.jpg](https://backend.habilelabs.io/uploads/cross_browser_testing_make_your_website_universal_using_selenium_grid_4_aa5e9ae1f5.jpg)


- **Step 6–** Now, move to Machine A, refresh selenium web interface, and you will see the following screen.

![cross-browser-testing-using-selenium-5.jpg](https://backend.habilelabs.io/uploads/cross_browser_testing_make_your_website_universal_using_selenium_grid_5_c92578e4c8.jpg)

At the time, we have set up a simple grid with a NODE on machine B, which is controlled by Hub, on machine A.

Now we move to the Gris’s web interface, hover on the icon of the browser that will be automated. We can note the platform name and Browser name shown by hovering.

Insights for the enthused minds!

Want to know more

How we build pillars to achieve heights

Want to join us ?

Let’s fill the gaps with IT