Remote Working, as the term suggests, means to work remotely- _“When individuals and teams are not required to show up at a specific physical location on a regular basis to work and they can work from anywhere they want to”_.

Remote working might be favorable when it comes to a few employees but shifting the whole business to remote, now that is something most companies try to avoid unless it is mandatory and it’s mostly preferred only in times of crisis. Though this mode of working is quite difficult in some areas of professional activity, it is a high time due to **_[COVID-19](https://www.habilelabs.io/blog/small-businesses-amidst-and-post-covid-pandemic)_** crisis that requires us to adopt it.


This blog is all about what challenges one might face during working from home and a few tips to maintain **_[productivity](https://www.habilelabs.io/blog/mastering-the-essence-of-productivity)_**-

## Common Challenges While Working Remotely


While working from home can be a relief, it can be quite challenging as well. Employees often struggle to adjust to this new working mode and face several difficulties, such as-

- Maintaining focus & engagement
- Dealing with distractions
- Keeping up morale
- Too much work to handle


A survey found the most common challenges employees face during working remotely-

![effective-remote-working-performance-management-tips-1.jpg](https://backend.habilelabs.io/uploads/effective_remote_working_performance_management_tips_1_3726e0137b.jpg)


However, these challenges can be vanquished by following a performance management strategy. Perhaps, you should refer to the Effective Remote Working Tips described in the subsequent paragraph-

## Performance Management in Remote Working


A major advantage of working from home is that the time tracking tool would speak about your hard work and dedication in a way, which is not possible in your day-to-day routine.

It’s been said that remote work diminishes the productivity and efficiency of the workers. It might be true in some cases, but on a whole, it’s more like a miscalculation. Yes, there are some disadvantages of remote working but this perception varies from person to person.


Here’re a few tips about **‘How to Stay Productive During Remote Working’**-

### #Figure Out a Schedule That Works for You


Figure out a routine that is convenient for you and stick to it. Fix a timing for everything from working hours to tea and lunch breaks. Taking breaks at regular intervals is important to release work anxiety and boredom.

In my case, I prefer to work half time in the morning and remaining in the evening, taking a proper break in the day-time. It helps me lift my spirits. Working continuously for 8 to 9 hours?? That doesn’t really work for me.

Maybe you like to work at night, that’s fine. Go for it! But while you’re working, try to put your hundred percent effort and concentration into it.

### #Find A Dedicated Workspace


Working remotely comes with several privileges such as working whenever, wherever and however one wants to. But it isn’t, at all, necessary to take it literally.

Working at the couch, bed, dining table, etc. seems fine but for a short while. Whereas, for long-term remote working, it becomes important to seek out a place that is invested for working only, where our mind feels ready and active to work, and the place makes you feel like a virtual version of office.

Having a dedicated workspace can act as a catalyst for your work. Find out a space at your home, maybe a spare room or a pair of table and chair in a corner, and create yourself a home-office where you can dedicate yourself to work.


### #Set Clear Goals & Timelines


Plan your tasks a day before and try to finish them in the given timelines only. Challenge yourself to complete that loads of work in a short span of time. It will keep you focused on the work. Before switching on the laptop, you should better have tasks in your mind because an aimless mind leads nowhere.

Keep yourself busy. Recently, I came to know about this bizarre fact that _“If you want something done, ask a busy person”_. So contradicting, but true. You’d have experienced yourself that busier you are, more productive you are. Whatever comes to your desk, you just want to finish it fast. It’s like Newton’s Law of Inertia- _Things in motion, want to stay in motion. Things at rest, want to stay at rest_.

### #Working Outside Home Can Do Wonders


Yes, that’s true. Just because you’re working from home, you don’t need to work only from home. Going out for a while in quiet evenings with your laptop to a nearby cafe shop or other similar places to work can enhance your mood greatly and keep your morale high. (Not in these COVID-19 times, of course!!)

However, in this lockdown period, working in the garden or in the balcony would be a good option too. Well, there is just this one place you should avoid- the bed. It’s fine if you’re sick but one should avoid using the bed as a workspace as the results come out are least productive.

## General Report About Remote Working Worldwide


Remote working is comparatively more common amongst youngster staff than others and the case is same across the continents.

Iwo Szapar, CEO of Remote-How says that – Employees in their 20s and mid-30s value meaningful experiences more than possessions, and they want to be able to pay attention to all the important aspects of their lives.

A survey report of 2019 found that-

- 61% of companies, globally, have some sort of remote working (Work from home) policy in their manual.
- The percentage of remote working has been increased by 140% since 2005.
- 80% employees of Japan are desirous to work from home.
- 4.3 million people in USA work remotely almost half the time.
- 85% of 15000 global businesses confirm that location flexibility has increased the productivity of their employees.


## Conclusion:


As almost the whole world is under lockdown, the businesses are coerced to operate from home in order to lower the corona outbreak. Following the lockdown, all of the Habilelabs members are working from home to safeguard themselves from the very unfortunate COVID-19 outbreak and contribute their bit in the lockdown period.

Well, I hope you would find this blog interesting.


Thanks for Reading!!

Effective Remote Working – Performance Management Tips

medium_effective-remote-working-performance-management-tips.jpg

small_effective-remote-working-performance-management-tips.jpg

thumbnail_effective-remote-working-performance-management-tips.jpg

**C**OVID-19 (Corona Virus Disease 2019) pandemic has unleashed itself upon the world and in a small period of just 2 months, has broken down the backbone of global economy.



Started as an epidemic in Wuhan of China, it has now turned into a global crisis. This outbreak was so sudden that nobody was prepared for it, even the Supreme Power (United States of America) was unable to recognize its devastating consequences.



By the time, the World Health Organization (WHO) warned the world about it and declared it a pandemic, it was too late. It had already set its foot across many continents. Though South Korea and China seem to have flattened the curve, the wrath of COVID-19 has just begun in other countries.



The situation has aroused fear and frustration amongst the population all around the world and the small business companies are left in a state of uncertainty, having both new opportunities and risks.



In the midst of such a crisis, several questions are occupying the minds of SMEs such as how to survive this outbreak? Are they even going to survive it? How does it going to impact their business and market? What can be expected from the post-pandemic market?

This blog is an effort to provide appropriate answers to all these suspicions along with stats derived by various surveys and researches-



## Impact of COVID-19 Crisis on Small Businesses-



>“The global outbreak of corona-virus came with a huge impact on various industries. From tailored product launches, cancellation or delay of major events, supply chain halted (shipments from China mainland), production delays to many other influencing factors.”



COVID-19 is as much contagious economically as it is medically. These are the distressing times for small businesses, daily workers, and small manufacturing units as the effects of this outbreak are catastrophic for them.



The economy is crashing, companies are shutting down, and people are losing their jobs. It will not be wrong to assume that the whole world is on the verge of falling down into the trench of unemployment and poverty.



According to a Goldman Sachs survey conducted in the USA on more than 1500 small-sized businesses and here’re the results (not very enthusiastic at all)-



- 51% say their business will only be able to continue to operate for 0–3 months.
- 96% say they have already been impacted by the outbreak.
- 75% say their business has been impacted by fewer sales.
- 53% say their employees don’t have the ability to telecommute.
- 13% are confident about their contingency plans to maintain.


If proper steps were not taken against it at the right time, the world’s economies would face a severe recession they had never seen before, even in the face of World Wars and other global crises.



Assuming that even if proper actions are taken, it may take years for the economy to recover the damage and reach to normalcy. This is the case for G7 countries, the situation will be worse for developing countries.



>“Michael Hicks, an economist at Ball State University, calculates that 28 million jobs or one in six U.S. workers are going to lose their jobs.”



India, being a developing country (and at an amazingly fast pace), had been expecting to achieve a $5 trillion economy by 2025 with a huge contribution from the MSMEs, could suffer substantial losses from the COVID-19 outbreak.

## How Can Small Business Survive Amidst Corona Outbreak??



Businesses are shuttering worldwide, and others are afraid of whether they will survive this outbreak or not. Only those who have gone digital are operating well which includes IT & software, digital marketing, and equivalent companies.



Here’re the few steps the small businesses can take to last in this pandemic period-



- Organizations are in the need for digital transformation. It’s time to shift to complete **_[remote-working](https://www.habilelabs.io/blog/effective-remote-working-performance-management-tips)_** or work-from-home through various digital platforms to minimize business disruption.
- To remain in the market, businesses need to engage more with social media.
- Brands can channelize their businesses towards supporting healthcare professionals who are fighting against COVID-19 and advertising about precautions against it.
- Businesses should adopt new ways of marketing and agile methods to address customer needs.



Well, the businesses can expect great help from the respective governments. Let’s check what the world leaders have planned to handle this crisis-



## Government Aid Plans for SMEs



If your business has faced a great deal of loss and struggling to gather funds, it might be a relief that it’s not all over yet, the governments all over the world will be there to back you up.



The governments, worldwide, have come forward and announced proper financial aids and legislation to provide low-interest federal disaster loans amid this pandemic to help out the SMEs and restore their economies.

For instance,



- The US [Small Business Administration](https://www.sba.gov/disaster-assistance/coronavirus-covid-19) (SBA) is going to offer Economic Injury Disaster Loan assistance for small businesses to help them recover from the economic injuries caused by COVID-19. Also, the [CARES Act](https://www.usa.gov/funding-options) (Coronavirus Aid, Relief, and Economic Security) has been signed to help individuals as well as businesses affected by the coronavirus pandemic.


>“There are speculations that the US is looking at a Senate vote to roll out a $2 trillion package, touted as one of the largest rescue packages in American history.”



- Italy has come up with an [Emergency Plan](https://ec.europa.eu/commission/presscorner/detail/en/ip_20_530) of 28 billion dollars to recover from economical losses. The European Commission has approved various support measures and aid rules for the Italian States such as direct grants, tax advantages, loan approval for companies, subsidized public loans, and short-term export credit insurance.


- Indonesia announced a total of $733 billion stimulus package to rescue its travel, aviation, and property industries.

## What Can Be Expected from The Post-Pandemic Market?



What chaos this corona outbreak will lead the world into is, indeed, hard to imagine. But there is a way to have a quick look into the future-market by getting insights about the market and economic status of China.



Yes, we have a good example of China before us, we can learn a few things from it and can take essential measures to minimize the losses.



The ESIEC (Enterprise Survey for Innovation an Entrepreneurship in China) team led a rapid follow-up survey that reflects the impact of COVID-19 upon the small and medium-sized businesses in China.



According to the team,



>“Our survey shows that COVID-19 has landed a heavy blow on Chinese SMEs, with huge differential effects across sectors and regions.”



Let’s see what the survey says -



- 14% of the surveyed firms will not last more than a month and 50% not more than 3 months due to a lack of cash flow.
- 80% of the surveyed firms haven’t resumed work, at all, and 40% of those who are going to resume their work, are not able to determine the eventual timeframe for resumption.
- The export firms in China have suffered more compared to non-export firms because they provide employment for many migrants. Being one of the biggest exporters, the implications are huge on the global supply-chain stability of this export slowdown. There’s been a 17.4% dropdown of China’s exports in the year 2020.
- While upstream firms are suffering due to labor shortages, the downstream firms are facing more grave challenges due to supply-chain halt and consumer demands.

## Final Words-



The COVID-19 has emerged fiercely at unprecedented speed on the global level. Almost the whole world is under lockdown, as a result, the commercial and business activities have been seriously affected.



It seems like another time in another world when everything was good and the world economy was growing just fine and a small virus, appeared out of nowhere, derailed the global economy just in a few months.



With these fine final words, cited by an economist at Bangkok University, I’ll end this blog-



The economy is a complex system that faces shocks, stumbles a bit, and returns to its original state or even better state. It’s like elastic, stretch it and leave, it will come to its original state. How many times have the world economy faced natural disasters and wars? Each time it gets small glitches here and there but, in the end, it rebounds and grows more expansive than ever. We can learn a lot from Japan, faced an atomic bomb, tsunami, and several other disasters, but today, it is listed among the most developed countries.



>“We may lose some momentum, but after a short stumble, we push forward.”



Thanks for reading this blog!!

medium_post-covid-19-pandemic_feature.jpg

small_post-covid-19-pandemic_feature.jpg

thumbnail_post-covid-19-pandemic_feature.jpg

Impact of COVID-19 upon Small Businesses

Python is the simplest and easiest programming language, ever found, in the programming world. Everything about it is so simple, its syntax, commands, libraries. You can literally understand the code by reading it. Quite convenient, isn’t it??

It’s a module-rich programming language that has a wide stack of applications in the IT world. You see, this is the reason it’s been ruling over the developer’s hearts. If you’ve switched to Python after spending years on other languages, you’re going to love it.

But, apart from its simplicity, it has other benefits as well. Python is considered as one of the best Data Analytics tools for Big Data due to a large set of data processing libraries it has in-store for you. That is why this branch of python is also known as ‘Python Data Analytics’.

In this blog, I’ve curated **5 Best Python Libraries for Data Science** and going to give a brief about them-


## NumPy


Numerical Python, abbreviated as NumPy, is the most popular Machine Learning package for scientific computation and data analytics in Python. It’s a general-purpose, N-dimensional array processing package.

You would be aware that Python does not provide an array data structure but with the NumPy library, one can create and perform all kinds of manipulations on an array.


![best-python-libraries-for-data-science – 1.jpg](https://backend.habilelabs.io/uploads/best_python_libraries_for_data_science_1_847dd01fe2.jpg)


It is to be noted that a Python list may contain any object type whether it is a character, number, tuple, whereas, the multi-dimensional NumPy arrays are homogeneous, i.e. they can contain only one object type at a time. Though, the advantage with these same object types is that it makes the comprehension of the required storage size for the array easier.

#### Features & Applications-


- Powerful N-dimensional Array Object
- Tools that integrate C/C++ and Fortran Code
- Sophisticated Functions
- Useful Linear Algebra, Fourier Transform, and Random Number Capabilities
- Seamless Integration of Various Databases

## Pandas

Pandas, stands for Python Data Analysis, is an open-source Python library package that contains fast, flexible, high-performance, and easy-to-use data analysis tools to perform various computing operations on data in Python programming language.

The variety of functionalities it possesses, i.e. data reading, manipulation, aggregation, and visualization, makes it the perfect tool to be used for data analysis in **_[Machine Learning](https://www.habilelabs.io/ai-ml)_** and Big **_[Data Analytics](https://www.habilelabs.io/data-analytics-bi)_**.

>‘Pandas is a Python package providing fast, flexible, and expressive data structures designed to make working with structured (tabular, multidimensional, potentially heterogeneous) and time-series data both easy and intuitive.’

It is well suited for heterogeneous object types, ordered as well as the disordered, tabular, arbitrary matrix, and other different forms of statistical and observational data sets.

#### Features and Functions-


- Explicit & Automatic Data Alignment
- Size Mutability
- Handling of Missing Data
- Robust Input/ Output tools for Uploading Data
- Performing of Split-Apply-Combine Operations on Data
- Label-Based Slicing, Subsetting, and Indexing of Large Datasets
- Intuitive Joining and Merging of Datasets
- Data Plotting

## TensorFlow


TensorFlow is an open-source, end-to-end platform used to create and deploy Machine Learning powered applications. It’s comprehensive libraries, the wide ecosystem of tools and active community resources let the developers push the limits beyond ML and help them to build Deep Learning models.

Its architecture consists of three main parts-

- Data Preprocessing
- Model Building
- Training and Estimation of the Model


TensorFlow manages all aspects of the ML system with its different APIs. It was first developed to work on an Artificial Intelligence (AI) model. The term ‘TensorFlow’ was derived from its core framework, i.e. Tensor. A tensor is an N-dimensional matrix that represents all types of data; the shape of this data defines the dimensionality of the matrix.


![best-python-libraries-for-data-science – 2.jpg](https://backend.habilelabs.io/uploads/best_python_libraries_for_data_science_2_ad02a5e86a.jpg)


The specialty of the TensorFlow library is that it uses Graph Computation- _It allows the developer to visualize the construction of the neural network with Tensorboard._

#### Its key features are-



- Easy Model Building
- Simple & Flexible Architecture
- Intuitive High-Level APIs
- Easy Deployment of Models on Cloud
- Robust ML Production Anywhere
- Support Deep Neural Networks and ML Concepts
- GPU/CPU Computing
- High Computation Scalability Across Huge Data Sets
- It has a large community on GitHub compared to other frameworks.

You can also read about **_[Spleeter](https://www.habilelabs.io/blog/spleeter-a-tensorflow-based-python-library)_**(A TensorFlow Based Python)

## SciPy


SciPy, also known as Scientific Python, is a collection of mathematical functions and algorithms and uses NumPy extension for more numerical operations. It contains several domain-specific modules and toolboxes that are used in signal and image processing, statistics, linear algebra, interpolation, optimization, integration, special functions, Fourier Transform, etc.

SciPy provides high-level classes and commands to the user for visualizing and manipulating data sets. Apart from that, it also provides an additional benefit of making powerful and robust programming language to develop modern programs and applications.

It’s a great module for data processing and fits well in the list of system-prototyping environment rivaling systems, such as MATLAB, Octave, R-Lab, IDL, and SciLab.

#### Features & Applications:



- Collection of Numerical Algorithms and Domain-Specific Toolboxes.
- Multidimensional Image Processing
- Built-in Functions for Solving Integral and Differential Equations
- Data Processing, Manipulation, and Visualization
- Parallel Programming to **_[Web](https://www.habilelabs.io/web-development)_** and **_[Data-Base](https://www.habilelabs.io/database-solutions)_** Subroutines

## Matplotlib


While the other libraries, mentioned above, are used to manipulate, operate and visualize the data sets, Matplotlib is specifically built for Data Visualization only.

>“Matplotlib is a comprehensive MATLAB-style data visualization library for creating static, animated, and interactive visualizations in Python.”

In simple words, Matplotlib is a data plotting and graphing library in Python that can generate a wide variety of different charts and graphs of various formats, such as scatter graphs, line charts, bar charts, heat maps, pie charts, and 3D plots. It processes the data by visualizing or plotting it in the form of a graph, diagram or chart.

#### Features:

- Support Animations and Interactive Displays
- Constructing of a Variety of Analytical Graphs

## Conclusion:


Apart from these five libraries, as discussed above, there are several other wonderful Python library modules available for data science that are special in their own functionalities and must be known to you and the world. If you passionately want to become a Data Science Specialist then the more data processing libraries you learn, the better.

Hope this article is useful for you. As you know Python is a popular programming language and you can get the best 10 tricks and facts about python programming easily by click on it.

Thank you for reading!! If you have like it, hit the like button.

medium_best-python-libraries-for-data-science.jpg

small_best-python-libraries-for-data-science.jpg

thumbnail_best-python-libraries-for-data-science.jpg

5 Best Python Libraries for Data Science

**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](https://www.habilelabs.io/blog/react-query-a-state-management-library-for-react-applications)_**, 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](https://www.habilelabs.io/custom-application-development)_**. 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](https://www.habilelabs.io/blog/react-native-react-web-and-expo-together-in-one-monorepo)_** 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](https://www.habilelabs.io/blog/what-are-react-functional-components)_** 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](https://www.habilelabs.io/blog/salesforce-export-to-excel-with-lightning-web-component)_**, 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)](https://www.habilelabs.io/blog/building-dynamic-filter-rules-with-salesforce-lightning-web-components)_** 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](monorepo-for-react-native-apps-with-nx)_** 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](https://www.habilelabs.io/blog/develop-a-responsive-layout-of-mobile-app-with-react-native)_**.



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](https://www.habilelabs.io/blog/best-folder-structure-for-react-native-project)_** 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](https://www.habilelabs.io/blog/an-overview-of-ai-ml-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](https://www.habilelabs.io/custom-application-development)_** 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](https://www.habilelabs.io/web-development)_** 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](https://www.habilelabs.io/blog/automation-using-cypress-end-to-end-testing-tool)_** 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](https://www.habilelabs.io/web-development)_** 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](https://www.habilelabs.io/custom-application-development)_** 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](https://www.habilelabs.io/blog/what-are-react-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.

You can also read **_[Relay Hooks](https://www.habilelabs.io/blog/relay-hooks-facebook-released-improved-react-hooks-based-apis-for-relay)_** - Facebook’s Newly Improved React-Hooks-Based APIs for Relay

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](https://www.habilelabs.io/blog/what-are-component-lifecycle-methods-in-react-js)_** 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](https://www.habilelabs.io/custom-application-development)_** 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](https://www.habilelabs.io/database-solutions)_** 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](https://www.habilelabs.io/blog/docker-develop-deploy-containerized-applications)_** 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](https://www.habilelabs.io/cloud-infrastructure)_** 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](https://www.habilelabs.io/blog/cross-browser-testing-make-your-website-universal-using-selenium-grid)_**, 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.

You can learn more here about **_[AI & ML Testing](https://www.habilelabs.io/blog/an-overview-of-ai-ml-testing)_** - Future of Software Testing?

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](https://www.habilelabs.io/blog/what-are-react-functional-components)_**.

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](https://www.habilelabs.io/blog/what-are-component-lifecycle-methods-in-react-js)**_. 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!!

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