DEV Community: Daksh Ranjan Srivastava

Real-World AI Application: Netflix Recommendation System

Daksh Ranjan Srivastava — Mon, 29 Sep 2025 16:49:02 +0000

🔹 What is it?

Netflix uses Artificial Intelligence (AI) and Machine Learning (ML) to recommend movies and shows tailored for each user. Instead of showing the same homepage to everyone, Netflix personalizes content to keep users engaged.

🔹 How It Works (Step-by-Step)

User Data Collection

Netflix collects huge amounts of data such as:

What you watch (movies, series, documentaries).

How long you watch (do you finish or leave midway?).

Actions (like, dislike, add to list, skip).

Device type (phone, TV, laptop).

Time of watching (weekend evenings vs weekdays).

2. Machine Learning Algorithms

Netflix applies multiple AI models:

Collaborative Filtering

Finds users with similar tastes.

Example: If you and another person both watched Money Heist and Narcos, and they also liked Breaking Bad, Netflix will suggest Breaking Bad to you.

Content-Based Filtering

Focuses on item details (actors, genres, directors).

Example: If you like movies with Shah Rukh Khan or in romance genre, Netflix suggests similar ones.

Deep Learning Models

Analyze viewing sequences, timing, and patterns.

Example: If you binge-watch thrillers late at night, Netflix prioritizes thrillers during that time slot.

3. Personalized Recommendations

Netflix ranks and orders content uniquely for every user.

Even the thumbnails/posters are personalized!

Example: For a romantic viewer, Netflix shows a romantic scene as the thumbnail of a movie, while for an action lover, the same movie may show a fight scene.

🔹 Diagram (Conceptual Flow)

   User Data (watch history, ratings, clicks, devices)
                             ↓
               Machine Learning Algorithms
   ┌─────────────────────┬─────────────────────┐
   │ Collaborative       │ Content-Based       │
   │ Filtering           │ Filtering           │
   └─────────────────────┴─────────────────────┘
                             ↓
                Deep Learning + Ranking
                             ↓
     Personalized Recommendations (Homepage content + Thumbnails)

🔹 Why It’s Important ?

80% of content watched comes from recommendations.

Saves time → Users don’t waste hours searching.

Keeps engagement high → People keep watching and renewing subscriptions.

Business impact → Reduces customer churn and boosts profits.

✅ This gives you both:

A detailed written explanation.

A diagram for visual clarity.

[https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bjwbp74zaqugsb5skpfp.png]

Digital Ethics: Position Paper

Daksh Ranjan Srivastava — Mon, 29 Sep 2025 16:33:48 +0000

AI in Hiring – Efficiency at the Cost of Fairness?
Artificial Intelligence (AI) has increasingly become a tool for automating hiring processes, from scanning résumés to conducting video interviews. Companies adopt AI hiring systems to save time, reduce costs, and process thousands of applicants quickly. While these systems appear to promise efficiency and objectivity, they raise serious ethical questions regarding bias, transparency, and fairness. In my view, AI in hiring should be used only as a supportive tool, not as the primary decision-maker, because unchecked reliance on it can reinforce discrimination and undermine trust in the recruitment process.

One of the strongest arguments in favor of AI hiring tools is efficiency. Multinational companies may receive tens of thousands of job applications for a single role. Traditional hiring methods make it nearly impossible for recruiters to fairly evaluate all candidates. AI algorithms can quickly filter out unqualified applicants, identify promising matches, and even rank candidates based on their skills and experience. Some organizations also claim AI reduces human bias because machines do not “get tired” or form subjective opinions during the evaluation process.

However, real-world examples reveal that AI systems are not neutral. In fact, they often reflect and amplify the biases present in the data they are trained on. Amazon famously scrapped an AI hiring system after discovering it consistently downgraded applications from women, simply because historical hiring data in tech favored men. This demonstrates that AI, far from eliminating bias, risks automating systemic discrimination on a large scale. Candidates who do not fit into the patterns established in past data—whether due to gender, race, disability, or unconventional career paths—can be unfairly excluded.

Transparency is another major ethical concern. Many AI hiring tools operate as “black boxes,” making decisions without offering explanations. Applicants are often unaware of how their résumés were filtered or why their video interviews were flagged as weak. This lack of accountability undermines fairness and can damage trust in employers. Job seekers deserve to know the criteria being applied to their applications, especially when decisions affect their livelihoods.

Despite these challenges, AI in hiring does not need to be discarded entirely. Instead, it should be reimagined as an assistive tool rather than an authority. For instance, AI could be used to anonymize applications, removing names, photos, and demographic details to reduce unconscious bias in the early stages. Human recruiters could then make final decisions, ensuring context and judgment are not lost. Additionally, strict regulations should be introduced requiring AI vendors to disclose how their models work, what data they are trained on, and what safeguards are in place against bias. Independent audits should become mandatory to certify fairness and reliability.

