DEV Community: Mitansh Panchal

How to Implement Video Streaming Services: A Behind-the-Scenes Look

Mitansh Panchal — Tue, 04 Mar 2025 06:24:46 +0000

Streaming video has become a cornerstone of modern entertainment, powering platforms like Netflix, YouTube, and Twitch. But how does a massive video file get from a server to your screen seamlessly, even over shaky internet connections? In this blog, we’ll peel back the curtain on video streaming services, exploring how they break videos into chunks, manage buffering on your device, and optimize the experience for millions of users.

Breaking Down Videos into Chunks

When you upload a video to a streaming platform, it doesn’t sit on a server as one giant file waiting to be sent whole. Instead, the service processes it into smaller, manageable pieces—a process critical to efficient delivery.

How It Works

Upload and Encoding:
- Once a video is uploaded, the server encodes it into multiple formats and quality levels (e.g., 240p, 720p, 4K). This creates versions suited for different devices and network speeds.
- Each version is then split into chunks—short segments, typically 2–10 seconds long.
Chunking Process:
- The original file (e.g., a 1-hour MP4) is divided into a sequence of smaller files or segments.
- Metadata (like a playlist or manifest file) is generated, listing where each chunk lives and in what order they should play.
Storage:
- Chunks are stored on a content delivery network (CDN)—a distributed set of servers worldwide—to reduce latency by serving them from a location near the viewer.

Here’s a simplified pseudocode representation of this process:

// On Video Upload
function processVideoUpload(videoFile):
    // Encode into multiple qualities
    qualities = ["240p", "720p", "1080p"]
    encodedVideos = []
    for quality in qualities:
        encodedVersion = encodeVideo(videoFile, quality)
        encodedVideos.append(encodedVersion)

    // Split into chunks
    chunkDuration = 5  // Seconds per chunk
    chunkedVideos = []
    for encodedVideo in encodedVideos:
        chunks = splitIntoChunks(encodedVideo, chunkDuration)
        chunkedVideos.append(chunks)

    // Generate manifest file
    manifest = createManifest(chunkedVideos)
    storeOnCDN(chunkedVideos, manifest)

// When Client Requests Video
function serveVideo(request):
    manifest = fetchManifestFromCDN(request.videoId)
    sendToClient(manifest)

Why Chunks?

Smaller files are easier to download incrementally.
If your connection drops, you don’t lose the whole video—just the current chunk.
Chunks enable adaptive bitrate streaming (more on that later), letting the player switch quality mid-stream.

When you hit “play,” your device fetches the manifest file, which tells it where to grab each chunk in sequence. The server streams these chunks one by one, stitching them together invisibly on your end.

How Buffering Works and Client-Side Management

Buffering is the unsung hero of streaming—those moments when your player loads a bit of video ahead of time to keep playback smooth. But how does it actually work?

How Buffering Works

Preloading Chunks:
- When you start a video, the client (your browser or app) doesn’t wait for the entire file. Instead, it downloads the first few chunks into a buffer—a small memory pool—before playback begins.
- As you watch, it keeps fetching chunks in the background to stay ahead.
Buffer Size:
- The buffer holds enough video (e.g., 10–30 seconds) to handle brief network hiccups without pausing playback.
- If the buffer runs dry (download speed < playback speed), you see the dreaded “buffering” spinner.
Adaptive Playback:
- The client monitors your network speed and adjusts quality. If it detects slowdown, it might switch to a lower-quality chunk to keep the buffer full.

Here’s pseudocode for a basic buffering system:

