DEV Community: Shamanta Sristy

🛳️ Titanic Survival Prediction: A Gentle Introduction to Data Science for Beginners📊

Shamanta Sristy — Tue, 13 May 2025 16:38:25 +0000

Hey there, curious minds! 👋
If you're new to data science and machine learning like me, this post is just for you. In this blog, I’ll walk you through one of the most classic beginner projects — predicting survival on the Titanic 🚢 — in a way that’s super beginner-friendly. We’ll explore the steps I took, the code I wrote, and the lessons I learned, all while keeping things simple and clear.

📚 What's the Titanic Project?

The Titanic dataset is one of the most popular datasets used to learn data science. The goal is to predict whether a passenger survived or not based on information like their age, gender, ticket class, etc.

This project is perfect for learning how to:

Explore data 📊
Clean and prepare it 🧹
Visualize patterns 🎨
Apply machine learning 🤖

📚 Project Overview

This project uses the Titanic dataset to predict whether a passenger survived based on their features like age, sex, class, etc. It’s perfect for learning:

Data analysis and visualization
Handling missing data
Feature engineering
Training a basic machine learning model (Logistic Regression)

🧰 Tools & Technologies Used

Language: Python
Libraries: Pandas, NumPy, Matplotlib, Seaborn, Scikit-learn
IDE: Jupyter Notebook

🔍 Step-by-Step Walkthrough

1. Importing Libraries

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

2. Loading the Data

df = pd.read_csv("titanic.csv")
df.head()

3. Checking for Missing Values

df.isnull().sum()

Age: 177 missing
Cabin: 687 missing → dropped
Embarked: 2 missing → filled with mode

4. Handling Missing Data

df['Age'].fillna(df['Age'].median(), inplace=True)
df['Embarked'].fillna(df['Embarked'].mode()[0], inplace=True)
df.drop(columns='Cabin', inplace=True)

5. Visualizing the Data

Survival by Gender

sns.countplot(x='Survived', hue='Sex', data=df)
plt.title("Survival Count by Gender")

Survival by Passenger Class

sns.countplot(x='Survived', hue='Pclass', data=df)
plt.title("Survival Count by Class")

6. Correlation Heatmap

plt.figure(figsize=(10, 6))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
plt.title("Correlation Heatmap")

7. Feature Encoding

df['Sex_encoded'] = df['Sex'].map({'male': 0, 'female': 1})
df = pd.get_dummies(df, columns=['Embarked'], drop_first=True)

8. Model Preparation

X = df[['Pclass', 'Sex_encoded', 'Age', 'Fare', 'Embarked_Q', 'Embarked_S']]
y = df['Survived']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

9. Logistic Regression Model

model = LogisticRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))
print(classification_report(y_test, y_pred))

🧠 Key Learnings

✅ How to explore and clean a real-world dataset
✅ Understanding visual patterns in data
✅ Feature encoding and selection
✅ Building a logistic regression model
✅ Evaluating model accuracy and performance

💭 Reflections

This project was more than just code — it helped me gain confidence in using ML tools and understand the real process behind building predictive models. I'm now more excited than ever to keep exploring!

Thanks for reading! If you're also starting out in machine learning or have suggestions for improvement, I’d love to connect and hear your thoughts 💬

🎯 How I Built My First Machine Learning Project (A Beginner-Friendly Guide)

Shamanta Sristy — Sun, 27 Apr 2025 17:32:29 +0000

Today, I’m sharing how I built my first machine learning project after restarting my tech journey — and I’ll walk you through it step-by-step so even beginners can follow along!

We’ll build a simple Iris Flower Classification project using Python.

Let’s dive in! 🚀

Step 1: Setting Up the Project

First, I created a clean folder structure like this:

iris-classification/
│
├── data/
├── notebooks/
├── src/
├── README.md
├── requirements.txt
└── .gitignore

✅ data/ for datasets

✅ notebooks/ for Jupyter notebooks

✅ src/ for Python scripts

✅ README.md to explain the project

✅ requirements.txt to list all needed Python packages

I highly recommend starting with good organization — it makes everything easier later!

Step 2: Loading and Exploring the Data

I used the famous Iris Dataset.

import pandas as pd

df = pd.read_csv('data/iris.csv')
print(df.head())

Then, I checked basic information:

df.info()
df.describe()

✅ Tip: Always look at your data first before modeling!

