DEV Community: Mehmet Ali Tilgen

Getting Started With Python Poetry

Mehmet Ali Tilgen — Mon, 24 Nov 2025 08:41:38 +0000

Dependency management, version pinning, and virtual environments often become a source of frustration in Python projects. Different machines install different versions, requirements files become messy, and package conflicts pop up unexpectedly.

This is exactly where Poetry steps in — a modern tool that brings structure, consistency, and automation to Python development.

In this guide, you’ll learn everything you need to start using Poetry confidently.

What You Will Learn

How to create new Python projects with Poetry
How to manage virtual environments
How to read and configure pyproject.toml
How to pin dependency versions
Why poetry.lock is essential
How to use the most important Poetry commands
How to add Poetry to an existing project

What Is Dependency Management?

Every Python project depends on external packages — FastAPI, NumPy, Pandas, SQLAlchemy, Requests, and many more.

Dependency management ensures that:

the correct versions are installed
these versions are compatible with each other
every team member uses the same versions

Without proper dependency management, projects become unstable and unpredictable.

Poetry solves all of this elegantly.

What Is Poetry?

Poetry is a modern dependency and package management tool designed to simplify the entire Python project lifecycle.

Its goal is to make Python development:

consistent
standardized
secure
reproducible

Poetry manages dependencies, virtual environments, packaging, and publishing — all through a single tool.

Starting a Project With Poetry

Poetry provides two ways to start a project depending on your needs.

1. Creating a New Project

If you want a clean, best-practice project scaffold:

poetry new project-name

This generates a ready-to-use structure:

project-name/
│
├── project_name/
│   └── __init__.py
│
├── tests/
│   └── __init__.py
│
├── pyproject.toml
└── README.md

Adding Poetry to an Existing Project If you already have a project folder:

poetry init

Poetry will ask you a few questions and create a pyproject.toml file.
It does not change your existing folder structure — which gives you full control.

You can now add dependencies:

poetry add fastapi
poetry add --dev pytest

What Is pyproject.toml?

pyproject.toml is the modern, universal configuration file for Python projects.

It replaces multiple legacy files:

setup.py
setup.cfg
requirements.txt
Inside this file you’ll find:
Project name and version
Dependencies
Python version
Dev dependencies
Build system information

Example:

[tool.poetry]
name = "pos-backend"
version = "0.1.0"
authors = ["Mehmet Ali Tilgen"]

[tool.poetry.dependencies]
python = "^3.11"
fastapi = "^0.115.0"

[tool.poetry.dev-dependencies]
pytest = "^7.0"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

What Is the poetry.lock File?

poetry.lock records the exact versions of all dependencies — including transitive ones.

Why is this important?

✔ Everyone on the team uses the same versions

✔ Local, CI/CD, and production environments become identical

✔ Builds become deterministic

✔ Updates are safe and intentional

You should never edit this file manually; Poetry maintains it automatically.

Essential Poetry Commands

Add a dependency

poetry add fastapi

Add a development dependency

poetry add --dev pytest

Activate the virtual environment

poetry shell

Run any command inside the environment

poetry run python main.py

Update all dependencies

poetry update

These commands cover 95% of practical use cases.

Conclusion

Poetry is more than a dependency manager — it’s a powerful ecosystem that brings order and professionalism to Python development. By unifying project setup, versioning, virtual environments, and builds under a single workflow, Poetry helps you:

avoid conflicts
maintain stable projects
collaborate more effectively
reproduce environments easily Whether you're building backend services, data pipelines, or web applications, Poetry will significantly improve your development experience.

See you in the next article!

Process Management in Python: Fundamentals of Parallel Programming

Mehmet Ali Tilgen — Thu, 02 Jan 2025 16:31:38 +0000

Parallel programming is a programming model that allows a program to run multiple tasks simultaneously on multiple processors or cores. This model aims to use processor resources more efficiently, reduce processing time and increase performance.

To illustrate parallel programming with an image, we can imagine that we have a problem. Before we start parallel processing, we divide this problem into smaller sub-parts. We assume that these sub-parts are independent of each other and have no knowledge about each other. Each sub-problem is translated into smaller tasks or instructions. These tasks are organized in a way that is suitable for parallel work. For example, many instructions can be created to perform the same operation on a dataset. These tasks are then distributed to different processors. Each processor processes its assigned instructions independently and in parallel. This process significantly reduces the total processing time and allows us to use resources more efficiently.

Python offers several tools and modules for parallel programming.