// Client-Side Buffering Logic
function playVideo(manifest):
    buffer = initializeBuffer()  // Empty buffer, e.g., 20s capacity
    currentPosition = 0  // Playback time in seconds
    quality = selectInitialQuality(networkSpeed)

    // Start preloading
    while playbackActive:
        if buffer.spaceAvailable() and not buffer.full():
            nextChunk = fetchChunk(manifest, currentPosition, quality)
            buffer.add(nextChunk)

        if buffer.hasEnoughData() or buffer.full():
            playFromBuffer(buffer, currentPosition)
            currentPosition = currentPosition + chunkDuration

        // Monitor network and adjust
        currentSpeed = measureNetworkSpeed()
        if currentSpeed < playbackRate and buffer.low():
            quality = downgradeQuality(quality)
        else if currentSpeed > playbackRate and buffer.nearlyFull():
            quality = upgradeQuality(quality)

function onNetworkDrop():
    if buffer.empty():
        pausePlayback()
        showBufferingSpinner()
    else:
        continuePlaybackFromBuffer()

Client-Side Management

Dynamic Adjustment: The player uses algorithms to predict how much buffer is needed based on network jitter (variability in speed).
User Experience: If the buffer empties, playback pauses to rebuild it. Smart clients might lower quality proactively to avoid this.
Local Storage: Some apps cache chunks locally (e.g., on your device) to speed up replays or handle offline viewing.

Buffering is a balancing act: too small, and you risk interruptions; too large, and you waste bandwidth preloading video you might never watch.

Optimizing Video Streaming Services

Streaming services face constant pressure to deliver fast, high-quality video without breaking the bank. Optimization happens at multiple levels—server, network, and client. Here are some key strategies:

1. Adaptive Bitrate Streaming (ABR)

How: Encode each chunk at multiple bitrates (e.g., 500 kbps, 2 Mbps, 5 Mbps). The client picks the best quality based on real-time network conditions.
Benefit: Reduces buffering by dropping to lower quality during slowdowns, then scaling back up when bandwidth allows.
Pseudocode:

  function fetchNextChunk(manifest, position, networkSpeed):
      availableQualities = manifest.getQualities()
      bestQuality = selectQualityBasedOnSpeed(availableQualities, networkSpeed)
      return downloadChunk(manifest, position, bestQuality)

2. Content Delivery Networks (CDNs)

How: Store chunks on servers close to users (e.g., Cloudflare, Akamai). A viewer in Tokyo hits a Tokyo-based server, not one in New York.
Benefit: Cuts latency and reduces load on origin servers.

3. Efficient Encoding

How: Use modern codecs like H.265 (HEVC) or AV1 instead of H.264. These compress video better, shrinking chunk sizes without sacrificing quality.
Benefit: Less bandwidth per chunk, faster downloads, happier buffers.

4. Client-Side Caching

How: Cache frequently accessed chunks (e.g., intros, popular scenes) on the user’s device or in the browser.
Benefit: Reduces server requests, especially for rewatches.

5. Predictive Preloading

How: Use machine learning to guess which video (or chunks) a user might watch next and preload them during idle time.
Pseudocode:

  function preloadNextVideo(userHistory):
      predictedVideo = predictNextWatch(userHistory)
      initialChunks = fetchInitialChunks(predictedVideo, lowQuality)
      storeInBackgroundCache(initialChunks)

6. Rate Limiting and Throttling

How: Cap bandwidth for users on slow connections to prioritize quality over quantity, or limit excessive rewinds/seeks to reduce server strain.
Benefit: Keeps costs predictable during spikes.

7. Progressive Download Fallback

How: For less critical content (e.g., tutorials), allow full chunk downloads in the background while playing, rather than pure streaming.
Benefit: Simpler for stable networks, less server overhead.

Wrapping Up

Video streaming services are a marvel of distributed systems and clever engineering. By breaking videos into chunks, they make massive files manageable and enable seamless delivery over the internet. Buffering keeps playback smooth on the client side, adapting to network hiccups with a mix of preloading and quality tweaks. And through optimizations like ABR, CDNs, and smart encoding, providers ensure you get your cat videos or 4K movies with minimal lag—at scale.

Next time you hit “play,” think about the army of chunks racing from a server somewhere, filling your buffer just in time to keep the show going. It’s not magic—it’s just really good tech.

