
Every year brings new knowledge, new people, new adventures, and challenges. I've decided to share what happened this year with you.

![2024, me at Google office](https://miro.medium.com/v2/1*SeH2AAYHNcg5D9hDT_vWwQ.jpeg)

## Work

![Me at Google office](https://miro.medium.com/v2/1*lQCg8msbvynIAdA0bwVMwQ.jpeg)

I had big plans for 2024, including working at a **FAANG** company, launching a successful startup, writing valuable blogs, and learning as much as possible. I can confidently say that I achieved most of these goals. This year, I received **16 job offers**, faced **one hiring freeze**, and got **hundreds of rejections**.

While getting rejected without even being considered by smaller startups was stressful, I successfully passed interviews at major companies like **Google**, **Meta**, **Dropbox**, **IBM**, and more.

Currently, I am focusing on my studies, which is why I had to turn down opportunities from **Meta** and **Google**—a five-day, eight-hour office job would limit my flexibility. However, **Dropbox** offered a fantastic remote work opportunity, which aligns perfectly with my goals.

## Startup (42.uz)

![42.uz platform](https://miro.medium.com/v2/1*8tcMry5rVkLGuBmBHtiLfQ.jpeg)

I've been trying to build startups since I was 18. Many of my early ideas didn’t last long, while some worked well enough to provide valuable experience that still benefits me today. In November 2023, I launched [42.uz](https://42.uz), and by January 2024, I became fully involved in the project.

![](https://miro.medium.com/v2/1*R-o4CfolGWI22v0glsAipA.jpeg)

We often say, _"Strength is in unity!"_ but rarely practice it. I could have built my own platform, but I chose to contribute to [42.uz](https://42.uz) instead—and I have no regrets. Instead of just offering video lessons, we focus on solving real-world problems and helping users gain hands-on experience.

![](https://miro.medium.com/v2/1*h3l6aZZCpMzVfXASog8Rtg.jpeg)

In 2024, we hosted [**42Conf**](https://t.me/qirikki/57), where I spoke about solving technical challenges. At the end of the conference, we shared our plans for 2025, engaged with students, and listened to their feedback. We’re also planning to organize even more impactful live conferences in the future (In sha Allah).

## Life

Balancing studies and work is challenging, but it has its own rewards. At university, I try to complete most of my courses at the beginning of the year. One thing I appreciate about studying in Europe is that knowledge matters more than attendance.

During my studies, I also got the opportunity to teach seven times. My professors liked my approach, projects, and ideas, which made my academic journey smoother (at least, that's how I feel).

![Brotherhood (Azimjon and Otabek)](https://miro.medium.com/v2/1*qPcbTNlUSXDqNrCYJA6khw.jpeg)

Living abroad is tough because your closest people are far away. Fortunately, Azimjon aka and I helped each other through this challenge. I found a brother, and I believe he found one too.

## Conclusion

My goal for this year is simple—**take action!** We know a lot, but we rarely apply our knowledge. This leads to endless questions, increased anxiety, and unnecessary fears. Knowledge is worthless if you don’t act on it—so just do it!

![Meme](https://miro.medium.com/v2/1*4F4kSnibmeU-5WnJgiuDTw.jpeg)

I’ve never categorized myself as just a Backend or Frontend developer. I see all challenges equally and focus on solving problems. The meme above perfectly illustrates how I joined the **42.uz** team. Instead of labeling yourself as a **Frontend Developer** or **Backend Developer**, strive to be **Otabek**—a true problem solver.

Let's win!


Every year brings new knowledge, new people, new adventures, and challenges. I've decided to share what happened this year with you.

2024 Recap


The coding interview process at MAANG companies has become both a dream and a nightmare for many aspiring engineers. Before writing this post, I had numerous discussions with friends working at such companies. In this guide, I will cover **preparation**, **LeetCode**, **optimal solutions**, **overcoming struggles**, and other essential strategies to succeed.

> Don't just read this post—act on it! If you don’t, this could be you in the interview 👇🏻

[![Your fate if you don’t prepare](https://telegra.ph/file/8b20fc062a25f1fb740de.gif 'Interview disaster')](https://telegra.ph/file/8b20fc062a25f1fb740de.gif 'Interview disaster')

## Coding Rounds

During this stage, your skills beyond algorithms will be tested. Interviewers assess multiple competencies, including:

- **Technical Competence**: Writing clean, efficient, and maintainable code.
- **Problem-Solving**: Breaking down complex problems into manageable parts and finding optimal solutions.
- **Ability to Work Under Pressure**: Handling time constraints and high-pressure scenarios.
- **Communication Skills**: Clearly articulating thoughts, explaining reasoning, and responding effectively to feedback.
- **High Standards**: The best performers across these categories receive job offers because top tech firms seek only the best candidates.

## Your Recruiter is Your Best Friend

![Recruiter reaching out](https://telegra.ph/file/7a270048de867e8a58310.png)

It might sound exaggerated, but from my personal experience, your recruiter is there to help you succeed. They’re not your enemy; they want you to pass all interview stages, land the job, and enjoy free meals at your dream company.

If you have questions, don’t hesitate to ask. Recruiters can provide preparation resources and even connect you with people in the role you're applying for. Always be proactive in seeking guidance.

## The Actual Coding Round

Feeling nervous? Butterflies in your stomach? Brain stuck on `HashMap`? Congrats, it's just the beginning.

![You have 60 seconds to invert a binary tree](https://telegra.ph/file/231032cdfb7bd7f9ac70a.gif)

You will typically have **45 minutes** to solve problems. Sometimes, the interviewer will start with an easy question to warm you up. However, you must efficiently manage time, ask clarifying questions, propose solutions, and write code within the given timeframe.

### Example Problem:
**Read a file and calculate the frequency of each word in it.**

Sounds simple, right? But panic can take over, leading to random thoughts:

> DP, HashMap, Linked List, RAM, Directed Graph, MOM, WHY AM I SO DUMB?!

Instead of spiraling, stay calm and prepare yourself properly.

## Confirm Your Understanding

Interviewers won’t just throw you into a problem without some ambiguity. It’s your job to ask clarifying questions:

- **“What format is the input file? JSON or CSV?”** Assumptions don’t help—get confirmation.
- **“How large is the file? Can it fit into memory?”** Handling a 30GB file line-by-line requires different logic than reading a small file at once.
- **“Are there Unicode characters?”** A seemingly minor detail that can cause major issues if overlooked.
- **“What’s the expected output format?”** Are you returning a dictionary, writing to a file, or outputting JSON?

Writing down input constraints during the discussion helps avoid mistakes later.

## Check Input Bounds

Understanding input and output boundaries is crucial. If you're working with an integer array, ask:

- Is the array sorted?
- Can it contain negative numbers?
- Can it be empty?
- Are values signed or unsigned integers?

These questions demonstrate analytical thinking and prevent unnecessary errors.

## Think Out Loud

Verbalizing your thought process is essential. It might feel awkward, but interviewers want insight into your approach. If you go silent and start writing code immediately, they have no idea what you're thinking.

![When a candidate starts coding without explaining](https://telegra.ph/file/64d02e5d3f70016c37820.jpg)

## Discuss Potential Limitations

Every solution has trade-offs. If you're using generators to handle large files efficiently, mention that they don’t allow backtracking. Showing awareness of such limitations highlights your depth of understanding.

## Start Coding

Once you’ve optimized your solution and received the go-ahead from your interviewer, start coding.

- Expect a **text editor**, not an IDE—no syntax highlighting, no auto-complete.
- Choose a language you’re fluent in and comfortable implementing **data structures** with.
- Use helper functions when appropriate. If solving a problem with an array, consider writing a separate function for hashing words.
- Write **clear variable names** and add **comments** where needed.

> **Tip:** Clarity in your code reflects clarity in your thinking.

## Preparation Process

Before diving into LeetCode, solidify your **data structures and algorithms** knowledge. Being able to implement them in **5-10 minutes** is ideal.

- Focus on understanding, not just memorizing.
- Analyze each line of code to grasp its purpose.
- If you struggle, revisit solutions and re-implement them until they feel natural.
- Reattempt problems after a few days to reinforce learning.

### Memorization?

Yes, sometimes it's necessary. Knowing standard solutions by heart isn't a bad thing—it's efficiency.

If this post was helpful, don’t forget to share it!

### © References:
- [Inspired by **Shafiqa Iqbal’s** Medium post](https://medium.com/@shafiqa_iqbal/everything-you-need-to-know-about-coding-interviews-in-big-tech-companies-bdd58720b0b5)
- Advice from friends
- Personal experience


A deep dive into the challenging yet rewarding process of coding interviews at MAANG companies.

Big Tech - Coding Interviews


Imagine you've been given a major project. To understand its scale, you discover that the platform already has 100 million users, and every day, **X** new users are joining. Your task is to check whether a given **username** already exists in the system when new users sign up.

![username](https://telegra.ph/file/686bec3b2605fc2a36e87.gif)

```sql
-- Returns 1 if the username "john" exists, otherwise returns 0.
SELECT EXISTS(SELECT username FROM Users WHERE username = 'john');
```

If your first instinct is to write a query like this, hold on! This post will help you optimize the lookup process from **O(n)** to **O(1)**. So, let’s dive in! ✨

## **Understanding the Problem**

SQL checks data row by row, following an **iterative approach**. Before performing the check, it also needs to load the data into RAM. Even though databases manage memory efficiently, loading large datasets still affects performance.

Now, let’s say our database has **24 million users**, meaning **24 million rows** to scan. As the number of users continues to grow, this could reach **N** rows, making our lookup complexity **O(n)**. Checking all rows every time a user picks a username is inefficient. We need a better approach—let’s start by exploring **caching**.

## **Caching: Is It a Solution?**

![Caching](https://telegra.ph/file/d8b7e2c9f8bb1de5c8f84.png)

Caching is great for **rarely changing** and **frequently accessed** data. For example, imagine building a stock market platform like **Bloomberg**, where stock prices change every second. If you cache a page, users will see outdated prices instead of real-time updates. 

Since cached data is stored in fast memory, servers can return results quickly. However, in our case, we have millions of records, and **we can't guarantee that usernames won’t change frequently**. This makes caching an unreliable solution. We need a **faster lookup** method.

## **Binary Search: A Step Forward?**

![Binary Search](https://telegra.ph/file/9b1637c7cad96e145aab0.jpg)

Since scanning every row is too slow, we consider **Binary Search**, one of the fastest search algorithms. If we have **100 million records**, Binary Search can find a result in just **27 comparisons**, which is incredibly fast. 

However, Binary Search requires the data to be **sorted**. Every time a new user registers, we would need to **re-sort** the data. Even using QuickSort, this would take **O(n log n)** time, which is still inefficient. So, is there an even better solution?

## **Bloom Filter: The Optimal Choice**

A **Bloom Filter** is a space-efficient **probabilistic data structure**. Unlike traditional data structures, it doesn't store actual values but **estimates the presence of an element** with a small probability of error. If your system can tolerate occasional **false positives**, Bloom Filters can significantly improve performance.

We know that **HashMaps** and **Sets** can find elements in **O(1)** time because they use **hashing**. Since Bloom Filters also rely on hashing, they achieve **O(1)** lookups. However, they come with a trade-off: **false positives**. This means the filter might mistakenly say a username exists when it actually doesn’t. On the bright side, Bloom Filters **never produce false negatives**, meaning if it says a username doesn’t exist, it’s 100% correct.

### **How Does It Work?**

![Array](https://telegra.ph/file/6e825890e084784be4715.jpg)

A Bloom Filter uses a **bit array** of size **N**, where all bits are initially set to **0**. When inserting a username, a **hash function** calculates an index, and we mark that position as **1**.

\[
hash(username) \% N = index
\]

Later, when checking if a username exists, we check if the bit at that index is **1**. If it is, the username *might* exist. If it's **0**, the username definitely doesn't exist.

![Bit Array](https://telegra.ph/file/959e76f417d4add07f2ff.jpg)

### **False Positives: The Trade-off**
If two different usernames generate the same hash index, the Bloom Filter may incorrectly indicate that the second username is already taken. This is known as a **false positive**.

To reduce false positives, we use **multiple hash functions**. Each username is stored in multiple positions in the bit array, increasing accuracy.

![Multiple Hash Functions](https://telegra.ph/file/1b14a4b6981fab9eb6b3a.jpg)

While false positives can never be eliminated entirely, mathematical formulas help determine the optimal number of hash functions and bit array size to keep errors minimal.

## **Conclusion: Choosing the Right Approach**

An **O(n)** approach isn't always bad, and an **O(1)** solution isn't always perfect. The key is understanding your system’s needs and choosing the most efficient method accordingly.

This post aimed to explain **when and why** Bloom Filters are useful. In a future post, I’ll discuss cases where an **iterative approach can sometimes outperform a constant-time solution**.

Share this post and help others grow! (And don't be like the guy in the meme below 😆)

![Funny Meme](https://telegra.ph/file/48d07c346ae90613a3a12.png)
```


Imagine you're assigned a large-scale project. To grasp its magnitude, you learn that it has 100 million users.

Bloom Filter


[Booking.com](https://www.booking.com), [Airbnb](https://www.airbnb.com), [Calendly](https://www.calendly.com), and [42Mentors](https://www.42.uz/mentors) all serve a common purpose: they allow users to book:

- Appointments
- Accommodations, meals, and other services

One of the most common yet critical issues these platforms face is the **double booking problem**.

![Picture about Booking](https://telegra.ph/file/2b90f53ac717de5854909.jpg)

### The Double Booking Problem

Imagine two users accessing your system at the same time. Both of them select the same slot—April 18 at 8:00 PM—and click the `Book` button simultaneously. If your system does not have a mechanism to handle this, it may confirm the booking for both users. This results in a major issue! 😢

Thankfully, databases like PostgreSQL and MySQL provide built-in solutions to tackle this problem efficiently.

### **Using SELECT ... FOR UPDATE**

```sql
SELECT id, name, school_number FROM schools;
```

Most developers are familiar with a standard `SELECT` query like the one above. However, not everyone is aware of the **FOR UPDATE** clause, primarily because they haven't encountered the need for it yet.

PostgreSQL provides an extensive explanation of the `SELECT` statement in its [documentation](https://www.postgresql.org/docs/current/sql-select.html). The **FOR UPDATE** clause is specifically discussed in the [Locking Clause](https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE) section.

**SELECT ... FOR UPDATE** not only retrieves a row but also **locks** it, preventing concurrent modifications. This helps prevent race conditions. The process follows three key steps:

1. **Row Locking** – The selected row is locked, ensuring no other operation can modify it.
2. **Transaction Scope** – The lock remains active until the transaction is either committed or rolled back.
3. **Concurrent Modification** – While the transaction is in progress, other transactions attempting to modify the same row are blocked.

### **Implementation**

To demonstrate this in practice, let’s use **JavaScript** with **PostgreSQL**. Before we begin, create a table and insert some sample data into your database:

```sql
CREATE TABLE slots (
	id SERIAL PRIMARY KEY,
	name VARCHAR(150),
	isbooked BOOLEAN
)
```

Start your PostgreSQL server and create a route in **Express.js** to retrieve all available slots:

```js
app.get('/slots', async (req, res) => {
  // Fetch all slots from the database
  const result = await pool.query('SELECT id, name, isbooked FROM slots');
  // Return the rows as a response
  res.send(result.rows);
});
```

### **Handling Slot Booking**

Now, let's create a route to book a slot based on `id` and `name`:

```js
app.put('/:id/:name', async (req, res) => {
  try {
    const id = req.params.id;
    const name = req.params.name;

    const conn = await pool.connect();
    // Fetch the slot to check if it's available
    const sql = 'SELECT id, name, isbooked FROM slots WHERE id = $1 AND isbooked = 0';
    const result = await conn.query(sql, [id]);

    // If no rows are returned, the slot is already booked
    if (result.rowCount === 0) {
      res.send({ error: 'Slot is already booked!' });
      return;
    }

    // If available, update the slot status to booked
    const sqlU = 'UPDATE slots SET isbooked = 1, name = $2 WHERE id = $1';
    const updateResult = await conn.query(sqlU, [id, name]);

    conn.release();
    res.send(updateResult);
  } catch (ex) {
    console.log(ex);
    res.sendStatus(500);
  }
});
```

At this stage, the system appears functional. However, there is still a major flaw: **we haven’t used FOR UPDATE yet**! If two users book a slot simultaneously, both will receive a success response, causing a **double booking issue**.

### **Preventing Double Booking with Transactions & FOR UPDATE**

To solve this, we modify the previous implementation by using transactions and **FOR UPDATE**:

```js
app.put('/:id/:name', async (req, res) => {
  try {
    const id = req.params.id;
    const name = req.params.name;

    const conn = await pool.connect();
    // Start transaction to isolate the process
    await conn.query('BEGIN');
    
    // Lock the selected slot to prevent race conditions
    const sql = 'SELECT id, name, isbooked FROM slots WHERE id = $1 AND isbooked = 0 FOR UPDATE';
    const result = await conn.query(sql, [id]);

    // If no rows are returned, the slot is already booked
    if (result.rowCount === 0) {
      res.send({ error: 'Slot is already booked!' });
      return;
    }

    // If available, update the slot status to booked
    const sqlU = 'UPDATE slots SET isbooked = 1, name = $2 WHERE id = $1';
    const updateResult = await conn.query(sqlU, [id, name]);

    // Commit the transaction before releasing the connection
    await conn.query('COMMIT');

    conn.release();
    res.send(updateResult);
  } catch (ex) {
    console.log(ex);
    res.sendStatus(500);
  }
});
```

### **Final Thoughts**

As you can see, by making a small but crucial modification—using transactions and **FOR UPDATE**—we successfully prevent **double booking**.

Of course, this approach also has its drawbacks, such as potential performance overhead when handling a high number of concurrent requests. To fully optimize your solution, it’s essential to read more documentation and experiment with different database locking mechanisms.

If you found this post helpful, make sure to explore further and share this knowledge with others! 🚀



Platforms like Booking.com, Airbnb, Calendly, and 42Mentors all serve a common purpose: they help users book appointments, accommodations, and other services.

Double Booking Problem


![Logo](https://i.pcmag.com/imagery/reviews/01eqrJlwTzs4ACRmWo01fCt-45.fit_scale.size_760x427.v1668723864.jpg)

In my previous article, I shared my interview experiences at IBM. During the interview process, a recruiter from **Dropbox** reached out to me, asking about my interest in an exciting opportunity they had. While I was negotiating with IBM, I was ready to accept a rejection by telling them, “If I don’t work out, someone else will.”

![Interviews](https://miro.medium.com/v2/1*SXYzHOGiHGInvwUORzUwhg.png)

## 1st Interview

The environment at Dropbox felt very similar to that of a FAANG interview. However, what set them apart was how they structured the interviews, allowing for a more relaxed schedule. I scheduled my **Technical Interviews** for day one, and the **System Design Interview** was set for another day (I asked for a four-day delay to prepare better). The final interview, as usual, was with the **Hiring Manager** and took place afterward.

The technical interview began, and I felt a little nervous. After the first problem didn’t work out, I thought to myself, "_Well, that’s the end of Dropbox._" They really test your **Data Structure and Algorithm** skills by immersing you in a real project, which is something I hadn't experienced before. It was a bit intimidating.

In the first interview, the main task revolved around **File Search**. We were dealing with large folders that contained millions of files. I was asked to write a program in **Python** to find a given file (since they use Python a lot). As they tested me further, they broke down the problem into multiple tasks to assess my deeper knowledge.

In **Task 1**, I suggested using `os.walk()`, which they liked, and I wrote the solution. For **Task 2**, they asked me to write the solution without `os.walk()`. After thinking for a moment, I expressed the solution using a **Trie** structure, which they appreciated. Finally, they asked me to implement **parallel scanning**, something Dropbox focuses on, unlike other companies in FAANG that don’t necessarily delve into **concurrency**, **parallelism**, or **asynchronous** topics. Be prepared for that. I provided a solution for this as well, but before I could write the code, time ran out. We chatted a bit more before parting ways.

## Other Interviews

The second interview was mainly focused on building an **Availability Calculator**. My prior research in this area proved useful, and I also sought advice from some acquaintances. The **System Design** interview was somewhat simpler than I expected. I was asked to design a **Web Crawler**. Thanks to reading books, blog posts, and various resources on the topic, it wasn’t too challenging. We spent more time discussing the details of one specific part of the system, designing it together.

The final interview with the Manager included **Behavioral Questions**. They asked about my previous job, why I left, and what kind of projects interested me. We discussed many things, and the interview ended with the Manager saying, "See you around." This gave me a bit of hope. We said our goodbyes with a "See you soon."

## Advice

During interviews with different companies, you’ll be tested on many aspects of your skills at once. Never limit yourself. Learn about **Concurrency**, **Algorithms**, and other topics—stay curious.

If possible, focus on **System Design** through hands-on practice. It’s not necessary to find a million users to test with, but testing itself is valuable experience. You’ll learn a lot by experimenting with it. Read books, practice, study mathematics—there’s no harm in learning useful skills.

## Outcome

![Final Decision](https://miro.medium.com/v2/1*iVLMHB6FJ9KbE0L-nAStQw.png)

So, after receiving an offer from **IBM**, I also received an offer from **Dropbox**. My manager told me, "You’re the first Uzbek developer at Dropbox." I still need to double-check that. In my next post, I’ll share how I received an offer from **Meta**. 



In my previous article, I wrote about the interviews at IBM. During my interview process, a recruiter from Dropbox reached out to me, inquiring about my interest in an exciting opportunity they had.

Got an offer from Dropbox 🎉


The internet primarily communicates using the HTTP(S) protocol. However, this protocol is **stateless** (meaning it does not store states). Now, imagine that the internet is stateless—how does it know whether we are authenticated or not?

Systems classify users in two categories: **authenticated users** and **unauthenticated users**. **Authenticated users** have logged in to the system, and because the system has information about these users, it recognizes them.

**Unauthenticated users**, on the other hand, are users who haven't logged in. The system doesn’t have any information about them, and some actions may be restricted for them (since they are considered "anonymous").

But, given that the HTTP(S) protocol is stateless, how does the system know whether the user has logged in or not?

### Session Authentication

When a user logs into the system using a **username/phone** and **password**, the system creates a unique **session ID** specifically for that user. This session ID is stored both on the server's database and in the user's browser. So, each time the user sends a request to the server, they send their session ID. If the server recognizes the session ID, it means the server knows the user is authenticated. If no such session ID exists, the system automatically **logs out** the user. If the user logs out, the server deletes the session ID associated with that user from its records.

**Drawbacks:**

- **Resource consumption**: If a user logs in from multiple devices at the same time, a separate session ID is created for each one. Now, imagine 1 billion users logging in from 3 devices each.
- **Temporary**: Session IDs are temporary. If the user hasn’t logged in for a while, the system deletes the session, and when the user returns, they will see that they’ve been logged out and need to log in again.
- And there are other reasons you can explore...

### Cookie Authentication

When a user logs into the system, the server sends a special cookie to the user's browser (this is not the "cookie" you might be thinking of). A cookie is a small file (up to 4 KB in size) that is stored in the browser.

- Every HTTP request is sent with the cookie, which increases the overall traffic size.
- It is not entirely secure; cookies are vulnerable to CSRF (Cross-Site Request Forgery) attacks.
- Cookies can store up to 4 KB of data. If you need more storage, this may not be the solution for you.

In the second part of this post, I will write about **Tokens**, **JWT**, and **Passwordless authentication**. Stay tuned by following my [channel](https://t.me/otabekswe)!



The internet primarily communicates using the HTTP(S) protocol. However, this protocol is stateless (meaning it does not store states).

How Authentication Works


![IBM Logo](https://kreafolk.com/cdn/shop/articles/ibm-logo-design-history-and-evolution-kreafolk_f6963bf2-5011-41cd-a198-3b9b4dcff48d.jpg?v=1717725060&width=2048)

Since coming to Europe, I started applying to various companies. In the process, I received over 200 rejection emails. Later, I began to lose hope in landing a job. After some time, however, larger companies (FAANG) started reaching out. This article focuses on my experience with IBM.

![Recruiter](https://miro.medium.com/v2/1*5685nCZojXEnlJFrN7q6EA.png)

IBM has many vacancies for **Entry-level** positions, and the **Cloud Platform Developer** role caught my interest. I was drawn to the opportunity to work with **Kubernetes**, **Terraform**, and **Cloud Computing**, so I applied to gain experience in this area. Although my background in Infrastructure was limited, they reached out, and we began the interview process.

## Panel Interview

![](https://miro.medium.com/v2/1*m5rWMT6yFlbBvKRi0zLAjw.png)

Such panel interviews are rare in FAANG companies, but IBM uses this format. A few team members enter the interview at the same time and assess your knowledge, thinking process, and how you make decisions under stress (since they will try to put you under pressure).

I was asked questions related to **IaC**, **K8S**, **Terraform**, **AWS/GCP**, and programming skills. I was given real-world scenarios and asked how I would solve the problems. I answered the questions to the best of my ability.

Two days later, I heard back from the recruiter. The email began with a **"Thank you..."**, which is typically a bad sign, but fortunately, this was not the case for me. They mentioned that the interview went very well and asked to schedule a final interview. I picked a date for the following week and began focusing on other tasks instead of preparing for the technical interview.

> I can't share the exact questions as I signed an NDA regarding this.

## Final Interview

![](https://miro.medium.com/v2/1*Gd1obtGI8YBuF6gxiJiEwg.png)

The final round was primarily a hands-on interview. Unlike the typical Leetcode-style interview, this one was based on a real-world scenario.

You are given a prepared API, and you need to interact with it, retrieve data based on given conditions, filter the data, and return the result. There were so many conditions for filtering that I forgot some of them, and when I ran the code, I encountered errors. I started to panic.

The interviewer, a Senior from **Bloomberg**, conducted the interview in a calm and friendly manner. He made jokes to lighten the mood. I passed 98% of the tests, but 2% failed (I had missed an edge case). Afterward, the interview ended, and he told me he wanted to speak with me for a bit. He reassured me with a “Don’t worry, we’ll take you in” and we said goodbye.

## The Result

![IBM](https://pnghq.com/wp-content/uploads/pnghq.com-download-logo-graphic-design-ibm-free-hq-image-hq-png-image.png)

At first, I thought the comment made in the final interview was just to comfort me. However, it turned out to be true. The team was based in the U.S., and they said it wouldn't be possible for me to work remotely from Poland.

My manager then asked me if I would be interested in applying for a **Middle position** in **Build System Engineering**, which had a great team. He mentioned it would only require one more interview, so I agreed.

I passed the final interview as well. The recruiter asked for my documents and assured me that they would send me an offer soon.

### Conclusion

I spent a lot of time thinking before writing this post. I know that receiving an offer from a company is exciting news. In the past, I thought writing a post like "**I got an offer from XYZ**" might sound boastful, and I didn’t want to come across as showing off.

However, after receiving many requests (even from my father), I decided to share my experience, the process, my preparation, and some other interesting topics. In my next post, I’ll talk about how I received an offer from **Dropbox**.


Since coming to Europe, I started applying to various companies. In the process, I received over 200 rejection emails. Later, my hopes of finding a job started to fade.

Got an offer from IBM 🎉


I try to avoid writing `If-else` or `match-case` statements as much as possible. I'll explain why in future posts. So, what should you write instead?

![](https://telegra.ph/file/444265b97572e2cd4c9ef.jpg)

Of course, it depends on the situation, but for many of the problems I encounter, I’ve solved them using a hashmap. Imagine you have a problem with specific or limited values. You need to solve it without writing `if-else` statements. For example, let’s say you need to check if a number is divisible by 2, and if it is, print "even", otherwise print "odd". What would you do?

Here’s how I would approach it:

```python
hashmap = {
    0: "even"
}

number = int(input("Enter a number: "))
print(hashmap.get(number % 2, "odd"))
```

Now, let's make the problem a bit more complex. You're building a system for currency conversion. The user enters an **amount**, **from** currency, and **to** currency, and you need to calculate the conversion without using `if-else` statements.

For example, here’s the data the user enters:

```bash
Amount: 24
From: USD
To: UZS
```

Now, you need to convert $24 into Uzbek Som (UZS). How would you do it?

Here’s my solution:

```python
# Store the conversion rate for 1$ for each currency
currencies = {
    "USD": 1,
    "UZS": 11300,
    "RUB": 90,
    "EUR": 0.85,
}

# Conversion methods
convert = {
    "TO_USD": lambda amount, rate: amount / rate,
    "FROM_USD": lambda amount, rate: amount * rate,
}

# User input part
amount = float(input("Amount: "))
from_currency = input("From: ").upper()
to_currency = input("To: ").upper()

# Convert the amount to USD first, then convert it to the desired currency
in_usd = convert["TO_USD"](amount, currencies[from_currency])

# Now convert the USD amount to the target currency
result = convert["FROM_USD"](in_usd, currencies[to_currency])

print(result)
```

![](https://media2.giphy.com/media/l4FB49aNstvAcSBQ4/giphy.gif?cid=6c09b9525m3ww55i9mnf6k5zfqgfoyg3mznoov3u6mpyocku&ep=v1_gifs_search&rid=giphy.gif&ct=g)

Think about lazy solutions like this. I’m glad if this was helpful!


`If-else` or `match-case` statements are something I try to avoid whenever possible. I'll explain why in upcoming posts. So, what should you write instead?

Lazy Solutions


Today, we will discover the world of Linux together. We'll cover why Linux's security, management, file system, commands, and overall environment are important to learn.

![Linux Meme](https://telegra.ph/file/3e722483adf40da6fd439.jpg)

> You don’t need to have Linux installed to follow the practical exercises in this post. Use [docker playground](https://labs.play-with-docker.com/) instead.

### Introduction

![](https://telegra.ph/file/60366987ac21ed14db237.gif)

There are two essential concepts you need to understand in the Linux world: **SHELL** and **KERNEL** (we’ll dive deeper into these at the end of this post). **KERNEL** is the core part of your operating system that manages everything. **SHELL**, on the other hand, is the interface that lets you communicate with the **KERNEL**. You've probably heard of it as **bash**, **zsh**, or even **fish**. In short, you type commands into the **SHELL**, it translates them to the **KERNEL**, and your computer performs the requested task. It's a simple concept.

Imagine you have a fresh Linux system with no software installed. Let’s start installing the necessary programs. We will need a package installer tool like `apt`, `apt-get`, `apk`, or `yum`. For example, let’s install **ipython**.

![](https://telegra.ph/file/171e0fe135da9345e9c04.gif)

Since we are using Linux Alpine, we’ll use **apk**, while Ubuntu uses **apt** or **apt-get**.

> Before using **apt install** in Ubuntu, remember to run **apt update** first, because the installer often comes with outdated URLs. Without updating, it might not be able to fetch the latest versions of software.

### File System

![Linux File System Meme](https://telegra.ph/file/feb7a9f1974ee30fe177f.png)

There are many types of **files**, such as txt, mp3, jpeg, png, etc. **Directory** is what you might call a **folder** in Russian (папка). Below is a list of the important **directories** in Linux (try to understand in English, as translations may sometimes alter meanings):

```bash
| Directory | Description                                          |
| --------- | ---------------------------------------------------- |
| /bin      | binary or executable programs.                       |
| /etc      | system configuration files.                          |
| /home     | home directory, where your personal files reside.    |
| /opt      | optional or third-party software.                    |
| /tmp      | temporary space, typically cleared on reboot.        |
| /usr      | user-related programs.                               |
| /var      | log files and variable data.                         |
```

For learning how to work with files, the best resource is the Linux section of the 42.uz Express Backend course:

<iframe width="1680" height="735" src="https://www.youtube.com/embed/PcoP1mykdEs" title="Shell Bor Joyda, Yo&#39;l Bor | Express Backend (1-bo&#39;lim)" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

### Access Control

Let’s imagine you’ve been hired as a **Cloud Administrator** (just kidding, don’t apply for this job yet). Now, you’re responsible for managing the security of the system. Developers in your office have asked you for access to certain resources. What will you do? **You**: I’ll give them root access. **Me**:

![](https://gifdb.com/images/high/matthew-perry-oh-no-eqz81f12tsymfmjl.gif)

No, don’t do that. Instead, create a new user for the person and grant only the permissions they need. To create a user, you can use the **adduser** command:

```bash
adduser <username>
```

When you create a new user, they can only read, write, and execute their own files. They won’t have access to modify other files. If you trust the user, you can give them **superuser** privileges (or **sudo**, short for superuser do). In Linux, users are organized into groups, and users can perform tasks based on the permissions granted to their group. To grant **sudo** access, you need to add the user to the **sudoers** group:

```bash
# usermod command to add user to sudo group
usermod -a -G sudo <username>
```

Now, the user can run commands with elevated privileges using **sudo**. Learn more about groups for better management. And just a heads-up, don't think just because you can use **sudo**, you should... 😅

![](https://telegra.ph/file/5ae6ce323bd96614a9726.jpg)

### Process Control

> In Linux, every program runs as a **process**, and each process is identified by a unique **PID** (Process ID).

Let’s say you granted access to a **jprq** (a random program), and now it’s using too many resources (RAM, CPU, or Storage) or acting strangely. You don’t know exactly what it's doing. To identify and monitor resource usage, use the `top` or `htop` commands.

Once you've identified the process and its **PID**, how do you stop it? Use the **kill** command. The **kill** command sends various **signals** to processes, but it doesn't actually kill the program; it simply informs it of the action. The program will respond to the signal based on its type.

![](https://telegra.ph/file/f8000f8bee541335efbd8.png)

```bash
kill <signal> <PID>
```

For example, the **-9** signal will forcefully terminate the process, while the **-20** signal suspends it. To resume a suspended process, you can use the `fg <PID>` command. There are many other commands to explore.

### Conclusion

In upcoming parts, we will dive deeper into the tricks used by young hackers and explore the darker sides of Linux with hands-on examples. Sharing is caring—feel free to share this post with your friends!



Today, we will explore the world of Linux. Why we study Linux's security, management, file system, commands, and the general Linux environment.

Linux World (part I)


In the [previous post](/blogs/linux-world-part-i), we explored some amazing aspects of Linux. In this post, we’ll dive into **system control** and test out some effective strategies for defending against attacks.

![Meme](https://telegra.ph/file/9051d841d3ae768cd4eff.png)

### System Control

Imagine you’ve made some changes to your system, but to apply those changes, you need to restart it. So, how do you do that? (There’s no power button in a virtual machine! 🙃)

![Tom looking for](https://media1.tenor.com/m/BK_Yx_9yvwYAAAAd/tom-and-jerry-looking-for.gif)

You’ll need the `systemctl` command, which is used to control various system services in Linux. Services are background programs that keep your system running. You can restart, stop, start, disable, or enable these services using **systemctl**.

```bash
# Restart the SSH service
systemctl restart sshd

# Check the status of the service
systemctl status sshd

# Disable the service (prevent it from starting automatically)
systemctl disable sshd
```

If you want to ensure that your program runs continuously in the background, you’ll want to learn about [**systemd**](https://www.suse.com/support/kb/doc/?id=000019672). It’s a simple framework that guarantees your program will keep running in the background thanks to the systemd (system daemon) file.

### Fork Bombing

![Fork bomb cat](https://telegra.ph/file/48abcfa8d77acd6000eef.png)

Back in 2020, I was a first-year student at **Shanghai JiaoTong University**, meeting incredibly smart and talented classmates from all over the world. After some time, I sent one of my friends the image above with a different message. The message was:

> If you run this command, you’ll see a cat image: :(){ :|:& };:

A young, curious student (me at the time) who was just beginning to understand OS concepts tried this on his own computer. Five minutes later, he messaged me saying that his computer shut down by itself 🥲 (well, he was new, and I wasn’t exactly experienced either!).

This command is called a **Fork Bomb**. It recursively creates new processes in the system (in Linux, processes are "forked" from the **main process**, which is why it's called a "fork bomb"). The goal of the command is to rapidly generate processes, leading to resource exhaustion. Too many processes can cause a slowdown, and in some cases, it can even crash your computer. So, how can you prevent this?

![Limits](https://telegra.ph/file/c6dc8df6cfec0fa9c19ee.jpg)

The answer is simple: set limits for your system. You can use the `ulimit` command to limit the number of processes and prevent **fork bombing**. Interesting, right?

```bash
# Check how many processes we can open
ulimit -u

# Get more information
ulimit -a

# Limit the number of processes to 20
ulimit -S -u 20
```

### Disk Space Filler

At [cloud.42.uz](https://cloud.42.uz), we work on various optimization tasks. However, there was this one “jprq” who constantly tried to crash the server using various clever methods. In a way, I’m thankful to him because he taught me a lot (I mean, he forced me to improve security and add more capabilities). His latest attack was the **Disk Space Filler**.

To prevent this kind of attack, we need to install the **quota tool**, which allows us to limit the number of file descriptors and clean up unnecessary files from the disk. I recommend you explore this on your own for better understanding.

### Conclusion

In conclusion, don’t believe everything you read or hear. Never run unfamiliar commands on your computer. Stay cautious, stay alert. Share what you've learned from this post with others!


In the previous post, we explored some amazing aspects of Linux. In this post, we’ll apply **system control** and explore some great strategies to protect against attacks.

Linux World (part II)


Some lazy and short-sighted developers claim that you don't need math to be a programmer. Based on my personal experience, I can say that math has improved my life as a developer far more than I expected. Let me prove it with some examples.

![Math is everywhere meme](https://telegra.ph/file/e0433ffc8fdb88f5b3d27.png)

### Math is in Algorithms

Imagine you’re in an interview, and you’re asked to calculate the sum of numbers from **1** to **100**. Would you just add up all the numbers manually? What if it were **1** to **1 million**, or even **1** to **N**, or **n** to **m**? This is where math comes in to help. The answer: **Arithmetic progression**.

$$
S_n = \frac{(a_1 + a_n)n}{2}
$$

With this formula, you can easily calculate the sum of numbers between **x** and **y** by just plugging in the starting number ($$a_1$$), the ending number ($$a_n$$), and the total count ($$n$$). Congratulations, you now have the skills to solve this [LeetCode problem](https://leetcode.com/problems/product-of-array-except-self) in **Time: O(1)**.

In school, you were taught the equation $$(a + b)^2 = a^2 + 2ab + b^2$$. They probably also taught you how to expand $$(a+b)^3$$, but what if an interview asks you to expand $$(a+b)^{10}$$? Well, that's easy too: **Pascal’s triangle or Binomial expansion**.

<iframe width="560" height="315" src="https://www.youtube.com/embed/v9Evg2tBdRk?si=XB9nAQkDF_Prz2_s" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

Congratulations! Now you can solve this [LeetCode problem](https://leetcode.com/problems/pascals-triangle 'LeetCode Problem'). In short, learning math can teach you how to ace FAANG interviews.

### Math is in the Tech World

Imagine two people recording a podcast. They both talk about something very important, but since they’re speaking at the same time, the audio becomes unintelligible. Or maybe you're conducting an interview and someone's baby starts crying, making it impossible to hear your interviewee. Again, math comes to the rescue, and the answer is: **Fourier transform**.

<iframe width="560" height="315" src="https://www.youtube.com/embed/spUNpyF58BY?si=MG8b1paE0jI1pONu" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

Human voices oscillate within a sinusoidal range, and with this formula, you can easily separate sound frequencies. This mathematical technique is even used to remove noise from audio. You can learn more about this by watching the video above.

### Conclusion

In conclusion, everything you use and develop in technology has math underlying it. Let's learn math. Prove and explain its usefulness to your friends as well!


Some lazy and short-sighted developers claim that you don't need math to be a programmer. Based on my personal experience, I can say that math can improve a developer's life in ways they never expected.

Math is Everywhere


![Facebook](https://about.fb.com/wp-content/uploads/2019/11/facebook_wordmark.gif)

In 2021, while I was at home, I received a message from one of the Telegram channels. Yes, you guessed it, [Azimjon aka](https://t.me/fikrlog/1054) had written about doing a "[Summer Internship](https://azimjon.com/blog/facebookdan-offer-oldim/)" at Facebook and the opportunities there. I was really impressed and showed it to my family. The next day, my mother brought me a **keychain** from the market. I always carry it in my bag. I still remember her saying, "_Every time you look at it, let it remind you of your dreams_." Today, that dream came true, and I was able to break through the Facebook interviews. Here’s a glimpse:

![Keychain](https://kidscare.pk/cdn/shop/products/MG_7809_7ebf9fd9-29ec-4c0c-b837-fac63d5e9791.jpg?v=1639483191&width=1152)

Meeting and connecting with many people opens doors to countless opportunities. My story began with one of my oldest friends, [Ahmad](https://www.linkedin.com/in/ahmadelkhawaga/), who works as a Senior Software Engineer at Meta. I met Ahmad at the Meta office, and from the moment we met, we talked for hours and instantly connected. Over time, he invited me to his team, and the interview process began.

## Technical Interviews

I applied for the **Software Engineering E3 (Junior)** position. The next day, I received a link to schedule my interview. Since there were three interviews in total, I scheduled two technical interviews on the same day and the **system design** interview for the following day. Yes, even as a junior at Meta, they still conduct a system design interview. With nothing to lose—since I had offers from **IBM** and **Dropbox**—I went into the interview without much preparation.

The first interview was with a Senior Software Engineer who had been working at the London office for 4 years. We started with a brief introduction and got to know each other. After about 7-8 minutes, we jumped into the questions and the challenge began. The first question was similar to [this LeetCode problem](https://leetcode.com/problems/verifying-an-alien-dictionary/). Initially, I didn’t fully understand the question, but after reading it a second time, it became clear. I asked some questions to clarify the problem further, proposed a solution, and they liked it, so I wrote it down.

The second question was about **Trees**, where I provided an optimal solution using post-order traversal. We considered edge cases and stuck with that solution, but I ran out of time before I could finish writing the code. The interviewer invited me to ask any questions I had, and we wrapped up the session by discussing some of my own questions. The second interview was a bit harder, with questions mostly about Matrix and Graphs. I managed to solve the Matrix problem, but I struggled to understand the Graph-related question. I ran out of time before proposing a solution.

## System Design Interview

Next came the **System Design** phase. The person conducting the interview had previously worked at Google, and the conversation was very friendly. This time, we had to design **Image storage**. Here are the conditions:

- 100 images are uploaded per second
- We need to prevent duplicates
- What to do if memory is limited?

Designing such a service in 45 minutes was tough, but we managed to work through it together. We focused especially on finding great solutions for avoiding duplicate images and dealing with limited memory environments. The interview went well, and we exchanged emails and LinkedIn connections before saying goodbye.

## Preparation

Many people have already given great advice on preparation. However, I’d like to add some resources that I found extremely helpful:

To get started with basic Algorithms, **Grokking Algorithms** is a great book. If you prefer videos, the [Express Algorithms](https://42.uz/course/express-algoritm) course on 42.uz is highly useful. For strengthening your math and deep algorithmic knowledge, I recommend **Introduction to Algorithms** and **The Algorithm Design Manual**—I haven't found anything better.

System Design is not something you can memorize. There are many resources available, and the best way to learn is to read from various places and practice. Try to implement solutions yourself. For working well with databases, **Design Data-Intensive Applications** and **Database Internals** were really helpful to me. For a comprehensive guide, [roadmap.sh](https://roadmap.sh) is an excellent resource.

## Result

After the System Design interview, 4 days later, the recruiter informed me that all the interviews had gone well, and they scheduled a 1:1 meeting with the manager. We set a time for the next day, and during the conversation, we discussed various topics. The manager congratulated me on performing well in the interviews, and we talked about the team, work environment, opportunities, salary, projects, and more. During the conversation, immigration came up, and I asked, "Could you transfer me to the Warsaw office? I haven't completed my Bachelor’s degree yet." I remember the manager’s face turning serious, and he paused for a moment. After thinking, he said that it was a tough situation, but they would discuss it further. After the conversation with the manager, I received this message:

![Last update](https://miro.medium.com/v2/1*R61CWNdKwwKFaG6qYbBuWQ.jpeg)

Of course, this is for the best. The most important thing is that I passed the interviews. The only reason they didn’t send the offer was because I don’t have a Bachelor's degree. If you want to immigrate, you definitely need a university degree. Azimjon aka wrote an excellent article about this. [Read it here!](https://azimjon.com/blog/universitetda-oqishga-7-sabab/)

The title of the article was originally "**I Almost Received an Offer from Meta**," but I shortened it. Apologies for that. I hope that even though I couldn’t cover everything in detail, I’ve still shared valuable information. Don’t stop learning!


In 2021, while I was at home, I received a message from one of the Telegram channels. A guy with name of Azimjon wrote post about 'Summer Internship' at Facebook and the opportunities there.

Got an offer from Meta 🎉


Entering the world of programming is an exciting yet overwhelming journey. Even those who have been in this field for a while occasionally ask themselves, "**What’s next?**" In the last two years, I’ve heard this more than a few times:

> "...I’ve learned various programming languages and technologies, but I don’t know what project to work on next. Or should I switch to a different language or framework?"

If you've ever found yourself in this situation, let's explore what steps we can take to move forward.

> These ideas are the author's personal thoughts, and there may be some suggestions that don’t resonate with you. 

### 1. Being Lazy (Strategically)

![Lazy image](https://telegra.ph/file/7e3c6afa3ce4fc663bde4.jpg 'Lazy image')

Yes, you read that right—but you might have misunderstood (in my humble opinion). There are countless problems around us. Sometimes they’re hard to solve or take too much time. The first rule of "strategic laziness" is:

> Achieve big results with minimal effort.

Take the time to deeply understand the problems that you and those around you are facing. If those problems can be systematized (many of them can be automated), tackle them before someone else does.

### 2. Networking

![Networking image](https://telegra.ph/file/3abb9ac2950e006df80d7.jpg)

Whenever I attend a **Job Fair**, I try to make as many connections as possible ("_Job hunting was just an excuse, I was looking for you among all those people_"). I talk to them and learn about the company’s work. This way, you can understand more problems and potential solutions, and by practicing, you gain experience.

> It’s not about knowing a lot; it’s about doing more.

### 3. Think Outside the Box

![Think outside the box](https://telegra.ph/file/b4ba135df35abfcca559c.jpg)

80% of the projects I’ve created started because I didn’t know something, but I was curious enough to learn. Not knowing something isn’t a mistake—failing to learn is. Sure, you can build an API or design a frontend, but ask yourself:

- Can you build a network proxy?
- Can you create a framework?
- ...

Don’t just keep doing what you already know. Trying things you don’t know will teach you far more and provide new skills. I've learned a lot from platforms like Webfy, Gylo (coming soon), cVPN (coming soon), and [42](http://42.uz '42'). If you’re unsure where to start, try using [**Build Your Own X**](https://build-your-own-x.vercel.app/ 'Build your own X') to learn step-by-step how to create projects. In short, try what you haven’t done yet...

### 4. Problem Solving

![Problem-solution](https://telegra.ph/file/570fce014c3b72f47ee6c.jpg)

Since I started solving problems on Leetcode, I've become more aware of how many problems exist. I’ve learned how to solve them in simpler ways, with less time and fewer resources. As Jahongir once said:

> "One Leetcode a day, keeps unemployment away."

### 5. Try

Trying doesn’t always lead to success. Just yesterday, I accidentally brought down the 42.uz server (with Azimjon, of course). Due to overlooking a small detail, users were temporarily disconnected from the system (some were working at 12-1 AM without sleeping). Only we truly know how it made us feel.

### Conclusion

To sum up, follow what you already know. You’ve likely heard most of the advice in this post before, but the real issue isn't that you don't know—it’s that you’re not acting on what you know (in my humble opinion).



Sometimes even those who have been in the programming world for a while ask themselves, 'What's next?'

Next Steps


If you write code in Python and enjoy working with this language, then this post is for you. Let’s have an interview and assess how well you understand Python.

![Interview meme](https://i0.wp.com/collegecore.com/wp-content/uploads/2018/02/job-interview-meme-17.jpg?ssl=1)

### Question 1

**Question**:  
Explain why the following code behaves the way it does:

```python
>>> a = 256
>>> b = 256
>>> a is b
True
>>> x = 257
>>> y = 257
>>> x is y
False
```

**Answer**:  
Python caches numbers in the range of **-5 to 256** [source](https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong).  
You can learn more about memory management in Python by reading the [Python Memory Management](/blogs/python-memory-management) post.

### Question 2

**Question**:  
How does `import` work in Python? Why does the following code return the results it does?

```python
>>> import math
>>> math.pi
3.141592653589793
>>> math.pi = 3
>>> math.pi
3
>>> import math
>>> math.pi
3
```

**Answer**:  
Python **frozen modules** ensure that the Python interpreter loads a module into the [sys.modules](https://docs.python.org/3/library/sys.html#sys.modules) dictionary only once and reuses it afterward. To see this in action, open a Python3 interactive shell (open a terminal, type `python3`, and hit enter), and try importing the `__hello__` module:

```python
>>> import __hello__
Hello world!
>>> import __hello__
>>>
```

### Question 3

**Question**:  
What is `__pycache__`, and what are `.pyc` files?

**Answer**:  
Whenever you run a Python program, the interpreter compiles your code to **bytecode** (for efficiency) and stores it in a folder named **`__pycache__`** [[source]](https://docs.python.org/3/glossary.html#term-interpreted).

If you look inside this folder, you’ll see `.pyc` or `.pyo` files. Rather than reading and executing the code line by line, the Python interpreter executes the cached `.pyc` bytecode in the [virtual machine](https://docs.python.org/3/glossary.html#term-virtual-machine). This process is similar to Java.

### Question 4

**Question**:  
What impact does exception handling have on the performance of a program? If it slows down the program, how would you minimize this slowdown?

**Answer**:  
Python uses a **stack** for exception handling. When an exception occurs, the interpreter looks for the exception handler in the **call stack** (your `try-except` code). If no handler is found, Python terminates the program and prints a **traceback** in the terminal.

Python encourages the use of [EAFP](https://docs.python.org/3.6/glossary.html#term-eafp) ("it's easier to ask for forgiveness than permission") over [LBYL](https://docs.python.org/3.6/glossary.html#term-lbyl) ("look before you leap") style coding. To write efficient and simple code, consider a scenario where users provide a list of numbers [1, 2, 3, 4], and the program calculates the sum. If you are confident that users will input numeric lists 90% of the time, you can use **try-except**. If not, it’s better to use an **if-else** statement to handle the control flow (based on personal experience and advice from Core Python Developers).

### Question 5

**Question**:  
Why does the following code return `False`? Both objects have the same value. How would you correct it?

```python
class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

x = Node(1)
y = Node(1)

x == y # False
```

**Answer**:  
There are two solutions for this.

**Solution 1**: Using [dunder methods](https://mathspp.com/blog/pydonts/dunder-methods). You can learn more by following the link.

```python
class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

    # The equal dunder method is used for the == operator.
    # If self is Node(1) and other is also Node(1), it compares their val attributes.
    def __eq__(self, other):
        return self.val == other.val

x = Node(1)
y = Node(1)

x == y # True
```

**Solution 2**: The [dataclasses](https://docs.python.org/3/library/dataclasses.html) module is useful here. If you don’t want to write all the dunder methods yourself, you can use the dataclass decorator, and it will automatically generate the necessary methods for you.

```python
from dataclasses import dataclass

@dataclass
class Node:
    val: any
    next: None = None  # Default is None, but it can be changed.

x = Node(1)
y = Node(1)

x == y # True
```

### Question 6

**Question**:  
What is the difference between a **metaclass** and a **class**? Can you demonstrate creating a metaclass?

**Answer**:  
**Classes** create objects, and classes themselves are objects. **Metaclasses** create classes.

```python
MyClass = MetaClass()  # Class created
my_object = MyClass()  # Object created from the class

# type() helps you create a metaclass:
MyClass = type('MyClass', (), {})

# type(name, base, dict)
# name => class name
# base => tuple of base classes
# dict => dictionary for attributes
MyMetaClass = type("MySimpleClass", (), {"val": 12})
obj = MyMetaClass()
print(obj.val)  # 12
```

### Question 7

**Question**:  
We have three different types of lists:

- [list](https://docs.python.org/3/library/functions.html#func-list)
- [collections.UserList](https://docs.python.org/3/library/collections.html#collections.UserList)
- [np.array](https://www.w3schools.com/python/numpy/numpy_creating_arrays.asp) [[numpy docs](https://numpy.org/doc/stable/reference/generated/numpy.array.html)].

If we create a list with `range(1, 10_000_000)` and check the sum using `sum()`, we find that the regular `list()` computes the sum much faster than the others. Why is it so much faster, and how is it computed so efficiently?

```python
import time
import numpy as np
from collections import UserList

regular_list = list(range(1, 10000000))  # Very fast
np_list = np.array(range(1, 10000000))  # Slow
user_list = UserList(range(1, 10000000))  # Slowest

start = time.perf_counter()
print("Sum of regular list:", sum(regular_list), f"Time taken: {time.perf_counter() - start:.6f} seconds")

start = time.perf_counter()
print("Sum of NumPy array:", sum(np_list), f"Time taken: {time.perf_counter() - start:.6f} seconds")

start = time.perf_counter()  # np.sum() is another matter
print("np.sum of NumPy array:", np.sum(np_list), f"Time taken: {time.perf_counter() - start:.6f} seconds")

start = time.perf_counter()
print("Sum of UserList:", sum(user_list), f"Time taken: {time.perf_counter() - start:.6f} seconds")
```

**Answer**:  
This question is for you to figure out. Send your answer to me via email at ask@otabekswe.uz.

To make the most of this post, study it and teach your friends (share it)!

---

This translation keeps your ideas clear and concise while adjusting phrasing for better readability in English. Let me know if any further changes are needed!

If you write code in Python and love the language, this post is for you. Let’s do a little interview and assess how well you know this language.

Python Interview Questions


If you want to write better code in Python, it's important to understand this topic well.

> This post might have some inaccuracies. Please feel free to research and explore on your own!

## Garbage Collection

![](https://telegra.ph/file/2e8f52e17018ab17745eb.jpg)

In English, "Garbage Collection" is the process of collecting unreferenced objects that are no longer in use. But when can something be considered garbage? It's simple—when you can no longer use an object or value, you consider it garbage. This process exists in programming languages as well. When a value or object is no longer usable, the **Garbage Collector** (GC) takes it and removes it from memory (deallocates it).

But why do we need a **Garbage Collector**? Without it, memory would fill up quickly. If you don't want your computer's memory to look like the image above, then the Garbage Collector is essential 🙃.

## Reference Count

![](https://telegra.ph/file/1863988454ce5bc97866e.png)

As humans, it's easy to understand garbage. You buy a bottle of water, drink it, and know that the bottle is no longer useful to you—it's now garbage. In programming, after a value or object is created, its **reference count** is calculated, which means how many variables are pointing to it. For example:

```python
# An object 1 is created in memory, but the computer doesn't know how to get it, so it deletes it immediately
>>> 1
# Variable x points to 1 in memory
>>> x = 1
# x holds the memory address and when you print x, it will show 1
>>> print(x)
# When you delete the variable, the reference to 1 is gone, and 1 becomes garbage.
del x
```

You might think **variables** store values, but they actually just provide references to those values. When you run `print(x)`, `x` doesn’t give the value directly; it just tells where to find that value in memory, and the program fetches it for you. So from now on, think of variables as **references**.

The `sys` library is used for system-related tasks in Python. The function `sys.getrefcount()` can show how many references an object has. However, this function always returns one extra reference count because it also points to the object to get the reference count. So, subtract 1 from the result to get the actual count.

```python
import sys

x = [4, 3, 2, 1]
sys.getrefcount(x) # 2

y = x
sys.getrefcount(y) # 3

z = y
sys.getrefcount(z) # 4

# If you modify z, both x and y will change because they all point to the same object.
z.append(0)
print(x, y, z, sep="\n")
# [4, 3, 2, 1, 0]
# [4, 3, 2, 1, 0]
# [4, 3, 2, 1, 0]

# If you set z to a new value or delete it:
z = 1
# or
del z
sys.getrefcount(y) # 3
```

Did you know that Python compares two objects in constant time, O(1)? Yes, you heard that right. Python doesn't compare the values of objects; it compares their memory addresses. That's it!

## Finalizer

![](https://telegra.ph/file/7a830856c0fa2c1170a64.png)

A **Finalizer** is a mechanism that allows you to define cleanup actions to be performed when an object is destroyed (by the Garbage Collector). This can be done using the `__del__` method or the `weakref.finalize` function. In simple terms, the `del object` statement triggers this process. However, Python doesn't guarantee that the object will be deleted when you use `del`. [[python doc](https://docs.python.org/3/reference/datamodel.html#object.__del__ 'source')]

```python
class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

x = Node(1)
y = Node(2)

x.next = y
y.next = x
```

Objects can reference each other, as shown in the code above, especially in data structures like **Linked Lists**, **Graphs**, or similar. This situation is known as **cyclic reference**. The Garbage Collector might struggle to detect and delete these cyclic references, which can lead to a [memory leak](https://en.wikipedia.org/wiki/Memory_leak). To handle this, you can use either the `__dict__` method or the `weakref.finalize()` function. The `obj.__dict__` method provides all the attributes of an object, allowing you to delete them automatically. CPython typically follows the `__dict__` approach.

One of the worst cases of cyclic references happens when a list appends itself, creating an infinite loop. Initially, it might appear to have only 8 items, but as you dig deeper, the number keeps growing.

```python
arr = []
arr.append(arr)
```

## Conclusion

![Stack](https://telegra.ph/file/8b92a3cceb9f4a6777122.jpg)

As seen in the error message above, you might be curious about why such an error occurs. Python uses a **Stack** data structure for code execution. The golden rule of the Stack is LIFO (Last In, First Out). When the code is executed, it pops the last item from the stack, and if any error occurs, it shows the sequence to help debug. Quite interesting, right? 😉

Additionally, research **weak references**, **Garbage collector graph traversal algorithms**, and **Stack** in Python, as they play crucial roles in memory management. I hope this post has been helpful in your understanding of Python's memory management.

If you find any errors in this post, feel free to contact me: ask@otabekswe.uz

---

Let me know if you'd like any changes or adjustments!

To write better code in Python, you need to have a good understanding of this topic.

Python: Memory Management


![Cover image](https://telegra.ph/file/05181ffb6134e0c2e3014.jpg)

I've read many posts discussing why **SELECT *** is bad and should be avoided, but most of them don’t clearly explain why. Today, let's discuss why using **SELECT *** is not recommended, especially when working with large datasets that include millions of rows or columns.

### 1. Unnecessary I/O

You don't always need to select all columns. If you fetch all columns but only use a few of them, it wastes resources because you're reading unnecessary data from every page (we'll discuss pages in future posts). Also, **SELECT *** can interfere with **index-only scans**, which are more efficient.

### 2. Increased Network Traffic

If you are fetching unnecessary columns, it means you are consuming more network bandwidth. The more data you transfer, the greater the network load, which can slow down your application, especially when dealing with large datasets.

### 3. Increased Application Memory Usage

As your dataset grows, your application will require more memory to store the unnecessary data being fetched. This can put extra pressure on your application's memory, leading to performance issues.

### 4. Client-Side Deserialization

Before data is sent to the client, it is serialized according to protocol rules. The more data you send, the more **serialization** operations are needed, which consumes CPU resources. After sending, when the client receives the serialized data, it needs to **deserialize** it. This step also consumes CPU resources, adding even more overhead.

### Conclusion

This post doesn’t claim that **SELECT *** is inherently bad, but rather, that not knowing when and where to use it is the real issue. It's fine to experiment with it while learning, but in production environments, using **SELECT *** indiscriminately can be costly in terms of performance.

Telegram: [otabekswe](https://t.me/otabekswe 'otabekswe') 



I’ve read many posts about why SELECT * is bad and should be avoided, but most of them don’t explain exactly why.

SELECT * is Bad...


If you've ever written Object-Oriented (OO) code, you've probably heard of S.O.L.I.D principles. You may not have fully grasped the concepts, but let's dive into them today (I'll discuss their shortcomings in the next episode).

### Single Responsibility

> Each class should have only one responsibility!

Let's say you created a class named `Open`. It doesn't really matter what it opens; if you ask it to open a **DB connection**, it will do so. If you ask it to open a file in 'w' mode, it will do that too. There's no real difference. But this is not a good solution because the more responsibilities a class has, the higher the chance it will contain bugs. Instead, it is recommended to create separate classes like `OpenDBConnection`, `OpenFile`, and `OpenFolder`.

### Open/Closed Principle

> Classes should be open for extension but closed for modification.

Take the `OpenFolder` class as an example. You could add functionality to it for opening files, but without changing or removing any existing functionality. For example, you can create a separate method like `open_file(filename: str, mode: str)` and use the `OpenFile` class for simplicity. This way, you're not adding extra logic but instead using single-purpose classes as mentioned earlier.

### Liskov Substitution Principle

> If class B is a subclass of class A, then an object of class B should be able to replace an object of class A without affecting the functionality.

Don’t rush to judge. To simplify, this means the child class should be able to do everything the parent class can do. For instance, if the son asks, "Hey, Dad, I can't make the coffee, can you make it for me?" the father shouldn’t respond with "Drink some water, I can't make coffee." The son should still be able to make the coffee. This is what we mean by the child class being able to perform the same tasks as the parent class. I think there’s no need for an overly complicated example, this should suffice. :)

### Interface Segregation Principle

> Clients should not be forced to depend on methods they do not use.

For example, the `OpenFile` class doesn’t need to connect to a database. Forcing it to do so would be unnecessary and counterproductive. Each class should only handle the tasks relevant to its specific responsibility. To make it clearer, even static methods should follow this principle and not become a hassle. 😉

### Dependency Inversion Principle

> High-level modules or classes should not depend on low-level modules or classes. Instead, both should depend on abstractions.

- **High-level class**: the performer of the task.
- **Low-level class**: the tool performing the task.
- **Abstraction**: the connector between the two.

For example, consider a TV remote. The remote should not depend on the TV's internal mechanisms. If the TV's internal mechanism breaks, you wouldn't call a technician for the remote; you’d call for the TV. Instead, the remote should be an abstraction that can be fixed separately. If the remote’s battery is dead, you wouldn’t open the TV to fix it—you’d replace the remote battery. If the remote breaks, you don’t need to fix the TV, you just fix the remote. In this case, abstraction serves as the connection between the two.

---

The above concepts have been briefly explained to make them easy to understand. The goal was to provide a general idea of these principles. In future posts, we will dive deeper into each one, discussing their pros and cons in detail.


If you’ve ever written OO code, you’ve probably heard of this paradigm.

S.O.L.I.D Principles


![SQL execution order](https://telegra.ph/file/30b6f141ebd357228fa99.jpg)

SQL queries perform a three-step operation to filter data:

1. **Row filtering** – This step triggers the `FROM`, `WHERE`, `GROUP BY`, and `HAVING` clauses.
2. **Column filtering** – Columns are usually filtered with the `SELECT` statement.
3. **Row filtering** – The `DISTINCT`, `ORDER BY`, and `LIMIT` clauses are executed.

Yes, you read that correctly: row filtering happens twice. This occurs if your SQL query demands it or if clauses like `DISTINCT`, `ORDER BY`, `LIMIT`, and others are present in the query. Let’s write a query and analyze how this works:

```sql
SELECT id, full_name, university, gpa
FROM student
WHERE gpa > 3.00
ORDER BY full_name;
```

### FROM, WHERE Execution

![WHERE, FROM](https://telegra.ph/file/74c75a6e0ba0b9384f54b.gif)

First, the `FROM` and `WHERE` clauses are executed. But why? Imagine you’re asked to bring a **sanomara** (a specific product). What’s the first thing you’d ask? At the very least, you’d ask **"From which store?"** This is similar to how SQL works. It first runs the `FROM` and `WHERE` clauses to filter the rows. It selects users whose GPA is greater than 3.00 from the student table. This selection is made through some kind of loop mechanism where each row is filtered. If the GPA is greater than 3.00, the row is selected; if not, it moves on to the next one.

### GROUP BY, HAVING Execution

![Grouping](https://telegra.ph/file/721e06d80ef6953ae24bf.gif)

After selecting students with a GPA greater than 3.00, the loop finishes. If you’ve requested data to be grouped, the `GROUP BY` clause will be triggered. If you need to apply additional conditions to the grouped data, you’ll use `HAVING` (not `WHERE`). This is because `WHERE` operates before grouping. After the data is grouped, you’ll need to use the `HAVING` clause to filter, delete, or perform other operations on the grouped data.

### SELECT Execution

![Select](https://telegra.ph/file/0ed4ed6d8d394297eefbd.gif)

The main task of `SELECT` is to return the columns you need. In other words, whatever columns you specify in the `SELECT` statement are what will be shown. If you’re wondering why it’s bad to use `SELECT * FROM ...`, you can read more about it in [this article](select-is-bad).

### ORDER BY, LIMIT Execution

Now that we’ve identified the columns, tables, and rows we want, it’s time to sort them. If you use `ORDER BY`, the query will sort the selected elements by the specified column. If you’ve also applied a `LIMIT`, after sorting, it will return only the number of rows you’ve specified.

As you can see, the speed of an SQL query depends on its various stages, and knowing when to use specific **clauses** is crucial to optimizing performance. Understanding these operations and practicing with them will help you become more efficient. Keep learning and continue following us!

**Telegram**: [@otabekswe](https://t.me/otabekswe)



SQL queries perform a 3-step operation to filter data...

SQL Execution Order


A protocol is a set of standard rules that ensure communication between two or more devices. Therefore, TCP is a protocol, and we can say that it is a standard that facilitates communication between devices.

You may have heard about the 3-way handshake (handshaking) required to establish a TCP connection. It might look something like this:

![](https://telegra.ph/file/c6ff988922c78faec880d.png)

Let’s break it down in simple terms. As usual, the conversation begins with the Client, and the Server responds. First, the Client sends a SYN flag. You may not immediately understand what’s happening, so let’s see it through code and then analyze it:

```python
import socket


def main():
    sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sck.bind(('localhost', 1712))
    sck.listen(1)

    print("I am listening on port 1712")

    (client_socket, address) = sck.accept()

    while True:
        msg = client_socket.recv(1024)
        if not msg:
            break
        print(f"FROM: {address} \nMESSAGE: {msg}")
        print()
    client_socket.close()


if __name__ == "__main__":
    main()
```

We’ve written the server side. Now, let’s look at the client side. The server is the listener, and the client is the speaker. Remember the rule: The ear doesn’t hear until the mouth speaks. :)

```python
import socket


def main():
    sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sck.connect(('localhost', 1712))
    print("Sending data...")
    sck.sendall(b"Hello server!")
    sck.close()


if __name__ == "__main__":
    main()
```

The code I’ve written is a bit sparse on comments, but writing comments was just an excuse. By adding comments, I’m explaining this code to you now.  
![](https://telegra.ph/file/f64137c0f85af3e9dea38.png)  
_The code I wrote_

Now, when we run the server first, followed by the client through the terminal, the server will keep listening. If the client tries to speak but the server doesn’t listen, the client might be frustrated.

![](https://telegra.ph/file/4920cbd174828137510ef.png)  
_The message I received_

To fully track these events, we’ll need Wireshark (you might have heard this term more in network hacking—wow!). It should be available for both Windows and Mac. In the next post, we’ll continue with this topic...


A protocol is a set of standard rules that facilitate communication between two or more devices. TCP, being a protocol, ensures communication between devices as a standard.

TCP Handshake (part-1)


Next, let’s analyze the handshake. To do this, we will need Wireshark (to listen to TCP packets and communication, of course). Now, let’s start the server and observe what happens using the Wireshark interface.

When you click the button on the left side of the red rectangle, it starts listening to the packets. After entering the program, it will ask you where you want to listen to the incoming and outgoing communication. You can select the one with the label **Loopback**:

![](https://telegra.ph/file/ffcea76d3c31993004e2b.gif)

Nothing happened yet. Now, let's start the client side:

![](https://telegra.ph/file/88e1856d9d4c29be6426e.gif)

Wow, progress! This means a two-way communication has been established, and data has been exchanged.

## The First SYN

Nothing happened while the server was running, but as soon as the client started, it sent the first **SYN packet** to the server.

![](https://telegra.ph/file/7a23c2f3c563b7190e208.png)

If you look at the panel at the bottom left, you’ll notice fields such as **Acknowledgment Number**, **Flags**, **Sequence Number**, **Window size**, and others.

- **Acknowledgment Number**: A unique identifier sent by the receiving device to confirm the successful receipt of data packets.
- **Flags**: Used to identify the type of the TCP packet sent.
- **Sequence Number**: Ensures that data packets are sent in the correct order and that none are missed.
- **Window size**: Limits the amount of data the server can send to the client without waiting for confirmation. (This is typically 65,535 bytes, meaning you can’t send more than that in one transfer.)

All of these are managed by the framework or library you’re using, so you don’t need to worry about them. Thus, the first **SYN packet** sent by the client to the server can be considered a "greeting" or "introduction" packet.

![](https://telegra.ph/file/affb30a9e7ec2452e1877.png)

## Response from the Server

The server responds to this **SYN** with a **SYN-ACK** packet. If you look at the above image, you’ll see the Info section of the second packet shows **SYN-ACK** (which are examples of the flags mentioned earlier).

![](https://telegra.ph/file/7f48a51451b842c03320d.png)

## ACK Response from the Client

This is the final part of the handshake (the handshake). Here, the client notifies the server of its current sequence number. This sequence number will be 1 more than the previous sequence number (like how 1 comes after 0). It also includes the expected sequence number from the server, which is the acknowledgment number.

![](https://telegra.ph/file/8e2fffa4093da7024730c.png)

## Conclusion

As you can see, if you start the client-server again, they will exchange nearly 10 packets in the same way. I hope this post helps explain why opening connections such as database connections, TCP connections, websockets, and others is not always a good practice.

Take the time to deeply understand the language, framework, or technology you are learning. This way, you will have a clear understanding of when each method, function, or class opens a connection and when it closes.

**Feel free to share the post**,  

> You can also bring me a coffee (you’ll find more information in the channel profile).  


Next, let's analyze the handshake. To do this, we will need Wireshark (to listen to TCP packets and communication). Now, let's run the server and observe what happens through Wireshark’s interface.

TCP Handshake (part-2)


Before any discovery is presented to the public, it undergoes various tests. Of course, the systems and applications developed by programmers are no exception to this. Today, we will focus more on testing our applications.

![UI Design vs User Testing](https://miro.medium.com/v2/1*EZvHrZfS_9U5zuIdjdUaPg.jpeg)

### Unit Test

The word **Unit** can be translated from English as "point" or "part." When you want to test a specific part of the program, you write unit tests for it. Imagine you are a professor at a university, and you are testing the code written by 10,000 students. As a human, it’s impossible to check them quickly, but computers can do this. For a simpler example:

```python
# Input: join_words("hello", "it's", "me", "Otabek")
# Output: "hello it's me Otabek"
def join_words(*words: tuple[str], sep: str = " ") -> str:
    return sep.join(words)
```

Let’s consider the function above: you input several words, and the function combines them (you can separate the words in any desired way using `sep`). All students submit their homework, and a simple unit test is enough to check them.

```python
import unittest  # Import unittest

class TestJoinWords(unittest.TestCase):  # Start class name with Test...
    # It’s best to name methods starting with test_...
    def test_simple(self):
        # assertEqual checks for equality, so -> add(1, 2) == 3
        # This means when you run the function("value"), its result should be "result"
        self.assertEqual(join_words("it's", "me"), "it's me")
        self.assertEqual(join_words("testing", "in", "action", sep="-"), "testing-in-action")

if __name__ == '__main__':
    unittest.main()
```

I recommend researching unit tests in more detail and writing more tests afterwards. Unit tests are best written for classes, methods, and functions. I believe they are the best choice to ensure everything is functioning correctly.

### Integration Test

![](https://miro.medium.com/v2/1*5fFw_rC0oi2W6bmVLaX4TQ.jpeg)

Let’s say you have a program that serves thousands of users well. You’ve added new features to it. To ensure that the new features integrate successfully with the program, work flawlessly with other services, and check for any other potential issues, you would write **Integration** tests.

> The word **Integration** means **joining**. So, when you integrate a new feature with an existing system, you write tests to ensure nothing breaks.

I know of two types of integration tests: **Big Bang** and **Incremental**. As the name suggests, the **Big Bang** test involves testing all parts of the program at once, and this is typically used in small projects because it naturally takes a lot of time and resources in large projects. In the **Incremental** type, you test each module or feature in smaller groups. This is more commonly seen in large applications, and companies that use **monorepo** approaches typically use this type of testing.

While unit tests test a small function or class methods, integration tests check if they work together properly and return the expected result.

```python
# For example, let's test a simple API server
def user_info(name: str, age: int) -> dict:
    return {"user": name, "age": age}

def display_user_info(data: dict) -> str:
    return f"User {data['user']} is {data['age']} years old."

def get_user_info(name: str, age: int) -> str:
    data = get_data(name, age)
    return display_user(data)

# Integration test part
assert get_user_info("Otabek", 23) == "User Otabek is 23 years old."
assert get_user_info("John", 14) == "User John is 14 years old."
```

### Functional Test

The goal of functional tests is to answer the question "_Is this thing working as we expect it to?_". These tests are typically used to check if business logic is working correctly. Business logic refers to how a business solves its problems as described. The main focus is not on how the program works but on whether it can solve the problem correctly. I believe no further example is needed for this concept. : )

### E2E (End-to-End) Test

The concept of end-to-end can be translated as from "start to finish," but it’s a broader concept. Here, the word **end** is used twice:

- **The first end** refers to the server. It is primarily responsible for servicing requests and handling incoming queries.
- **The second end** refers to the user. This is the side that interacts with the server and consumes its services.

For the user, the last destination to receive the message is considered the **end**. For the server, if the message reaches the user, the task is completed. Performing end-to-end testing means that the tests you write should behave just like a real user would. This means that before your servers provide services to real users, the system should be tested to behave just like they would interact with it. It’s hard to explain with code, but I hope you understand (if code were written, this could be a Git repository, not an article).

![End-to-End testing meme](https://miro.medium.com/v2/1*c231Y-idAokGRDtV-Hrzyw.png)

### Canary Test

In the past, miners would release a bird into a mine before entering to check if the air was safe. If the bird didn’t die, it was safe to enter. If it did, no one would go inside. The same concept applies in programming. We often deploy a smaller version of a system for a small group of users to check for bugs. This process is known as **canary deployment**, and the people you trust try the new features. If there are issues, they report them to the tech team. If everything works, the system is released to the public.

![Canary test meme](https://testsigma.com/blog/wp-content/uploads/What-is-Canary-Testing-A-Comprehensive-Overview.png)

### Stress Test

Stress testing involves pushing the system to its limits, by making heavy requests or operations to see if it can handle the load without crashing. For instance, if a user sends endless requests through a loop, stress testing ensures the server doesn’t shut down. Similarly, if a user works on multiple large files at once, stress testing ensures the program performs smoothly without freezing. Here's a simple stress test example:

```python
def test_infinite_loop():
    try:
        while True:
            append_new_users()
    except MemoryError:
        print("Oops! We hit a breaking point!")

def test_heavy_tasks():
    try:
        while True:
            do_heavy_task()
    except MemoryError:
        print("Oops! We hit a breaking point!")
```

### UI Testing

UI tests are written to check the User Interface of your program. You may want to check if your application is **pixel perfect** or whether specific texts appear on the page, or if classes, colors, and attributes are correct. For example, to check if a simple text exists in React, we would write a test like this:

```javascript
// Writing a simple UI test with React
import { render, screen } from '@testing-library/react'
import App from './App'

test('renders welcome message', () => {
  render(<App />)
  expect(screen.getByText(/welcome/i)).toBeInTheDocument()
})
```

### Monkey Test

![Monkey test meme](https://miro.medium.com/v2/1*LWHbxjZhkaGyDPz3JzZ06A.gif)

Have you ever given a device to a monkey? If you haven’t, you might want to try it (just kidding). When a monkey gets a new device, it randomly presses buttons and does things you can’t predict. This test, invented by Netflix, is highly effective. If the program passes the monkey test, you shouldn’t worry about its performance with real users.

```python
import random

def click_button(buttons):
    return random.choice(buttons)

# Randomly pressing buttons for the test
buttons = ['Save', 'Cancel', 'Delete']
clicked_button = click_button(buttons)
assert clicked_button in buttons  # We hope this doesn’t break
```

The above test is just a **basic overview**. In practice, monkey tests are much more complex.

### Fuzz Testing

For example, you are given fields for first_name and last_name, and everyone knows they should write names there. However, some may enter numbers, true/false, {"name": "Jprqjon"}, or even 👑KING👑. If your function is designed to accept only numbers, the important thing is that the system doesn't crash and provides a proper warning to the user. In such cases, you need to write **fuzz (uncertain) tests**. Here’s an example of a simpler test written in **Go** (because of static typing):

```go
package main

import (
    "fmt"
    "testing"
)

// Function that reverses strings
func Reverse(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

// Fuzz test function
func TestReverse(f *testing.F) {
    testCases := []string{"hello", "world", "", "a", "racecar", "Go is fun!"}
    for _, tc := range testCases {
        f.Add(tc)
    }

    f.Fuzz(func(t *testing.T, input string) {
        reversed := Reverse(input)
        doubleReversed := Reverse(reversed)
        if input != doubleReversed {
            t.Errorf("Expected %q but got %q", input, doubleReversed)
        }
        if len(reversed) != len(input) {
            t.Errorf("LengthError: input length %d, reversed length %d", len(input), len(reversed))
        }
    })
}

func main() {
    fmt.Println("Run `go test` to execute fuzz testing.")
}
```

### Others

There are many other types of tests available. In this article, I tried to cover as many as possible with examples. The rest can be found on the internet or discovered through hands-on experience.

We may discuss **regression tests**, **security tests**, **A-B tests**, **smoke tests**, **load tests**, **performance tests**, **acceptance tests**, and more in the future.


Before any discovery is introduced to the public, it undergoes various tests. Of course, systems and software developed by developers are no exception to this.

Testing in Action


If you're asked, **"What's the difference between Procedural and Functional Programming?"** in an interview, there's no need to panic. In this post, we'll mainly discuss **Functional Programming** and what sets it apart from other **paradigms**.

![What is Functional Programming?](https://miro.medium.com/v2/1*FDn8bRsxPNBkDYSKnKQfQg.jpeg)

## FP, What?

Functional Programming (FP) is a declarative programming style that tackles complex problems through sequential functions. When we say "functions," we're not referring to the typical code we write daily but rather to mathematical functions. In FP, you write code without relying on **shared state** or **mutable** values.

- **Imperative**: You write “Hello Otabek” to a buffer, and then to the standard output... `there’s still a lot to say`
- **Declarative**: You simply print "Hello Otabek": `print("Hello Otabek")`

## Immutability

![Mutate variable meme](https://i.chzbgr.com/full/9721547520/h628DD729/ahh-mutating-global-state-s-functional-programmer-not-afraid-side-effects-stop-patrick-scaring-him)

You’ve probably heard it—one of the core concepts in FP is **immutability**. Once you declare a variable, you cannot change it. It’s like saying that all values are constants, not variables.

Imagine you're running a program and you know the variables you've declared will never change. Would you still use **try-except** or **catch-throw** statements? Of course not, because the variables never change, and bugs won’t appear (unless you write buggy code yourself).

## Recursion

![recursion](https://preview.redd.it/0wap3cp4khm01.jpg?auto=webp&s=3dec95610a58f519cdc503061ef41bf85ed63295)

When we need to repeat a task or iterate through something, we often use **loops** (like `while`, `for`, etc.). But loops use variables, and they store state. This goes against the principle of immutability we talked about earlier. That’s where **recursion** comes in.

Recursion has a **base case**, which tells us when to stop calling the function. Each function call utilizes the **stack** data structure, following the LIFO (Last In, First Out) principle. When the **base case** tells us to stop, elements are popped from the stack in order to process results in the desired way.

```python
# This function says hello as many times as you want.
def say_hello(times: int):
    if times == 0:  # base case, tells us when to stop.
        return
    print("Hello!")
    return say_hello(times - 1)

say_hello(5)
```

## Pure Functions

A **pure function** is exactly that—a function without side effects. If you provide the same input, it will always return the same output. There are no hidden changes happening in the background.

Pure functions are fast because they can be cached. Since they always produce the same output for the same input, there's no need to recalculate results. It’s simple, but believe me, it works wonders.

## High Order vs First-Class Functions

One of the key concepts in FP is **First-class functions**. This means that functions are treated as first-class citizens—essentially, they can be passed as arguments to other functions or returned from functions. For example:

```python
# You can use both regular or lambda functions
five = lambda: 5
six = lambda: 6

def add(x, y):
    return x + y

add(five() + six())  # This is essentially 5 + 6
```

Another important concept is **High-order functions**. These are functions that can take other functions as arguments or return functions as their result. For instance:

```python
# Takes a function as an argument
def apply_twice(func, x):
    return func(func(x))

def add_two(n):
    return n + 2

result = apply_twice(add_two, 5)
# func(func(x)) means calling the function twice
# add_two(add_two(5)) => add_two(7) => add_two(7) => 9
print(result)  # Output: 9
```

## Procedural vs Functional

Procedural programming is what we typically use when writing code—it involves variables, functions, statements, etc. However, in Functional Programming, the approach is fundamentally different. In short: it’s all about functions and immutability. 😉

## Conclusion

![](https://www.vasinov.com/images/i-should-cat.jpg)

I haven’t written about the pros and cons because the main points you need to understand about FP have already been covered. FP is filled with many terms that belong to the world of mathematics. If you're interested, dive into those topics; there’s a lot to learn. I think this post serves as a great introduction for anyone starting out.

Now, you’re ready to explain the difference between Functional and Procedural programming without hesitation. Cheers!


If you're ever asked in an interview, What's the difference between Procedural and Functional Programming?, don't worry. In this post, we'll mainly talk about Functional Programming and what makes it different from other paradigms.

Recent Posts

Older Posts

Something's on the horizon