DEV Community: Jaimin Bariya

What makes things different? If we learn what is different in all terms that come under one big umbrella, which is AI, then it will be easy for us to learn more in these fields.

Let's do it.

Listen, guys, I am not going to discuss the definition. This is totally raw stuff, okay?!

1. AI [Artificial Intelligence]

The broadest umbrella that covers everything. It's about creating machines that can mimic human intelligence.

But remember, it is not just about mimicking human intelligence but also making decisions autonomously and learning from interaction.
Includes:

Machine Learning (ML)
Deep Learning (DL)
Natural Language Processing (NLP)
Computer Vision (CV)
Robotics & Automation

2. ML [Machine Learning]

ML is the subset of AI, one machine learns from past data to predict future outcomes without being explicitly programmed for specific task.

Example: Predicting house prices based on features like size and location.

Includes:

Supervised Learning: Predict house prices
Unsupervised Learning: Customer clustering
Reinforcement Learning: Training an AI agent for games

Job Roles:

ML Engineer: Builds models, optimizes algorithms
ML Developer: Focuses on integrating ML models into products

3. DL [Deep Learning]

A subset of ML, the Same things learn from the past data and try to predict the future, but DL has more power like [ML + Some energy booster] 😅.

Using a Neural Network [Layer of the network where each layer thinks - so more layers it thinks more], Machine solves complex problems like generative AI, and Natural Language Processing [NLP - talk and understand human language].

One big difference is in ML we choose features like size, color, etc from input, there are like parameters that we use to train the ML Model that is called feature engineering,

But in DL this is done automatically means feature selection does automatically that's why it can be called a*utomatic feature extraction (instead of "feature engineering").*

Includes:

ANNs: General neural networks
CNNs: Image recognition
RNNs: Time-series forecasting

Job Roles:

AI Developer (DL Focus): Develops complex AI systems
Computer Vision Engineer: Focus on image-related models
NLP Engineer: Language models (chatbots, translation)

4. DS [Data Science]

Focuses on data analysis, pattern discovery, and storytelling using data.

Mainly focus on the data part, which includes data analysis, finding insights, and storytelling using data and facts, in short, find something helpful in data with patterns to take any decision that helps.

Key outcome: Data-driven decision-making.

Includes:

Data Cleaning & Preprocessing
Visualization & Reporting
Predictive Analytics

Job Roles:

Data Scientist: Builds insights and predictive models
Data Analyst: Analyzes and visualizes data

5. Robotics

Building physical machines with sensors, AI, and automation logic.

Robotics doesn't always need AI. Basic robots can be pre-programmed without AI. But when AI is integrated, they become intelligent and adaptable.

Example: Boston Dynamics' robots vs simple pick-and-place industrial robots.

Includes:

Self-driving cars
Robot assistants (e.g., industrial robots)

Job Roles:

Robotics Engineer: Develops hardware + software
AI Robotics Specialist: Integrates AI for intelligent behavior

6. Automation

Using software/hardware to perform tasks without human intervention.

Software Automation:
Automates virtual tasks (RPA for data entry).
Hardware Automation:
Automates physical tasks (like robotic arms in factories or smart home systems).

Includes:

RPA (Robotic Process Automation): Automating repetitive business tasks
AI Automation: Smart decision-making systems

Job Roles:

Automation Engineer: Focus on automation solutions

7. Data Engineering & ML Ops

Ensures data pipelines and model deployments are smooth.

Data Engineering: Building pipelines to process and move data efficiently for analytics or AI models.

ML Ops: Deploying, scaling, and maintaining ML models in production environments.

Includes:

Cloud infrastructure (AWS, GCP)
CI/CD for ML models

Job Roles:

ML Ops Engineer: Focuses on deploying AI/ML systems
Data Engineer: Builds pipelines for large-scale data

Summary Table 🧠

Field	Focus Area	Job Roles
AI	Broad decision-making	AI Developer, AI Engineer
ML	Learning from data	ML Engineer, ML Developer
DL	Neural networks	DL Specialist, NLP Engineer
Data Science	Analytics & predictions	Data Scientist, Analyst
Robotics	Smart machines	Robotics Engineer
Automation	Task automation	Automation Engineer
Data Engineering	Data pipelines	Data Engineer, ML Ops

Okay, a little bit of time for my introduction, My name is Jaimin Bariya, and if you find this article helpful plz give all likes (all 5), and throw one comment (anything like nice, super, greetings, etc... ), if it is possible then share with your one friend.

Okay Bye Bye, See you in the next article and try to simplify more hard things 😅.

Checkout my previous articles, if you like AI, you will like them

Top 10 Tech Podcasts for Software Engineers to Level Up in 2025

Jaimin Bariya ・ Jan 26

#programming #softwaredevelopment #podcast #hacktoberfest23

Python Complexity Cheat Sheet 🚀

Jaimin Bariya ・ Jan 25

#python #datastructures #webdev #career

Top 10 Tech Podcasts for Software Engineers to Level Up in 2025

Jaimin Bariya — Sun, 26 Jan 2025 04:04:30 +0000

Top 10 Tech Podcasts for Software Engineers to Level Up in 2025

Okay, Let's come to the points (introduction later 🫡)

Podcasts are a treasure trove of insights for software engineers looking to sharpen their skills and stay up-to-date with industry trends. Here’s a roundup of the best tech podcasts you should tune into:

1. Soft Skills Engineering

While technical skills are critical, soft skills like communication, teamwork, and emotional intelligence can set you apart. This podcast provides practical advice on balancing these aspects with technical expertise. Episodes are humorous yet packed with actionable tips.

Best For: Developers working in team environments or client-facing roles.
Website: Soft Skills Engineering