When Should You Consider Using Microservices?

Mitansh Panchal — Sun, 23 Feb 2025 08:15:44 +0000

Microservices are a hot topic in software development, but they’re not a magic bullet. They can transform how you build and scale applications, or they can bog you down in complexity if you adopt them at the wrong time. So, when does it make sense to ditch the old-school monolith and break your app into smaller, independent pieces? Let’s walk through the signs and scenarios, with some plain-English explanations of the jargon along the way.

What Are Microservices, Anyway?

Microservices are a way of designing an application as a collection of small, self-contained services. Each service does one job—like handling payments, managing user logins, or serving up content—and runs independently. They talk to each other over a network (usually via APIs) instead of being glued together in one big codebase. Compare that to a monolith, where everything—your app’s frontend, backend, database logic—lives in a single, unified program. Think of a monolith as a Swiss Army knife: versatile but bulky. Microservices? They’re a set of specialized tools, each sharpened for its task.

Major usecase

If your development team is growing and you’ve got multiple people (or squads) working on the same app, a monolith can turn into a coordination nightmare. Imagine one team tweaking the payment system while another’s revamping the user dashboard—all in the same codebase. Every change risks breaking something unrelated, and merging code becomes a game of whack-a-mole.

Microservices let you split the app into domains—logical chunks like “payments” or “authentication”—and assign each to its own service. Teams can then work in parallel, deploying their service without touching the others. It’s like giving each crew their own sandbox instead of sharing one crowded playground.

Deploying just means pushing your code live so users can access it. In a monolith, you deploy the whole app at once. With microservices, you deploy only the service you’ve changed.

Your App’s Needs Don’t Scale Evenly

Not every part of your app gets the same workout. Maybe your payment system gets hammered during a flash sale, but your blog section just sits there quietly. In a monolith, scaling up means scaling everything—you’re renting a bigger server for the whole app, even the parts that don’t need it. That’s wasteful.

With microservices, you can scale each piece independently. Need more juice for payments? Spin up extra instances of that service alone. This is where horizontal scaling comes in: adding more machines (or containers) to handle load, rather than beefing up one giant server. Cloud platforms like AWS or Kubernetes make this a breeze—but it’s overkill if your app’s still small and predictable.

Scaling is about handling more users or traffic. Horizontal scaling adds more servers; vertical scaling upgrades the one you’ve got.

Deploys Are Slow and Risky

Ever dread pushing a tiny update because it means rebuilding and redeploying your entire app? In a monolith, even a one-line fix can trigger a full test suite and a nail-biting rollout. If something breaks, good luck figuring out what went wrong in that massive tangle of code.

Microservices shrink the blast radius. Each service is its own mini-app with its own codebase and deployment pipeline. A bug in the login service won’t crash your checkout flow. Plus, smaller services are faster to test and deploy, so you can ship updates more often without sweating bullets.

A codebase is all the source code for a project. A deployment pipeline is the automated process that takes your code from your laptop to the live app.

One Tech Stack Doesn’t Fit All

Monoliths lock you into one programming language or framework. Built your app in Java? Great—until you realize Python’s machine-learning libraries would be perfect for your new analytics feature. With a monolith, you’re stuck twisting Java into knots or rewriting everything.

Microservices let each service pick its own tech stack. Your payment system could stay in Java for reliability, while your analytics service uses Python for data crunching. It’s like letting each chef in a kitchen use their favorite tools instead of forcing them all to wield the same spatula.

When Not to Use Microservices

Hold up—don’t start smashing your app apart just yet. Microservices come with trade-offs. They’re a distributed system, meaning your app’s now spread across multiple services talking over a network. That introduces headaches like network latency (delays in communication), data consistency (keeping everything in sync), and extra monitoring to track what’s breaking where. If your app’s simple or your team’s small, these costs might outweigh the benefits.

Better Practice