In conclusion, AI in hiring sits at the crossroads of innovation and ethics. While it offers undeniable efficiency, its risks to fairness and transparency cannot be ignored. If left unregulated, AI hiring systems may entrench inequality instead of creating opportunity. The solution lies not in rejecting AI outright, but in demanding responsible design, oversight, and human accountability. Only then can we ensure technology serves as a bridge to opportunity rather than a barrier to it.

Cloud vs Edge vs Local Architecture (Use-Case: Security Camera).

Daksh Ranjan Srivastava — Mon, 29 Sep 2025 16:30:47 +0000

1. Cloud Computing

How it works:
The camera captures video and streams it to a cloud server. Processing (like motion detection, face recognition, storage) happens in the cloud.

Diagram:

[Security Camera] ---> [Internet] ---> [Cloud Server] ---> [User App]

Pros:
✅ Scalable storage
✅ Powerful AI/ML processing
✅ Accessible from anywhere

Cons:
❌ High latency (delays in alerts)
❌ Requires strong internet connection
❌ Privacy risks (data stored in cloud)

2. Edge Computing
How it works:
The camera or a nearby edge device (router/gateway) does the processing (motion detection, AI inference). Only relevant data or alerts are sent to the cloud.

Diagram:

[Security Camera + Edge Processor] ---> [Filtered Data/Alerts] ---> [Cloud / User App]

Pros:
✅ Low latency (faster alerts)
✅ Reduced bandwidth (only key data sent)
✅ Better privacy (raw video stays local)

Cons:
❌ Higher hardware cost
❌ Limited processing power compared to cloud
❌ Still needs internet for remote access

3. Local Computing
How it works:
All processing and storage happen within the camera or a local DVR/NVR. Users connect via LAN or directly to the device.

Diagram:

[Security Camera + Local Storage/Processor] ---> [User (LAN/Direct)]

Pros:
✅ Very fast response (no internet needed)
✅ Maximum privacy (data stays local)
✅ Works even without internet

Cons:
❌ Limited storage (hard drive fills up)
❌ No remote access without setup
❌ Limited AI features compared to cloud

Comparison Table

| Feature             | Cloud                  | Edge                           | Local                |
| ------------------- | ---------------------- | ------------------------------ | -------------------- |
| Latency             | High (due to internet) | Low                            | Very Low             |
| Storage             | Virtually unlimited    | Limited (depends on edge node) | Limited (local disk) |
| Privacy             | Lower                  | Medium                         | High                 |
| Internet Dependence | High                   | Medium                         | Low                  |
| Cost                | Subscription-based     | Higher hardware cost           | One-time device cost |

✅ Summary:

Use Cloud if you want scalability and remote access everywhere.

Use Edge if you need fast AI decisions (motion alerts, face detection) with reduced bandwidth.

