DEV Community: Nimish Bordiya

Explaining AI Through a Case Study: Netflix Recommendation System

Nimish Bordiya — Wed, 01 Oct 2025 10:13:54 +0000

Introduction

Netflix has over 260 million users worldwide, each with different tastes in movies and TV shows. Instead of showing everyone the same list, Netflix uses Artificial Intelligence (AI) to personalize recommendations. Around 80% of what users watch on Netflix comes from these AI-driven recommendations.

How It Works

The Netflix recommendation system uses Machine Learning algorithms that analyze three main factors:

User Behavior
- What you watch, how long you watch, what you skip, and when you stop watching.
Content Features
- Information about movies/TV shows (genre, cast, director, language, release year, etc.).
Collaborative Filtering
- Finds users with similar tastes and recommends what they enjoyed.
- Example: If User A and User B both liked “Stranger Things,” and User A also liked “Wednesday,” then “Wednesday” might be suggested to User B.

Diagram – Netflix Recommendation AI Flow

[User Data: watch history, ratings, clicks]
                    |
                    v
        +-----------------------------+
        | Machine Learning Algorithms |
        +-----------------------------+
            /           |           \
           v            v            v
 [Content-based]  [Collaborative]  [Trending/Context]
   Filtering         Filtering        Awareness
                    (similar users)  (time, device)
                    |
                    v
          [Personalized Recommendations]

Real Example

Imagine a new user watches only sci-fi movies like Interstellar and Inception.

The system will analyze the content features (sci-fi, time travel, space).
It will check what similar users have watched next (maybe The Martian or Dark).
It will combine this with trending content and suggest a personalized list.

Benefits

Saves time for users by reducing “scroll fatigue.”
Keeps users engaged on the platform.
Boosts Netflix revenue by improving user satisfaction and retention.

Challenges

Cold Start Problem – For new users with no history, recommendations are harder.
Filter Bubble – Users may only see content similar to what they already like, missing diverse options.
Privacy Concerns – The system relies heavily on personal viewing data.

Conclusion

The Netflix recommendation system is a powerful real-world example of AI improving user experience. By combining machine learning, user behavior, and content analysis, Netflix delivers highly personalized suggestions. However, ethical use of data and balance between personalization and diversity remain important for the future of AI-driven recommendations.

Digital Ethics Position Paper: AI in Hiring

Nimish Bordiya — Wed, 01 Oct 2025 09:58:55 +0000

Digital Ethics Position Paper: AI in Hiring

Artificial Intelligence (AI) has rapidly become a central tool in modern recruitment. Companies increasingly rely on algorithms to screen résumés, evaluate candidate interviews, and even predict future job performance. At first glance, this seems efficient and fair—machines do not get tired, show favoritism, or suffer from unconscious bias. However, the use of AI in hiring raises serious ethical concerns, particularly around fairness, transparency, and accountability. I believe that while AI can assist in recruitment, it should not be given unchecked authority in hiring decisions. Without proper oversight, AI in hiring risks reinforcing bias instead of removing it.

One of the primary concerns is algorithmic bias. AI systems learn from historical data, which often reflects existing inequalities in the workplace. For example, Amazon famously scrapped its AI recruitment tool after it was found to disadvantage female candidates for technical roles. The system had been trained on data from past hires—mostly men—and consequently learned to prioritize male candidates. This case highlights the central problem: AI is not inherently objective; it replicates the biases present in its training data. Left unchecked, such systems can perpetuate discrimination under the guise of neutrality.

Another ethical issue is transparency. Many applicants are unaware that their applications are being evaluated by algorithms, let alone how these systems work. Unlike human recruiters, who can explain their reasoning, AI systems often function as "black boxes"—their decision-making process is opaque, even to their developers. This lack of explainability undermines trust in the hiring process. If a candidate is rejected, they have a right to know why. Was it because of their skills, their phrasing of answers, or something as arbitrary as keyword mismatches? Without transparency, applicants are left powerless.