Step 3: Visualizing the Data

I made some simple visualizations to understand the features better.

import seaborn as sns
import matplotlib.pyplot as plt

Correlation heatmap

plt.figure(figsize=(10,8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
plt.title('Feature Correlation Heatmap')
plt.show()

Pairplot

import seaborn as sns
import matplotlib.pyplot as plt

# Create a smaller pairplot using the correct label
g = sns.pairplot(df, hue='target', height=2.3)

# Add a title
g.fig.suptitle('Pairplot of Iris Features', y=1.03)

# Clean layout
plt.tight_layout()

# Save if needed
plt.savefig('pairplot.png', dpi=300, bbox_inches='tight')

plt.show()

✅ Tip: Visualization helps you see patterns that numbers alone can't show!

Step 4: Preparing the Data

I separated features (X) and labels (y).

X = df.drop('species', axis=1)
y = df['species']

Then I split the data:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

✅ Tip: Always split your data — training and testing on the same data gives fake results.

Step 5: Organizing and Pushing to GitHub

Finally, I learned to push my project properly to GitHub:

git init
git add .
git commit -m "First ML project: Iris Classification"
git branch -M main
git remote add origin https://github.com/ShamantaSristy/iris-classification.git
git push -u origin main

✅ Tip: Save your work online — GitHub shows your growth and makes you look professional!

🎉 What I Learned
💡How to structure and organize a machine learning project

💡How to analyze, visualize, and prepare data

💡How to push and maintain a clean GitHub repository

👉 My full project is here:
🔗 Iris Flower Classification GitHub Repo

If you're also starting your journey, trust me — you can do this! 🌱
One small project at a time, and you’ll get better every day.

See you in the next post, where I'll tackle my next project: the Titanic Survival Prediction 🚢❓

🎉 I'm Back — And Here's Why I Left (And Why I'm Writing Again)

Shamanta Sristy — Tue, 15 Apr 2025 10:02:06 +0000

Hey there, lovely people of Dev! 👋

It's been a while. Maybe even too long.

I used to write here — sharing my tech experiments, beginner experiences, and whatever curious thing caught my eye. But then... life happened. Academic pressure, burnout, shifting interests — I paused my writing, not because I didn’t love it, but because I forgot how much I did.

After a long break, I'm returning to share my journey in ML, Computer Vision, and creative tech. Here's why I stopped writing — and what’s next.

But here I am again, with a heart full of ideas and a mind that refuses to stop learning.

And this time? I want to write consistently, creatively, and courageously.

👩‍💻 What I’ve Been Up To

I finished my BSc in Electrical and Electronic Engineering (EEE).
I dove head-first into Machine Learning, Smart Grids, and recently... Computer Vision (and I love it!).
I led the IEEE WIE Affinity Group at my university, starting initiatives from zero funding and turning them into community-building successes.
I’ve been building skills, preparing for higher studies, and rediscovering my passion for writing.

💭 What I’ll Be Writing About

You can expect posts on:

My learning journey in Machine Learning and Computer Vision
Beginner-friendly guides and tutorials
Reflections from my leadership, academic, and tech experiences
Tips and tools for staying curious, creative, and kind in the tech world

🤝 Let's Connect!

If you're also learning ML, experimenting with CV, or just figuring things out — I’d love to connect with you.

Let’s support, grow, and geek out together 💻❤️

Thanks for sticking around. I'm excited for this new chapter, and I hope you’ll be part of it.

Stay curious, stay kind,

— Sristy 🌻

What is Event loop in JavaScript?

Shamanta Sristy — Mon, 30 Aug 2021 12:55:30 +0000

Let's look into JavaScript Event loop from a different angle. Sounds interesting, right? It is! So, sit tight and let's dive into it!
The concept of event loop is very simple. But in order to understand that, first we need to be clear about some concepts related to event loop.

Inside Browser, there is a Javascript engine (we are considering V8 for chrome.) and an environment to run javascript properly. Javascript engine has two parts, Heap and Call Stack. And the engine has some assistant named Web APIs and Callback Queue.

Heaps

It's an unstructured memory block. Our code's memory allocation happens here. As a programmer we don't have to worry much about heaps.

Call Stack

We can consider Call Stack as a kitchen where all our code executed or cooked. Whenever we try to run a piece of code, it goes to call stack first and then executed. It works in LIFO style. That is Last In First Out.

const lunch = () => console.log("It's time for lunch!");

const dinner = () => console.log("It's time for dinner!");

const breakfast = () => {
  console.log("Time to breakfast!");
  setTimeout(lunch, 3000);
  dinner();
};

breakfast();

If we run the code above, The global execution context main() runs on the browser, and JS engine will start to read the code from the first line and will search for tasks. On the last line, one function is called. So, this function will go to the Call Stack and will execute the tasks. First it will print Time to breakfast! , then goes to the next line, where we have an asynchronous block of code.
As we know, JavaScript is synchronous and single-threaded language, this asynchronous block of code goes to the call stack and suddenly pops out. Here JS engine takes help from it's assistant, Web API. The setTimeout() waits on the Web API and after it's timer runs out (In this case, 3 seconds), After 3 seconds the callback function goes to the Callback Queue and waits for Call stack to be free. By this time, Call stack runs the other piece of codes. Prints

It's time for dinner!

Web APIs

Web API works as JS engines assistant. When JS engine have to deal with asynchronous code, it takes the help of Web API. Web API handles the blocking behavior of JavaScript code.
In this case, from our code above, we can say Web API will take the callback function

setTimeout(lunch, 3000);

, run it's timer, and pass it to Callback Queue after 3 seconds.

Callback Queue

It's a guard who monitors the stack of asynchronous callback functions who just completed the task of waiting and passed the gate of Web API. Callback Queue works using FIFO (First In First Out ) method. And now, they waits here to go back to Call Stack. But how will Call Stack know that there's some callback functions waiting in Callback Queue?
Here comes the star, Event Loop!

Event Loop

Event loop is just a guardian who keeps a good communication with Call Stack and Callback Queue. It checks if the call stack is free, then lets know the callback queue. Then Callback queue passes the callback function to Call stack to be executed. When all the callback functions are executed, the call stack is out and global execution context is free.

See! it was not complex at all! 😄
Thanks for reading.

10 Important JavaScript Concepts for Interview

Shamanta Sristy — Sat, 08 May 2021 14:51:16 +0000

Truthy and Falsy values

By default, javascript considers some values as true and the others false. Almost all values other than 0 and ''(empty string) are considered true in Javascript.
Some specific cases are there when Javascript will show true or false. Now we will discuss them.

True values:

'', '0', {} , [] All these will give true value

False values:

false, undefined, null , 0, NaN

Null vs Undefined

Null is a value that was defined but empty or null, whereas undefined is a value that was declared but no value assigned.
Undefined is a type where null is an object.

Double Equal ( == ) vs Triple equal ( === )

Double equals just check values and while triple equals check values with the type of the values. Double equals convert the type of the value and then check the value.

Scope

Scope means the accessibility of variables. Javascript has two types of scope: Local scope and Global scope.

Variables declared within a function are the local scope and these variables are accessible within only that function.

A global scope is a variable declared outside of a function and accessible from any function, scripts, and webpage,

Block scope

A block scope in Javascript is the area within any loop or condition like for, while, if, switch etc. To make it more clear, any javascript code within curly braces {} are block. ES6 made things easy for developers. let and const keywords are used in specific cases to declare variables that are accessible only within the block.

Closuer

Closure in javascript is when there's a function declared within a function. Or a function returns a function. The second function which is declared within the first one has variables that are not accessible from the parent function or first function (private variable). But the children function can access the value of the parent function.

Bind

The bind() method creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.

Call

Call returns function where parameters are separated by a comma.

function.call(firstParam, secondParam, thirdParam);

Apply

Apply returns an array

function.apply(1st param, [secParam, thirdParam]);

Window

The window object is supported by all browsers. It represents the browser's window. All global JavaScript objects, functions, and variables automatically become members of the window object. Global variables are properties of the window object.
Global functions are methods of the window object.

A Deep Dive in JSX

Shamanta Sristy — Fri, 07 May 2021 15:02:37 +0000

To know JSX in-depth, we should have a clear idea of what is JSX and is used? The full form of JSX is Javascript XML. To clear the whole JSX concept first, we will discuss what is JSX?

What is JSX?

JSX is an XML/HTML-like syntax used by React.js which extend Javascript so that XML/HTML-like text can co-exist with JavaScript/React code.

Why JSX?

JSX allows us to write HTML elements in JavaScript and place them in the DOM without any createElement() and/or appendChild() methods.JSX converts HTML tags into react elements.
For example, with JSX , we can write code like below:

const firstElement = <h1>My first JSX</h1>;

ReactDOM.render(firstElement, document.getElementById('root'));

And without JSX:

const firstElement= React.createElement('h1', {}, 'I do not use JSX!');

ReactDOM.render(firstElement, document.getElementById('root'));

From above, we can see that, with JSX writing code for React application is quite easy.

Expressions in JSX

Inserting a Single Line HTML

In JSX we can write expressions inside curly braces { } .
The expression can be a React variable, or property, or any other valid JavaScript expression. JSX will execute the expression and return the result:

const text = <h1> This is an expression in JSX </h1>

Inserting A Block of HTML

To insert a block of HTML expression on multiple lines, we need to put the HTML block inside parentheses:

const list= (
  <ul>
    <li>Apples</li>
    <li>Bananas</li>
    <li>Cherries</li>
  </ul>
);

Specifying The React Element Type

The first part of a JSX tag determines the type of the React element.

Capitalized types indicate that the JSX tag is referring to a React component.

React Must Be in Scope

Since JSX compiles into calls to React.createElement, the React library must also always be in scope from JSX code.

For example, both of the imports are necessary in this code, even though React and CustomButton are not directly referenced from JavaScript:

import React from 'react';
import CustomButton from './CustomButton';

function WarningButton() {
  // return 
React.createElement(CustomButton, {color: 'red'}, null);  return <CustomButton color="red" />;
}

User-Defined Components Must Be Capitalized

React recommend naming components with a capital letter. If a component is declared that starts with a lowercase letter, we need to assign it to a capitalized variable before using it in JSX.

For example, this code will not run as expected:

import React from 'react';

// This is a component and should be capitalized:function Hello(props) { This use of <div> is legitimate because div is a valid HTML tag:
  return <div>Hello {props.toWhat}</div>;
}

function HelloWorld() {
  // React knows <Hello /> is a component because it's capitalized. 
   return <Hello toWhat="World" />;}

Choosing the Type at Runtime

We cannot use a general expression as the React element type. If we do want to use a general expression to indicate the type of the element, we have to just assign it to a capitalized variable first.
For example:

import React from 'react';
import { PhotoStory, VideoStory } from './stories';

const components = {
  photo: PhotoStory,
  video: VideoStory
};

function Story(props) {
  // JSX type can be a capitalized variable. 
  const SpecificStory = components[props.storyType];
  return <SpecificStory story={props.story} />;}

Props in JSX

There are several different ways to specify props in JSX

JavaScript Expressions as Props

Any JavaScript expression can be passed as a prop, by surrounding it with {}. For example, in this JSX:

<MyComponent foo={1 + 2 + 3 + 4} />

String Literals

String literals can be passed as a prop. These two JSX expressions are equivalent:

<MyComponent message="hello world" />
<MyComponent message={'hello world'} />

Spread Attributes

If we already have props as an object, and we want to pass it in JSX, we can use ... as a “spread” operator to pass the whole props object. These two components are equivalent:

function App1() {
  return <Greeting firstName="Ben" lastName="Hector" />;
}

function App2() {
  const props = {firstName: 'Ben', lastName: 'Hector'};
  return <Greeting {...props} />;}

Children in JSX

There are several different ways to pass children:

String Literals

We can put a string between the opening and closing tags and props. children will just be that string. This is useful for many of the built-in HTML elements. For example:

<MyComponent>Hello world!</MyComponent>

JSX Children

We can provide more JSX elements as the children. This is useful for displaying nested components:

<MyContainer>
  <MyFirstComponent />
  <MySecondComponent />
</MyContainer>

JavaScript Expressions as Children

Passing any JavaScript expression as children in JSX is allowed, by enclosing it within {}. For example, these expressions are equivalent:

<MyComponent>foo</MyComponent>

<MyComponent>{'foo'}</MyComponent>

Functions as Children

Normally, JavaScript expressions inserted in JSX will evaluate to a string, a React element, or a list of those things.

function Repeat(props) {
  let items = [];
  for (let i = 0; i < props.numTimes; i++) {    items.push(props.children(i));
  }
  return <div>{items}</div>;
}

function ListOfTenThings() {
  return (
    <Repeat numTimes={10}>
      {(index) => <div key={index}>This is item {index} in the list</div>}    </Repeat>
  );
}

Children passed to a custom component can be anything, as long as that component transforms them into something React can understand before rendering. This usage is not common, but it works if you want to stretch what JSX is capable of.

Booleans, Null, and Undefined Are Ignored

false, null, undefined, and true are valid children. They simply don’t render. These JSX expressions will all render to the same thing:

<div />

<div></div>

<div>{false}</div>

<div>{null}</div>

<div>{undefined}</div>

<div>{true}</div>

If You are new to the JSX concept more's here.

10 Interesting hacks about JS (ES6) Block Bindings

Shamanta Sristy — Thu, 06 May 2021 15:45:19 +0000

Today we are going to discuss an interesting topic of EcmaScript6(ES6), Block Bindings. This discussion is going to be about bindings variables to scope.

Binding?

Binding is the formal name of variables. When we declare and/or initialize a variable, we actually bind a value to a name inside a scope. And scope means to a specific part of a program.
So we bind a variable whenever we declare and/or initialize a variable using one of these keywords: var, let and const in JavaScript.

Example:

var a
let b
const last = c

Hoisting

In short, hoisting is a mechanism that handles execution contexts in JavaScript. This means the variable and function declarations (not initializations) are put into the memory during the compile phases before going for any execution.

For example:

function getName(condition) {

var name

if (condition) {
name = 'Sherlock'
console.log(name)
}
else {
console.log(name)
}
console.log(name)
}

From the above example, we can see, the declaration is hoisted to the top but the initialization is staying exactly where we type the name variable. This means that we can access the name variable from everywhere in the enclosing block in case of var binding.

Block Level Declarations

Inside a function (function block)
Inside a block (wrapped with two curly { } braces)

Let Declarations

We have already seen these block-level scopes in the example above. Now we will use the previous function again but this time using either let or const. So, we are using let :

function getName (condition) {

if (condition) {
let name = 'Nicholas'
console.log(name)
}
else {
// 'name' does not exists here
return null
}
// 'name' does not exists here
}

At the let binding, we can see, name only exists inside the if block. It is not available outside the if block. Because JavaScript engine does not hoist let and const declarations. So the name is not accessible in else and enclosing blocks.

No Redeclaration

var name = "x"
//syntax error
let name = "y"

In this example, name is declared twice: once with var and once with let.Because let will not redefine an identifier that already exists in the same scope, the let declaration will throw an error. On the other hand, no error is thrown if a let declaration creates a new variable with the same name as a variable in its containing scope, as demonstrated in the following code:
Example:

var count = 30;

// Does not throw an error
if (condition) {

    let count = 40;

    // more code
}

Constant Declarations

You can also define variables in ES6 with the const declaration syntax. Variables declared using const are considered constants, meaning their values cannot be changed once set.

Constants vs Let Declarations

Constants, like let declarations, are block-level declarations. That means constants are destroyed once execution flows out of the block in which they were declared, and declarations are not hoisted, as demonstrated in this example:

if (condition) {
    const maxItems = 5;

    // more code
}

// maxItems isn't accessible here

Block Binding in Loops

Perhaps one area where developers most want block-level scoping of variables is within for loops, where the throwaway counter variable is meant to be used only inside the loop. For instance, it's not uncommon to see code like this in JavaScript:

for (var i=0; i < 10; i++) {
    process(items[i]);
}

// i is still accessible here
console.log(i);

Functions in Loops

The characteristics of var have long made creating functions inside of loops problematic because the loop variables are accessible from outside the scope of the loop. Consider the following code:

var funcs = [];

for (var i=0; i < 10; i++) {
    funcs.push(function() { console.log(i); });
}

funcs.forEach(function(func) {
    func();     // outputs the number "10" ten times
});

Let Declarations in Loops

A let declaration simplifies loops by effectively mimicking what the IIFE does in the previous example. On each iteration, the loop creates a new variable and initializes it to the value of the variable with the same name from the previous iteration. That means you can omit the IIFE altogether and get the results you expect, like this:

var funcs = [];

for (let i=0; i < 10; i++) {
    funcs.push(function() {
        console.log(i);
    });
}

funcs.forEach(function(func) {
    func();     // outputs 0, then 1, then 2, up to 9
})

Constant Declarations in Loops

The ECMAScript 6 specification doesn't explicitly disallow const declarations in loops; however, there are different behaviors based on the type of loop you're using. For a normal for loop, you can use const in the initializer, but the loop will throw a warning if you attempt to change the value. For example:

var funcs = [];

// throws an error after one iteration
for (const i=0; i < 10; i++) {
    funcs.push(function() {
        console.log(i);
    });
}

Global Block Bindings

Another way in which let and const are different from var is in their global scope behavior. When var is used in the global scope, it creates a new global variable, which is a property on the global object (window in browsers). That means you can accidentally overwrite an existing global using var, such as:

// in a browser
var RegExp = "Hello!";
console.log(window.RegExp);     // "Hello!"

var ncz = "Hi!";
console.log(window.ncz);        // "Hi!"

Emerging Best Practices for Block Bindings

While ES6 was released, developers thought let should behave exactly as var did. So, the direct replacement makes logical sense. In this case, you would use const for variables that needed modification protection
However, as more developers migrated to ECMAScript 6, an alternate approach gained popularity: use const by default and only use let when you know a variable's value needs to change.

10 Mostly used Javascript string prototypes you need to know as a beginner

Shamanta Sristy — Wed, 05 May 2021 15:47:55 +0000

A string in javascript stores a series of characters, for example:

"Harry Potter"

A sting can be anything inside a single or double quote.
Today we will discuss some commonly used string prototypes of javascript.

concat()

The concat() method of string contacts or add one string to the other and returns a new string. This addition or concatenation of string is like the second string that sits after the first one and makes a chain-like structure.
Example:

const str1 = “Hello”
const str2 = “Albus”
console.log(str1.concat(',  ', str2));

Output: “Hello, Albus”

indexOf()

The indexOf() method returns exactly where the string belongs. By default, the indexing or identity of the position of a string starts from [0] and then moves on [1,2,3, ….]. So, if we want to know the exact position of a word in a string, we need to use the indexOf() method. One important thing here to note that, if we ask for any invalid index or a string or word that does not exist in particular that string, it will return the value -1.
Example:

const  paragraph = “I am reading about javascript”;
const  searchString = “about”;
const index = paragraph.indexOf(searchString );
console.log(index)

Output: 13

replace()

replace() method returns a string. If we have a string with series of words of multiple characters, we can change or replace a string or character of the mother string using the replace() method.
Example:

const  paragraph = “I am reading about javascript”;
console.log(paragraph.replace('reading', ‘writing’));

Output: I am writing about javascript

toLowerCase()

If we want to make a string all lowercase, we will use the toLowerCase() method.
Example:

const dotted = "Bangladesh";
console.log(dotted.toLowerCase());

Output:
bangladesh

toUpperCase()

The toUpperCase() method returns a string that all the characters are converted to uppercase. This is exactly the opposite of the toLowerCase() method.
Example:

const lower = "hello";
console.log(lower.toUpperCase());

Output:
HELLO

charAt()

Previously we have discussed finding words inside of a string using their index. Now we will discuss something that closely matches that. We will try to find a character in a string using the charAt() method.
Example :

```const text = "Hello World";
const index = 4;




Output:
o
## includes()
The includes() method performs a case-sensitive search.It finds whether one string may be found within another string. And returns true or false as output.
Example:

const isThere = "hello world";
const word = "word";
console.log(isThere.includes(word));



Output:
false
## slice()
The slice() method extracts a section of a string and returns it as a new string, without modifying the original string.

Example:

const text = 'The quick brown fox jumps over the lazy dog.';

console.log(str.slice(31));




 Output: "the lazy dog."

If we want to slice from one index and end another,we have to write that.

const text = 'The quick brown fox jumps over the lazy dog.';
console.log(str.slice(4, 19));
Output: "quick brown fox"




We can determine inverse index too.

const text = 'The quick brown fox jumps over the lazy dog.';
console.log(str.slice(-4));



Output: "dog."

## split() 
The split() method divides a String into an ordered list of substrings, puts these substrings into an array, and returns the array.

const str = 'The quick brown fox jumps over the lazy dog.';

const words = str.split(' ');
console.log(words[3]);



Output: "fox"
## startsWith() 
The startsWith() method determines whether a string begins with the characters of a specified string, returning true or false as appropriate.

Example :

const str1 = 'Saturday night plans';

console.log(str1.startsWith('Sat');



Output: true