Start with a monolith. It’s easier to build, test, and deploy when you’re small or prototyping. Only when you hit real pain points—like slow deploys, team bottlenecks, or uneven scaling—should you consider refactoring into microservices. As the saying goes: “Monoliths are your friend until they’re not.”

How to Set Up a PostgreSQL Database on a VPS and Access It Remotely

Mitansh Panchal — Sun, 08 Sep 2024 06:41:13 +0000

Setting up a PostgreSQL database on a Virtual Private Server (VPS) is an essential skill for developers and system administrators who want to manage databases remotely. This guide will walk you through the process of setting up PostgreSQL on a Debian 12 server and configuring it for remote access.

1: Create a VPS

To get started, you’ll need a VPS. You can use any cloud provider, but for this guide, we'll assume you're using Vultur. The first step is to create a new VPS instance and select Debian 12 as your server operating system.

2: Install PostgreSQL

Once your VPS is up and running, connect to it via SSH. Then, update your package list and install PostgreSQL with the following commands:

sudo apt update
sudo apt install postgresql

This command installs PostgreSQL and its associated packages.

3: Configure PostgreSQL for Remote Access

By default, PostgreSQL is configured to only allow connections from the local system. To enable remote connections, follow these steps:

Edit the postgresql.conf file:

Open the configuration file located at /etc/postgresql/16/main/postgresql.conf (the version number 16 might vary depending on your PostgreSQL version).

   sudo nano /etc/postgresql/16/main/postgresql.conf

Locate the line:

   #listen_addresses = 'localhost'

Uncomment it and change localhost to *:

   listen_addresses = '*'

This change allows PostgreSQL to listen for connections on all available IP addresses.

Edit the pg_hba.conf file:

Next, you'll need to modify the pg_hba.conf file to allow remote access:

   sudo nano /etc/postgresql/16/main/pg_hba.conf

Add the following line to the file:

   host    all             all             0.0.0.0/0               md5

This line allows all users (all) from any IP address (0.0.0.0/0) to connect to any database (all) using password authentication (md5).

4: Restart PostgreSQL

After making these changes, restart the PostgreSQL service to apply the new configuration:

sudo systemctl restart postgresql

5: Configure the Firewall

To allow remote connections to your PostgreSQL server, you need to ensure that your firewall permits traffic on port 5432 (the default PostgreSQL port). Use the following command to allow traffic on this port:

sudo ufw allow 5432/tcp

This command opens port 5432 for TCP connections, enabling remote access to your PostgreSQL database.

6: Connect to Your PostgreSQL Database Remotely

With everything configured, you can now connect to your PostgreSQL database remotely using a PostgreSQL client like psql, DBeaver, or pgAdmin. Use the following connection details:

Host: The IP address of your VPS.
Port: 5432 (or the port you configured).
Username: Your PostgreSQL username.
Password: Your PostgreSQL password.
Database: The name of the database you want to connect to.

Conclusion

Setting up PostgreSQL on a VPS and configuring it for remote access is a straightforward process that gives you the flexibility to manage your databases from anywhere. By following the steps outlined in this guide, you'll have a fully functional PostgreSQL server accessible from any machine.

Shell scripting to change wallpaper - Wallhaven API

Mitansh Panchal — Sun, 01 Sep 2024 18:26:24 +0000

1. Introduction

Changing your desktop wallpaper regularly can be a fun way to keep your workspace fresh and inspiring. Automating this task through shell scripting can save time and effort, allowing your system to change wallpapers based on your preferences without manual intervention. In this guide, we'll explore how to use shell scripting with the Wallhaven API to automatically change your wallpaper on a Linux system.

2. What is Shell Scripting?

Shell scripting is a way to automate tasks in a Unix-like operating system by writing a series of commands in a file that can be executed by the shell. It allows users to automate repetitive tasks, making it a powerful tool for system administration and everyday tasks.

Shell scripting is highly useful for automating small tasks in Linux, such as system maintenance, task scheduling, data processing, and more. It helps users perform operations more efficiently, reducing manual effort and the possibility of errors.