Multiprocessing
It allows the program to take advantage of true parallelism by enabling it to run multiple processes at the same time. multiprocessing module overcomes the limitations of GIL (Global Interpreter Lock), allowing to achieve full performance on multi-core processors.

Global Interpreter Lock (GIL) is a mechanism used in the popular implementation of Python called CPython. GIL allows only one thread to execute Python bytecode at a time. This is a construct that limits true parallelism when multithreading is used in Python.

Example Square and Cube Calculation

from multiprocessing import Process

def print_square(numbers):
    for n in numbers:
        print(f"Square of {n} is {n * n}")

def print_cube(numbers):
    for n in numbers:
        print(f"Cube of {n} is {n * n * n}")

if __name__ == "__main__":
    numbers = [2, 3, 4, 5]  

    # İşlemler (processes) oluşturma
    process1 = Process(target=print_square, args=(numbers,))
    process2 = Process(target=print_cube, args=(numbers,))

    # İşlemleri başlatma
    process1.start()
    process2.start()

    # İşlemlerin tamamlanmasını bekleme
    process1.join()
    process2.join()

Why We Need Multiprocessing We can explain the need for multiprocessing with the analogy of a cook and a kitchen. You can think of a cook cooking alone in a kitchen as a single-process program. We can liken it to multiprocessing when more than one cook works together in the same kitchen.

Single Process - Single Cook

There is only one cook in a kitchen. This cook will make three different dishes: a starter, a main course and a dessert. Each dish is made in turn:
He prepares and completes the starter.
He moves on to the main course and finishes it.
Finally, he makes the dessert.
The problem:

No matter how fast the cook is, he or she takes turns and this wastes time in the kitchen.
If three different dishes need to be cooked at the same time, the time will be longer.
Multiprocessing - Many Cooks

Now imagine that there are three cooks in the same kitchen. Each is preparing a different dish:
One cook makes the starter.
The second cook prepares the main course.
The third cook makes the dessert.
Advantage:

Three dishes are made at the same time, which significantly reduces the total time.
Each cook does its own work independently and is not affected by the others.
Sharing Data Between Processes in Python
In Python, it is possible to share data between different processes using the multiprocessing module. However, each process uses its own memory space. Therefore, special mechanisms are used to share data between processes.

import multiprocessing

result = []

def square_of_list(mylist):
    for num in mylist:
        result.append(num**2)
    return result

mylist= [1,3,4,5]

p1 = multiprocessing.Process(target=square_of_list,args=(mylist,))
p1.start()
p1.join()

print(result) # [] Boş Liste

When we examine the code sample, we see that the result list is empty. The main reason for this is that the processes created with multiprocessing work in their own memory space, independent of the main process. Because of this independence, changes made in the child process are not directly reflected in the variables in the main process.

Python provides the following methods for sharing data:

1. Shared Memory
Value and Array objects are used to share data between operations.
Value: Shares a single data type (for example, a number).
Array: Used for sharing an array of data.

from multiprocessing import Process, Value

def increment(shared_value):
    for _ in range(1000):
        shared_value.value += 1  

if __name__ == "__main__":
    shared_value = Value('i', 0)  
    processes = [Process(target=increment, args=(shared_value,)) for _ in range(5)]

    for p in processes:
        p.start()
    for p in processes:
        p.join()

    print(f"Sonuç: {shared_value.value}")

2. Queue
It uses the FIFO (First In First Out) structure to transfer data between processes.
multiprocessing.Queue allows multiple processes to send and receive data.

from multiprocessing import Process, Queue

def producer(queue):
    for i in range(5):
        queue.put(i)  # Kuyruğa veri ekle
        print(f"Üretildi: {i}")

def consumer(queue):
    while not queue.empty():
        item = queue.get()  
        print(f"Tüketildi: {item}")

if __name__ == "__main__":
    queue = Queue()

    producer_process = Process(target=producer, args=(queue,))
    consumer_process = Process(target=consumer, args=(queue,))

    producer_process.start()
    producer_process.join()

    consumer_process.start()
    consumer_process.join()

3. Pipe
multiprocessing.Pipe provides two-way data transfer between two processes.
It can be used for both sending and receiving data.

from multiprocessing import Process, Pipe

def send_data(conn):
    conn.send([1, 2, 3, 4])  
    conn.close()

if __name__ == "__main__":
    parent_conn, child_conn = Pipe()  

    process = Process(target=send_data, args=(child_conn,))
    process.start()

    print(f"Alınan veri: {parent_conn.recv()}")  # Veri al
    process.join()

