DEV Community: Gbengacode

5 Reasons Why Some Junior Developers Never Become Seniors

Gbengacode — Fri, 09 May 2025 20:19:48 +0000

Becoming a senior developer isn’t just about years of experience—it's about how you grow, think, and adapt. Unfortunately, not every junior developer makes it to the senior level. In this post, I’ll break down five common reasons why that growth sometimes stalls.

1. Lack of Continuous Learning

You risk becoming outdated if you’re not actively learning new frameworks, languages, or patterns. Reading documentation, experimenting with side projects, and staying curious are essential habits. Seniors don’t stop learning—they learn faster and more strategically.

Tip: Allocate a few hours each week to explore something new, even if it's outside your current stack.

2. Weak Problem-Solving Skills

It’s one thing to write code that works—it’s another to understand why it works and how it can be improved.

Junior developers who always reach for Stack Overflow before thinking through a problem or who shy away from complex bugs may struggle to grow. Senior developers are expected to break down problems, propose solutions, and think critically under pressure.

Tip: Practice solving problems on platforms like LeetCode, CodeWars, or by contributing to open source.

3. No Ownership Mentality

Are you just completing tasks, or are you owning features?

Taking ownership means being responsible for the design, development, testing, and success of what you build. Juniors who always wait to be told what to do—or deflect responsibility when things go wrong—miss out on opportunities to lead.

Tip: Start by volunteering to take charge of small features or improvements end-to-end.

4. Poor Communication & Collaboration

You could be the best coder on the team, but if you can’t communicate your ideas or work well with others, you’re not going to grow.

Senior developers are often bridges between teams. They write documentation, review pull requests, and mentor juniors. If you’re not building those soft skills, it will be hard to take the next step.

Tip: Practice explaining technical concepts in plain English. Write blog posts. Lead a sprint demo. Pair program.

5. Fear of Failure or Avoiding Challenges

Growth comes from discomfort. The sooner you’re okay with being wrong or struggling with tough problems, the sooner you’ll grow.

Some juniors avoid challenging work because they’re afraid to fail. But every senior developer has a graveyard of bugs and broken deployments behind them—it’s part of the journey.

Tip: Say “yes” to things that scare you. Take on that refactor. Dive into legacy code. You’ll learn faster than you think.

Final Thoughts

Not every junior developer becomes a senior, but every senior started as a junior. It’s not just about coding more, it’s about thinking differently, owning your growth, and embracing the challenges ahead.

Are you working on leveling up right now? What’s been your biggest obstacle or breakthrough?

Let me know in the comments. See you in my next post.

Lynx vs. React Native: Is TikTok’s New Framework a Game Changer?

Gbengacode — Tue, 11 Mar 2025 08:49:07 +0000

Introduction

Lynx, developed by ByteDance, and React Native, created by Facebook, are both frameworks designed to facilitate cross-platform mobile application development. Here's a comparison highlighting their key differences and similarities:

Architecture and Performance

Lynx: Utilizes a multi-threaded interactivity model that separates UI rendering from business logic, aiming to enhance performance and responsiveness. This design ensures smoother UI experiences, especially in resource-intensive applications.
React Native: Employs a JavaScript bridge to communicate between JavaScript code and native modules, which can introduce performance bottlenecks in complex applications. However, React Native's new architecture, Fabric & JSI, aims to reduce dependency on the JS bridge, allowing direct interaction with native code.

Development Approach

Lynx: Designed to be framework-agnostic but currently offers robust support for React. Developers can write markup and CSS similarly to web development, making it accessible for those familiar with web technologies. However, Lynx is primarily intended for integrating shared views into existing native applications rather than building entire apps from scratch.
React Native: Allows developers to build entire applications using JavaScript and React, with components rendering as native widgets. It provides a comprehensive solution for developing full-fledged mobile applications across platforms.

Community and Ecosystem

Lynx: Recently open-sourced, Lynx's public ecosystem is still developing. While it has been used internally by ByteDance for years, it currently lacks the broader community support and third-party libraries that more established frameworks offer.
React Native: Boasts a mature ecosystem with extensive community support, numerous plugins, and third-party libraries, facilitating faster development and troubleshooting.

Use Cases

Lynx: Suitable for integrating high-performance, native-like views into existing applications. It's particularly beneficial for apps requiring complex UI components and smooth animations
React Native: Ideal for building entire cross-platform applications from scratch, especially when leveraging React's component-based architecture and existing JavaScript knowledge.