3. What is the Wallhaven API?

Introduction to Wallhaven: Wallhaven is a popular platform known for its vast collection of high-quality wallpapers. Users can explore a wide range of wallpapers, including themes like nature, abstract, anime, and more.

Wallhaven API: The Wallhaven API provides programmatic access to the Wallhaven database, allowing users to search for wallpapers based on specific criteria such as tags, categories, and resolutions. This API makes it possible to fetch wallpaper URLs and download images directly through scripts or applications.

API Key: To use the Wallhaven API, you need an API key, which you can obtain by creating a free account on Wallhaven. The API key is used to authenticate requests and access the API's features.

4. Using `curl` in Shell Scripting to Fetch API Data

Introduction to curl: curl is a command-line tool used for transferring data to or from a server using various protocols, including HTTP, HTTPS, FTP, and more. It's commonly used in shell scripting for interacting with APIs, downloading files, and testing server responses.

Basics of Using curl with APIs:

The basic syntax for making a GET request with curl is:

  curl -X GET "URL"

For APIs that require headers or authentication, you can add options like -H for headers and -d for data.

Fetching Data from Wallhaven API:

Use curl to fetch data from the Wallhaven API by sending a GET request to the API endpoint.
Handle headers and parse JSON responses using tools like jq, which helps extract specific data points from the JSON output.

5. Creating the Shell Script to Change the Wallpaper

Prerequisites:

Tools Needed: curl for making API requests, jq for parsing JSON responses, a command to set the wallpaper (feh, gsettings, swww for Wayland), aria2c for downloading images, and wal for generating themes.
API Key: A valid Wallhaven API key.

Step-by-Step Script Breakdown:

#!/bin/bash

# Define your Wallhaven API key
KEY="YOUR_API_KEY"

# Clear previous wallpapers from the cache
rm -rf /home/looph0le/.cache/wallhaven*

# Accept the wallpaper name or search keyword as an argument
wallname=$1

# Check if a search keyword is provided
if [[ $(echo "$wallname" | wc -c) -gt 1 ]]; then
  # Fetch wallpaper URL using the Wallhaven API
  imageUrl=$(curl -s "https://wallhaven.cc/api/v1/search?apikey=$KEY&purity=111&categories=111&ratios=16x9&sorting=random&q=$wallname" | jq .data[].path | shuf -n1)

  # Format the URL link
  imageLink=$(echo $imageUrl | cut -d'"' -f2)

  # Download the wallpaper
  echo $imageLink
  aria2c -d ~/.cache/ $imageLink

  # Generate a theme using pywal
  wal -i ~/.cache/wallhaven*

  # Set the wallpaper using swww (a wallpaper utility for Wayland)
  swww query || swww init
  swww img ~/.cache/wallhaven* --transition-fps 60 --transition-type outer --transition-duration 3

  # Reload Waybar (status bar for Wayland)
  sh ~/.config/waybar/launch.sh
fi

6. Testing and Running the Script

Execution: Save the script with a .sh extension, make it executable using:

  chmod +x change_wallpaper.sh

Run the script with a keyword to search for a specific type of wallpaper:

  ./change_wallpaper.sh "nature"

Scheduling with Cron: To automate the wallpaper change, add the script to your crontab:

  crontab -e

Add a line to run the script every hour:

  0 * * * * /path/to/change_wallpaper.sh "nature"

7. Conclusion

We have explored how to automate wallpaper changes using shell scripting and the Wallhaven API. By leveraging tools like curl, jq, and aria2c, and using utilities for setting wallpapers, you can easily customize your desktop with new wallpapers automatically.
Feel free to modify the script to suit your preferences, such as filtering wallpapers by categories, tags, or resolutions. Explore other API options and enhance your script with additional features.

Understanding OAuth 2.0

Mitansh Panchal — Thu, 04 Jul 2024 03:58:12 +0000