[https://dev-to-uploads.s3.amazonaws.com/uploads/articles/am5n4ap26j4kdujxw92w.png]
[https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hcacd96i00vrr0j9cd0m.png]

System chosen — Online Food Delivery System.

Daksh Ranjan Srivastava — Mon, 29 Sep 2025 16:19:06 +0000

Below are a simple Level 0 (context) and a Level 1 (decomposed) DFD (Data Flow Diagram). I picked an online food-delivery system since it’s real, common, and ties to your earlier food/nutrition project.

Legend

External Entity = [ENTITY]

Process = (P#) Name

Data Store = =DATA=

Data Flow shown with --> or <--

Level 0 DFD (Context diagram)

Single high-level process showing how external entities interact with the system.

  [Customer] ---> (P0) Online Food Delivery System ---> [Restaurant]
       |                  |         ^    |                 ^
       |                  |         |    |                 |
       |                  v         |    v                 |
       |               =ORDERS=     | =MENU_DB=            |
       |                  ^         |    ^                 |
       |                  |         v    |                 |
       +--> [Payment Gateway] <---- (P0) <--- [Delivery Partner]

Text explanation (Level 0)

Customer places orders and makes payments.

Restaurant receives orders and confirms.

Delivery Partner receives dispatch information to deliver food.

Payment Gateway handles payments.

System stores orders and menu data.

**Level 1 DFD (Decomposition of P0 into main sub-processes)**
    [Customer]
       |
       | (1) Search menu / place order
       v
    (P1) Browse & Order -------------------------------> =MENU_DB=
       | order details / payment request
       |                                         ^
       |                                         |
       v                                         |
    (P2) Payment Processing --(payment auth/request)-> [Payment Gateway]
       | payment status (success/fail)
       v
    =ORDERS= <---- (order + payment status) ---- (P3) Restaurant Order Mgmt
       ^                                             |
       | order acceptance / prep status              |
       |                                             v
    (P4) Dispatch & Delivery <---- dispatch info ---- [Delivery Partner]
       | delivery status updates
       v
    [Customer] <--- notifications (ETA, delivered) --- (Notifications)

Elements (Level 1)

(P1) Browse & Order

Inputs: customer search, menu from =MENU_DB=

Outputs: order request to =ORDERS=, payment request to (P2)

(P2) Payment Processing

Interacts with [Payment Gateway] for authorization; writes payment status to =ORDERS=

(P3) Restaurant Order Management

Reads order from =ORDERS=, updates prep status, sends order acceptance/reject

(P4) Dispatch & Delivery

Assigns delivery partner (reads partner availability), sends dispatch details, updates delivery status in =ORDERS=

Notifications (cross-cutting process)

Sends SMS/push: order confirmation, ETA, delivery complete

Data Stores

=MENU_DB= — stores restaurants’ menus, item prices, availability

=ORDERS= — stores order records, status, payment info, customer address

(optional) =USER_DB= — stores customer profiles, addresses, payment tokens

Short notes on DFD best-practices used

Level 0 = single process showing all external actors.

Level 1 = breaks the big process into 4–5 logical sub-processes with clear flows to data stores and external systems.

Avoid crossing lines where possible; group related flows (order → payment → restaurant → delivery).

Keep data stores passive — only processes read/write them.

SDLC for To-Do List App.

Daksh Ranjan Srivastava — Mon, 29 Sep 2025 15:56:29 +0000

Requirement Analysis

Users should be able to add tasks with a title.

Users should be able to mark tasks as complete.

Users should be able to delete tasks.

Tasks should be stored locally (no backend for simplicity).

The interface should be simple and mobile-friendly.

Design (Wireframe Sketch)

 -------------------------
 |     To-Do List App     |
 -------------------------
 |  [ Add Task + Button ] |
 -------------------------
 |  [ ] Task 1            |
 |  [✓] Task 2            |
 |  [ ] Task 3            |
 -------------------------
 |   Completed: 1 Task    |
 -------------------------

Development (Pseudocode)

START

FUNCTION main():
    INIT empty list tasks

FUNCTION addTask(taskName):
    CREATE newTask with name = taskName, status = incomplete
    APPEND newTask to tasks

FUNCTION markTaskComplete(taskID):
    FIND task in tasks by ID
    SET task.status = complete

FUNCTION deleteTask(taskID):
    REMOVE task from tasks list

FUNCTION displayTasks():
    FOR each task in tasks:
        PRINT task.name + task.status

END

Testing Plan

| Test Case ID | Description                          | Expected Result                     | Status |
| ------------ | ------------------------------------ | ----------------------------------- | ------ |
| TC-1         | Add a task                           | Task appears in the task list       | Pass   |
| TC-2         | Mark a task as complete              | Task status changes to "Complete"   | Pass   |
| TC-3         | Delete a task                        | Task is removed from the list       | Pass   |
| TC-4         | Add multiple tasks                   | All tasks appear correctly          | Pass   |
| TC-5         | Mark already completed task again    | Status remains "Complete"           | Pass   |
| TC-6         | Delete a non-existing task (invalid) | Error handled gracefully (no crash) | Pass   |

✅ This covers all four SDLC stages: Requirements → Design → Development → Testing.

HOW COMPUTERS THINK IN 1s AND 0s ?

Daksh Ranjan Srivastava — Mon, 29 Sep 2025 10:03:18 +0000

When you type on your laptop, stream a video, or even play a game, it might feel like the computer understands you. But beneath the colorful screens and apps, every action boils down to something surprisingly simple: a series of 1s and 0s, known as binary code.

WHY 1s AND 0s ?

Computers are electronic machines that run on electricity. Electricity has two states: on and off. To represent this, computers use 1 for “on” and 0 for “off.” This binary system is the foundation of all digital communication.

Think of it like a light bulb:
• If the bulb is on, we call it 1.
• If the bulb is off, we call it 0.

By combining many such switches, computers can represent complex information.

From Binary to Meaning

At first, binary may look meaningless. But imagine this sequence:
01001000 01001001

To us, it’s just numbers. To a computer, each group of eight digits (called a byte) represents a character. In this case, the two bytes spell HI in text.

So, with enough 1s and 0s, a computer can store words, images, music, and even entire movies.

The Logic Behind It

Computers don’t just store data; they make decisions using logic gates. These gates take in 1s and 0s and output results based on rules like AND, OR, and NOT. For example:
• AND gate: Both inputs must be 1 to give 1.
• OR gate: If at least one input is 1, the output is 1.

By combining millions (or billions) of these gates, computers can solve problems, process data, and run software.

Simple Diagram: How Computers Process Binary
Input (1s and 0s) → Logic Gates → Processor → Output (Text, Images, Sound)

Why It Matters !

Understanding binary helps us appreciate how much power comes from simplicity. Just two symbols—1 and 0—drive the modern digital world. The smartphone in your pocket, the AI chatbot you talk to, or the spacecraft exploring Mars all rely on this fundamental language.

Conclusion !

Computers may seem like magic, but their “thoughts” are really streams of 1s and 0s flowing through tiny circuits. It’s the clever arrangement of these binary signals that turns raw electricity into something intelligent, powerful, and essential in our daily lives.