DEV Community: Lakshgupta

React States & Virtual DOM

Lakshgupta — Sun, 11 Jun 2023 19:40:28 +0000

In React, the virtual DOM (Document Object Model) is an abstraction of the actual DOM. It is a lightweight representation of the UI components and their structure.

When there is a state change in a React component, React creates a new virtual DOM tree. It then compares the new virtual DOM tree with the previous one to identify the minimal set of changes needed to update the actual DOM efficiently. This process is known as "reconciliation."

Here's a step-by-step overview of how state updates and reconciliation occur in React:

State Update: When the state of a component changes, either through user interaction or other triggers, the component re-renders. During re-rendering, a new virtual DOM tree is created for the component, reflecting the updated state.
Diffing: React then performs a diffing algorithm to compare the new virtual DOM tree with the previous one. It analyzes the differences between the two trees, identifying the minimal set of changes required to update the actual DOM.
Update: Once the differences are identified, React applies the necessary updates to the actual DOM to reflect the changes. It selectively updates only the parts of the DOM that have changed, optimizing performance.

By using the virtual DOM, React minimizes the number of actual DOM manipulations, which can be expensive in terms of performance.

React's diffing algorithm efficiently determines which parts of the UI need to be updated, reducing the overhead of rendering and improving the overall user experience.

"Defer" Keyword in Golang

Lakshgupta — Sat, 10 Jun 2023 20:10:35 +0000

Most of the Developers are switching to the recently developed Golang tech by Google in 2009 because of its code efficiency and less execution time as it is a compiled language.

Will talk about an important keyword used in Golang "Defer" in this article..

Defer is used for some bytes of code if a prior cleanup is required for the function created in Golang before its return.
With the help of "defer" keyword, we can have optimized code promoting more robust and reliable code.

*Defer makes the statement fall at a position in stack that the code after the keyword just takes execution just before the function is returned.
*
Defer Keyword contributes to enhance the code in following ways:

Cleanup of Code
To lock the opened results
Close opened files to make code reliable.

Refer the code for the same & understand the steps of execution by the summary below :

package main

import (
    "fmt"
    "os"
)

func main() {
    file := createFile("example.txt")
    defer closeFile(file)

    writeToFile(file, "Hello, Golang!")
}

func createFile(filename string) *os.File {
    fmt.Println("Creating file:", filename)
    file, err := os.Create(filename)
    if err != nil {
        panic(err)
    }
    return file
}

func writeToFile(file *os.File, message string) {
    fmt.Println("Writing to file:", message)
    _, err := file.WriteString(message)
    if err != nil {
        panic(err)
    }
}

func closeFile(file *os.File) {
    fmt.Println("Closing file")
    err := file.Close()
    if err != nil {
        panic(err)
    }
}

In this piece of Code because of we using defer keyword the function just before returning closes the opened file and hence make no mistake & no misplace of any data.

Defer is a keyword defined its use in the Golang Documentation.
Refer to the documentation to understand more and learn implementation:

Ansible and Python

Lakshgupta — Fri, 03 Mar 2023 18:32:03 +0000

Firstly, Ansible is written in the Python programming language and has a quite minimal learning curve.
Ansible setup is pretty simple and functionality it provides is widely used in the IT services automation.
Python is the preferred language to use to develop as it is quite compatible and easy to sync with ansible.

Ansible with Python:

Ansible Playbooks:

Simple yml formatted files which helps the developers to define a streamline flow of tasks to be achieved while performing a job. These Playbooks can be referred to as automated bots which helps us perform for example shell commands, python scripting and many more additional features.

Basic Programming language add ons are present to like storing data in variables and modifying the same. Can be reused, recyclable for other used cases. Sometimes separate tasks are created and included like classes in C++.

Action Plugins:

To talk about in a nutshell, these are basically python scripts itself just that some extra functionality and classes are added to integrate them with the playbooks. Action Plugins act as a programming soldier that inputs data declared by the playbook and modify the data for the used case as programmed by us. We can return the data to the playbook such that further tasks can be performed on that data.

Mainly purpose is to automate the manual steps and reduce vulnerabilities.

Ansible Tower:

Ansible Tower can be called as a hub of the ansible playbooks which makes the playbooks easier to maintain, run and debug while development. Tower is an open source tool which can be altered as per the requirements by the organizations. Tower provides too many functionalities like scheduling the playbooks and automating them, add separate projects directly and easily as its UI is clean and easy to use. After a basic understanding debugging is easy to execute and trustworthy process is cultivated for a long term.

Ansible Tower is the Manager of the Ansible Playbooks which assists the developers on more than what I offered in this article. Will create a detailed article on this though. Checkout for more.

Why Django? - MVT Model

Lakshgupta — Thu, 02 Mar 2023 18:34:02 +0000

Django is a framework easy to adopt with the frontend where python settling the backend of a fullstack website. Easy designs add ups with the help of HTML, CSS, JS. Django is easy to integrate at both the frontends and backends..

Other than the basics, Django follows the MVT Model at its core:

Models:

Defined as an entities to work with while crating the website. Basically call it a entities of the flow we create of a software.
Blueprints are declared before hand withe the help of Django Models.

Eg: Created a user based website where employees interacted with the website. Roles were of a Employee and a Employer. Models were defined before hand and for the ease of further development some day.

Views:

Defined as the work which will be done with certain entities. Views can be called as functions in layman's language. Certain sections are associated with these views and provides the user full functionality with much more ease. Views are triggered upon interaction with the users.

Eg: Employee Log-in Log-out will count as a view. Certain groups of UI will trigger such functionalities which is declared in the views itself.

Templates:

Defined as the different page styles or basic html pages in layman's language. Templates comprises of the html formatted tags with the add of jquery based functionalities triggering and the css styling. Certain Views trigger the separate templates defined within this frame.

Eg: Separate Log-in page for employee and employer for separate user experience and separate functionalities defined before hand with the models defined.

Python Django User Interface

Lakshgupta — Wed, 01 Mar 2023 09:19:02 +0000

To make use of Mongo database collections and to omit command line interface interactions, planned to create a user interface based on Python Django tech stack.

Developed a UI which has a MongoDB based data extraction
mechanism.
Button Based UI which is easily accessible over internal platform and preferably less functionalities than the Mongo Atlas to enjoy the comfort of less information.
CRUD operations can be performed onto the UI which is deployed into production via internal servers.
Integrated Role Based Access Control (RBAC) Mechansism in user creation model of Mongo UI.
Worked on Real time IDE creation and developed UI Frontend design taking all the requirements under consideration.
Converted the conventional update of data to streamline
flow via Django based UI.
Reduced the human intervention and execution time and automated the workflow.

APIs - Brahmastra for Developers

Lakshgupta — Tue, 28 Feb 2023 11:25:28 +0000

APIs, or Application Programming Interfaces, were introduced to enable different software applications to communicate with each other easily and efficiently. APIs provide a way for developers to access data or functionality from a remote server or application without having to know the inner workings of that application or server.

Before APIs, developers would need to develop custom integrations or use more manual methods like screen scraping to access data from another application. This was time-consuming, error-prone, and often required significant technical expertise.

With APIs, developers can access data and functionality through a standardized interface, allowing them to build integrations and applications more quickly and easily. This has enabled the development of many new software applications and services, as well as the integration of existing applications and services to create new, innovative solutions.

In addition, APIs have helped to facilitate the growth of cloud computing and software as a service (SaaS) models, allowing applications and services to be hosted remotely and accessed through APIs. This has enabled greater flexibility, scalability, and cost savings for both developers and end-users.

Static vs Dynamic Data Typed Languages

Lakshgupta — Mon, 27 Feb 2023 07:59:37 +0000

Static Data type Languages:

Variables are judged at compile time.
Explicitly type declarations are required before hand.
Values are static types which can't be altered once set.
Produces more optimized code with the compile time performance check.
C , C++ , JAVA , GO

string language_type;
language_type = "static"

~~language_type = 1~~

Dynamic Data type Languages:

Variables are evaluated at runtime.
No need to declare the data type before hand.
Values are dynamic and can be altered with their types.
Reduces extra efforts but in the end is less optimized as the code is prone to runtime errors.
PHP , Perl , Python , JavaScript

var language_type;
language_type = "dynamic"

language_type = true