What is OAuth 2.0?

OAuth 2.0 is an authorization framework that allows third-party services to exchange access to user information without revealing the user’s credentials. Instead of sharing credentials, OAuth 2.0 uses access tokens to grant access. This mechanism is widely adopted by major platforms like Google, Facebook, and GitHub.

Key Concepts and Components

1. Resource Owner (User)

The resource owner is the user who owns the data stored on the resource server. They grant access to this data to third-party applications.

2. Client (Application)

The client is the third-party application that wants to access the user's data on the resource server. It needs authorization from the resource owner to obtain access tokens.

3. Authorization Server

The authorization server is responsible for authenticating the resource owner and issuing access tokens to the client after successful authentication and authorization.

4. Resource Server

The resource server hosts the protected resources and accepts access tokens from the client to serve the requested resources.

5. Access Token

An access token is a string representing the authorization granted to the client. It is issued by the authorization server and used by the client to access protected resources on the resource server.

6. Refresh Token

A refresh token is used to obtain a new access token without requiring the resource owner to re-authenticate. This enhances user experience by maintaining seamless access.

OAuth 2.0 Authorization Flow

OAuth 2.0 supports several authorization flows tailored for different scenarios. The most common flows are:

1. Authorization Code Grant

The authorization code grant is suitable for web applications and involves the following steps:

Authorization Request
- The client directs the resource owner to the authorization server's authorization endpoint.
- The resource owner authenticates and grants permission.
- The authorization server redirects the resource owner to the client with an authorization code.
Token Exchange
- The client exchanges the authorization code for an access token by making a request to the authorization server's token endpoint.
- The authorization server verifies the authorization code and issues an access token (and optionally a refresh token).
Access Resource
- The client uses the access token to access protected resources on the resource server.

2. Implicit Grant

The implicit grant is optimized for client-side applications, such as single-page applications (SPAs). It omits the token exchange step, directly issuing an access token.

Authorization Request
- The client directs the resource owner to the authorization server's authorization endpoint.
- The resource owner authenticates and grants permission.
- The authorization server redirects the resource owner to the client with an access token embedded in the URL fragment.
Access Resource
- The client extracts the access token from the URL fragment and uses it to access protected resources on the resource server.

3. Resource Owner Password Credentials Grant

This flow is used in highly trusted applications, such as the official client of a service, where the resource owner’s credentials are directly shared with the client.

Credentials Submission
- The client collects the resource owner's username and password.
- The client sends these credentials to the authorization server's token endpoint.
Token Issuance
- The authorization server verifies the credentials and issues an access token (and optionally a refresh token).
Access Resource
- The client uses the access token to access protected resources on the resource server.

4. Client Credentials Grant

The client credentials grant is used for server-to-server communication, where the client is acting on its own behalf rather than on behalf of a user.

Token Request
- The client sends its own credentials to the authorization server's token endpoint.
Token Issuance
- The authorization server verifies the client credentials and issues an access token.
Access Resource
- The client uses the access token to access protected resources on the resource server.

Security Considerations

OAuth 2.0 addresses various security concerns through several mechanisms:

Scopes: Define the level of access requested by the client.
State Parameter: Prevents CSRF attacks by maintaining state between the client and authorization server.
PKCE (Proof Key for Code Exchange): Enhances security in public clients by mitigating interception attacks.

Conclusion

OAuth 2.0 has revolutionized the way third-party applications interact with user data, providing a secure and scalable framework for authorization. Understanding its components, flows, and security measures is essential for developers to implement OAuth 2.0 effectively. By leveraging OAuth 2.0, applications can enhance user experience and data security, fostering trust and reliability in digital interactions.

Whether you're developing a web application, a mobile app, or a server-to-server integration, OAuth 2.0 offers a versatile and robust solution for managing authorization in the modern digital landscape.

What can you make using JavaScript ?

Mitansh Panchal — Thu, 19 Jan 2023 06:20:12 +0000