In summary, while both Lynx and React Native aim to simplify cross-platform mobile development, they differ in architecture, performance optimization, development approach, and ecosystem maturity. React Native offers a more established environment for building complete applications, whereas Lynx provides a modern approach to integrating high-performance components into existing apps, with the potential to evolve into a comprehensive framework as its ecosystem grows.

Kindly like, share, and follow see you in my next post.

React Reconciliation

Gbengacode — Sat, 04 May 2024 20:57:44 +0000

Introduction

React, a popular JavaScript library for building user interfaces employs a sophisticated process called reconciliation to efficiently update the UI in response to changes in data or state. Reconciliation lies at the heart of React's performance optimization strategy, ensuring that UI updates are fast and seamless. In this article, we'll delve into the intricacies of React reconciliation, exploring its key concepts and how it optimizes the rendering process.

The concept of the Virtual Dom in React

At the core of React's reconciliation process is the Virtual DOM, a lightweight, in-memory representation of the actual DOM. When a component's state changes, React constructs a new Virtual DOM tree, which mirrors the structure of the UI. This Virtual DOM serves as a blueprint for what the UI should look like based on the updated state.

Diffing Algorithm the algorithm for React Reconciliation

React's reconciliation algorithm employs a technique known as tree diffing to compare the previous Virtual DOM with the new one. This process involves traversing both trees and identifying the differences between them. By comparing the two trees, React can determine precisely which parts of the UI have changed, need to be added, or should be removed.

Component Lifecycle Methods for Aiding React Reconciliation

React provides developers with a set of lifecycle methods that allow them to fine-tune the reconciliation process. Two key methods, shouldComponentUpdate and componentDidUpdate, play a crucial role in optimizing component rendering.

shouldComponentUpdate: This method allows developers to control whether a component should re-render based on changes in state or props. By implementing custom logic within shouldComponentUpdate, developers can prevent unnecessary re-renders, thus improving performance.
componentDidUpdate: After a component has been updated and re-rendered, the componentDidUpdate method is called. This lifecycle hook is useful for performing side effects or additional updates based on the new state.

Keyed Reconciliation: Optimizing List Rendering

Rendering lists of elements efficiently is a common challenge in web development. React addresses this challenge through keyed reconciliation, where each element in a list is assigned a unique identifier (key). By using keys, React can track individual elements and optimize updates accordingly.
For example


<ul>
  {items.map(item => (
    <li key={item.id}>{item.name}</li>
  ))}
</ul>

In this example, each <li>element is assigned a unique key based on the item.id. React leverages these keys to identify which elements have changed, moved, or been added/removed within the list.

Summary

React reconciliation is a critical aspect of React's performance optimization strategy. By leveraging the Virtual DOM, a sophisticated diffing algorithm, and lifecycle methods, React ensures that UI updates are fast, efficient, and seamless. Understanding the principles of reconciliation empowers developers to build high-performance React applications that deliver exceptional user experiences.

Kindly like, share, and follow see you in my next post.

The Concept of API Versioning in API Design

Gbengacode — Fri, 03 May 2024 16:50:05 +0000

What is API Versioning?

API Versioning is the practice of managing different releases or iterations of an API. It involves assigning unique identifiers (usually in the form of version numbers or labels) to distinct sets of functionalities and endpoints within an API. This allows developers to introduce changes, enhancements, or fixes to an API while maintaining backward compatibility with existing client applications.

Approaches to API Versioning

URI Versioning: In this approach, the API version is specified directly in the URI (Uniform Resource Identifier) of each endpoint. For example:

https://api.example.com/v1/users
https://api.example.com/v2/users

Query Parameter Versioning: The API version is included as a query parameter in API requests. For example:

https://api.example.com/users?version=1
https://api.example.com/users?version=2

Header Versioning: Header versioning refers to the practice of including the API version information as a standard HTTP header in API requests. This typically involves using existing HTTP header fields, such as Accept or Content-Type.
Media Type Versioning: The API version is indicated in the media type (MIME type) of the request or response. For example:

Accept: application/vnd.example.v1+json
Content-Type: application/vnd.example.v2+json

Custom header versioning: Custmo header versioning is a specific subset of header versioning where a custom header is created solely for the purpose of conveying the API version. Unlike standard HTTP headers like Accept or Content-Type, custom headers are specifically defined by API providers to carry version information. For example

GET /users HTTP/1.1
Host: api.example.com
X-API-Version: 1