*Padding Between Processes
*“Padding between processes” is often used for process memory organization or to avoid data alignment and collision issues when accessing data shared between multiple processes.

This concept is especially important in cases such as cache-line false sharing. False sharing can lead to performance loss when multiple processes try to use shared memory at the same time. This is due to the sharing of cache-lines in modern processors.

**Synchronization Between Processes
**With the multiprocessing module in Python, multiple processes can run simultaneously. However, it is important to use synchronization when multiple processes need to access the same data. This is necessary to ensure consistency of data and avoid issues such as race conditions.

from multiprocessing import Process, Lock

def print_numbers(lock, name):
    with lock:  # Kilidi alır
        for i in range(5):
            print(f"{name}: {i}")

if __name__ == "__main__":
    lock = Lock()  # Kilit oluştur
    processes = [
        Process(target=print_numbers, args=(lock, f"Process {i}")) for i in range(3)
    ]

    for p in processes:
        p.start()

    for p in processes:
        p.join()

Lock allows only one process to access shared data at a time.
Before the process using the lock finishes, other processes wait.

**Multithreading

Multithreading is a parallel programming model that allows a program to run multiple threads simultaneously. Threads are smaller independent units of code that run within the same process and aim for faster and more efficient processing by sharing resources.
In Python, the threading module is used to develop multithreading applications. However, due to Python's Global Interpreter Lock (GIL) mechanism, multithreading provides limited performance on CPU-bound tasks. Therefore, multithreading is generally preferred for I/O-bound tasks.

thread is the sequence of instructions in our program.

import threading

def print_numbers(name):
    for i in range(5):
        print(f"{name}: {i}")

# İş parçacıkları oluşturma
thread1 = threading.Thread(target=print_numbers, args=("Thread 1",))
thread2 = threading.Thread(target=print_numbers, args=("Thread 2",))

# İş parçacıklarını başlatma
thread1.start()
thread2.start()

# İş parçacıklarının tamamlanmasını bekleme
thread1.join()
thread2.join()

print("All threads finished")

**Thread Synchronization
**Thread synchronization is a technique used to ensure data consistency and order when multiple threads access the same resources simultaneously. In Python, the threading module provides several tools for synchronization.

**Why Need Thread Synchronization?
**Race Conditions:

When two or more threads access a shared resource at the same time, data inconsistencies can occur.
For example, one thread may read data while another thread updates the same data.
*Data Consistency:
*
Coordination between threads is required to ensure that shared resources are updated correctly.
Synchronization Tool Examples in Python
**1. Lock
**When a thread acquires the lock, it waits for the lock to be released before other threads can access the same resource.

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:  # Kilidi alır
            counter += 1  # Güvenli şekilde artırır

threads = [threading.Thread(target=increment) for _ in range(5)]

for t in threads:
    t.start()

for t in threads:
    t.join()

print(f"Final Counter Value: {counter}")  # Doğru sonuç: 500000

2-Event

import threading
import time

event = threading.Event()

def worker():
    print("Worker waiting for event to be set")
    event.wait()  # Olay tetiklenene kadar bekler
    print("Event is set, worker proceeds")

thread = threading.Thread(target=worker)
thread.start()

time.sleep(2)  # Bekleme simülasyonu
print("Setting the event")
event.set()  # Olay tetiklenir
thread.join()

**Conclusion:
**Thread synchronization is critical to prevent data inconsistencies when threads access shared resources. In Python, tools such as Lock, RLock, Semaphore, Event, and Condition provide effective solutions according to synchronization needs. Which tool to use depends on the needs of the application and synchronization requirements.

What is Celery?

Mehmet Ali Tilgen — Mon, 21 Oct 2024 11:08:52 +0000

HTTP, as it is known, is a protocol based on a request-response loop between client and server. When developing web applications, managing this loop in the most efficient way possible is a critical goal. The ideal is to optimize the interaction by providing the user with a meaningful and accurate response as soon as possible. However, this request-response cycle does not always run smoothly; users sometimes experience delays, incorrect responses, or errors due to system load. This is where task queuing tools like Celery come in, helping to increase performance and improve user experience in web applications by managing busy background processes.

To understand this better, let’s take a simple example. Let’s say we have a function that analyzes the photos uploaded by users and then sends the analysis results via email:

def photo_analysis_view(request):
    user = request.user
    photo_analysis = analyize_photo(user=user)
    send_photo_analysis_email(photo_analysis=photo_analysis, user=user)
    return JsonResponse({"message": "Your photo analyis has been sent your email."})

When we analyze the execution of this function, we need to remember that Python processes code line by line. So, function send_photo_analysis_email will not run until function analyze_photo is complete. Let’s assume that this function send_photo_analysis_email takes 5 minutes on average. In this case, users would have to wait for 5 minutes for their browser to respond, resulting in a very bad user experience.

This is where Celery comes in.

What is Celery?
Celery is a popular open source library that enables asynchronous task management and processing in Python programs. It is used to efficiently handle long-running or workload-intensive tasks and parallel processing. The main goal of Celery is to distribute the workload to specific workers to prevent the main program from waiting and improve system performance. In this way, we can execute time-consuming operations in the background that are not directly part of the request-response cycle, and we can perform these operations discrete and concurrently by assigning them to one or more workers.

Celery Architecture and Operating Principle.
Celery’s architecture, as an implementation of a distributed messaging system, consists of three basic components. These components are a producer or application that creates and sends messages, a broker or queue that forwards and stores messages bidirectionally, and consumers or workers that perform specific operations based on the received messages.

This architecture plays an important role in managing and distributing tasks in web applications. The message sender (producer) is usually a web application or a block of code that implements a specific business logic. This application generates the workload as messages and adds these messages to a queue through a broker (usually Redis or RabbitMQ). The broker reliably stores these messages and forwards them to the appropriate consumers (workers) for processing.

Workers are independent units that receive these messages and perform specified operations in the background. This can be time-consuming tasks such as sending emails, processing data, analyzing large files or interacting with external APIs. Workers can process multiple messages at the same time, allowing them to manage the workload simultaneously.

The interaction between these components allows the workload to be managed and distributed in a centralized way. Thus, the main application can respond quickly to user requests, while the complex and intensive work in the background is handled by the workers. With this structure, Celery offers both a scalable and flexible solution, providing great advantages in terms of performance optimization and user experience in web applications.

Let’s show a step-by-step demo to turn the photo_analysis_view function into a background task using Celery.

A Simple Demo

In this demo, we will run a function in the background of a Django web application that analyzes photos uploaded by users and sends the analysis results via email. We will improve the user experience by running long email sending processes in the background.

Redis Setup

First, Celery needs a broker. We run Redis with Docker:

$ docker container run --rm -p 7055:6379 -d --name celery_demo_broker redis:alpine

This command will run Redis over port 7055.

Installing Python Dependencies

$ pip install "celery[redis]"

Celery Configuration and Defining Tasks

We do our Celery configuration by creating the main.pyfile:

from celery import Celery

app = Celery('celery_demo', broker='redis://localhost:7055/0')

@app.task
def send_photo_analysis_email_task(photo_analysis, user):
    print(f"Sending email to {user.email} with analysis result: {photo_analysis}")
    return f"Email sent to {user.email} with analysis result."

Updating the Django View

In your Django application, you can update your photo analysis function to run in the background. For this update, we will call the task we defined from
Celery:

from django.http import JsonResponse
from .tasks import send_photo_analysis_email_task

def photo_analysis_view(request):
    user = request.user
    photo_analysis = analyze_photo(user=user)  
    send_photo_analysis_email_task.delay(photo_analysis=photo_analysis, user=user)
    return JsonResponse({"message": "Your photo analysis has been sent to your email."})

Starting Celery Worker

Celery workers are independent processes that take the tasks you define and run them. To start a worker, we use the following command:

$ celery --app main.app worker --loglevel=info

This command starts the worker using the Celery application named app in main.py. This worker listens to the tasks sent to Redis and takes care of them.
In this demo, we saw how to manage a time-consuming email sending process in the background using Django and Celery. Redis is used as the broker and Celery workers process these tasks in the background, allowing the main application to return a quick response to the user.

We have explained celery, which has gained a place in the Python world. Don’t forget to follow our articles.

Which Android Architecture Should Be Chosen? MVC, MVP, MVVM

Mehmet Ali Tilgen — Mon, 17 Jun 2024 08:16:19 +0000

What are these concepts and how do they help us in designing software?

As the size and complexity of modern application development processes increase, it becomes necessary to simplify these processes and reduce their complexity. Therefore, the design of application architectures is of great importance. Architectural designs ensure that systems are modular and manageable, allowing the development process to proceed more efficiently and error-free. Additionally, these designs make it easier to maintain and update applications.