Accountability is equally critical. When a human recruiter discriminates, there are clear channels for complaint and accountability. But who is responsible when an AI system unfairly rejects a qualified applicant? The hiring manager? The software vendor? The data scientist who trained the model? This ambiguity makes it difficult for rejected candidates to seek redress. A system that directly impacts people’s livelihoods must not operate without clear accountability structures.

Despite these challenges, I do not advocate for eliminating AI from hiring altogether. The solution lies in responsible and ethical use. First, AI should be used as a supportive tool, not the ultimate decision-maker. Human recruiters must remain in the loop, especially for final decisions. Second, AI systems must undergo bias audits by independent reviewers to ensure they do not reinforce discrimination. Third, companies should commit to algorithmic transparency, clearly informing applicants when AI is used and providing understandable explanations for decisions. Finally, there must be regulatory oversight that holds organizations accountable for unfair practices.

In conclusion, AI has the potential to make hiring more efficient, but it must not come at the expense of fairness and human dignity. Left unchecked, AI systems risk reinforcing the very inequalities they promise to eliminate. A balanced approach—where AI aids decision-making but humans retain ultimate control, with transparency and accountability built into the system—is both ethical and practical. Hiring is not just about filling positions; it is about giving individuals a fair chance at opportunity. AI should serve that purpose, not undermine it.

Cloud vs Edge vs Local Computing (Security Camera Example)

Nimish Bordiya — Wed, 01 Oct 2025 09:45:23 +0000

Cloud vs Edge vs Local Computing (Security Camera Example)

1. Cloud Computing (Centralized)

How it works:
- Camera records video → uploads raw/processed video to the cloud.
- Cloud server runs AI (e.g., motion detection, face recognition).
- Alerts/recordings sent back to user app.
Diagram:

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

✅ Pros:
- Powerful processing (scalable).
- Centralized updates & analytics.
- Easy to manage across many devices.
❌ Cons:
- High bandwidth usage (video streaming to cloud).
- Latency (slower response).
- Privacy concerns (sensitive data stored in cloud).

2. Edge Computing (Near-device Processing)

How it works:
- Camera sends data to a nearby edge device (e.g., router with AI chip, local server, ISP edge node).
- AI processing (motion detection, object recognition) happens on the edge.
- Only relevant results/alerts sent to cloud or user.

Diagram:

[Camera] ---> [Edge Device/Local Gateway] ---> [Cloud/Optional] ---> [User App]

✅ Pros:
- Reduced bandwidth (only relevant data sent).
- Faster response (low latency).
- Balance between performance & cloud convenience.
❌ Cons:
- Requires investment in edge hardware.
- Still partial dependency on cloud.
- Limited compared to cloud’s massive compute.

3. Local Computing (On-device)

How it works:
- Camera itself has built-in AI chip.
- Processes video locally (motion detection, storage on local drive).
- Sends alert directly to user app without cloud.
Diagram:

[Smart Camera] ---> [User App]   (No Cloud needed)

✅ Pros:
- Very low latency (real-time).
- No internet dependency.
- High privacy (data stays local).
❌ Cons:
- Limited storage & compute power.
- Harder to update/improve AI models.
- No central management for multiple devices.

Comparison Table

Feature	Cloud Computing	Edge Computing	Local Computing
Latency	High (due to internet)	Medium (close to device)	Very low (real-time)
Privacy	Low (data leaves home)	Medium (partial local processing)	High (data stays local)
Cost	Subscription/server cost	Edge device setup cost	Hardware cost (smart cam)
Processing Power	Very high (scalable)	Medium (edge hardware dependent)	Low (device-limited)
Internet Dependency	Always needed	Partial	Not required

System chosen — Online Food Delivery System.

Nimish Bordiya — Wed, 01 Oct 2025 09:02:28 +0000

Level 0 DFD (Context Diagram – Food Delivery System)