JavaScript is a versatile programming language that can be used to build a wide range of applications. Here are just a few examples of what you can build using JavaScript:

Websites: JavaScript can be used to create dynamic, interactive websites. You can use JavaScript to create responsive designs, animations, and user interfaces.
Web Applications: JavaScript can be used to build web applications that run in a browser. These apps can include anything from simple calculators to full-fledged e-commerce platforms.
Mobile Applications: JavaScript can be used to build mobile apps through frameworks such as React Native, Ionic, or PhoneGap.
Desktop Applications: JavaScript can be used to build desktop apps through frameworks such as Electron. Electron allows you to build cross-platform desktop apps using JavaScript, HTML, and CSS.
Games: JavaScript can be used to create games that run in a browser. You can use JavaScript to create simple games like Tetris or more complex games like 3D first-person shooters.
Machine Learning: JavaScript can be used to build machine learning applications with libraries such as TensorFlow.js.
Internet of Things (IoT) : JavaScript can be used to build IoT applications using libraries such as Johnny-Five.
Back-end Development: JavaScript can be used to build server-side applications using Node.js. Node.js allows you to run JavaScript on a server, which is useful for building back-end services such as APIs.

Overall, JavaScript is a powerful tool that can be used to build a wide range of applications. With its versatility and continued growth, it has become one of the most popular programming languages in the world.

Computer Science in Academia

Mitansh Panchal — Tue, 03 Jan 2023 19:19:23 +0000

Computer Science as a field of study has been around for decades, but it has only recently become a mainstream topic of discussion. This is because the advancements in technology in the past few decades have made it possible for people to interact with computers in ways that were previously unimaginable. As a result, the demand for individuals with a strong understanding of computer science has skyrocketed, making it a highly sought after field of study in academia.

But what exactly is computer science and what do those who study it do? At its core, computer science is the study of the design, development, and use of computers and computer systems. This includes everything from the hardware and software that make up a computer to the algorithms and programming languages used to create software applications.

There are many different subfields within computer science, including artificial intelligence, human-computer interaction, and computer security. Those who study computer science may choose to specialize in one of these areas or choose a more general course of study.

One of the major advantages of studying computer science in academia is the opportunity to work with and learn from experts in the field. Professors and researchers in computer science are often at the forefront of technological advancements, and students have the opportunity to work with them on research projects and gain valuable hands-on experience.

In addition to the practical skills gained through coursework and research, studying computer science in academia also provides students with a strong foundation in theoretical concepts. This is important because it helps students understand the underlying principles behind the technology they are working with, rather than simply learning how to use it.

Overall, studying computer science in academia is a great choice for individuals who are interested in the field and want to gain a strong foundation in the concepts and technologies that drive it. Whether you are looking to enter the workforce after graduation or pursue further studies, a degree in computer science from a reputable academic institution can open many doors and provide a strong foundation for a successful career.

Why javascript for everything?

Mitansh Panchal — Wed, 28 Dec 2022 23:08:30 +0000

JavaScript is a programming language that is essential for modern web development. It is a versatile language that can be used to build a wide range of applications, from simple websites to complex web-based systems. Here are a few reasons why you should consider learning JavaScript:

Demand for JavaScript developers is high: JavaScript is one of the most popular programming languages in the world, and there is a high demand for developers who are proficient in it. According to a survey by the website Indeed, JavaScript is the most sought-after programming language by employers.
It's easy to learn: JavaScript is a relatively easy language to learn, especially for those who already have some programming experience. There are many resources available online, including tutorials, videos, and online courses, to help you get started.
It's versatile: JavaScript can be used for a wide range of applications, including web development, mobile app development, and even desktop applications. This versatility makes it a valuable skill to have in your toolkit.
It's constantly evolving: The JavaScript ecosystem is constantly evolving, with new libraries and frameworks being developed all the time. This means that there is always something new to learn, and you can stay up-to-date with the latest developments in the field.
It's fun: JavaScript is a fun language to work with, and it allows you to build interactive and engaging websites and applications. This can make learning and using it a rewarding and enjoyable experience.