Semantic Versioning: This approach assigns version numbers according to the Semantic Versioning (SemVer) scheme, which consists of three parts: MAJOR.MINOR.PATCH. This scheme is typically used for libraries or SDKs but can also be applied to APIs.

Advantages of API versioning

1. Maintaining Compatibility: As your API evolves over time, you may need to introduce changes that could potentially break existing client implementations. Versioning allows you to make these changes without disrupting existing users who may rely on specific behaviors or data formats. Each version can be maintained independently, allowing clients to continue using older versions while new ones are developed.

2. Enabling Evolution: APIs need to evolve to accommodate new features, bug fixes, and improvements. Versioning provides a structured approach to introducing these changes while ensuring backward compatibility with existing clients. Without versioning, changes could lead to unexpected behavior or even failure in client applications.

3. Managing Deprecation: As APIs evolve, certain functionalities or endpoints may become deprecated. Versioning allows you to communicate these changes clearly to clients, providing them with ample time to migrate to newer versions that offer equivalent or improved functionality. Deprecation policies should be documented and communicated to API consumers.

3. Supporting Multiple Clients: APIs are often consumed by multiple clients, such as web applications, mobile apps, and third-party services. Versioning enables you to cater to the diverse needs of these clients without forcing them to adopt changes that may not be relevant to their use cases. Clients can choose to upgrade to newer versions at their own pace.

4. Facilitating Testing and Debugging: With versioned APIs, developers can test their applications against specific versions to ensure compatibility and reliability. This simplifies the testing process and reduces the risk of introducing bugs or regressions in production environments.

5. Enhancing Security: Security vulnerabilities may be discovered in older versions of APIs. Versioning allows you to address these vulnerabilities by releasing patches or updates to affected versions while maintaining support for newer versions. This helps protect both your API and its consumers from potential security threats.

Let me know your thoughts about API versioning and how you have used them. See you in my next post.

React 19 Is Here!

Gbengacode — Sat, 24 Feb 2024 06:41:07 +0000

Introduction

React 19 emerges as a game-changer in front-end development, introducing many innovative features. From refined concurrent rendering to novel state-handling mechanisms, React 19 enhances both performance and developer experience. In this article, we explore these cutting-edge additions, providing insights into how they reshape the landscape of dynamic user interface development. Whether you're a seasoned React developer or new to the framework, understanding React 19's advancements is crucial for staying ahead in modern web development. Join us on a journey to unravel the transformative features that make React 19 a milestone release, setting the stage for the future of front-end innovation.

New features

1. React Compiler

React Compiler, no longer a research project, is now powering Instagram.com in production, representing a significant advancement in React's capabilities. It addresses the issue of excessive re-renders on state changes by introducing an optimizing compiler. Unlike manual memoization, this compiler automatically re-renders specific UI parts when the state changes, eliminating code clutter. Operating within the rules of both JavaScript and React, it ensures safety and performance. Developers can validate their code with tools like Strict Mode and React's ESLint plugin. The compiler is already active on Instagram.com and is set for further integration across Meta surfaces, with plans for an open-source release.

2. Actions

Actions allow you to pass a function to DOM elements such as

<form action={search}>
  <input name="query" />
  <button type="submit">Search</button>
</form>

The action function has the flexibility to operate synchronously or asynchronously. It can be defined on the client side using standard JavaScript or on the server using the 'use server' directive. React takes charge of managing the data submission life cycle when an action is employed, offering hooks like useFormStatus and useFormState for accessing the current form action's state and response.

import { useFormStatus } from "react-dom";
import action from './actions';

function Submit() {
  const status = useFormStatus();
  return <button disabled={status.pending}>Submit</button>
}

export default function App() {
  return (
    <form action={action}>
      <Submit />
    </form>
  );
}

import { useFormState } from "react-dom";

async function increment(previousState, formData) {
  return previousState + 1;
}

function StatefulForm({}) {
  const [state, formAction] = useFormState(increment, 0);
  return (
    <form>
      {state}
      <button formAction={formAction}>Increment</button>
    </form>
  )
}

By default, Actions are submitted within a transition, maintaining the interactivity of the current page during processing. With support for async functions, the introduction of async/await in transitions enables the display of pending UI, utilizing the isPending state to signal ongoing processing during asynchronous requests like fetching data.

3. React Canary

Canaries mark a shift in our React development approach. Unlike the previous method where features were researched and developed privately within Meta, Canaries involved building in public with community collaboration to refine features showcased in the React Labs blog series. This approach ensures that users are informed about upcoming features earlier in the development process. It allows them to witness the finalization stages rather than only encountering the polished product upon Stable release.

Some of the features in the react canary are
React Server Components, Asset Loading, Document Metadata, and Actions

1. Directives

"use client" and "use server" are bundler features designed for full-stack React frameworks. They mark the “split points” between the two environments: "use client" instructs the bundler to generate a <script> tag (like Astro Islands), while "use server" tells the bundler to generate a POST endpoint (like tRPC Mutations). Together, they let you write reusable components that compose client-side interactivity with the related server-side logic.

2. Document Metadata:

Support for rendering <title>, <meta>, and metadata <link> tags anywhere in your component tree has been added. These work the same way in all environments, including fully client-side code, SSR, and RSC. This provides built-in support for features pioneered by libraries like React Helmet.

3. Actions

Actions are to manage sending data from the client to the server. You can add action to elements like <form/>, access the status with useFormStatus, handle the result with useFormState, and optimistically update the UI with useOptimistic.

import { useOptimistic } from 'react';

function AppContainer() {
  const [optimisticState, addOptimistic] = useOptimistic(
    state,
    // updateFn
    (currentState, optimisticValue) => {
      // merge and return new state
      // with optimistic value
    }
  );
}

To get started with the React canary

//for npm 
npm install react@canary react-dom@canary
//for yarn
yarn add react@canary react-dom@canary

Creating a dedicated testing environment is preferable to modifying your current production dependencies. This approach enables you to offer feedback without causing disruptions to your live applications.

That is all for now. See you in my next post. Kindly like, share, comment, and follow.

How to monitor your Next.js Application performance and track errors with Sentry

Gbengacode — Fri, 23 Feb 2024 10:01:16 +0000

What is Sentry

Sentry is an open-source platform for tracking and monitoring errors, empowering developers to detect, prioritize, and address issues in real-time promptly. This tool delivers comprehensive error reports, stack traces, and deep insights into the underlying causes of errors, facilitating swift diagnosis and resolution. It extends its support across various platforms and languages such as JavaScript, Node.js, Python, and Java. By leveraging Sentry's robust features, development teams can effectively maintain the stability and dependability of their applications.

How to setup Sentry in your Next.js Application

The easiest way to setup is to through the use of SDK
Sentry captures data by using an SDK within your application’s runtime.

Procedures

Sign in to Sentry
Bootstrap a Next.js Application by running
```
npx create-next-app@latest
```
Install the SDK through the installation wizard
```
npx @sentry/wizard@latest -i nextjs
```

The wizard will prompt you to log in to Sentry. It will then automatically do the following steps for you:

create config files with the default Sentry.init() calls for each runtime (node, browser, edge)
create or update your Next.js config with the default Sentry configuration
create .sentryclirc with an auth token to upload source maps (this file is automatically added to .gitignore)
add an example page to your app to verify your Sentry setup

We can pass extra configuration the through the option in the Sentry.init() calls.

Sentry.init({
  dsn: "https://69cb89218edf8713f71b66a00c5c9f66@o4506789727305728.ingest.sentry.io/4506789728419840",
  maxBreadcrumbs: 50,
  debug: true,
});

The list of the common options are dsn, debug, release, environment etc. You can check the doc for more option exploration https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/options/

Let's make a sample Next.js API call and test Sentry error reporting

"use client"
import * as Sentry from "@sentry/nextjs"
export default function Home() {
  const failedApiCall = async () => {
    try {
       throw new Error("this is an error")
    } catch (error) {
      Sentry.captureException(error)
    }
  }
  return (
    <main className="flex min-h-screen flex-col items-center justify-between p-24">
      <button className="p-3 border border-blue-500" onClick={failedApiCall}>Throw an Error</button>
    </main>
  );
}

Sentry Performance Monitoring and Error Reporting

From the report, we can get useful insight into the error where the application that leads to the error the source URL the browser, and the system which the user uses to access the application and other useful sights.
That is it for now. For more posts like this kindly follow, like, and comment. See you in my next post

Exploring the New Features in Node.js Version 20 for Implementing Them in a Project

Gbengacode — Sat, 09 Sep 2023 08:44:31 +0000

Node.js v20+

Node.js v20, launched on April 18, 2023, introduces a range of exciting enhancements. In this release, Node.js focuses on bolstering its security by minimizing external dependencies and introducing a reliable built-in test runner. Moreover, Node.js v20 empowers developers to build self-contained executable applications that can run seamlessly on Windows, macOS, and Linux without the need for Node.js installation on users' systems.
In this post, we will be looking at some of the features of this improved version of Node.js and how to integrate them into your projects.

Features in the Node.js v20

Built-in .env file support
Experimental Permission Model
Custom ESM loader hooks on a dedicated thread
Synchronous import.meta.resolve()
url.parse() warns URLs with ports that are not numbers
Stable test runner
V8 JavaScript engine updated to V8 11.3

Getting Started

Download and Installation Node.js if it is not installed on your machine.
Use Node version Manager to upgrade your Node.js version if it is not v20.

nvm install v20.6.1
nvm use v20.6.1

Initialize your node application with

npm init -y

Built-in .env file support

What is an environment variable

Environment variables provide insights into a process's operational context, encompassing aspects like production, development, and the build pipeline. In Node.js, they serve as a secure repository for sensitive information, such as passwords and API credentials, that should not be hard-coded in the codebase. Utilizing environment variables is essential for configuring variables or settings that may vary across different environments.

Node.js inherently supports environment variables, rendering them a superior choice compared to alternative configuration methods like config.js or config.json files. Leveraging environment variables, especially in tandem with automation tools like build pipelines, enables you to steer clear of cumbersome tasks like scripting configuration files.
One of the most popular package use in configuration of environment variable in node is the dotenv package but with the introduction of Node.js v20. Starting from Node.js v20.6.0, Node.js supports .env files for configuring environment variables.

Your configuration file should follow the INI file format, with each line containing a key-value pair for an environment variable.

URL = 'http://test.com'

To initialize your Node.js application with predefined configurations, use the following CLI command:

node --env-file=.env filename.js

. We can specific the folder in which the .env file is in

node --env-file=foldername/.env filename.js

We can go ahead and configure the package.json file to with above CLI command

We notice that this using nodemon package to turn our server.js file, this is useful for development purpose since it's watch for changes and restart the server if need be.

Stable test runner

A test runner is a software tool or framework that automates the execution of tests for software applications. Its primary purpose is to locate, run, and report on the results of tests, making it an essential component of the software testing process. Test runners are particularly valuable in the context of automated testing and continuous integration (CI) pipelines. Here are some key aspects and functions of a test runner:

Test Discovery: Test runners typically have the capability to discover and locate test cases within a codebase automatically. They can identify test files, classes, functions, or methods that are intended for testing.
Execution: Test runners execute the identified tests, running them one by one or in parallel, depending on the configuration. They simulate the interaction with the application to verify that it behaves as expected.
Reporting: Test runners collect and report the results of test execution. They provide information on which tests passed, which failed, and any errors or exceptions encountered during testing. This reporting helps developers identify and address issues in their code.
Configuration: Test runners often allow configuration options to control how tests are executed. This includes specifying test environments, controlling parallelism, and filtering tests based on criteria like tags or categories.
Integration: Test runners can be integrated into continuous integration (CI) and continuous delivery (CD) pipelines, enabling automated testing as part of the software development and deployment process. They can also integrate with other development tools and services.
Support for Multiple Testing Frameworks: Many test runners are designed to work with various testing frameworks, such as JUnit, NUnit, Mocha, Jasmine, pytest, and more. This flexibility allows developers to choose the testing framework that best suits their project.

For Node.js we mostly used test runner like Jest or Mocha. With Node.js v20 we can now run tests without using external test runners.

Get started with Node Native Test

The Node Test Module

The node:test module facilitates the creation of JavaScript tests. To access it:

import test from 'node:test';

Tests created via the test module consist of a single function that is processed in one of three ways:

A synchronous function that is considered failing if it throws an exception, and is considered passing otherwise.
A function that returns a Promise that is considered failing if the Promise rejects, and is considered passing if the Promise resolves.
A function that receives a callback function. If the callback receives any truthy value as its first argument, the test is considered failing. If a falsy value is passed as the first argument to the callback, the test is considered passing. If the test function receives a callback function and also returns a Promise, the test will fail.

The Node.js v20 also exposes the assert module

import assert from 'node:assert'

Running tests can also be done using describe to declare a suite and it to declare a test. A suite is used to organize and group related tests together. it is a shorthand for test().

Sample Test

import { describe, it } from 'node:test'
import assert from 'node:assert'
import { add, multiply, subtract } from '../calc.js'
describe('test', () => {
  it('should do some addition operation', () => {
    const result = add(2, 3)
    assert.equal(result, 5)
  })

  it('should do some subtraction operation', () => {
    const result = subtract(5, 3)
    assert.equal(result, 2)
  })

  it('should do some subtraction operation', { skip: true }, () => {
    const result = multiply(5, 3)
    assert.equal(result, 15)
  })
})

The result of the test

We also have extra options for our test like
Skipping tests
Individual tests can be skipped by passing the skip option to the test, or by calling the test context's skip() method
Only tests
If Node.js is started with the --test-only command-line option, it is possible to skip all top level tests except for a selected subset by passing the only option to the tests that should be run.
Filtering tests by name
The --test-name-pattern command-line option can be used to only run tests whose name matches the provided pattern. Test name patterns are interpreted as JavaScript regular expressions.
That is it for now. See you in my next post

How to Speed up and Improve Performance of Your Node JS Application

Gbengacode — Mon, 28 Aug 2023 11:29:21 +0000

When building Node.js applications, especially in the case of larger projects, it becomes paramount to maintain minimal data transfer during client interactions. This practice is instrumental in achieving peak performance on the client side. Consequently, there is a demand for reducing the payload of the responses being sent to users, all the while preserving the integrity of the response content.

A Node.js compression middleware known as Compression the-shelf solution for effectively compressing responses sent from the application to clients. This tool seamlessly addresses the aforementioned need, ensuring that data transmission remains efficient and optimized.

How to implement compression package in to your node application

install the compression package npm install compression
use the compression middleware in your application

Sample code with an Express Application

import express from "express";
import compression from "compression";

const app = express();
const PORT = 7000; // Change this to the port you want to listen on

// Apply compression middleware with custom configuration
app.use(
  compression({
    level: 6, //
    threshold: 0,
    filter: (req, res) => {
      if (!req.headers['x-no-compression']) {
        return compression.filter(req, res);
      }
      return false; // Don't apply compression if 'x-no-compression' header is present
    },
  })
);

app.get('/', (req, res) => {
  const data = 'This is a post about how to use the compression package'.repeat(10000);
  res.send(data);
});

app.listen(PORT, () => {
  console.log(`Listening on port ${PORT}`);
});

Custom configuration of compression

level

The level of zlib compression to apply to responses. A higher level will result in better compression, but will take longer to complete. A lower level will result in less compression, but will be much faster.

Threshold

The byte threshold for the response body size before compression is considered for the response, defaults to 1kb. This is a number of bytes or any string accepted by the bytes module.

filter

A function to decide if the response should be considered for compression. This function is called as filter(req, res) and is expected to return true to consider the response for compression, or false to not compress the response.
The default filter function uses the compressible module to determine if res.getHeader('Content-Type') is compressible.

Before Compression

After Compression

The size of payload before was 550kb before and after is 181b

ChatGPT "The New Magic Response System"

Gbengacode — Sat, 17 Dec 2022 12:18:26 +0000

Introduction
The ChatGPTt is the most intelligent and impressive artificial intelligent chatbot created by Open AI. It was released on November 20, 2022. ChatGPT is a natural language processing that can answer questions, follow up on the question, admit flaws, challenge incorrect premises, and reject inappropriate requests.

What are the uses of the ChatGPT

Answering user questions.
Writing text compositions.
Solving math equations
Writing text
Debugging and fixing code
Translating between lanaguage creating text summaries recommendaton
Classifying things

How does it work
ChatGPT has been trained using a large database of information obtained from the internet. According to Open AI, ChatGPT employs the use of Reinforcement Learning from Human Feedback (RLHF). It has an easy-to-use interface that allows it to respond to follow-up questions, reject certain requests, and detect when it has malfunctioned. It is also relatively simple to use.

How to use ChatGPT
Go to https://chat.openai.com on your computer or phone, login to your account or create a new account

ChatGPT In Action

Asking ChatGPT to explain version control system

Asking ChatGPT to solve leetcode question

Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where:

'.' Matches any single character.
'*' Matches zero or more of the preceding element.
The matching should cover the entire input string (not partial).

ChatGPT VS Search engine
ChatGPT is a conservational base model that uses information from training data and general responses while Search engines help to get information by indexing web pages on the internet.

Limitation of ChatGPT
The inability to provide contextual answers that are required in a specific way. The quality of the response is the main issue with chatGPT. According the openAi some of the limitations of ChatGPT are:

May occasionally generate incorrect information
May occasionally produce harmful instructions or biased content
Limited knowledge of the world and events after 2021