This shows the system as a single process interacting with external entities.

Entities & Flows:

Customer → sends Order Request → Food Delivery System
Food Delivery System → sends Order Confirmation & Delivery → Customer
Restaurant ↔ exchanges Order Details & Food ↔ Food Delivery System
Delivery Agent ↔ gets Pickup/Delivery Info ↔ Food Delivery System
Payment Gateway ↔ handles Payment Details ↔ Food Delivery System

🖼️ Diagram structure (Level 0)

Customer ----------------------> 
                                   \
                                    \         +-------------------+
                                     ----->   |                   |
   Restaurant <------------------->           | Food Delivery      |
                                              |     System         |
   Delivery Agent <----------------->         |                   |
                                              +-------------------+
   Payment Gateway <---------------->

Level 1 DFD (Decomposition of Food Delivery System)

Now we break down the single process into sub-processes.

Processes in Food Delivery System:

Browse & Select Food
- Customer searches for restaurants/menus.
Place Order
- Customer places order → order sent to restaurant.
Process Payment
- System sends payment info to Payment Gateway, gets confirmation.
Assign Delivery Agent
- System assigns nearest agent.
Track & Deliver
- Customer can track order until delivered.

Data Stores:

D1: Customer Database (profiles, addresses)
D2: Order Database (order history, status)

🖼️ Diagram structure (Level 1)


                  +-----------------------------+
 Customer ------> | 1. Browse & Select Food     |
                  +-------------+---------------+
                                |
                                v
                  +-------------+---------------+
 Customer ------> | 2. Place Order              | ------> Restaurant
                  +-------------+---------------+
                                |
                                v
                  +-------------+---------------+
                  | 3. Process Payment           | <----> Payment Gateway
                  +-------------+---------------+
                                |
                                v
                  +-------------+---------------+
                  | 4. Assign Delivery Agent     | <----> Delivery Agent
                  +-------------+---------------+
                                |
                                v
                  +-------------+---------------+
                  | 5. Track & Deliver           | -----> Customer
                  +------------------------------+

✅ This covers both Level 0 (context) and Level 1 (detailed process) diagrams.

Simple Calculator App – SDLC Stages

Nimish Bordiya — Wed, 01 Oct 2025 08:27:56 +0000

1. Requirement Analysis

Objective: Build a simple calculator mobile/desktop app that can perform basic arithmetic operations.

Functional Requirements:

User should be able to input two numbers.
App should support basic operations: addition (+), subtraction (−), multiplication (×), division (÷).
Display the result on the screen. 4.Provide a "Clear" button to reset inputs and result.

Non-Functional Requirements:

Easy-to-use interface.
Fast response (instant calculations).
Should not crash for invalid inputs (e.g., division by zero).

2. Design
Wireframe / Sketch (simple UI idea):

 --------------------------
|   Simple Calculator      |
|--------------------------|
|  [  Input 1  ]           |
|  [  Input 2  ]           |
|                          |
|  [+]  [-]  [×]  [÷]      |
|                          |
|  Result: [      ]        |
|                          |
|  [ Clear ]               |
 --------------------------

Two input boxes for numbers.
Four buttons for operations.
A result box to show the answer.
A "Clear" button.

3. Development (Pseudocode)

// Start Calculator App

BEGIN

DISPLAY "Enter first number:"
READ num1

DISPLAY "Enter second number:"
READ num2

DISPLAY "Choose operation: +, -, *, /"
READ op

IF op == "+"
    result = num1 + num2
ELSE IF op == "-"
    result = num1 - num2
ELSE IF op == "*"
    result = num1 * num2
ELSE IF op == "/"
    IF num2 == 0
        DISPLAY "Error: Division by zero not allowed"
    ELSE
        result = num1 / num2
    ENDIF
ENDIF

DISPLAY "Result = " + result

// Clear function resets num1, num2, and result

END

4. Testing Plan

Test Cases:

| Test Case ID | Input 1 | Input 2 | Operation | Expected Output         | Notes             |
| ------------ | ------- | ------- | --------- | ----------------------- | ----------------- |
| TC01         | 5       | 3       | +         | 8                       | Basic addition    |
| TC02         | 10      | 4       | -         | 6                       | Subtraction       |
| TC03         | 6       | 7       | *         | 42                      | Multiplication    |
| TC04         | 20      | 5       | /         | 4                       | Division          |
| TC05         | 8       | 0       | /         | Error: Division by zero | Edge case         |
| TC06         | A       | 2       | +         | Error: Invalid input    | Non-numeric input |
| TC07         | 100     | 200     | -         | -100                    | Large numbers     |

Testing Types:

Unit Testing: Verify each function (add, subtract, multiply, divide).
Integration Testing: Check interaction between UI and logic.
System Testing: Ensure the entire app works smoothly.
User Acceptance Testing (UAT): Ask real users to try for ease of use.

How Computers Think in 1s and 0s

Nimish Bordiya — Wed, 01 Oct 2025 05:42:47 +0000

How Computers Think in 1s and 0s

When we look at our computers, phones, or even smart devices, they seem intelligent. They can process images, play videos, run apps, and even talk back using AI assistants. But deep inside, all of this “thinking” happens using just two digits: 1 and 0. This is called the binary system, and it is the foundation of how computers work.

The Binary Language of Computers
Unlike humans who use the decimal number system (0–9), computers operate in binary because their electronic circuits have two simple states:

ON → represented as 1
OFF → represented as 0 Every action a computer performs—whether it is saving a file, playing music, or displaying a photo—is broken down into millions or billions of these tiny 1s and 0s.

How Binary Works
Think of binary as a light switch. A switch can either be on (1) or off (0). Now imagine billions of such switches working together. By combining these states, computers can represent numbers, letters, and even images.

Example: Convert binary 101 to decimal

Rightmost digit = 1 × 2^0 = 1
Middle digit    = 0 × 2^1 = 0
Leftmost digit  = 1 × 2^2 = 4

Add them up → 4 + 0 + 1 = 5

So, binary is just a different way of counting—but one that suits machines perfectly.

Representing Text and Images in Binary
Numbers are easy, but how do computers handle letters and pictures?

Text: Each character is assigned a binary code. For example, the letter A is represented as 01000001 in ASCII (American Standard Code for Information Interchange).
Images: Pictures are broken down into tiny dots called pixels. Each pixel has a color value (like red, green, and blue), which is stored in binary form.
This means that whether you’re typing a message or streaming a movie, it all comes down to billions of 1s and 0s being processed at lightning speed.

Logic Gates: The Building Blocks
Computers don’t just store 1s and 0s; they also process them. This is done through logic gates, which are electronic circuits that take one or more binary inputs and produce a binary output.

Some common gates are:

AND gate → outputs 1 only if both inputs are 1
OR gate → outputs 1 if at least one input is 1
NOT gate → flips 1 to 0 and 0 to 1

By combining millions of these gates, computers perform calculations, make decisions, and run programs.

Diagram: How Computers Think in 1s and 0s

Below is a simple diagram showing the flow of binary information inside a computer:

Input (Keyboard/Mouse) → Binary Conversion → Processing (Logic Gates & CPU) → Output (Screen/Speaker)

And an example of a logic gate:

 Input A -----
                 \
                  AND ----> Output
                 /
   Input B -----

If A = 1 and B = 1, the output is 1. Otherwise, the output is 0.

Conclusion
At first glance, it may seem mysterious how complex devices run on something as simple as 1s and 0s. But this simplicity is what makes computers so powerful. By combining binary numbers, encoding systems like ASCII, and billions of logic gates, modern computers can perform incredible tasks—from simple calculations to advanced artificial intelligence.
So next time you see a computer performing a “smart” task, remember: deep inside, it’s just flipping billions of tiny switches between 1 and 0.