In this article, we will focus on popular architectural designs for the Android platform. Model View Controller (MVC), Model View Presenter (MVP), and Model View ViewModel (MVVM) are among the main architectures preferred for developing secure and high-performance Android applications. To better understand which architecture should be chosen, we will examine each one in detail in this blog post.

Before looking at each architecture, let's familiarize ourselves with the terms that make them up.

Model, View, ViewModel, Controller, and Presenter
Before diving into these architectures, let's get to know the building blocks that constitute these terms.

Model: Represents the data source of the application. The model is the component that contains your data and application logic. This can include retrieving and processing data from databases, network operations, or other data sources. The model forms the functional foundation of the application, undertaking the task of operating on the data and sharing this data with other components.

View: Refers to the interface presented to the user and is responsible for the visual representation of the data provided by the model.

ViewModel: Specific to the MVVM model. It is an abstraction of the view layer. It acts as a binder between the View and Model. The ViewModel takes the necessary data from the View and requests this data from the Model for processing.

Controller: Found in the MVC (Model-View-Controller) architecture model. The controller is responsible for managing user inputs and controlling the application flow. It takes requests from the user interface and determines how to respond to them.

Presenter: Belongs to the MVP (Model-View-Presenter) architecture model. It is the main component that manages the interaction between the Model and View. The presenter takes data from the Model, processes this data, and presents it appropriately to the View. Unlike MVC (Model-View-Controller), this architecture envisages a tighter connection between the Presenter and View; that is, it communicates directly with the View, ensuring that the View plays a passive role only related to user interface updates.

Model-View-Controller (MVC)
The MVC architectural model is popular in the field of web applications. In Android, the MVC (Model-View-Controller) architecture is a pattern used in application development that aims to separate different aspects of the application (data processing, user interface, and control logic) from each other.

Model: Represents the data and business logic of the application. The model includes functionalities such as database operations, network requests, or processing data received from the user.
View: Includes the interface elements shown to the user. In Android, this typically includes layout files defined with XML and the Activity or Fragment classes that inflate these layouts. The view captures user interactions and forwards them to the Controller when necessary.
Controller: Acts as a bridge between the Model and View. In Android, the Controller is typically implemented as Activity or Fragment. The controller captures actions from the user, forwards them to the Model for processing, and updates the user interface by transferring the results to the View.
In Android, the MVC architecture can sometimes be difficult to define clearly due to the nature of the platform. This is because Android tends to use UI components (Activities and Fragments) as both Controllers and Views, making the traditional implementation of MVC challenging.

MVP (Model-View-Presenter)
MVP is a variation of the MVC (Model-View-Controller) pattern and works more effectively in event-driven programming environments like Android. Here are the main components of MVP:

Model: Represents the data and business logic of the application. The model includes responsibilities such as database operations, API calls, and processing user data.
View: The interface elements displayed to the user. In Android, the view is typically represented by UI components like Activity or Fragment. The view forwards user interactions to the Presenter and updates the interface according to directives from the Presenter.
Presenter: Acts as an intermediary between the Model and View. The presenter takes user actions from the View, executes the necessary business logic on the Model, and then transfers the results to the View to update the UI.
MVP is popular among Android developers because it prevents Activities and Fragments from being overloaded and allows for better organization of the different layers of the application.

MVVM (Model-View-ViewModel)
MVVM (Model-View-ViewModel) architecture is a design pattern that is especially popular in modern application development environments and is an effective design pattern for Android applications. Unlike MVC and MVP patterns, MVVM offers a more data-binding and UI component-independent approach.

Model: As in all architectures, the model in MVVM represents the data and business logic of the application.
View: Represents the interface visible to the user, similar to other models. However, in MVVM, the view directly receives data flow from the ViewModel through data binding, resulting in less and cleaner code.
ViewModel: The most important part of MVVM, the ViewModel acts as a mediator between the View and Model. Unlike the Presenter in MVP, the ViewModel performs its connection with the View through data binding. This means the View is unaware of the existence of the ViewModel and thus is less dependent.
Conclusion
MVP and MVVM are more advanced architectural models than MVC. In MVP, the presenter is completely abstracted from the View, increasing testability. However, each View requires a presenter, which can be a disadvantage. MVVM provides a modern, efficient, and testable architecture for Android and is especially preferred in large-scale projects or applications with heavy data binding. Therefore, it may be appropriate to choose between MVP and MVVM according to the requirements of the project.