DEV Community: Dmitry Koleev

"What Every Programmer Should Know About Memory" by Ulrich Drepper.

Dmitry Koleev — Tue, 08 Oct 2024 17:54:09 +0000

I highly recommend that every programmer reads this document at least once in their life.

Brief overview

In his seminal work, Ulrich Drepper provides a deep dive into the intricacies of modern memory subsystems and offers practical advice for developers aiming to optimize software performance. As CPU cores become faster and more numerous, memory access has emerged as a key bottleneck for many applications. Drepper's paper breaks down how programmers can utilize hardware advancements like CPU caches and RAM to improve efficiency.

1. Memory Bottlenecks in Modern Systems

The paper starts by highlighting the increasing gap between CPU speed and memory performance. While CPUs have evolved rapidly, memory subsystems, particularly DRAM, have not kept pace. This discrepancy leads to delays, as CPUs often have to wait for data to be retrieved from memory. To combat this, modern systems use caches, but their effectiveness depends on how well software leverages them.

2. CPU Caches and Their Importance

CPU caches, small but fast memory storage areas, are critical for bridging the gap between slow memory access times and fast CPU cycles. Caches store frequently accessed data, reducing the number of times the CPU needs to fetch data from slower RAM. Drepper explains the multi-level cache hierarchy (L1, L2, and sometimes L3 caches), detailing how data flows through these caches and how proper usage can drastically reduce access times. The paper also emphasizes that programmers must understand how data is loaded into and evicted from caches to optimize code performance.

3. RAM Types: DRAM vs. SRAM

Drepper discusses the differences between two main types of RAM: Static RAM (SRAM) and Dynamic RAM (DRAM). While SRAM is faster, it's more expensive and takes up more space. Therefore, it is typically used for CPU caches. DRAM, on the other hand, is cheaper and used for main memory, but it is slower and requires constant refreshing. These trade-offs mean that efficient use of memory is essential for performance, especially when designing memory-intensive applications.

4. Non-Uniform Memory Access (NUMA) and Direct Memory Access (DMA)

For large systems, memory access can become even more complicated due to architectures like NUMA, where memory is divided into regions that are closer to specific processors. Accessing remote memory in a NUMA system is slower, and Drepper stresses the importance of optimizing memory allocation to reduce latency. Similarly, DMA allows devices to access memory directly without involving the CPU, which can lead to faster data transfers but also introduces competition for memory bandwidth.

5. Optimizing Software for Memory Subsystems

A significant portion of Drepper’s paper provides actionable advice for programmers. To maximize performance, developers need to design software that aligns with the hardware's memory architecture:

Cache-friendly algorithms: Organize data structures and access patterns in ways that take advantage of the spatial and temporal locality that caches thrive on.
Prefetching: Both hardware and software prefetching techniques can be used to load data into caches before it is needed, reducing wait times.
Data locality: Keeping data that is frequently accessed together helps ensure that it stays in the cache longer, improving performance.

6. Tools for Analyzing Memory Usage

Drepper also introduces various tools that can help programmers analyze their software’s memory usage. These tools can detect cache misses, memory access patterns, and bottlenecks in the system, giving developers the insight they need to optimize their code further.

Conclusion: The Future of Memory and Software Optimization

Drepper concludes by looking toward the future, discussing upcoming memory technologies and trends, such as faster DDR RAM and more sophisticated cache systems. However, he emphasizes that no matter how advanced memory technology becomes, software must be designed with these hardware constraints in mind. For developers, understanding the structure of memory and CPU caches is crucial for writing efficient code that can handle the demands of modern, multi-core, and multi-threaded processors.

In summary, "What Every Programmer Should Know About Memory" is an essential guide for developers looking to optimize their software for modern hardware. By understanding how memory works, from caches to RAM to NUMA systems, programmers can write code that performs more efficiently and leverages the full potential of today's computing architectures.

How to Create Custom Git Commands on Windows