In conclusion, learning JavaScript is a valuable skill that can open up a wide range of opportunities for you as a developer. It is a versatile language that is in high demand, easy to learn, and constantly evolving. Whether you are a beginner or an experienced developer, learning JavaScript is a great investment in your career.

Why i use Arch other than any Linux distribution and you should NOT as a noob ?

Mitansh Panchal — Mon, 08 Aug 2022 16:16:49 +0000

First of all, why even Linux <?>

If you have been using computers enough, you seem to have no reason to switch a whole new operating systems.
There might be some reasons.

Windows just works, Which is true.
Linux just seems too much learning!
I'm comfortable with windows, thanks!

Today i want to share few things with you guys that changed from introduction of Linux in my programming career.

Let's be straight here, Linux is cool. When you see someone using it you already assume he must be a genius. All those terminals open on the screen, text running through it.
But in reality all hes doing is just running update commands or cmatrix[A matrix effect on the terminal].

The thing is, you can also it.

linux is not hard.

You don't have to star hard. Thats what i have seen people do while moving new to linux.
They want to run Arch linux on the first go because they want the best distro.
No doubt Arch is the distro to go for but its too early for that. Getting an idea on what your going in is important.
Learning how things work is important.
Knowing the new environment is what should be the goal.

If you want to get in, without having to know anything about linux.
Just get a Ubuntu installed. and use it.
Use for chilling, browsing web. get use to the new environment. And trust me once you get it, you dont wanna look back to windows.

And about the command line.
I'll say once you get the linux environment you'll learn the tools too.
Just be patient and relax. Relax with linux and you will not need to learn it.

Thanks for reading !

DEV Community: Mitansh Panchal

How to Implement Video Streaming Services: A Behind-the-Scenes Look

Breaking Down Videos into Chunks

How It Works

Why Chunks?

How Buffering Works and Client-Side Management

How Buffering Works

Client-Side Management

Optimizing Video Streaming Services

1. Adaptive Bitrate Streaming (ABR)

2. Content Delivery Networks (CDNs)

3. Efficient Encoding

4. Client-Side Caching

5. Predictive Preloading

6. Rate Limiting and Throttling

7. Progressive Download Fallback

Wrapping Up

When Should You Consider Using Microservices?

What Are Microservices, Anyway?

Major usecase

Your App’s Needs Don’t Scale Evenly

Deploys Are Slow and Risky

One Tech Stack Doesn’t Fit All

When Not to Use Microservices

Better Practice

How to Set Up a PostgreSQL Database on a VPS and Access It Remotely

1: Create a VPS

2: Install PostgreSQL

3: Configure PostgreSQL for Remote Access

4: Restart PostgreSQL

5: Configure the Firewall

6: Connect to Your PostgreSQL Database Remotely

Conclusion

Shell scripting to change wallpaper - Wallhaven API

1. Introduction

2. What is Shell Scripting?

3. What is the Wallhaven API?

4. Using curl in Shell Scripting to Fetch API Data

5. Creating the Shell Script to Change the Wallpaper

6. Testing and Running the Script

7. Conclusion

Understanding OAuth 2.0

What is OAuth 2.0?

Key Concepts and Components

1. Resource Owner (User)

2. Client (Application)

3. Authorization Server

4. Resource Server

5. Access Token

6. Refresh Token

OAuth 2.0 Authorization Flow

1. Authorization Code Grant

2. Implicit Grant

3. Resource Owner Password Credentials Grant

4. Client Credentials Grant

Security Considerations

Conclusion

What can you make using JavaScript ?

Computer Science in Academia

Why javascript for everything?

Why i use Arch other than any Linux distribution and you should NOT as a noob ?

First of all, why even Linux <?>

4. Using `curl` in Shell Scripting to Fetch API Data