2. Talk Python to Me

If Python is your go-to language, this podcast is a must-listen. Host Michael Kennedy dives into topics like web development, data science, machine learning, and Python frameworks. Expect deep conversations with Python community leaders.

Best For: Python enthusiasts and data science learners.
Website: Talk Python to Me

3. The Changelog

Exploring open-source projects? This podcast highlights the creators and maintainers of impactful projects. Hosts Adam Stacoviak and Jerod Santo delve into the evolution of open-source software and community contributions.

Best For: Developers passionate about open-source.
Website: The Changelog

4. Darknet Diaries

Peek into the world of cybersecurity with true stories of hacking, breaches, and cybercrime. Jack Rhysider makes technical security topics accessible while keeping listeners engaged with thrilling storytelling.

Best For: Engineers interested in cybersecurity and ethical hacking.
Website: Darknet Diaries

5. Coding Blocks

Focused on software architecture, design patterns, and clean code principles, this podcast helps developers understand high-level concepts with practical examples.

Best For: Engineers aiming to grow their system design and architectural knowledge.
Website: Coding Blocks

6. Software Engineering Daily

Daily episodes that cover a variety of tech topics, including programming, artificial intelligence, and cloud computing. Industry leaders share insights, making it a reliable source for learning new technologies.

Best For: Staying updated with tech trends.
Website: Software Engineering Daily

7. Developer Tea

Short, actionable episodes tailored to busy developers. Topics include productivity, personal development, and decision-making, ideal for those looking for quick inspiration.

Best For: Engineers juggling multiple responsibilities.
Website: Developer Tea

8. Front End Happy Hour

A casual, fun podcast hosted by front-end engineers from companies like Netflix and Twitch. They discuss web development, JavaScript frameworks, and career growth, often over drinks.

Best For: Front-end developers.
Website: Front End Happy Hour

9. Hanselminutes

Hosted by Scott Hanselman, this podcast focuses on topics ranging from programming languages to diversity in tech. It’s perfect for developers who value inclusivity and innovation.

Best For: Developers seeking a broad perspective on tech.
Website: Hanselminutes

10. Command Line Heroes

Produced by Red Hat, this podcast narrates the history of software development, open source, and cloud technologies. It’s a mix of technical insight and storytelling.

Best For: Engineers curious about tech history and its impact.
Website: Command Line Heroes

Why Listen to Podcasts?

Tech podcasts are a fantastic way to learn while commuting, exercising, or during downtime. They provide real-world insights from industry leaders and often share lessons not found in textbooks or blogs.

Okay Here it is, My name is Jaimin Bariya, and I hope you will give all 5 likes if this post adds some value, Follow to grow together. Visit my special post 😅

Final Thoughts

Whether you're interested in mastering Python, exploring cybersecurity, or leveling up your soft skills, these podcasts are tailored to software engineers at all levels. Dive in and let the knowledge flow! 🎧

Python Complexity Cheat Sheet 🚀

Jaimin Bariya — Sat, 25 Jan 2025 04:42:34 +0000

📢 New GitHub Repo: Python Complexity Cheat Sheet 🚀

Okay, Let's come to the point (introduction at the end 🤘)

Hey Developers! 👋

I’m thrilled to share that I’ve created a comprehensive Python Complexity Cheat Sheet 🐍 for all the coders out there who want to write efficient and optimized Python code. This cheat sheet is designed to help you understand the average and worst-case complexities of operations across Python’s built-in data structures.

🔗 Repository Link:

👉 Python Complexity Cheat Sheet

💡 Why Did I Create This Repo?

Understanding the time complexity of operations is essential for writing scalable applications. Python’s built-in data structures like lists, dictionaries, sets, and tuples are powerful but knowing their performance under different operations can make a huge difference.

This repo:

Summarizes complexities of common operations (e.g., append, pop, sort, etc.).
Covers lists, dictionaries, sets, tuples, and strings.
Is beginner-friendly and easy to reference during coding. ✅

📂 What’s Inside?

Here’s a sneak peek into what you’ll find in the repo:

Lists:
- Operations like append, pop, remove, sort, and more.
- Complexity tables for quick reference.
Dictionaries:
- Key-based operations (get, pop, setdefault) and iteration performance.
Sets:
- Methods like add, remove, union, intersection, and their costs.
Tuples:
- Immutable operations and their complexities.
Strings:
- Performance of slicing, searching, and concatenation.
Overview:
- A high-level summary comparing all data structures.

📖 How to Use This Repo?

Clone the repo:

   git clone https://github.com/yourusername/python-complexity-cheatsheet.git

Bookmark it for quick reference during coding. ⭐️

🙌 Contributions Welcome!

If you find this repo helpful, feel free to:

Give it a ⭐️ on GitHub.
Share it with fellow developers.
Submit a pull request if you spot improvements or want to add more content.

🌟 Bonus Repo Coming Soon!

I’m also working on a Python DS Methods and Properties Cheat Sheet, where you’ll find all the essential methods and properties for Python’s data structures. Stay tuned! 🔥

Okay, I did it here it is -> Python DS Methods and Properties Cheat Sheet

Let’s write efficient Python code together! 🐍✨

Okay, My Name is Jaimin Bariya, a Simple developer, AKA Cloud Boy, Follow me to learn together, Keep your eyes on my GitHub for good products (forget to make the project, shift your self to make a product, In short, don't make a project, make product).

Happy Coding! 😄

371 SUM OF TWO INTEGERS - leetcode - Python

Jaimin Bariya — Wed, 22 Jan 2025 06:52:53 +0000

Let's come to the point

We have to perform sum without using the + operator. So developers first thoughts, say -> I guess,` have to use binary manipulation, which is correct.

Let's think more about this approach.

Do this like normal numbers

start summing from the right side as usual, 1 + 1, 0 + 1, 1 + 0, and 0 + 0.
because we are doing with binary, if the number goes to 2 (sum) then make it 0 [like 1 + 1 -> 2 but we can not exceed 0 to 1]
Do this with all numbers, we gate half answer, why because we did not care about carry numbers 😁

this task can done by using the XOR bitwise operator,

Rule of XOR Operator

if bits are the same then -> 0, and if bits are different then -> 1

This matches our need because we have to do 1 + 1 -> 0 and 0 + 1 or 1 + 0 -> 1 (do the usual sum 🤘). and 0 + 0 -> 0 [Based on XOR Rule - Same number than 0 and also usual 0 + 0 -> 0]

Cary your Carry Numbers [think little for them]

Usually, we pass carry to the left number, read it again, I said pass carry to the left number, Here developer's first thinking suggests about using shift operators like << and >>.

But, How we get carry number, for that, think more about and (&) operator.

And & Operator rule said -> if both bits are 1 then result is 1, Great we get carry for those where both bits are 1.

To shift this to the left, we will use << left shift operator. example 0001 << 1 -> 0010

Okay, Enough story building, now let's go to the algorithm

Algorithm:

Initial Step:
- sum = a ^ b (This is the XOR to get the sum without carry)
- carry = (a & b) << 1 (This is the AND to get the carry, shifted left)
Repeat:
- Until carry == 0, update a and b as:
  - a = sum
  - b = carry

In each iteration, you compute the new sum and carry, until the carry becomes zero.

Example:

Let’s walk through the example of adding 5 and 3 step by step.

Initial Values:
First iteration:
- sum = a ^ b = 0101 ^ 0011 = 0110 (sum without carry, which is 6)
- carry = (a & b) << 1 = (0101 & 0011) << 1 = 0001 << 1 = 0010 (carry of 2)

So now:

Second iteration:
- sum = a ^ b = 0110 ^ 0010 = 0100 (new sum, which is 4)
- carry = (a & b) << 1 = (0110 & 0010) << 1 = 0010 << 1 = 0100 (carry of 4)

Now:

Third iteration:
- sum = a ^ b = 0100 ^ 0100 = 0000 (new sum, which is 0)
- carry = (a & b) << 1 = (0100 & 0100) << 1 = 0100 << 1 = 1000 (carry of 8)

Now:

Fourth iteration:
- sum = a ^ b = 0000 ^ 1000 = 1000 (final sum, which is 8)
- carry = (a & b) << 1 = (0000 & 1000) << 1 = 0000 << 1 = 0000 (carry is now 0)

Now, the carry is 0, so we stop, and the final result is 8.

Pseudocode Thought Process

Use XOR to add without carry.
Use AND + shift to compute the carry.
Keep updating the result with XOR and carry until the carry becomes 0.

Okay, perfect, we done it. but when I run this, I got TLE error.

I got this error just because I am using Python for this manipulation, I will teach you why, and how to resolve this, but see what happens when I code in C++, jaimin bariya, SUM OF TWO INTEGERSImage description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k4u0x5sydlmfeyf8pdyc.png)
It is working, but if you are also using python for DSA like me, then congratulation, we have a chance to learn something new here.

New Chapter begins

We got this issue because python is unbounded, and it works well with positive integer but make problem with negative integer like we have shown in image,

So, the main issue arises when working with negative numbers in Python because integers in Python are unbounded, unlike in many other programming languages where integers are represented using fixed bits (e.g., 32-bit or 64-bit integers).

What’s Happening in the Code:

In your implementation, you're calculating carry as:

a & b: This finds the bits where both a and b are 1.
<< 1: This shifts all bits of the result left by 1 position to simulate carrying them over for addition.

The Problem with Negative Numbers in Python:

Infinite Precision Integers:
- Python's integers are not fixed-size like in many other languages (e.g., 32-bit or 64-bit integers).
- Instead, Python integers can grow in size as needed, meaning there's no limit to the number of bits used to represent a number.
Sign Bit Behavior:
- In fixed-size integers (e.g., 32-bit), the most significant bit (MSB) is reserved as the sign bit:
  - 0 = Positive number
  - 1 = Negative number (two's complement form)
- In Python, there’s no fixed MSB to act as the sign bit because integers are unbounded. Negative numbers are stored in two's complement form but don’t have a fixed number of bits.
Infinite Carry Growth:
- When working with negative numbers, the & operation can produce bits beyond the expected range.
- When you shift left (<<), these bits can keep growing indefinitely.
- For example:

(a & b) produces a bit pattern that keeps extending.
<< 1 shifts the bits left, growing the number further.
This can lead to an infinite loop because the condition b != 0 never resolves.

Why Fixed-Size Integers Avoid This:

In a 32-bit integer, bits are confined to 32 positions.
Shifting left (<<) causes overflow (bits outside the range are discarded).
This keeps the calculation bounded, ensuring the loop terminates.

Fix in Python:

To prevent infinite growth, you can simulate fixed-size integers using a mask to limit the bits:

This ensures:

Only the last 32 bits are considered.
The calculation doesn’t grow indefinitely.

Key Takeaway:

Because Python integers are unbounded, operations like & and << on negative numbers can create infinite precision values, causing your loop to run forever. Using a mask helps simulate fixed-size integer behavior to avoid this issue. 🚀

Challenges with Negative Numbers

When performing bitwise operations on negative numbers in Python, the lack of a fixed bit-width can lead to unexpected results. For example, the left shift operation << can cause the number to grow indefinitely, leading to a Time Limit Exceeded (TLE) error in competitive programming or coding platforms.

Solution

To handle negative numbers correctly, you can simulate a fixed bit-width environment. Here's how you can modify your function to work within a 32-bit integer range:

Explanation

MASK: 0xFFFFFFFF is a 32-bit mask (all bits set to 1). Applying & MASK ensures that we only consider the last 32 bits of the result, effectively simulating a 32-bit integer.
MAX_INT: 0x7FFFFFFF represents the maximum positive value for a 32-bit signed integer.
Handling Negative Results: If the result a exceeds MAX_INT, it indicates a negative number in 32-bit two's complement form. To convert it to a Python negative integer, we use the bitwise complement operator ~ in conjunction with ^ MASK.

The code if a > MAX_INT: a = ~(a ^ MASK) ensures that a stays within the 32-bit signed integer range.

What Happens:

a ^ MASK: Flips all the bits of a (simulate overflow).
~(...): Converts the flipped result back into a negative number (32-bit two's complement).

This handles overflow caused by Python's unbounded integers, making sure a behaves like a 32-bit signed integer.

For example:

If a = 2147483648 (overflowed), it becomes -2147483648 after this operation.

Example with negative number

Let's break it down using your specific example where:

a = -12
b = -8

The goal is to compute a + b using the bitwise operations in 32-bit integer arithmetic. Let's see why the output differs and how the if a > MAX_INT condition fixes it.

Step-by-Step Explanation

Initial Values

a = -12 → In 32-bit signed representation: 0xFFFFFFF4
b = -8 → In 32-bit signed representation: 0xFFFFFFF8

Bitwise Addition Logic

First Iteration:
- sum = a ^ b:
  - a ^ b = 0xFFFFFFF4 ^ 0xFFFFFFF8 = 0xFFFFFFFC
- carry = (a & b) << 1:
  - a & b = 0xFFFFFFF4 & 0xFFFFFFF8 = 0xFFFFFFF0
  - carry = 0xFFFFFFF0 << 1 = 0xFFFFFFE0
Update a and b:
- a = sum = 0xFFFFFFFC
- b = carry = 0xFFFFFFE0

Repeat Until `b == 0`

Second Iteration:
- sum = a ^ b:
  - a ^ b = 0xFFFFFFFC ^ 0xFFFFFFE0 = 0x0000001C
- carry = (a & b) << 1:
  - a & b = 0xFFFFFFFC & 0xFFFFFFE0 = 0xFFFFFFE0
  - carry = 0xFFFFFFE0 << 1 = 0xFFFFFFC0

Update:
- a = sum = 0x0000001C
- b = carry = 0xFFFFFFC0

Third Iteration:
- Keep repeating this process until b = 0.

Final Result in Python

After the loop ends, the raw value of a is 0xFFFFFFEC, which is 4294967276 in Python because Python treats it as an unbounded integer.

Adjusting for 32-bit Signed Range

To ensure the result fits into a 32-bit signed integer range, we do:

Define constants:
- MAX_INT = 0x7FFFFFFF (2147483647)
- MASK = 0xFFFFFFFF (all bits set to 1)
Handle Overflow:
- If a > MAX_INT, we convert it back to its negative form: python a = ~(a ^ MASK)
- Here:
  - a = 4294967276 (decimal)
  - a ^ MASK = 4294967276 ^ 0xFFFFFFFF = 0x13 (decimal 20)
  - ~(a ^ MASK) = ~0x13 = -20

Final Output

The corrected result after handling overflow is:
- a + b = -20

This step ensures the output matches the expected value in 32-bit arithmetic.

Why the Condition Exists

Without the if a > MAX_INT logic, Python's integers overflow to large positive numbers (e.g., 4294967276 instead of -20). This condition ensures we bring the result back into the 32-bit signed range, making it behave like a real 32-bit system.

Simple and done! 😊

My Name is Jaimin Bariya, if you find something useful give all 5 likes plz, and throw a comment below, and Follow me on github jaimin-bariya

Leetcode Blind 75

Jaimin Bariya — Sun, 12 Jan 2025 04:04:59 +0000

Let's come to the point

I have created a list of Blind 75 because when I searched for it, it was on GFG, but I wanted it on leetcode (IDK why!!). So here it is the list of Blind 75 on leetcode

One request, some of the problems are premium, so if anyone found these problems on an alternative platform, plz comment it for all :)

If you have little bit more time plz start this repo Blind-75

Array

Binary

Dynamic Programming

Graph

Clone Graph
Course Schedule
Course Schedule II
Pacific Atlantic Water Flow
Number of Islands
Longest Consecutive Sequence
Alien Dictionary (Leetcode Premium)
Graph Valid Tree (Leetcode Premium)
Number of Connected Components in an Undirected Graph (Leetcode Premium)

Interval

Linked List

Matrix

String

Tree

Okay, then. My name is Jaimin Bariya. I write posts on DSA, Python, AI-ML, and React, but I love them all. So, if you found this content helpful, save it, give it all 5 likes (😅), and Share it on your LinkedIn if you are going to start this challenge today.

If you have a little bit of time, plz comment to suggest to me what my next post on. See you next time 👋 🫡

Happy Coding :)

Why Quick Sort is Faster Than Heap Sort

Jaimin Bariya — Sat, 11 Jan 2025 05:55:33 +0000

Let's come to the point...

Sorting algorithms are fundamental to computer science, and two common algorithms often discussed are Quick Sort and Heap Sort. While both have similar time complexities, their performance in real-world scenarios can differ significantly. In this article, we’ll dive into why Quick Sort is generally faster than Heap Sort despite both having the same average time complexity.

Time Complexity and Space Complexity

Let’s start by comparing the time complexity (TC) and space complexity (SC) of both algorithms.

Quick Sort:

Best and Average Case: O(N log N)
Worst Case: O(N²) (when pivot selection is poor)

Heap Sort:

Best, Average, and Worst Case: O(N log N) (consistent)

Space Complexity:

Quick Sort: O(log N) (due to recursion stack in best/average case)
Heap Sort: O(1) (in-place, no extra space for heap)

Why Quick Sort is Faster

Even though both algorithms have O(N log N) time complexity in the average case, Quick Sort tends to outperform Heap Sort in real-world applications. Let's break down why that happens.

1. Cache Efficiency and Memory Access

Quick Sort is an in-place sorting algorithm, meaning it rearranges elements within the same array. This leads to better cache locality, as elements that are close in the array are also close in memory. This makes Quick Sort more cache-friendly, which speeds it up in practical use cases.
On the other hand, Heap Sort relies on a binary heap structure. The heap requires random memory access for operations like heapifying and extracting elements, leading to more cache misses and slower performance compared to Quick Sort.

2. Constant Factors and Overhead

Quick Sort has smaller constant factors due to its partitioning approach. It works by selecting a pivot and dividing the array into smaller sub-arrays, which are recursively sorted. This leads to fewer operations and lower overhead.
Heap Sort, however, requires more complex operations to maintain the heap structure. Ensuring the heap property (parent nodes are larger or smaller than child nodes) introduces additional overhead, making it slower in practice.

3. Adaptability: Pivot Selection in Quick Sort

One of the advantages of Quick Sort is its adaptive nature. By using pivot selection techniques like median-of-three or random pivots, Quick Sort can minimize the chances of hitting its worst-case time complexity (O(N²)). This adaptability helps Quick Sort perform efficiently in most scenarios.
Heap Sort, in contrast, does not have the same level of adaptability. It follows a fixed set of operations for building the heap and extracting elements, regardless of the input. This lack of adaptability means it can't optimize performance based on input data.

4. Practical Performance

In real-world scenarios, Quick Sort typically outperforms Heap Sort. Its better cache efficiency, smaller constant factors, and pivot optimization allow it to run faster on most inputs.
While Heap Sort guarantees O(N log N) time complexity for all cases, it is often slower due to higher overhead and inefficient memory access patterns. Because of this, Heap Sort is less commonly used in practice compared to Quick Sort.

Conclusion

To summarize:

Quick Sort: O(N log N) average case, O(log N) space, and faster in practice due to better cache performance, smaller overhead, and pivot optimization.
Heap Sort: O(N log N) for all cases, O(1) space, but slower due to higher overhead and poor memory access patterns.

Even though both algorithms have the same time complexity, Quick Sort is typically faster in practical applications. Its cache-friendliness and adaptive pivoting make it more efficient overall, while Heap Sort suffers from overhead and inefficiencies in memory usage.

My Name is Jaimin Bariya, If you find this article helpful, give us all 5 likes 😅, and throw a comment plz. See you next time 👋

Python's Magic Methods

Jaimin Bariya — Sun, 29 Dec 2024 11:37:14 +0000

1 -> `new(cls)` Method

The __new__ method is called when a new object is created in Python. It's responsible for creating and returning the new instance of the class. This method is usually used when you want to customize object creation, such as for singleton patterns, caching, or managing memory.

When is `new` Called?

The __new__ method is called before __init__ and is used to create the new object. Here's the typical order of events when you create a new object:

__new__: Creates the object (memory allocation).
__init__: Initializes the object (setting up attributes).

Use Cases for `new`:

Singleton Pattern: The Singleton pattern ensures that only one instance of a class exists. In this case, __new__ checks if an instance already exists and reuses it, instead of creating a new one.

   class Singleton:
       _instance = None

       def __new__(cls):
           if cls._instance is None:
               cls._instance = super(Singleton, cls).__new__(cls)
           return cls._instance

   s1 = Singleton()
   s2 = Singleton()
   print(s1 is s2)  # True, both are the same instance

Caching Objects: If you want to cache objects based on certain conditions, you can use __new__ to check if an object already exists (e.g., in a dictionary) before creating a new one. This can help optimize memory usage.

   class CachedObject:
       _cache = {}

       def __new__(cls, value):
           if value in cls._cache:
               return cls._cache[value]
           obj = super().__new__(cls)
           cls._cache[value] = obj
           return obj

   obj1 = CachedObject("hello")
   obj2 = CachedObject("hello")
   print(obj1 is obj2)  # True, the same object is reused

Memory Management:
If you want to control the memory allocation of objects (e.g., to optimize memory usage or manage large objects), __new__ can be used to customize how objects are created.
Immutable Objects:
__new__ is often used with immutable objects like tuples and strings. For instance, when you want to create a custom immutable object, you would override __new__ to ensure it’s properly created.

   class MyTuple(tuple):
       def __new__(cls, *args):
           return super().__new__(cls, args)

   t = MyTuple(1, 2, 3)
   print(t)  # (1, 2, 3)

In Summary:

__new__ is called when an object is being created and is responsible for returning the instance of the class.
It is useful for optimizing object creation, implementing patterns like Singleton, managing object caching, or even customizing the memory allocation process.

SQL Basic And Intermediate Questions For Interview

Jaimin Bariya — Fri, 27 Dec 2024 11:27:34 +0000

SQL Basic and Intermediate Questions for Interview

Jaimin Bariya ・ Dec 27 '24

#sql #mysql #interview #database

SQL Basic and Intermediate Questions for Interview

Jaimin Bariya — Fri, 27 Dec 2024 08:19:31 +0000

Let's come to the point.

I have created an Awesome SQL Interview GitHub repo to prepare for interview questions and practice SQL queries. I have divided the SQL queries into three sections: Basic (L0), Intermediate (L1), and Advanced (L2). This is the solution for the basic section.

This is L1 (Intermediate) SQL queries to practice, refer to L0 first for better practice.

Note: These examples are tested in MySQL. Syntax may vary for other databases like MS-SQL or Oracle.

L1: Intermediate SQL

Queries that involve working with multiple tables, using JOIN, GROUP BY, HAVING, and complex WHERE conditions.
Introduction to subqueries, aggregate functions, and case statements.

Questions:

Write a query to retrieve the customerName and city for customers in 'USA' and 'France'.
How do you fetch the employeeNumber, lastName, and officeCode of all employees who work in the 'San Francisco' office?
Write a query to find the total number of orders for each customer using orders and customers tables.
How do you retrieve the productName, quantityInStock, and buyPrice for products that have been ordered more than 10 times?
Write a query to fetch the orderNumber, status, and customerName for orders placed by a customer whose customerNumber is 103.
Write a query to find the total sales value (quantityOrdered * priceEach) for each order in the orderdetails table.
How do you find the average quantityOrdered for each orderNumber in the orderdetails table?
Write a query to list the productLine with the highest total revenue (quantityOrdered * priceEach) in the orderdetails table.
Write a query to display the employeeNumber, firstName, lastName, and the office name where the employee works by joining the employees and offices tables.
How do you find the customers who have never placed an order?
Write a query to retrieve the customerName and the total number of orders placed by each customer (include customers who haven’t placed any orders).
Write a query to find the productName and quantityOrdered for all orders where the quantity of the product ordered is greater than 50.
Retrieve the employeeNumber, firstName, and orderNumber of employees who are assigned as sales representatives to customers that have placed an order.
Write a query to calculate the average price of products in the products table based on buyPrice.
How do you fetch the top 3 most expensive products in the products table?
Write a query to retrieve the customerName, orderNumber, and orderDate of all orders that have a status of 'Shipped'.
How do you display the total number of products sold for each productLine?
Write a query to find employees who report directly to the employee with employeeNumber = 1143.
Write a query to calculate the total number of orders in the orders table, grouped by status.
List employees with their manager’s name.

I will mention wrong things also, It is important to know what do to but also very important what not to do, and where we make mistake. let's go to the point again...

Solution with the explanation `WHERE` needed

Query to retrieve the customerName and city for customers in 'USA' and 'France'.
- OR -> Slightly slower if there are a lot of conditions, as the query checks each condition one by one.
- IN -> slightly optimized internally by the database engine, especially for long lists.
- Both are fine for 2-3 conditions. For readability and scalability, IN is better, especially when handling larger lists of values.
- IS is used for checking conditions like IS NULL or IS NOT NULL, not for string comparison.
Fetch the employeeNumber, lastName, and officeCode of all employees who work in the 'San Francisco' office.
Query to find the total number of orders for each customer using orders and customers tables.
- Always include non-aggregated columns in the GROUP BY clause when using aggregate functions in your query.
- This ensures SQL knows how to group rows and avoids ambiguity when selecting additional columns.
- In our example: customerNumber and customerName must both be in the GROUP BY clause since we are selecting them along with COUNT(*).
💡 Golden Rule:
Every column in the SELECT list must either:
Be in the GROUP BY clause, OR
Use an aggregate function like COUNT(), SUM(), etc.
Retrieve the productName, quantityInStock, and buyPrice for products that have been ordered more than 10 times?
- This query is efficient for small and medium size databases, for large sizes we can use indexes, and reduce data scanned using WHERE clause instead of relying solely on HAVING clause
Fetch the orderNumber, status, and customerName for orders placed by a customer whose customerNumber is 103.

Explanation:
- Tables Used:
  - orders: Contains orderNumber and status.
  - customers: Contains customerName.
- INNER JOIN:
  - Combines orders and customers tables using the customerNumber column (common key).
- WHERE Clause:
  - Filters the data to include only records where customerNumber = 103.
- Columns Selected:
  - o.orderNumber: The order number.
  - o.status: The order status.
  - c.customerName: The name of the customer placing the order.
Find the total sales value (quantityOrdered * priceEach) for each order in the orderdetails table.
Find the average quantityOrdered for each orderNumber in the orderdetails table.
- Explanation:
- orderNumber:
  - Groups the rows by the orderNumber.
- AVG(quantityOrdered):
  - Calculates the average quantityOrdered for all rows that belong to the same orderNumber.
- GROUP BY:
  - Ensures the average is calculated for each orderNumber separately.
Query to list the productLine with the highest total revenue (quantityOrdered * priceEach) in the orderdetails table.
- Explanation:
- productLine:
  - Categorizes the products into different lines, like "Motorcycles" or "Planes."
- SUM(od.quantityOrdered * od.priceEach):
  - Calculates the total revenue for each productLine.
- INNER JOIN:
  - Joins products and orderdetails tables on productCode to associate product lines with their order details.
- GROUP BY p.productLine:
  - Groups the results by each productLine.
- ORDER BY totalRevenue DESC:
  - Sorts the grouped results in descending order of revenue, so the highest revenue appears first.
- LIMIT 1:
  - Restricts the result to only the productLine with the highest revenue.
Query to display the employeeNumber, firstName, lastName, and the office name where the employee works by joining the employees and offices tables.
- CONCAT(column, 'separater', column, 'separater', column)
- CONCAT_WS('separater', columns)
Find the customers who have never placed an order

Explanation:
- LEFT JOIN: Retrieves all customers from the customers table, whether or not they have matching rows in the orders table.
- o.orderNumber IS NULL: Identifies customers who do not have any corresponding orders (i.e., orderNumber is NULL because there's no match in the orders table).
- Columns:
  - customerNumber: Unique identifier for the customer.
  - customerName: Name of the customer.
Query to retrieve the customerName and the total number of orders placed by each customer (include customers who haven’t placed any orders).
Find the productName and quantityOrdered for all orders where the quantity of the product ordered is greater than 50.
Retrieve the employeeNumber, firstName, and orderNumber of employees who are assigned as sales representatives to customers that have placed an order.

Explanation:
- FROM employees e:
  - We start with the employees table (aliased as e) because we want the employee details, specifically the employeeNumber and firstName.
- JOIN customers c ON e.employeeNumber = c.salesRepEmployeeNumber:
  - We join the customers table (aliased as c) on the employeeNumber from employees and salesRepEmployeeNumber from customers. This creates the relationship between employees (sales reps) and customers. Now, we can identify which employee is assigned to each customer.
- JOIN orders o ON c.customerNumber = o.customerNumber:
  - We further join the orders table (aliased as o) with the customers table using the customerNumber. This gives us the orders placed by each customer.
- SELECT e.employeeNumber, e.firstName, o.orderNumber:
  - Finally, we select the employeeNumber and firstName from the employees table (sales reps) and the orderNumber from the orders table for each customer who has placed an order.
Query to calculate the average price of products in the products table based on buyPrice.
Fetch the top 3 most expensive products in the products table?
Rretrieve the customerName, orderNumber, and orderDate of all orders that have a status of 'Shipped'.
Display the total number of products sold for each productLine
Find employees who report directly to the employee with employeeNumber = 1143.
Query to calculate the total number of orders in the orders table, grouped by status.
List employees with their manager’s name.

Hey, My name is Jaimin Baria AKA Cloud Boy..., If you have enjoyed and learned something useful, like this post, add a comment, and visit my Awesome SQL Interview GitHub repo.

Don't forget to give it a start 😅.

Happy Coding 🧑‍💻

🛠️ Fixes Suggested by Readers

Steps to Create AI ML Solution

Jaimin Bariya — Sun, 22 Dec 2024 11:47:49 +0000

Detailed roadmap that will guide you through data collection, model training, and deployment. This process is iterative, so you'll often loop back to earlier steps as you fine-tune your solution.

Step 1: Understand the Problem

Before gathering any data, you need to:

Define the problem clearly: Understand what you're trying to solve. Is it a classification problem (e.g., spam detection), a regression problem (e.g., price prediction), or a recommendation system?
Define success criteria: What does a successful model look like? For example, do you want 90% accuracy, low latency, or high precision?

Step 2: Data Collection

The data you gather should be directly tied to your problem. Here’s how to collect it:

A. Identify Data Sources

Public Datasets:

Use datasets from places like:
- Kaggle: Offers numerous datasets across different domains.
- UCI Machine Learning Repository: Another great place for data.
- Government data portals: Some governments provide open datasets (e.g., data.gov).
Web Scraping:

If your data source is not available, you can scrape websites using tools like:
- BeautifulSoup (Python library)
- Scrapy (Python framework)
APIs:

You can use APIs to collect data from services like:
- Twitter API (for social media data)
- Google Maps API (for location data)
Databases:

Sometimes your company or project may already have access to databases (SQL, NoSQL) where data is stored.
IoT Devices:

If you're building an AI solution for hardware, collect data from sensors or other IoT devices.

B. Data Quantity and Quality

Collect enough data to train the model. More data usually leads to better models, but the data needs to be relevant.
Quality over Quantity: Make sure the data is clean (no missing values, no outliers unless they are important).

Step 3: Data Cleaning & Preprocessing

Raw data is rarely in a form that can be directly fed into a model. Data cleaning involves:

A. Handle Missing Data

Imputation: Fill missing values with the mean, median, or mode (for numerical data) or the most common value (for categorical data).
Remove Missing Data: Drop rows or columns with too many missing values.

B. Remove or Fix Outliers

Statistical Methods: Use Z-scores, IQR, or visualizations like box plots to identify and remove or correct outliers.

C. Data Transformation

Normalization/Standardization: Scale numerical data (e.g., MinMax scaling, Z-score standardization).
Encoding Categorical Variables: Convert categorical variables into numbers (e.g., One-hot encoding, Label encoding).

D. Feature Engineering

Create new features from existing ones (e.g., extracting day, month, or year from a date, creating ratios between columns).
Feature Selection: Remove irrelevant or highly correlated features to reduce overfitting and improve model performance.

Step 4: Data Splitting

Once your data is cleaned and ready, you need to split it into:

Training Set (usually 70-80%): Used to train the model.
Validation Set (usually 10-15%): Used to tune hyperparameters and validate the model’s performance.
Test Set (usually 10-15%): Used to evaluate the final model’s generalization to unseen data.

Step 5: Model Selection

Choose an appropriate machine learning model based on your problem.

A. Types of Models

Supervised Learning:
- Classification: If the output is a category (e.g., spam vs. not spam).
- Regression: If the output is continuous (e.g., predicting house prices).
Unsupervised Learning:
- Clustering: Grouping similar data points (e.g., customer segmentation).
- Dimensionality Reduction: Reducing the number of features while retaining essential information (e.g., PCA).
Reinforcement Learning:
- Used when an agent learns by interacting with an environment to maximize rewards.

B. Choose Algorithm

Based on your problem, choose the model. Examples:

Linear Regression, Decision Trees, Logistic Regression for supervised tasks.
K-Means, DBSCAN for clustering.
KNN, Random Forests, SVMs for classification/regression.

Step 6: Model Training

Train your model using the training set.

A. Model Training Process

Fit the Model: Use your training data to teach the model how to predict or classify.
Track Performance: During training, monitor the model’s performance (e.g., loss function, accuracy).

B. Hyperparameter Tuning

Grid Search: Try multiple combinations of hyperparameters to find the best set.
Random Search: A faster alternative to Grid Search for hyperparameter tuning.
Bayesian Optimization: An advanced technique to find the best model parameters.

Step 7: Model Evaluation

Evaluate the trained model using the validation set. Use appropriate metrics to assess its performance:

Accuracy: Proportion of correct predictions (for classification).
Precision, Recall, F1-Score: Useful when dealing with imbalanced classes.
RMSE (Root Mean Squared Error): For regression problems.
Confusion Matrix: To see true positives, false positives, etc.

A. Cross-Validation

K-fold cross-validation: Split the data into k parts and train and validate the model k times, each time using a different fold as the validation set.

Step 8: Model Optimization & Tuning

Improve your model based on the evaluation results.

A. Regularization

Use L1 (Lasso) or L2 (Ridge) regularization to prevent overfitting by penalizing large coefficients.

B. Ensemble Methods

Use techniques like Random Forests, Boosting (e.g., XGBoost, AdaBoost) to combine multiple models and improve performance.

C. Model Stacking

Combine predictions from multiple models (e.g., combining outputs from SVMs, logistic regression, and decision trees).

Step 9: Model Deployment

Once the model performs well, deploy it to a production environment.

A. Deployment Process

Containerization: Use Docker to package the model and all dependencies in a container.
Model Serving: Use tools like Flask, FastAPI, or TensorFlow Serving to expose the model as an API.
CI/CD Pipelines: Automate model deployment with GitLab CI, Jenkins, or GitHub Actions.

B. Scalability & Monitoring

Ensure the system can handle real-world traffic (e.g., multiple API requests).
Monitor: Track the model’s real-time performance, and if it degrades over time, retrain the model with fresh data.

Step 10: Post-Deployment (Monitoring & Maintenance)

Model Drift: Over time, the model might lose its accuracy due to changes in data patterns. Retrain it with new data regularly.
A/B Testing: Test multiple models against each other to see which one performs better in production.

Summary of the Full Process

Problem Understanding → 2. Data Collection → 3. Data Cleaning & Preprocessing → 4. Data Splitting → 5. Model Selection → 6. Model Training → 7. Model Evaluation → 8. Model Optimization & Tuning → 9. Model Deployment → 10. Post-Deployment Monitoring

The key is iterative refinement. You might need to go back to earlier steps (like data collection or preprocessing) as you learn more about your model’s performance. And always keep an eye on reproducibility, collaboration, and scalability throughout the process! 😎

DEV Community: Jaimin Bariya

[Boost]

Turn Any React App into an MCP Client in Under 10 Minutes

[Boost]

Git Branching Strategies: A Comprehensive Guide

AI ML DL DS Robotics Automation differences ???

1. AI [Artificial Intelligence]

2. ML [Machine Learning]

3. DL [Deep Learning]

4. DS [Data Science]

5. Robotics

6. Automation

7. Data Engineering & ML Ops

Summary Table 🧠

Top 10 Tech Podcasts for Software Engineers to Level Up in 2025

Jaimin Bariya ・ Jan 26

Python Complexity Cheat Sheet 🚀

Jaimin Bariya ・ Jan 25

Top 10 Tech Podcasts for Software Engineers to Level Up in 2025

Top 10 Tech Podcasts for Software Engineers to Level Up in 2025

1. Soft Skills Engineering

2. Talk Python to Me

3. The Changelog

4. Darknet Diaries

5. Coding Blocks

6. Software Engineering Daily

7. Developer Tea

8. Front End Happy Hour

9. Hanselminutes

10. Command Line Heroes

Why Listen to Podcasts?

Final Thoughts

Python Complexity Cheat Sheet 🚀

📢 New GitHub Repo: Python Complexity Cheat Sheet 🚀

🔗 Repository Link:

💡 Why Did I Create This Repo?

📂 What’s Inside?

📖 How to Use This Repo?

🙌 Contributions Welcome!

🌟 Bonus Repo Coming Soon!

371 SUM OF TWO INTEGERS - leetcode - Python

Do this like normal numbers

Rule of XOR Operator

Cary your Carry Numbers [think little for them]

Algorithm:

Example:

Pseudocode Thought Process

New Chapter begins

What’s Happening in the Code:

The Problem with Negative Numbers in Python:

Why Fixed-Size Integers Avoid This:

Fix in Python:

Key Takeaway:

Challenges with Negative Numbers

Solution

Explanation

What Happens:

Example with negative number

Step-by-Step Explanation

Initial Values

Bitwise Addition Logic

Repeat Until b == 0

Final Result in Python

Adjusting for 32-bit Signed Range

Final Output

Why the Condition Exists

Leetcode Blind 75

Why Quick Sort is Faster Than Heap Sort

Time Complexity and Space Complexity

Quick Sort:

Heap Sort:

Space Complexity:

Why Quick Sort is Faster

1. Cache Efficiency and Memory Access

2. Constant Factors and Overhead

3. Adaptability: Pivot Selection in Quick Sort

4. Practical Performance

Conclusion

Python's Magic Methods

1 -> __new__(cls) Method

Repeat Until `b == 0`

1 -> `new(cls)` Method

When is `new` Called?

Use Cases for `new`:

Solution with the explanation `WHERE` needed