Dmitry Koleev — Tue, 01 Oct 2024 08:28:08 +0000

Introduction

Git is one of the most popular version control systems, widely used by developers to manage and track changes in their code. While Git comes with built-in commands that handle most tasks, sometimes you may want to create custom commands to simplify repetitive tasks or enhance your workflow.

Why Create Custom Git Commands?

Before diving into the technical details, it's important to understand why creating custom Git commands can be useful:

Automation: Save time on repetitive tasks by wrapping multiple Git commands into one.
Simplification: Reduce complex command sequences into a single, easy-to-remember command.
Consistency: Ensure that your team follows the same workflow by creating shared commands.
Personalization: Tailor Git’s behavior to match your specific workflow needs.

In this article, we’ll walk through how to create a custom Git command.

Fast Push Command

Let’s create a command called fpush for quickly pushing changes. This command will perform the following steps:

Pull data from the current branch
Stage all unstaged changes
Commit these changes
Push the commit to the server

1. Create the Command File

Create a new folder to hold files with custom commands (for example, "E:/git-custom-commands").
Inside this folder, create a new command file named git-fastpush.cmd.

Add the following content to the file:

git pull
git add .
git commit -m %1
git push

Explanation of Commands:

git pull: Fetch changes from a remote repository into the current branch.
git add .: Stage all unstaged changes.
git commit -m %1: Commit changes, where %1 is the first argument passed to the command (e.g., git fpush "this_is_commit_message").
git push: Push the local commit to the server.

2. Add a New Alias to the Git Config

Next, we need to add the new alias to the Git configuration with reference to our file. Run the following command in the console:

git config --global alias.fpush "!E:/git-custom-commands/git-fastpush.cmd"

2. Run the New Command

You're all set! Now you can execute your new Git command:

git fpush "your_comment"

Here we go. Feel free to create your own custom commands!

Host Telegram Bot on Raspberry Pi 5

Dmitry Koleev — Tue, 24 Sep 2024 17:02:40 +0000

Intruduction

In my previous article, I demonstrated how to create and run a Telegram Bot using Python. You can find it here

In this guide, I’ll walk you through hosting your Telegram bot on your own Raspberry Pi server.

Install OS on Raspberry Pi 5

Follow this guide to create an image with Raspberry Pi Imager.

I recommend choosing Raspberry Pi OS Lite OS because it is the best option in terms of lightweight simplicity.

In the imager settings check the box next to Enable SSH and select use password authentification. This will allow you to connect to your Raspberry Pi via SSH.

After creating the image on a USB flash drive, insert the flash card into your Raspberry Pi and power it on.

Connect to Raspberry Pi via `SSH`

Open the console (cmd or PowerShell on Windows)
Ping your Raspberry Pi the following command:

ping raspberrypi.local

You’ll receive ping statistics along with the IP address of your Raspberry Pi.

Use this IP address to connect via SSH:

SSH pi@<your_raspberry_pi_ip> (for example: SSH pi@192.168.0.10)

Enter the password (default is raspberry). I strongly recommend changing this later.
If the password is correct, you will be connected to your Raspberry Pi via SSH.

Prepare Envariement

Update your Raspberry Pi

sudo apt update
sudo apt upgrade

Install Python Raspberry Pi OS usually comes with Python pre-installed. Check if it's installed:

python3 --version

If Python is not installed, you can install it using:

sudo apt install python3 python3-pip

Set Up a Virtual Environment (Optional but Recommended) It’s a good practice to create a virtual environment to keep your project dependencies isolated:

sudo apt install python3-venv
python3 -m venv telegram-bot-env
source telegram-bot-env/bin/activate

Install the Python Telegram Bot Library

pip install python-telegram-bot --upgrade

Create and Run the Bot

Create a new Python file using the nano text editor

nano bot.py

Write your bot code in this new file _(you can use code from my previous article). Press CTRL + O then hit Enter to save changes. To exit press CTRL + X.
Run the bot

python3 bot.py

Your bot is now running, and you can test it on Telegram.

However, this method will terminate the bot when you close the terminal.

To keep it running in the background we can use tmux

Keep the Bot Running in the Background Using `tmux`

Create an Executable Shell Script to Start Your Bot

Install tmux

sudo apt update
sudo apt install tmux

Create a new shell script to start your bot. You can name it start_bot.sh

nano start_bot.sh

Add the following lines to the script, replacing bot.py with the name of your Python bot file and telegram-bots-env with your env name:

#!/bin/bash
source telegram-bots-env/bin/activate
python3 bot.py

Save and exit (CTRL + O, Enter, CTRL + X).
Make the script executable:

chmod +x start_bot.sh

Run Bot via `tmux`:

Start a new tmux session:

tmux new -s my_bot_session

Inside the tmux session, run your bot script:

./start_bot.sh

Detach from the tmux session by pressing CTRL + B, then D
Reattach to the tmux Session (if needed) To reattach to your bot’s tmux session later, use:

tmux attach -t my_bot_session

Automatically Start the Bot on Boot (Optional)

If you want your bot to start automatically on boot, you can use a systemd service. Here’s how:

Create a new service file:

sudo nano /etc/systemd/system/my_bot.service

Add the following configuration, modifying paths as needed:

[Unit]
Description=My Bot Service

[Service]
ExecStart=/usr/bin/tmux new-session -d -s my_bot_session '/path/to/start_bot.sh'
WorkingDirectory=/path/to/my_bot
User=pi

[Install]
WantedBy=multi-user.target

Save and exit the file.
Reload the systemd daemon:

sudo systemctl daemon-reload

Enable the service to start on boot:

sudo systemctl enable my_bot.service

Start the service:

sudo systemctl start my_bot.service

Create a Telegram Bot on Python

Dmitry Koleev — Thu, 19 Sep 2024 11:16:41 +0000

1. What Is a Telegram Bot?

Bots are small applications that run entirely within the Telegram app. Users interact with bots through flexible interfaces that can support any kind of task or service.

You can read more about bots in the official documentation:
Bots
Telegram Bot API

2. Prerequisites

Before diving into bot creation, you'll need the following:

A Telegram Account: You can easily create one by downloading the Telegram app on your phone.
Python Installed: We will use Python 3, so make sure it’s installed on your computer. download link
Basic Python Knowledge: Understanding Python syntax and packages will help you navigate the code. I can recommend this book Automate the Boring Stuff with Python
BotFather Access: BotFather is a built-in Telegram bot that helps you manage and create new bots.
VS Code(Optional): I use it for writing my bots. But feel free to choose any other editor. But I'd recommended to use this one. Here you can download the latest version of VS Code, and here is instruction on how to set it for Python.

3. Creating a Bot on Telegram

To create your own bot, you need to use BotFather, the official tool for registering and managing bots on Telegram.

Steps:

Open Telegram and search for the BotFather bot. (Enter @botfather into the search menu)
Start a chat with BotFather by typing /start.
Create a new bot by typing /newbot.
You will be prompted to provide a name for your bot. Enter a unique name (e.g., Hello World).
BotFather will ask for a username for the bot. The username must end with "bot" (e.g., HelloWorldBot).
After completing these steps, BotFather will give you a token. This token is crucial as it authenticates your bot and allows you to interact with Telegram’s API.

Important: Keep your token private and do not share it publicly!

4. Setting Up Python Environment

Next, we need to set up our Python environment to interact with the Telegram API. We will use the python-telegram-bot library, which provides a simple and easy-to-use interface for developing Telegram bots.

Steps:

Install the python-telegram-bot library:
Run the following command to install the necessary library:

 pip install python-telegram-bot

Create a new Python file: You can name it something like my_bot.py to hold your bot's code.

5. Writing the Bot Code

Now that our environment is ready, let’s write the bot code.

Sample Code

Here’s a basic bot that responds to /start and /help commands:

import logging
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

# Enable logging
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                    level=logging.INFO)
logger = logging.getLogger(__name__)

# Define a start function to respond to the /start command
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text('Hello! I am your bot. How can I help you today?')

# Define a help function to respond to the /help command
async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text('You can use the following commands:\n/start - Start the bot\n/help - Get help')

def main():
    # Create the application and pass the bot token
    application = ApplicationBuilder().token('YOUR_BOT_TOKEN_HERE').build()

    # Add command handlers for /start and /help
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("help", help_command))

    # Start the bot and run it until manually stopped
    application.run_polling(allowed_updates=Update.ALL_TYPES)

if __name__ == '__main__':
    main()

Explanation:

Imports: We import telegram and telegram.ext modules to build our bot. These provide the classes and functions necessary to interact with the Telegram API.
Logging: Logging is enabled to track events and errors.
Start and Help Commands: We define two functions (start and help_command) that send a message when users trigger the corresponding commands.
Token: Replace 'YOUR_BOT_TOKEN_HERE' with the token you received from BotFather.
Polling: The bot uses polling to constantly check for new messages and responds to them as they come.

Running the Bot:

Replace the placeholder token in the code with your bot’s token.
Run your Python script:

 python my_bot.py

Your bot is now up and running! Open Telegram, send the /start or /help commands to the bot, and it will respond.

6. Deploying the Bot

Running the bot on your local machine is great for testing, but what if you want it to be available 24/7? To achieve this, you can deploy the bot to a server or cloud service.

Common Deployment Options:

Heroku: A free cloud platform where you can host your bot.
AWS (Amazon Web Services): More scalable but may require some setup for beginners.
VPS (Virtual Private Server): Gives you full control over your server.
PythonAnywhere: A beginner-friendly option with free tiers. Each platform offers unique ways to deploy Python applications. You can follow deployment tutorials specific to your chosen service.

7. Conclusion

Congratulations! You’ve successfully created a basic Telegram bot using Python. You learned how to:

Set up a Telegram bot using BotFather.
Write Python code to handle commands.
Run the bot locally and interact with it on Telegram.

Next, I'd recommend you to learn the example bots from python-telegram-bot

This is a series of articles. In the next articles, I'll explain how to host your bot on PythonAnywhere, host bots on your own Raspberry PI server, and create more complicated bots.

DEV Community: Dmitry Koleev

"What Every Programmer Should Know About Memory" by Ulrich Drepper.

Brief overview

1. Memory Bottlenecks in Modern Systems

2. CPU Caches and Their Importance

3. RAM Types: DRAM vs. SRAM

4. Non-Uniform Memory Access (NUMA) and Direct Memory Access (DMA)

5. Optimizing Software for Memory Subsystems

6. Tools for Analyzing Memory Usage

Conclusion: The Future of Memory and Software Optimization

How to Create Custom Git Commands on Windows

Introduction

Why Create Custom Git Commands?

Fast Push Command

1. Create the Command File

Explanation of Commands:

2. Add a New Alias to the Git Config

2. Run the New Command

Host Telegram Bot on Raspberry Pi 5

Table of Contents:

Intruduction

Install OS on Raspberry Pi 5

Connect to Raspberry Pi via SSH

Prepare Envariement

Create and Run the Bot

Keep the Bot Running in the Background Using tmux

Create an Executable Shell Script to Start Your Bot

Run Bot via tmux:

Automatically Start the Bot on Boot (Optional)

Create a Telegram Bot on Python

Table of Contents:

1. What Is a Telegram Bot?

2. Prerequisites

3. Creating a Bot on Telegram

Steps:

4. Setting Up Python Environment

Steps:

5. Writing the Bot Code

Sample Code

Explanation:

Running the Bot:

6. Deploying the Bot

Common Deployment Options:

7. Conclusion

Connect to Raspberry Pi via `SSH`

Keep the Bot Running in the Background Using `tmux`

Run Bot via `tmux`: