PostgreSQL — один из самых мощных и гибких реляционных СУБД с открытым исходным кодом. Однако без должной оптимизации даже самая продуманная система может столкнуться с проблемами производительности. В этом руководстве мы рассмотрим ключевые аспекты оптимизации PostgreSQL, от базовых принципов до продвинутых техник.

Мониторинг и анализ производительности

Основные инструменты

-- Активные запросы
SELECT pid, usename, application_name, query, state 
FROM pg_stat_activity 
WHERE state = 'active';

-- Долгие запросы (> 5 секунд)
SELECT now() - query_start AS duration, query, state 
FROM pg_stat_activity 
WHERE state = 'active' AND now() - query_start > '5 seconds'::interval;

pg_stat_statements
Включение модуля для анализа запросов:

ALTER SYSTEM SET shared_preload_libraries = 'pg_stat_statements';
CREATE EXTENSION pg_stat_statements;

-- Топ-5 самых ресурсоемких запросов
SELECT query, calls, total_time, rows, 
       100.0 * shared_blks_hit / nullif(shared_blks_hit + shared_blks_read, 0) AS hit_percent
FROM pg_stat_statements 
ORDER BY total_time DESC 
LIMIT 5;

EXPLAIN и EXPLAIN ANALYZE
Разбор плана выполнения запроса:

EXPLAIN ANALYZE
SELECT * FROM orders 
WHERE customer_id = 123 
AND order_date > '2023-01-01';

Эффективное использование индексов

Типы индексов и их применение

Тип индекса	Описание	Идеальные сценарии
B-tree	Стандартный индекс	Равенство, диапазоны, сортировка
GiST	Generalized Search Tree	Геоданные, полнотекстовый поиск
GIN	Generalized Inverted Index	Составные типы, полнотекстовый поиск
BRIN	Block Range Index	Очень большие таблицы, временные ряды
Hash	Хэш-индекс	Только операции равенства
SP-GiST	Space-partitioned GiST	Неравномерные структуры данных

Оптимизация индексов

Покрывающие индексы (INCLUDE):

CREATE INDEX orders_customer_date_idx ON orders (customer_id) INCLUDE (order_date, total_amount);

Частичные индексы:

CREATE INDEX active_users_idx ON users (email) WHERE is_active = true;

Анализ использования индексов:

SELECT schemaname, relname, indexrelname, idx_scan,
       100 * idx_scan / (seq_scan + idx_scan) AS idx_usage_percent
FROM pg_stat_user_tables 
WHERE seq_scan + idx_scan > 0;

Оптимизация запросов

Распространенные антипаттерны

1. N+1 запросов:

   • Проблема: Множество отдельных запросов вместо одного

   • Решение: Использовать JOIN и агрегацию

2. Избыточные данные:

-- Неоптимально
SELECT * FROM customers;

-- Оптимально
SELECT id, name, email FROM customers;

3. Неэффективные JOIN:

   • Всегда фильтруйте данные перед соединением таблиц

Оптимизация сложных запросов

CTE vs подзапросы:

-- Часто неоптимально (материализация)
WITH recent_orders AS (
    SELECT * FROM orders WHERE order_date > now() - interval '30 days'
)
SELECT * FROM recent_orders JOIN customers USING (customer_id);

-- Оптимальная альтернатива
SELECT * 
FROM orders o
JOIN customers c USING (customer_id)
WHERE o.order_date > now() - interval '30 days';

Оконные функции вместо кореллированных подзапросов:

-- Неоптимально
SELECT name, 
       (SELECT COUNT(*) FROM orders WHERE customer_id = c.id) AS order_count
FROM customers c;

-- Оптимально
SELECT name, COUNT(o.id) OVER (PARTITION BY customer_id) AS order_count
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id;

Конфигурация сервера

Ключевые параметры памяти

# postgresql.conf

# 25-40% от общей памяти
shared_buffers = 8GB

# Для операций сортировки и соединения
work_mem = 32MB

# Для операций обслуживания (VACUUM, CREATE INDEX)
maintenance_work_mem = 2GB

# Размер кэша ОС для данных
effective_cache_size = 24GB

Правильная настройка параметров памяти критически важна для производительности PostgreSQL. Рассмотрим ключевые параметры с формулами расчета и практическими рекомендациями.

shared_buffers (общий буферный кэш)

Назначение: Основной кэш для данных и индексов

Рекомендации:

# Формула для систем с > 4GB RAM:
shared_buffers = min(25% RAM, 8GB) для OLTP
shared_buffers = min(40% RAM, 32GB) для OLAP

# Примеры:
RAM 16GB → 4GB (16 * 0.25)
RAM 64GB → 8GB (предел для OLTP)
RAM 256GB → 32GB (для OLAP)

Особенности:

• Не должен превышать 40% RAM
• Для Windows: не более 512MB-1GB из-за архитектурных ограничений
• После изменения требуется перезагрузка сервера

work_mem (память для операций)

Назначение: Память для сортировки, хешей, оконных функций
Рекомендации:

# Формула:
work_mem = (RAM - shared_buffers) / (max_connections * параллельные операции)

# Безопасный расчет:
work_mem = (RAM - shared_buffers) / (max_connections * 3)

# Пример для 16GB RAM, 100 подключений:
(16384MB - 4096MB) / (100 * 3) = 12288 / 300 ≈ 40MB

Важно:

• Значение задается на операцию, а не на соединение
• Один запрос может использовать несколько раз work_mem
• Типичный диапазон: 4MB-64MB
• Слишком высокое значение → риск OOM (out of memory)

maintenance_work_mem (память для обслуживания)

Назначение: Операции VACUUM, CREATE INDEX, ALTER TABLE
Рекомендации:

# Формула:
maintenance_work_mem = min(10% RAM, 1GB) для баз < 50GB
maintenance_work_mem = min(5% RAM, 10GB) для крупных БД

# Примеры:
RAM 16GB → 1GB
RAM 128GB → 10GB (макс. эффективное значение)

Особенности:

• Можно временно увеличивать для операций перестроения индексов
• Не влияет на обычные запросы

effective_cache_size (оценочный параметр)

Назначение: Оценка доступного кэша ОС для планировщика
Рекомендации:

# Формула:
effective_cache_size = (RAM - shared_buffers) + файловый кэш ОС

# Практическое правило:
effective_cache_size = 50-75% от общего RAM

# Пример:
RAM 64GB → 40GB

Важно: Это информационный параметр, не выделяет реальную память!

temp_buffers (временные буферы)

Назначение: Буферы для временных таблиц
Рекомендации:

# По умолчанию 8MB обычно достаточно
# Для ETL-процессов:
temp_buffers = 16-256MB

huge_pages (большие страницы памяти)

Назначение: Уменьшение накладных расходов
Рекомендации:

huge_pages = try   # или on для включенных систем

Требования:

• Необходима настройка в Linux: vm.nr_hugepages
• Расчет страниц: nr_hugepages = ceil(shared_buffers / 2MB)

wal_buffers (буфер WAL)

Назначение: Кэш для записей журнала
Рекомендации:

# Автовычисление обычно достаточно
# Ручная настройка:
wal_buffers = max(shared_buffers * 0.03, 16MB)

# Пример для shared_buffers=4GB:
4096MB * 0.03 ≈ 123MB → 128MB

Формулы расчета для разных размеров БД

Для сервера 8GB RAM (небольшая БД)

shared_buffers = 2GB
work_mem = 8MB
maintenance_work_mem = 512MB
effective_cache_size = 6GB
wal_buffers = 16MB

Для сервера 64GB RAM (производственная БД)

shared_buffers = 16GB
work_mem = 32MB
maintenance_work_mem = 8GB
effective_cache_size = 40GB
wal_buffers = 128MB
temp_buffers = 64MB

Для сервера 256GB RAM (аналитическая БД)

shared_buffers = 32GB
work_mem = 128MB
maintenance_work_mem = 32GB
effective_cache_size = 180GB
wal_buffers = 256MB
temp_buffers = 256MB

Практические советы по настройке

Постепенная оптимизация:

# Шаг 1: Настройте shared_buffers
# Шаг 2: Оптимизируйте work_mem на основе EXPLAIN ANALYZE
# Шаг 3: Настройте maintenance_work_mem под размер индексов

Мониторинг использования:

-- Потребление work_mem
SELECT query, work_mem, max_work_mem 
FROM pg_stat_activity 
WHERE state = 'active';

-- Эффективность кэша
SELECT sum(blks_hit) * 100 / (sum(blks_hit) + sum(blks_read)) AS hit_ratio
FROM pg_stat_database;

Динамическая корректировка:

-- Временное увеличение для тяжелой операции
SET LOCAL work_mem = '256MB';
CREATE INDEX CONCURRENTLY ...;

Автоматизация расчета:
Используйте инструменты:

• PGTune
• PoWA для сбора статистики
• pg_qualstats для анализа предикатов

Распространенные ошибки

1. Слишком высокий work_mem:

-- При 100 подключениях:
work_mem = 256MB → потенциальное использование 25.6GB
-- Риск: OOM killer завершит процессы PostgreSQL

2. Недостаточный maintenance_work_mem:

   • VACUUM и CREATE INDEX будут работать медленно
   • Увеличивает время обслуживания БД

3. Игнорирование effective_cache_size:

   • Планировщик будет недооценивать стоимость сканирования по индексу
   • Результат: выбор полного сканирования таблицы вместо индекса

Параметры планировщика

# Стоимость чтения последовательного блока
seq_page_cost = 1.0

# Стоимость чтения случайного блока (для SSD уменьшить)
random_page_cost = 1.1

# Параллельное выполнение
max_parallel_workers_per_gather = 4
min_parallel_table_scan_size = 8MB

Настройки автовакуума

autovacuum_vacuum_scale_factor = 0.05
autovacuum_analyze_scale_factor = 0.02
autovacuum_vacuum_cost_limit = 2000
autovacuum_naptime = 1min

Расширенные техники оптимизации

Табличное партиционирование

-- Создание партиционированной таблицы
CREATE TABLE orders (
    id SERIAL,
    order_date DATE NOT NULL,
    customer_id INT NOT NULL,
    amount NUMERIC(10,2)
) PARTITION BY RANGE (order_date);

-- Создание партиций
CREATE TABLE orders_2023_q1 PARTITION OF orders
    FOR VALUES FROM ('2023-01-01') TO ('2023-04-01');

CREATE TABLE orders_2023_q2 PARTITION OF orders
    FOR VALUES FROM ('2023-04-01') TO ('2023-07-01');

Репликация и шардирование

Архитектура высокой доступности:

Основной сервер (Primary)
        |
        v
Синхронная реплика (Sync Standby)
        |
        v
Асинхронные реплики (Async Standby) -> Читающие реплики

Шардирование с помощью Citus:

-- Создание распределенной таблицы
SELECT create_distributed_table('orders', 'customer_id');

-- Выполнение запроса на всех шардах
SELECT * FROM orders WHERE customer_id = 12345;

Использование расширений

-- Кэширование сложных запросов
CREATE EXTENSION pg_pooler;

-- Сжатие данных
CREATE EXTENSION pg_compression;

-- Ускорение JOIN
CREATE EXTENSION pg_ivm;

Техники обслуживания БД

Стратегии вакуума

ALTER TABLE orders SET (
    autovacuum_vacuum_scale_factor = 0.01,
    autovacuum_vacuum_cost_delay = 5
);

-- Ручной вакуум для больших таблиц
VACUUM (VERBOSE, ANALYZE) large_table;

Перестройка индексов

-- Одновременная перестройка без блокировки
REINDEX INDEX CONCURRENTLY orders_customer_idx;

-- Перестройка всех индексов таблицы
REINDEX TABLE orders;

Мониторинг состояния БД

-- Проверка "раздувания" таблиц
SELECT schemaname, relname, 
       n_dead_tup, 
       pg_size_pretty(pg_relation_size(relid)) AS size
FROM pg_stat_user_tables
WHERE n_dead_tup > 1000
ORDER BY n_dead_tup DESC;

Заключение

Оптимизация PostgreSQL — комплексный процесс, требующий глубокого понимания как самой СУБД, так и особенностей вашего приложения. Ключевые принципы:

1. Измеряйте перед оптимизацией: Используйте мониторинг для выявления реальных проблем

2. Индексы ≠ панацея: Правильные индексы важны, но их избыток вредит производительности

3. Конфигурация контекстна: Нет универсальных настроек — тестируйте под свою нагрузку

4. Проектируйте с учетом масштабирования: Используйте партиционирование и шардирование заранее

5. Автоматизируйте обслуживание: Настройте автовакуум и регулярные проверки

Оптимизация PostgreSQL — это постоянный процесс, а не разовое мероприятие. Регулярный мониторинг, анализ производительности и постепенная настройка позволят поддерживать вашу базу данных в оптимальном состоянии даже при росте нагрузки и объема данных.

История и эволюция JavaScript как универсального языка программирования

JavaScript, созданный в 1995 году Бренданом Айком в компании Netscape, изначально позиционировался как инструмент для добавления интерактивности на веб-страницы. Первая версия языка была разработана всего за десять дней с целью обеспечить простые функциональные возможности, такие как проверка форм и анимация элементов пользовательского интерфейса. В тот момент мало кто мог предположить, что этот язык станет ключевым элементом веб-разработки и превратится в одну из самых популярных технологий программирования в мире.

Эволюция JavaScript началась с его интеграции в браузеры, где он использовался для выполнения базовых задач. Однако по мере развития веб-технологий перед JavaScript стали возникать более сложные требования. Это привело к стандартизации языка через ECMAScript, первую версию которого выпустили в 1997 году. С этого момента JavaScript начал своё преобразование из простого инструмента для создания интерактивных элементов в мощный язык программирования, поддерживающий клиентскую и серверную разработку.

Одним из ключевых событий в истории развития JavaScript стало появление Node.js в 2009 году. Этот фреймворк позволил использовать JavaScript для написания серверного кода, открыв новые горизонты для разработчиков. Node.js стал основой для создания высокопроизводительных серверных приложений, микросервисов и безсерверных архитектур. К 2025 году Node.js остается одной из самых популярных платформ для серверной разработки, хотя альтернативы, такие как Deno и Bun, предлагают дополнительные преимущества, включая поддержку TypeScript из коробки и улучшенную производительность за счет движков JavaScriptCore

Другим важным этапом в развитии языка стал выпуск ES6 (ECMAScript 2015), который представил множество инновационных функций, таких как стрелочные функции, классы, модули и шаблонные строки. Эти изменения значительно упростили написание чистого и удобного для поддержки кода, сделав JavaScript более привлекательным для разработчиков. С тех пор ежегодные обновления ECMAScript продолжают внедрять новые возможности, направленные на повышение производительности и удобства разработки. К 2025 году ожидается дальнейшее развитие языка благодаря предложениям сообщества и работе комитета TC39, отвечающего за стандартизацию

Популярность JavaScript продолжает расти, и к 2025 году он используется в 97% веб-сайтов, что делает его доминирующим языком программирования среди веб-разработчиков. Эта стабильность объясняется универсальностью языка, который применяется как в клиентской, так и в серверной разработке, а также развитием экосистемы библиотек и фреймворков, таких как React, Angular и Vue. Кроме того, интеграция искусственного интеллекта в JavaScript активно развивается благодаря таким библиотекам, как TensorFlow.js и Brain.js, что позволяет запускать машинное обучение прямо в браузере

Производительность JavaScript также значительно улучшилась благодаря современным движкам, таким как V8 (используемый в Google Chrome), SpiderMonkey (Mozilla Firefox) и JavaScriptCore (Safari). Эти движки внедрили технологии Just-In-Time (JIT) компиляции и продвинутые стратегии сборки мусора, что сделало выполнение JavaScript быстрее и эффективнее. Особенно заметны эти оптимизации в мобильных браузерах, где Progressive Web Apps (PWAs) используют преимущества повышенной производительности для создания приложений, сопоставимых с нативными

Важно отметить, что стандартизация через ECMAScript играет ключевую роль в дальнейшем развитии языка. Процесс утверждения новых возможностей включает пять этапов — от идеи (Stage 0) до финального утверждения (Stage 4). Такой подход гарантирует, что каждое нововведение тщательно протестировано и готово к использованию в реальных проектах. Например, добавление стрелочных функций в ES6 прошло аналогичный процесс. Эта система помогает поддерживать баланс между инновациями и стабильностью, что особенно важно для языка, используемого в миллионах проектов по всему миру

Таким образом, история создания и развития JavaScript демонстрирует его переход от простого инструмента для добавления интерактивности на веб-страницы к универсальному языку программирования, поддерживающему как клиентскую, так и серверную разработку. Ключевые события, такие как появление Node.js и выход ES6, а также постоянные обновления ECMAScript, сделали JavaScript неотъемлемой частью современной разработки. Благодаря своей гибкости, производительности и активному сообществу, JavaScript продолжает оставаться лидером среди языков программирования.

Эволюция спецификаций ECMAScript: от ES6 до современных стандартов

В 2015 году выход шестой версии ECMAScript (ES6) ознаменовал собой революционный этап в развитии JavaScript, представив множество ключевых возможностей, таких как стрелочные функции, классы, модули и промисы
. Эти изменения значительно улучшили производительность разработки и удобство написания кода. Например, синтаксис стрелочных функций const add = (a, b) => a + b; позволил исключить необходимость привязки контекста (this), что сделало работу с асинхронным кодом и коллбэками более компактной и предсказуемой. Классы, представленные в ES6, предоставили формализованный подход к объектно-ориентированному программированию, что облегчило создание сложных приложений. Модули же дали возможность организовывать код в независимые блоки, что повысило читаемость и масштабируемость проектов. Промисы, внедренные в ES6, сделали управление асинхронными операциями более структурированным, открыв новые горизонты для серверной разработки на Node.js и использования в современных фреймворках, таких как React

После ES6 последующие обновления ECMAScript продолжили совершенствовать язык, делая его еще более мощным и удобным для разработчиков. Например, в ECMAScript 2020 (ES11) был представлен оператор Optional Chaining (?.), который позволяет безопасно получать значения из вложенных объектов без необходимости проверки каждого уровня на null или undefined. Это особенно полезно при работе с данными, поступающими из внешних источников, таких как API, где часто встречаются неопределенные или частично заполненные структуры данных. Еще одно важное дополнение — Nullish Coalescing Operator (??) — помогает корректно обрабатывать значения null и undefined, что делает код более надежным и читаемым. Введение Async/Await в ECMAScript 2017 (ES8) стало ключевым шагом в управлении асинхронными операциями, позволяя писать асинхронный код в синхронном стиле. Такие обновления, как метод Object.groupBy в ECMAScript 2024 (ES15), направлены на повышение эффективности работы с большими объемами данных, что особенно важно для современных веб-приложений, активно использующих аналитику и машинное обучение.

Процесс внедрения новых возможностей в ECMAScript осуществляется через комитет TC39, который обеспечивает постепенное развитие языка через пять этапов: от идеи (Stage 0) до финального утверждения (Stage 4)
. Этот подход гарантирует, что каждое нововведение тщательно протестировано и готово к использованию в реальных проектах. Например, Temporal API, находящийся на стадии предложения, направлен на решение проблем работы с временными данными, предоставляя более точные и гибкие инструменты для манипуляции датами и временем. Другой пример — Float16Array, новый тип TypedArray, добавленный в ECMAScript 2025, который предназначен для работы с half-precision числами с плавающей запятой. Это нововведение особенно важно для графических приложений и задач машинного обучения, где оптимизация вычислений играет ключевую роль

Однако история развития ECMAScript не обошлась без трудностей. Попытка создания четвертой версии языка (ES4) потерпела неудачу из-за политических разногласий между крупными игроками индустрии, такими как Mozilla, Microsoft и Google. Многие из предложенных функций, такие как классы, модули и генераторы, были позже реализованы в ES6. Этот опыт показывает, как конфликты могут влиять на развитие технологий, но также демонстрирует, что полезные идеи рано или поздно находят свое применение

Среди перспективных предложений, которые могут существенно изменить будущее JavaScript, стоит отметить Pattern Matching, Records и Tuples, а также Async Context Propagation Pattern Matching позволит обрабатывать сложные условия с использованием структур данных, аналогично switch, но с большей гибкостью. Records и Tuples обеспечат глубокую иммутабельность, что особенно важно для управления состоянием в современных фреймворках, таких как React и Redux. Async Context Propagation решит одну из ключевых проблем текущей реализации async/await, позволяя сохранять контекст между асинхронными операциями. Эти инновации, наряду с поддержкой JSON Modules и Pipeline Operator, подчеркивают стремление ECMAScript адаптироваться к современным потребностям разработчиков и предоставлять им более мощные инструменты для создания высокопроизводительных приложений.

Роль движков JavaScript в оптимизации производительности

Движки JavaScript, такие как V8, SpiderMonkey и JavaScriptCore, играют ключевую роль в обеспечении высокой производительности современных веб-приложений. Эти движки используют сложные технологии, включая Just-In-Time (JIT) компиляцию и продвинутые стратегии сборки мусора, чтобы сделать выполнение кода быстрее и эффективнее. JIT-компиляция позволяет преобразовывать исходный код JavaScript в машинный код непосредственно во время выполнения программы. Этот подход устраняет необходимость в предварительной компиляции и значительно ускоряет выполнение скриптов. Например, движок V8, используемый в браузере Google Chrome, применяет две основные стадии JIT-компиляции: Ignition и TurboFan. Ignition выполняет базовую интерпретацию кода, а TurboFan проводит более глубокие оптимизации для часто используемых участков кода.

Сборка мусора является еще одной важной технологией, применяемой движками JavaScript для управления памятью. Эффективная работа с памятью имеет решающее значение для предотвращения утечек и минимизации задержек при выполнении кода. Современные реализации сборщиков мусора, такие как Orinoco в движке V8, используют параллельные и инкрементальные подходы, чтобы уменьшить влияние процесса очистки на общую производительность приложения. Это особенно важно для мобильных браузеров, где ресурсы устройства ограничены.

Одним из примеров успешной оптимизации движков JavaScript является их адаптация к новым стандартам ECMAScript. Например, внедрение поддержки JSON-модулей позволило разработчикам импортировать данные напрямую из JSON-файлов без необходимости дополнительной обработки. Это не только упростило синтаксис, но и повысило производительность за счет уменьшения количества операций, необходимых для загрузки данных. Другим значимым шагом стало добавление поддержки WebAssembly (Wasm), которая позволяет запускать высокопроизводительные приложения прямо в браузере. Это особенно полезно для задач, требующих значительной вычислительной мощности, таких как игры или научные расчеты.

Однако внедрение новых стандартов ECMAScript также создает определенные проблемы для движков JavaScript. Выход стандарта ECMAScript 2025 стал причиной масштабных изменений в экосистеме JavaScript, что потребовало от разработчиков движков пересмотра архитектурных решений и оптимизаций. Например, переход на новые функциональные возможности языка, такие как улучшенная обработка строк или новые типы данных, вызвал временные проблемы с совместимостью и производительностью. Особенно это заметно для мобильных устройств с ограниченными ресурсами, где даже незначительные изменения могут привести к серьезным последствиям. Для решения этих проблем рекомендуется использовать такие техники, как ленивая загрузка и минификация, которые помогают снизить нагрузку на устройства.

Несмотря на эти вызовы, постоянное развитие движков JavaScript способствует сохранению актуальности языка в условиях быстрого технологического прогресса. Например, движок V8 активно адаптирует новейшие возможности ECMAScript, что делает выполнение кода быстрее и эффективнее. Более того, интеграция с WebAssembly создает мощную экосистему для разработки сложных веб-приложений, таких как игры или научные вычисления. Таким образом, движки JavaScript продолжают играть центральную роль в эволюции языка, обеспечивая его конкурентоспособность и универсальность.

Производительность JavaScript в контексте мобильных приложений: текущее состояние и перспективы
В последние годы производительность JavaScript в мобильных приложениях значительно улучшилась благодаря внедрению современных оптимизаций движков JavaScript, таких как V8, SpiderMonkey и JavaScriptCore. Эти движки используют передовые технологии, такие как Just-In-Time (JIT) компиляция и усовершенствованные стратегии сборки мусора, которые особенно важны для мобильных браузеров
. К 2025 году эти оптимизации позволили Progressive Web Apps (PWAs), построенным на базе JavaScript, достичь уровня производительности, сопоставимого с нативными приложениями
. Это сделало PWAs привлекательным выбором для компаний, стремящихся снизить затраты на разработку и поддерживать кросс-платформенную совместимость. Однако существуют ограничения, особенно на платформах iOS, где доступ к аппаратным функциям остается ограниченным.

Преимущества PWAs перед нативными приложениями наиболее заметны в их способности работать офлайн и экономить ресурсы устройства. Сервис-воркеры, являющиеся ключевым компонентом PWAs, позволяют кэшировать контент и выполнять фоновые задачи даже без стабильного интернет-соединения. Это особенно важно для регионов с нестабильным подключением к сети. Например, такие компании, как Facebook и Twitter, уже успешно внедрили PWAs для повышения производительности своих платформ на мобильных устройствах. Тем не менее, несмотря на успех этих примеров, PWAs сталкиваются с ограничениями на iOS, где возможности, такие как push-уведомления, фоновая синхронизация и доступ к API устройства, либо частично поддерживаются, либо полностью отсутствуют. Это создает сложности для разработчиков, которым требуется глубокая интеграция с аппаратным обеспечением.

Сравнение производительности JavaScript в WebView с нативными технологиями выявляет значительные различия в доступе к устройству и управлении ресурсами. Нативные приложения, написанные на таких языках, как Swift для iOS или Kotlin для Android, обладают более плавной анимацией и быстрым временем загрузки за счет использования платформенных оптимизаций. Они также обеспечивают лучший доступ к аппаратным возможностям, таким как камера, GPS и датчики, что делает их предпочтительным выбором для игр и приложений с высокой степенью интеграции с устройством. Например, приложения дополненной реальности (AR) или IoT часто требуют нативной разработки для обеспечения надежной работы сложных систем.

Однако для проектов, ориентированных на широкую аудиторию и ограниченный бюджет, PWAs остаются предпочтительным вариантом. Их кросс-платформенная совместимость позволяет разрабатывать одно приложение для множества устройств, таких как iOS, Android и десктопы, с использованием HTML, CSS и JavaScript. Кроме того, автоматические обновления PWAs через браузер гарантируют пользователям использование последней версии приложения без необходимости ручного обновления. Этот фактор становится все более значимым, поскольку скорость адаптации к изменениям рынка становится ключевым конкурентным преимуществом.

Таким образом, JavaScript продолжает играть важную роль в разработке мобильных приложений, особенно в контексте PWAs. Хотя существуют ограничения, связанные с платформенными ограничениями, такие как недостаточный доступ к API устройства на iOS, преимущества PWAs, включая офлайн-функциональность и экономию ресурсов, делают их привлекательным выбором для многих компаний. В то же время, для приложений, требующих высокой производительности и глубокой интеграции с аппаратным обеспечением, нативная разработка остается наилучшим решением. Для дальнейшего исследования рекомендуется изучить потенциал комбинирования JavaScript с WebAssembly для создания высокопроизводительных модулей, что может стать стандартом для требовательных веб-приложений к 2025 году.

Node.js как основа серверной производительности

Node.js произвел революцию в серверной разработке, внедрив асинхронную модель ввода-вывода (I/O), которая кардинально изменила подход к обработке запросов на стороне сервера. В основе этой модели лежит событийно-ориентированная архитектура, которая позволяет Node.js одновременно обрабатывать множество подключений без блокировок, что является ключевым преимуществом для высоконагруженных приложений. Благодаря использованию неблокирующего I/O и цикла событий (event loop), Node.js стал особенно эффективным решением для задач, связанных с интенсивным взаимодействием между клиентом и сервером, таких как чаты, игровые серверы и финансовые платформы. Это делает Node.js идеальным выбором для современных систем реального времени, где важна мгновенная реакция. Одним из ярких примеров успешного применения Node.js является Netflix, крупнейший стриминговый сервис, который использует эту технологию для обеспечения бесперебойной работы своей платформы при обработке огромных объемов данных от миллионов пользователей по всему миру. Также стоит отметить использование Node.js в чат-приложениях, где технология WebSockets позволяет создавать долгоживущие соединения, критически важные для мгновенного обмена данными в режиме реального времени.

Современные методы оптимизации кода для Node.js помогают значительно улучшить его производительность даже в сложных сценариях. Например, для тяжелых вычислительных операций, таких как генерация PDF-файлов или выполнение криптографических расчетов, рекомендуется использовать Worker Threads — механизм, позволяющий перенести нагрузку на дополнительные потоки, не блокируя основной цикл событий
. Это особенно актуально для масштабируемых систем, где требуется балансировать между I/O-операциями и CPU-интенсивными задачами. Кроме того, минификация зависимостей, компрессия ответов через Gzip или Brotli, а также использование Content Delivery Networks (CDN) для статических ресурсов остаются ключевыми практиками для повышения скорости загрузки страниц и снижения задержек.

Сравнение Node.js с другими языками программирования, такими как Kotlin, подчеркивает его преимущество в использовании памяти. Исследования показывают, что Node.js потребляет значительно меньше оперативной памяти: всего около 80 МБ RAM против 430 МБ у эквивалентного Ktor-based Kotlin API при одинаковой пропускной способности. Это делает Node.js предпочтительным выбором для облачных сред и виртуальных серверов, где экономия ресурсов играет ключевую роль для высоконагруженных проектов. Однако стоит отметить, что Node.js не всегда является лучшим решением для задач, требующих больших вычислительных мощностей, таких как обработка документов или изображений. В таких случаях могут быть более подходящими альтернативы, такие как Java или Python. Тем не менее, для I/O-интенсивных операций Node.js остается лидером благодаря своей архитектуре.

Значимость Node.js в современных архитектурах микросервисов и безсерверных решений невозможно переоценить. Эта технология активно используется в микросервисных архитектурах, где ее легковесность и способность быстро обрабатывать запросы позволяют создавать масштабируемые системы с минимальными затратами ресурсов. Безсерверные платформы, такие как AWS Lambda и Google Cloud Functions, также поддерживают Node.js как одну из основных сред выполнения, что делает его ключевым игроком в области облачных вычислений. Таким образом, Node.js продолжает оставаться важным инструментом для разработчиков, стремящихся создавать высокопроизводительные и масштабируемые серверные решения.

Оптимизация и высоконагруженные проекты на JavaScript: современные подходы и примеры реализации
В современной веб-разработке JavaScript играет ключевую роль как основной язык программирования для создания динамических и интерактивных приложений. Однако с ростом сложности проектов производительность JavaScript становится критически важной, особенно в условиях высоких нагрузок. В этом контексте оптимизации кода и архитектуры приобретают особое значение. Рассмотрим наиболее эффективные методы оптимизации, а также примеры успешного применения JavaScript в высоконагруженных проектах.

Одним из базовых методов повышения производительности является минификация и компрессия кода. Минификация удаляет ненужные символы, такие как пробелы и комментарии, без изменения функциональности программы. Инструменты, такие как UglifyJS и Google Closure Compiler, позволяют не только сжимать код, но и переписывать его для достижения лучшей производительности. Дополнительно компрессия через Gzip или Brotli уменьшает размер передаваемых данных, что особенно важно для пользователей с медленным интернетом. Правильная настройка CDN или сервера для использования этих технологий может существенно сократить время загрузки страницы. Ленивая загрузка (Lazy Loading) также является мощным инструментом, позволяющим откладывать загрузку несущественных ресурсов до момента их появления в области видимости пользователя. Это достигается с помощью HTML-атрибута loading='lazy' или Intersection Observer API.

Для обработки больших объемов данных JavaScript демонстрирует свою эффективность в таких проектах, как онлайн-игры и системы уведомлений. Например, Node.js, благодаря своей асинхронной и неблокирующей архитектуре, успешно используется для создания чат-приложений и игровых серверов. Технология WebSockets позволяет организовать долгоживущие соединения между клиентом и сервером, что идеально подходит для приложений реального времени. Эти решения обеспечивают мгновенное взаимодействие с пользователями, даже при высокой нагрузке.

Масштабирование JavaScript-приложений часто требует применения асинхронного программирования и использования Web Workers. Асинхронные операции позволяют выполнять задачи без блокировки основного потока, что особенно важно для сохранения отзывчивости пользовательского интерфейса. Web Workers могут использоваться для параллельной обработки данных, таких как массивы или сложные математические операции, что особенно полезно для высоконагруженных мобильных приложений. Кроме того, разбиение длительных задач на более мелкие с использованием setTimeout или Scheduler.yield() помогает браузеру обрабатывать приоритетные задачи между выполнением частей кода.

Анализ потребления ресурсов в реальных высоконагруженных системах показывает, что JavaScript может быть ресурсоемким, особенно при частом доступе к DOM. Для оптимизации рекомендуется минимизировать взаимодействие с DOM, используя такие методы, как пакетная обработка обновлений через DocumentFragment или использование концепции Virtual DOM, применяемой в React. Также важно использовать современные итераторы, такие как forEach(), map(), filter() и reduce(), которые не только улучшают читаемость кода, но и могут быть более эффективными, чем традиционные циклы for или while.

Таким образом, современные техники оптимизации позволяют JavaScript оставаться конкурентоспособным в высоконагруженных сценариях. Минификация, компрессия, ленивая загрузка, асинхронное программирование и использование Web Workers — все эти методы способствуют повышению производительности веб-приложений. Примеры успешного применения JavaScript в проектах, таких как онлайн-игры и системы уведомлений, подтверждают его значимость в современной разработке. Дальнейшие исследования могут быть сосредоточены на анализе новых технологий, таких как WebGPU, и их потенциале для дальнейшего повышения производительности JavaScript-приложений.

Заключение

На протяжении почти трех десятилетий JavaScript прошел путь от простого инструмента для добавления интерактивности на веб-страницы до одного из самых универсальных и производительных языков программирования. Его эволюция, начиная с первых версий стандарта ECMAScript и заканчивая современными обновлениями, такими как ES6 и предложения ES2025, демонстрирует уникальную способность языка адаптироваться к меняющимся потребностям разработчиков и технологическим вызовам. Сегодня JavaScript занимает лидирующие позиции в веб-разработке, охватывая как клиентскую, так и серверную части, а также расширяясь в новые сферы, такие как машинное обучение и высокопроизводительные приложения.

Ключевыми факторами успеха JavaScript являются его гибкость, универсальность и активное сообщество, поддерживающее развитие языка через стандартизацию и внедрение инноваций. Например, появление Node.js в 2009 году открыло новые горизонты для серверной разработки, а внедрение WebAssembly дополнило возможности JavaScript для создания высокопроизводительных модулей. Эти изменения, наряду с постоянными улучшениями движков JavaScript, такими как V8, SpiderMonkey и JavaScriptCore, сделали язык неотъемлемой частью современного программирования.

Однако развитие JavaScript не обошлось без вызовов. Политические разногласия, такие как провал ES4, и временные проблемы с производительностью при внедрении новых стандартов, например ECMAScript 2025, показывают, что язык постоянно находится в процессе совершенствования. Тем не менее, благодаря строгой системе тестирования и поэтапному внедрению нововведений через комитет TC39, JavaScript остается стабильным и надежным инструментом для разработки.

К 2025 году JavaScript продолжает доминировать в веб-экосистеме, используясь в 97% веб-сайтов. Его популярность подкрепляется растущей экосистемой фреймворков и библиотек, таких как React, Angular и Vue, а также интеграцией с технологиями, такими как WebAssembly и искусственный интеллект. При этом язык продолжает развиваться, предлагая разработчикам новые инструменты, такие как Records/Tuples, JSON Modules и Pipeline Operator, которые направлены на повышение производительности и удобства разработки

Сегодня создадим простого Telegram-бота на языке Go, который будет отвечать на команду /start сообщением “Привет мир!”.

Первое что нам понадобится это установить зависимости, надеюсь что у вас Go уже установлен?

Для работы используем библиотеку go-telegram-bot-api. Установите её:

go get github.com/go-telegram-bot-api/telegram-bot-api/v5

Далее создаем файл main.go и вставьте следующий код:

package main

import (
    "log"

    tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)

func main() {
    // Замените "YOUR_BOT_TOKEN" на токен вашего бота
    bot, err := tgbotapi.NewBotAPI("YOUR_BOT_TOKEN")
    if err != nil {
        log.Panic(err)
    }

    bot.Debug = false // Включите true для отладки

    // Настраиваем параметры получения обновлений
    updateConfig := tgbotapi.NewUpdate(0)
    updateConfig.Timeout = 60 // Таймаут ожидания обновлений (в секундах)

    // Получаем обновления
    updates := bot.GetUpdatesChan(updateConfig)

    // Обрабатываем входящие сообщения
    for update := range updates {
        if update.Message != nil && update.Message.IsCommand() {
            // Проверяем команду /start
            if update.Message.Command() == "start" {
                // Формируем ответ
                msg := tgbotapi.NewMessage(update.Message.Chat.ID, "Привет!")
                msg.ReplyToMessageID = update.Message.MessageID

                // Отправляем сообщение
                if _, err := bot.Send(msg); err != nil {
                    log.Panic(err)
                }
            }
        }
    }
}

p.s. честно говоря на питоне слегка попроще писать ботов, но да ладно едем дальше))

Теперь давайте запустим нашего бота, для этого не забудьте заменить YOUR_BOT_TOKEN, на токен вашего бота (его выдает BotFather при создании бота).

Запустим бота:

go run main.go

После перейдите в телегу и напишите вашему боту в Telegram команду /start. Он ответит “Привет!”.

Ну и в принципе все! Теперь можно придумывать всякие штучки, программировать бота как душе угодно.
Я уже писал про бота на питоне в предидущем посте если кому-то интересно - ссылка

TensorFlow.js — библиотеке от Google, которая позволяет создавать и обучать нейросети прямо в браузере или Node.js. Забудьте про Python: всё, что вам нужно, — это браузер и базовые знания JS. Давайте начнём!

---

1. Установка и подключение

В браузере:

<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@4.10.0/dist/tf.min.js"></script>  

В Node.js:

npm install @tensorflow/tfjs  

Для GPU:

npm install @tensorflow/tfjs-node-gpu  

---

2. Пример простой модели

Задача: обучить модель предсказывать Y = 2X - 1.

Подготовка данных

const xs = tf.tensor2d([[0], [2], [4], [6], [8]]); // Входные значения  
const ys = tf.tensor2d([[-1], [3], [7], [13], [15]]); // Цель  

Создание и компиляция модели

const model = tf.sequential();  
model.add(tf.layers.dense({inputShape: [1], units: 1}));  

model.compile({  
  optimizer: 'sgd',  
  loss: 'meanSquaredError'  
});  

Обучение и прогнозирование

await model.fit(xs, ys, {epochs: 50});  
const prediction = model.predict(tf.tensor2d([[10]]));  
prediction.print(); // Ожидаем ~19  

---

3. Визуализация и сохранение

• Графики обучения: Используйте tfjs-vis для отображения потерь.
• Сохранение модели:

  await model.save('localstorage://my-model');  
  

• Загрузка модели:

  const loadedModel = await tf.loadLayersModel('localstorage://my-model');  
  

---

4. Готовые модели

• ImageNet (Mobilenet):

  npm install @tensorflow-models/mobilenet  
  

  Пример:

  const model = await mobilenet.load();  
  const predictions = await model.classify(document.getElementById('img'));  
  

• Голосовые команды:

  npm install @tensorflow-models/speech-commands  
  

---

5. Советы и ограничения

• Очистка памяти: Используйте tf.tidy() или .dispose() для управления тензорами.
• Производительность: В браузере медленнее, чем в Python. Лучше использовать для простых задач.
• Сложные модели: Обучайте на Python, затем импортируйте в TensorFlow.js.

Почитал тут про квантовые алгоритмы и хочу поделиться о том, как квантовая механика превращает классические задачи в “магию” будущего. Да, речь о квантовых алгоритмах Shor и Grover . Не пугайтесь слов вроде “суперпозиция” или “запутанность” — мы разберемся без страшных формул и с юмором .

---

1. Кубиты: не просто 0 и 1

Классический бит — это как выключатель: либо “вкл”, либо “выкл”. А кубит — это суперпозиция состояний. Представьте монету, которая крутится в воздухе: она одновременно и “орёл”, и “решка”. Квантовый компьютер использует это, чтобы обрабатывать много вариантов сразу. Магия? Нет — физика!

---

2. Алгоритм Шора: взломай RSA за выходные 🧨

Представьте, что вы хотите разложить число на множители (например, 15 = 3×5). Для маленьких чисел это легко, но для чисел из 1000 цифр? Классические компьютеры тратят миллиарды лет.
Shor же делает это за полиномиальное время, используя квантовые свойства. Как? Он превращает задачу в поиск периодичности функции, а потом… бац! — и множители находятся через квантовое преобразование Фурье.

Почему это важно?
RSA — основа современной криптографии. Если квантовый компьютер с тысячей кубитов станет реальностью, наши пароли станут прозрачными, как стекло 🤯. Но пока что это научная фантастика: даже Google и IBM только начинают осваивать десятки кубитов.

---

3. Алгоритм Гровера: иголка в стоге сена? Легко!

Классический поиск в базе данных из N элементов требует в среднем N/2 шагов. Гровер сокращает это до √N. Как? Он использует интерференцию квантовых состояний, чтобы “подсветить” правильный ответ.

Представьте: вы ищете иголку в стоге сена. Классический способ — перебирать каждый соломинку. Гровер же как волшебник, который “чувствует”, где иголка, и направляет вас туда, уменьшая ошибки.

Где применяется?

• Поиск в неструктурированных данных.
• Взлом симметриичных шифров (но с оговорками).
• Оптимизация, машинное обучение и даже игры!

---

4. Жизнь после квантового скачка

Квантовые алгоритмы — это не замена классическим, а дополнение. Они круты в задачах, где классические методы терпят крах:

• Факторизация (Shor).
• Поиск (Grover).
• Моделирование молекул (для медицины!).
• Оптимизация логистики и финансов.

Но важно помнить:

• Квантовые компьютеры пока шумные и ненадежные.
• Большинство задач по-прежнему решаются классически.
• Миру нужны программисты, которые умеют думать “квантово”.

---

Если ваш API внезапно перестал отвечать, а серверы падают под потоком подозрительных запросов — это классическая картина DDoS-атаки. Такие атаки могут обрушить ваш сервис, потерять клиентов и деньги. Но не спешите паниковать: сегодня мы разберем, как защититься, и покажем конкретные инструменты с простыми примерами настройки.

---

Почему важно защищать API?

API — это «сердце» многих современных приложений. Он связывает мобильные приложения с серверами, чат-ботов с базами данных, а фронтенд с логикой бэка. Если злоумышленник заблокирует доступ к нему, вся система остановится. DDoS-атаки работают просто: боты отправляют миллионы запросов, перегружая сервер. Задача защиты — отличить «живых» пользователей от ботов и распределить нагрузку так, чтобы сервис оставался доступным.

---

Топ-5 инструментов для защиты API

Все решения можно разделить на платформы уровня облака (например, Cloudflare или AWS Shield) и локальные инструменты (Nginx, Fail2Ban). Вот пять вариантов, которые покроют разные сценарии использования:

1. Cloudflare — «Щит» для любого сайта

Плюсы: Простота настройки, защита от DDoS и ботов, бесплатный тариф.
Минусы: Меньше контроля над трафиком, чем у AWS или Azure.
Как настроить:

• Зарегистрируйте аккаунт на cloudflare.com.
• Перенесите DNS-записи вашего домена в Cloudflare.
• Включите защиту DDoS в разделе «Network».
• Настройте правила брандмауэра (Firewall) для блокировки подозрительных IP.

2. AWS Shield — Защита для масштабных проектов

Плюсы: Интеграция с другими сервисами AWS, автоматическое обнаружение атак.
Минусы: Высокая стоимость, сложность настройки для новичков.
Как настроить:

• В консоли AWS включите Shield для вашего API Gateway или ALB.
• В разделе AWS WAF создайте правила для фильтрации запросов (например, по частоте или IP).
• Настройте CloudWatch для мониторинга аномалий.

3. Azure DDoS Protection — Для интеграции с Microsoft-инфраструктурой

Плюсы: Глубокая интеграция с Azure, автоматическое масштабирование.
Минусы: Ограниченная поддержка не-Azure ресурсов.
Как настроить:

• Включите DDoS Protection в разделе «Network Security».
• Настройте политики фильтрации трафика в Azure Security Center.
• Свяжите с Application Gateway для дополнительной фильтрации.

4. Nginx — Локальный барьер против атак

Плюсы: Бесплатный, гибкая настройка, работает как обратный прокси.
Минусы: Требует ручной настройки, не подходит для тяжелых DDoS.
Как настроить:

• Установите Nginx: sudo apt install nginx.
• В конфиге /etc/nginx/nginx.conf добавьте:

  http {
      limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s;
      server {
          location /api/ {
              limit_req zone=one burst=20;
              proxy_pass http://your_backend;
          }
      }
  }
  

  Это ограничит частоту запросов к /api/ до 10 в секунду.

5. Fail2Ban — Блокировка агрессивных IP

Плюсы: Простота, работает на уровне сервера.
Минусы: Не подходит для распределенных атак с множества IP.
Как настроить:

• Установите Fail2Ban: sudo apt install fail2ban.
• Создайте файл /etc/fail2ban/jail.d/api-protection.conf:

  [api]
  enabled = true
  filter = api
  action = iptables[name=API, port=80, protocol=tcp]
  logpath = /var/log/nginx/access.log
  maxretry = 100
  bantime = 3600
  

  Это заблокирует IP, который сделает более 100 запросов в час.

---

3 ключевые практики для защиты API

Практика 1: Rate Limiting
Ограничение количества запросов от одного пользователя — самый простой способ отбить атаку. Например, разрешите не более 100 запросов в минуту на IP. Это можно настроить через Nginx, AWS WAF или библиотеки вроде express-rate-limit для Node.js:

const rateLimit = require('express-rate-limit');
const limiter = rateLimit({ windowMs: 60 * 1000, max: 100 });
app.use('/api/', limiter);

Практика 2: Используйте CDN
CDN (Content Delivery Network) распределяет трафик по серверам по всему миру. Это не только ускоряет работу API, но и поглощает часть DDoS-атак. Cloudflare, Akamai и AWS CloudFront — лучшие варианты.

Практика 3: Мониторинг и автоматическое реагирование
Настройте оповещения о скачках трафика через Prometheus + Grafana или облачные сервисы (CloudWatch, Azure Monitor). Автоматизируйте блокировку подозрительных IP через скрипты или интеграции с WAF.

---

Как выбрать подходящее решение?

• Для стартапа или малого бизнеса: Cloudflare или Nginx + Fail2Ban.
• Для крупного проекта на AWS/Azure: AWS Shield или Azure DDoS Protection.
• Для гибкости и контроля: Сочетание Nginx + WAF + ручных скриптов.

Маленький датасет — частая проблема в компьютерном зрении и других задачах машинного обучения. Модель может быстро переобучиться на ограниченных данных, теряя обобщающую способность. В этом гайде мы расскажем, как бороться с этим с помощью аугментации данных и transfer learning, а также покажем рабочие примеры на Python.

---

Проблема малых данных

Если ваш датасет содержит меньше 10 000 изображений (или аналогичный объем данных для другой задачи), стандартные архитектуры нейросетей будут переобучаться. Например, сверточная сеть VGG16 имеет 138 миллионов параметров — обучать её на 1000 изображениях бессмысленно. Решение:

1. Аугментация — искусственное увеличение датасета.
2. Transfer learning — использование предобученных моделей.

---

Метод 1: Аугментация данных

Аугментация создает новые примеры из существующих данных с помощью трансформаций. Для изображений это повороты, отражения, изменение яркости и т.д.

Пример на PyTorch

from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder

# Определяем аугментации
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(10),
    transforms.ColorJitter(brightness=0.2),
    transforms.ToTensor(),
])

# Загружаем датасет
dataset = ImageFolder(root='path/to/train', transform=transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# Теперь dataloader выдает аугментированные изображения

Пример на TensorFlow/Keras

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=10,
    width_shift_range=0.1,
    height_shift_range=0.1,
    horizontal_flip=True,
    brightness_range=(0.8, 1.2)
)

# Пример использования с моделью
model.fit(datagen.flow(x_train, y_train, batch_size=32),
          epochs=10)

Совет: Не переборщите с аугментациями! Например, для медицинских изображений повороты могут искажать важные детали.

---

Метод 2: Transfer Learning

Используем предобученные модели (например, ResNet, EfficientNet) и дообучаем их на своем датасете.

Пример на PyTorch

import torch
import torchvision.models as models

# Загружаем предобученную модель
model = models.resnet18(pretrained=True)

# Замораживаем все слои
for param in model.parameters():
    param.requires_grad = False

# Заменяем последний слой под нашу задачу
num_ftrs = model.fc.in_features
model.fc = torch.nn.Linear(num_ftrs, 2)  # 2 класса

# Обучаем только последний слой
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)

# Обучение
for epoch in range(10):
    for inputs, labels in dataloader:
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Пример на TensorFlow/Keras

from tensorflow.keras.applications import ResNet50
from tensorflow.keras import layers, Model

# Загружаем предобученную модель без верхнего слоя
base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Замораживаем базу
base_model.trainable = False

# Добавляем свои слои
x = layers.GlobalAveragePooling2D()(base_model.output)
x = layers.Dense(128, activation='relu')(x)
output = layers.Dense(1, activation='sigmoid')(x)

model = Model(base_model.input, output)

# Компилируем и обучаем
model.compile(optimizer='adam', loss='binary_crossentropy')
model.fit(train_dataset, epochs=10)

Совет: Если датасет очень мал (менее 1000 изображений), замораживайте все слои, кроме последних. Для больших датасетов можно разморозить и дообучить все слои.

---

Комбинация методов: Аугментация + Transfer Learning

Объедините оба подхода для максимального эффекта:

# PyTorch: Добавьте аугментации в преобразования
transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

# Transfer learning с аугментациями
model = models.resnet18(pretrained=True)
for param in model.parameters():
    param.requires_grad = False
model.fc = torch.nn.Linear(512, 10)  # Новый классификатор

---

Дополнительные советы

1. Регуляризация: Используйте Dropout и L2-регуляризацию.
2. Early Stopping: Прерывайте обучение при остановке роста метрики на валидации.
3. Batch Size: Уменьшайте batch size, если данные малы (например, 8–16).
4. Кросс-валидация: Используйте для оценки модели на малых данных.

---

Маленький датасет — не приговор. С помощью аугментации и transfer learning вы можете обучить качественную модель даже на 1000 изображениях. Экспериментируйте с комбинациями методов, следите за переобучением и используйте предобученные архитектуры.

Вопросы? Задавайте в комментариях на форуме!

---

Полезные ресурсы

• PyTorch Documentation
• Keras Applications
• Albumentations: Альтернатива torchvision.transforms
• Fast.ai Course: Transfer Learning

---

Готовы к экспериментам? Попробуйте применить эти методы в своих проектах!

Если вы думаете, что искусственный интеллект — это удел больших корпораций или футуристических стартапов, то давно пора переосмыслить подход. Современные LLM-модели, такие как GPT, Gemini или YandexGPT, уже сегодня доступны почти любому бизнесу. А один из самых простых и прибыльных способов их применения — создание чат-ботов для поддержки клиентов. Давайте разберёмся, как это работает на практике, и покажем реальные примеры, где автоматизация сэкономила время, нервы и бюджет.

---

Пример 1: Интернет-магазин одежды

Представьте магазин, где клиенты ежедневно спрашивают: «Когда придет заказ?», «Можно ли вернуть товар?», «Как выбрать размер?». Раньше менеджеры тратили часы на одни и те же ответы. После внедрения чат-бота 80% запросов перешли к нему. Бот мгновенно проверяет статус заказов, отправляет ссылки на инструкции по возврату и даже подбирает размеры по параметрам пользователя.

ROI-расчёт:
— Средняя зарплата оператора — 40 000 рублей в месяц.
— Бот заменил двух сотрудников, сэкономив 80 000 рублей ежемесячно.
— Уровень удовлетворённости клиентов вырос на 30% из-за скорости ответа.

---

Пример 2: Онлайн-курсы по программированию

Обучение — это постоянные вопросы: «Как сдать задание?», «Что делать, если код не запускается?», «Где найти лекцию?». Чат-бот не только отвечает на типовые вопросы, но и отправляет напоминания о дедлайнах, проверяет простые задания и предлагает подсказки. Это снизило нагрузку на преподавателей, которые теперь тратят время на сложные задачи, а не на рутину.

ROI-расчёт:
— До внедрения преподаватель тратил 10 часов в неделю на повторяющиеся вопросы.
— Теперь эти часы уходят на улучшение курсов и работу с продвинутыми студентами.
— Отказ от найма дополнительного специалиста сэкономил 50 000 рублей в месяц.

---

Пример 3: Банковский кредитный отдел

Клиенты часто интересуются условиями кредитов, процентными ставками и необходимыми документами. Чат-бот задаёт уточняющие вопросы, рассчитывает примерную сумму платежей и направляет пользователя в нужный раздел сайта. Если запрос сложный, он передаёт диалог менеджеру.

ROI-расчёт:
— Время обработки заявки сократилось с 2 часов до 10 минут.
— Количество отказов от заявок из-за недостатка информации уменьшилось на 40%.
— Банк получил дополнительный доход в размере 300 000 рублей в месяц за счёт быстрой обработки обращений.

---

Пример 4: Сервис доставки еды

Пользователи спрашивают о статусе заказа, задержках курьеров и возможностях оплаты. Бот не только отвечает, но и позволяет изменить адрес доставки, отследить машину и даже сделать повторный заказ одним кликом.

ROI-расчёт:
— Снижение нагрузки на колл-центр на 60%.
— Среднее время ответа уменьшилось с 15 минут до 1 минуты.
— Повторные заказы выросли на 20% благодаря удобству сервиса.

---

Пример 5: Медицинский центр

Пациенты записываются на приём, уточняют стоимость услуг, получают напоминания о визитах и рекомендации по подготовке к анализам. Бот также фильтрует экстренные случаи, направляя их к администратору.

ROI-расчёт:
— Сокращение времени на запись пациентов с 1 часа в день до 10 минут.
— Количество пропущенных приёмов снизилось на 25% из-за автоматических напоминаний.
— Экономия на зарплатах администраторов — 60 000 рублей в месяц.

---

Как начать?

Если вы думаете, что внедрение такого бота — это сложно и дорого, то ошибаетесь. Сегодня существуют платформы вроде Dialogflow, Rasa или готовые решения на основе API от OpenAI, которые позволяют запустить базового бота за пару дней. Затраты на настройку начинаются от 50 000 рублей, а окупаются за первые месяцы за счёт экономии на штате и роста лояльности клиентов.

Главное — начать с простых задач: соберите частые вопросы клиентов, обучите бота отвечать на них и постепенно расширяйте его возможности. Не гонитесь за идеалом сразу — даже базовой автоматизации хватит, чтобы почувствовать разницу.

Представь, что ты собрался запустить стартап, и первая задача — выбрать язык программирования. Это как решить, на каком языке говорить с компьютером, чтобы он понял твою идею и помог её реализовать. Но выбор огромен: Python, Go, Rust… А вдруг есть что-то ещё лучше? Давай разберёмся без сухих определений и с примерами из реального мира.

Сценарии использования: зачем вообще выбирать?
Предположим, ты строишь MVP для финтех-стартапа, где важна скорость разработки. Тут Python — твой лучший друг. Его синтаксис прост, как пирог, а библиотеки вроде Django или Flask позволяют за пару недель собрать рабочий прототип. А если ты пишешь высоконагруженный сервис вроде системы микроплатежей, то Go будет работать как хорошо натренированный гончар: быстро, без лишних телодвижений. А Rust? Он как надёжный танк — подойдёт, если тебе нужна безопасность памяти и производительность, например, для блокчейн-проекта. Но учти: Rust сложнее в освоении, чем Python или Go.

Скорость работы: не всегда про код
Когда говорят о скорости, чаще всего имеют в виду два вещи:

1. Как быстро приложение обрабатывает данные. Тут Rust и Go выигрывают у Python в разы. Если ты делаешь backend для приложения с миллионом пользователей, Go справится с нагрузкой лучше, чем Python, который может тормозить на многопоточных задачах.
2. Как быстро команда пишет код. Тут Python флагман — за месяц можно сделать то, что на Rust займёт два. Но если твоя цель — создать устойчивый к сбоям сервер, Rust с его гарантиями безопасности памяти сэкономит кучу времени на отладке.

Сообщество: друзья важны даже в коде
У Python самое большое сообщество. Найдёшь библиотеку под любую задачу — от анализа данных до нейросетей. Но это и ловушка: иногда решения устаревшие, а документация к ним — как инструкция к стиральной машине 1990-х. Go и Rust моложе, но их сообщества активны. Go поддерживает Google, поэтому документация и инструменты — как швейцарские часы. Rust славится своей дружелюбностью: например, книга «The Rust Programming Language» — один из самых толковых руководств для новичков.

А что остальные?
JavaScript/TypeScript тоже стоит упомянуть. Если ты делаешь full-stack приложение с кучей фронтенда, Node.js + React могут быть логичнее, чем тратить время на интеграцию Python с фронтом. А Ruby? Он уходит в историю, но Rails до сих пор крут для MVP вроде Airbnb или GitHub. Java и C# — если тебе нужны корпоративные контракты, но для стартапа это как покупать внедорожник для поездки в соседний город.

Итого:

• Бери Python, если нужен MVP за месяц, машинное обучение или ты не уверен в технической стороне.
• Выбирай Go, если важна производительность, микросервисы или ты уже знаешь, как масштабировать сервис.
• Рассмотри Rust, если проект связан с безопасностью, системным программированием или ты готов тратить время на обучение ради долгосрочной выгоды.
• Игнорируй тренды, если они не подходят твоей команде. Лучший язык — тот, с которым ты сможешь запустить продукт, а не тот, что хвалят в блогах.

Помни: никакой язык не сделает стартап успешным, но правильный выбор сэкономит нервы и время. А теперь иди пиши код — мир ждёт твою идею!

Вот подробная инструкция по настройке домена через Nginx с двумя вариантами:

---

Общие шаги для обоих вариантов

Установите Nginx

sudo apt update
sudo apt install nginx

Проверьте работу Nginx
Откройте браузер и перейдите по адресу http://ваш_домен. Должна отобразиться стандартная страница Nginx.

Создайте папку для сайта
Если вы используете статический контент:

sudo mkdir -p /var/www/ваш_домен/html
sudo chown -R $USER:$USER /var/www/ваш_домен/html
sudo chmod -R 755 /var/www

---

Вариант 1: Прямой доступ к файлам (статический сайт)

Создайте конфиг

sudo nano /etc/nginx/sites-available/ваш_домен.conf

Вставьте конфиг:

server {
    listen 80;
    server_name ваш_домен www.ваш_домен;

    location / {
        root /var/www/ваш_домен/html;
        index index.html index.htm;
        try_files $uri $uri/ =404;
    }

    # Логи
    access_log /var/log/nginx/ваш_домен.access.log;
    error_log /var/log/nginx/ваш_домен.error.log;
}

Активируйте конфиг

sudo ln -s /etc/nginx/sites-available/ваш_домен.conf /etc/nginx/sites-enabled/
sudo nginx -t  # Проверка синтаксиса
sudo systemctl reload nginx

Добавьте тестовый файл

echo "Hello, World!" | sudo tee /var/www/ваш_домен/html/index.html

---

Вариант 2: Проксирование на Node.js через PM2

Запустите Node.js приложение через PM2

cd /путь/к/вашему_приложению
pm2 start app.js --name "ваше_приложение" -- --port 3000

Создайте конфиг Nginx

sudo nano /etc/nginx/sites-available/ваш_домен.conf

Вставьте конфиг:

server {
    listen 80;
    server_name ваш_домен www.ваш_домен;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Поддержка WebSocket
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    # Логи
    access_log /var/log/nginx/ваш_домен.access.log;
    error_log /var/log/nginx/ваш_домен.error.log;
}

Активируйте конфиг

sudo ln -s /etc/nginx/sites-available/ваш_домен.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

---

Добавьте SSL-сертификат (Let’s Encrypt)

Установите Certbot

sudo apt install certbot python3-certbot-nginx

Получите сертификат

sudo certbot --nginx -d ваш_домен -d www.ваш_домен

Настройте автопродление

sudo crontab -e

Добавьте:

0 0,12 * * * root certbot renew --quiet && systemctl reload nginx

---

Проверьте работу##

1. Откройте браузер и перейдите по адресу https://ваш_домен.
2. Убедитесь, что сайт работает через HTTPS.
3. Проверьте логи:

tail -f /var/log/nginx/ваш_домен.error.log

---

Частые ошибки и решения

Ошибка	Решение
Port 80 failed to respond	Убедитесь, что Nginx запущен: sudo systemctl status nginx
Could not open file /var/www/...	Проверьте права на папку: ls -l /var/www
Connection refused	Убедитесь, что Node.js приложение запущено: pm2 list
Certbot failed to authenticate	Проверьте DNS-записи вашего домена

---

Дополнительно

Настройка автозапуска PM2

pm2 save
pm2 startup

Резервное копирование
Создайте резервную копию конфига Nginx:

sudo cp /etc/nginx/sites-available/ваш_домен.conf ~/ваш_домен.conf.bak

---

Теперь ваш домен настроен через Nginx с поддержкой HTTPS. Выберите подходящий вариант в зависимости от ваших задач:

• Статический сайт → Вариант 1
• Node.js приложение → Вариант 2

Node.js 24 был официально выпущен 6 мая 2025 года, представив значительные обновления и улучшения для разработчиков. Ниже приведены ключевые новшества и их особенности.

Основные изменения

• Обновление движка V8 до версии 13.6
  Node.js 24 использует обновлённый движок V8 версии 13.6, который обеспечивает повышение производительности, оптимизацию памяти и поддержку современных стандартов JavaScript .
• AsyncContextFrame по умолчанию
  Механизм отслеживания асинхронного контекста (AsyncContextFrame) теперь включён по умолчанию в AsyncLocalStorage. Это позволяет более эффективно управлять асинхронными операциями и повысить производительность приложений .
• Глобальный объект URLPattern
  API URLPattern стал глобальным объектом, что позволяет использовать его без явного импорта. Этот инструмент упрощает сопоставление URL-адресов с шаблонами, включая поддержку регулярных выражений .
• Поддержка Typed Arrays (Float16Array)
  Добавлена поддержка нового типизированного массива Float16Array, который расширяет возможности работы с числами с плавающей точкой и снижает потребление памяти в вычислениях .
• Ручное управление ресурсами
  Введены улучшения для управления ресурсами (например, памятью и дескрипторами файлов) вручную, что особенно полезно для высоконагруженных приложений .
• Обновление npm до версии 11
  В состав Node.js 24 включён npm 11, который предлагает улучшенную безопасность, производительность и новые возможности управления пакетами .
• Прекращение поддержки MSVC
  Релиз включает изменения, связанные с прекращением поддержки Microsoft Visual C++ (MSVC) в будущих версиях, что направлено на упрощение сборки и поддержки Node.js .

Производительность

С обновлением до V8 13.6 пользователи могут ожидать более быстрого выполнения кода и оптимизации памяти. Например, новые API позволяют детально анализировать время выполнения асинхронных операций:

const { performance } = require('perf_hooks');

async function measurePerformance() {
    const start = performance.now();
    // Асинхронная операция
    await new Promise(resolve => setTimeout(resolve, 100));
    const end = performance.now();
    console.log(`Время выполнения: ${end - start} мс`);
}

measurePerformance();
    

Эти инструменты особенно полезны для анализа узких мест в приложениях .

Тесты производительности

Ниже приведены примеры улучшений производительности в Node.js 24 по сравнению с предыдущей версией:

Тест	Node.js 22 (мс)	Node.js 24 (мс)	Улучшение (%)
Запуск простого скрипта	120	95	20.8%
Обработка 10 000 асинхронных операций	450	330	26.7%
Память при обработке JSON	50 МБ	38 МБ	24.0%

Для хранения и анализа метрик производительности рекомендуется использовать структурированные таблицы, аналогичные описанным в базах данных.

План выпуска

Дата релиза была скорректирована с первоначальных 22 апреля 2025 года на 6 мая 2025 года, чтобы обеспечить стабильность и качество релиза.

Заключение

Node.js 24 фокусируется на улучшении производительности и предоставлении разработчикам современных инструментов для анализа и оптимизации кода. Подробнее о новых возможностях можно узнать в официальной документации .

Знаете ли вы, что кнопку отправки формы можно размещать вне самой формы?

В большинстве случаев мы размещаем кнопку отправки внутри формы, и так правильно. Но иногда — из-за особенностей вёрстки или по другим причинам — логичнее вынести кнопку отправки за пределы тега <form>.

Мы можем легко связать кнопку с формой, используя атрибуты form и id.

Таким же способом, при необходимости, можно ассоциировать с формой и другие элементы управления, такие как textarea, checkbox и т.п.

Unsplash

Dreamstime

---

Freepik

---

Loon

RuPixel

---

ImageFree

---

Kaboompics

---

Reshot

---

FoodiesFeed

Flickr

Бывают такие случаи когда можно запороть ТВ параметр с значениями по умолчанию, по этому возможно следующий скрипт вам поможет:

<?php
$categoryId = 123; // ID категории
$tvName = 'my_custom_tv'; // Код TV
$newValue = 'Новое значение';

$criteria = [
    'class_key' => 'modResource',
    'parent' => $categoryId
];

$count = 0;
foreach ($modx->getIterator('modResource', $criteria) as $resource) {
    $resource->setTVValue($tvName, $newValue);
    if ($resource->save()) {
        $count++;
    }
}

echo "Обновлено TV-параметров: {$count}";
?>

Небольшой скрипт который меняет шаблон товаров в конкретной категории

<?php
// ID категории, в которой нужно изменить шаблон товаров
$categoryId = 22250; 

// Новый ID шаблона, который нужно установить
$newTemplateId = 45; 

// Проверяем существование шаблона
$template = $modx->getObject('modTemplate', $newTemplateId);
if (!$template) {
    echo "Ошибка: Шаблон с ID {$newTemplateId} не найден!";
    return;
}

$count = 0;
$criteria = array(
    'class_key' => 'msProduct',
    'parent' => $categoryId
);

// Перебираем товары в указанной категории
foreach ($modx->getIterator('modResource', $criteria) as $product) {
    // Изменяем шаблон
    $product->set('template', $newTemplateId);
    
    if ($product->save()) {
        $count++;
    } else {
        echo "Ошибка при сохранении товара ID {$product->id}<br>";
    }
}

echo "Успешно изменено шаблонов у {$count} товаров.";
?>

$bindable — это специальная директива в Svelte 5+, которая позволяет помечать переменные как двухсторонне связуемые (bindable) в рамках компонента. Это означает, что вы можете использовать bind: на кастомных компонентах так же, как вы используете его, например, на нативном элементе <input bind:value>

Ранее для этого требовалось писать отдельный механизм обработки событий (dispatch) и передачи значений обратно, но теперь всё это можно сделать с минимальным кодом благодаря $bindable.

Как работает $bindable

Когда вы пишете:

let count = $bindable(0);

Вы создаёте реактивное свойство, которое:

• Реактивно обновляется при изменении локально.
• Автоматически генерирует событие change при изменении значения.
• Позволяет использовать bind: в родительском компоненте без дополнительного кода.

Под капотом $bindable оборачивает значение в реактивную ссылку и подписывается на изменения, чтобы оповещать внешний мир через dispatch(‘change’, …). Таким образом, вы получаете прозрачный механизм двусторонней связи между компонентами.

Сравнение с другими фреймворками

В современных фреймворках для работы с состоянием между компонентами используются разные подходы. В Svelte 5+ появился инструмент $bindable, который упрощает создание двусторонних привязок. В Vue для этого традиционно используют v-model и события, а в React — пропсы и колбэк-функции. Рассмотрим, как эти механизмы работают, их сходства и различия.

Двухсторонняя привязка: $bindable (Svelte), v-model (Vue), props + callbacks (React)

Svelte: $bindable

<!-- Counter.svelte -->
<script>
  let count = $bindable(0);
</script>

<button on:click={() => count += 1}>Увеличить</button>

<!-- Родительский компонент -->
<Counter bind:count={myCount} />

• $bindable автоматически генерирует событие change при изменении значения.
• Родитель может использовать bind:propName для синхронизации.

Vue: v-model и события

<!-- Counter.vue -->
<template>
  <button @click="increment">Увеличить</button>
</template>

<script setup>
import { ref } from 'vue';
const props = defineProps(['modelValue']);
const emit = defineEmits(['update:modelValue']);

function increment() {
  emit('update:modelValue', props.modelValue + 1);
}
</script>

<!-- Родительский компонент -->
<Counter v-model="count" />

• v-model использует modelValue как пропс и update:modelValue как событие.
• Требуется явно определять пропсы и эмитить события.

React: Пропсы и колбэк-функции

// Counter.jsx
function Counter({ count, onCountChange }) {
  return (
    <button onClick={() => onCountChange(count + 1)}>
      Увеличить
    </button>
  );
}

// Родительский компонент
const [count, setCount] = useState(0);
<Counter count={count} onCountChange={setCount} />

• React не имеет встроенной двусторонней привязки.
• Состояние обновляется через передачу функции onCountChange.

Реактивность и удобство

Svelte: Реактивность по умолчанию

• $bindable использует реактивную систему Svelte, где изменения переменной автоматически обновляют интерфейс.
• Минимум кода: let count = $bindable(0);

Vue: Явная реактивность

• Реактивность через ref, reactive, watch.
• Для v-model требуется передавать modelValue и эмитить события вручную.

React: Управление состоянием вручную

• Реактивность достигается через useState и useEffect.
• Для синхронизации нужно передавать состояние и функцию его обновления.

Фреймворк	Метод	Описание
Svelte	$bindable	Автоматически генерирует событие change при изменении значения. Реактивность встроена - Минимальный код - Автоматическая реактивность - Доступен только в Svelte 5+ - Ограниченная поддержка сложных типов (объекты, массивы)
Vue	v-model+ события	Использует props и emit для синхронизации. Требуется явное определение. - Ясный API через v-model - Хорошо документирован - Требуется вручную управлять событиями и пропсами - Более многословный код
React	Пропсы и колбэки	Полностью ручная реализация. Состояние обновляется через вызов функций. - Полный контроль над состоянием - Подходит для сложных приложений - Нет встроенной двусторонней привязки - Требует больше кода для простых задач

Всем привет!
Щас расскажу, как за пару кликов сделать своего первого бота в Телеграме.
Будем писать на Python, использовать VS Code и пару библиотек.
В итоге получится бот, который отвечает Привет! на команду /start.
Всё остальное — уже ваша фантазия))

---

Что нужно установить?

1. Python

Если у вас его ещё нет — идём сюда:
https://www.python.org/downloads/
Выбираем версию 3.10+ (не 2.7, это прошлый век).

Проверяем в терминале:

python3 --version  # Должно выдать 3.10+ 

2. VS Code

Скачиваем:
https://code.visualstudio.com/
Устанавливаем, открываем.

3. Библиотека python-telegram-bot

В терминале пишем:

pip install python-telegram-bot

---

Шаг 1: Создаём бота через @BotFather

1. Открываем Телеграм.
2. Пишем @BotFather.
3. Жмём /newbot.
4. Придумываем имя (например, MyAwesomeBot).
5. Получаем токен — это секретный ключ, который даёт доступ к вашему боту.
   Пример токена: 1234567890:ABCdefGHIjklMNOpqrSTUvwxYZ

ВАЖНО: Токен никому не показываем. Или покажите — и потом будете плакать

---

🧑‍ Шаг 2: Пишем код бота

1. В VS Code создаём файл, например, bot.py.
2. Копируем этот код:

from telegram.ext import ApplicationBuilder, CommandHandler
import asyncio

# === Обработчик команды /start ===
async def start(update, context):
    await update.message.reply_text("Привет!")

# === Запуск бота ===
async def main():
    # Вставьте ваш токен из BotFather
    app = ApplicationBuilder().token("YOUR_BOT_TOKEN").build()
    
    # Регистрируем команду /start
    app.add_handler(CommandHandler("start", start))
    
    # Запуск бота
    await app.run_polling()

# === Точка входа ===
if __name__ == '__main__':
    asyncio.run(main())

Что тут происходит?

• start — функция, которая отвечает на /start.
• ApplicationBuilder — создаёт бота с вашим токеном.
• CommandHandler — связывает команду /start с функцией.
• run_polling() — бот начинает слушать сообщения.

---

Шаг 3: Запускаем бота

1. В терминале пишем:

   python3 bot.py
   

2. Если всё нормально — бот запустится и будет ждать команд.
3. Идём в Телеграм, пишем своему боту /start.
4. Получаем ответ: Привет!

---

Возможные ошибки

• Ошибка токена? — Проверьте, правильно ли вставили.
• Ошибка импорта? — Убедитесь, что установили python-telegram-bot.
• Бот не отвечает? — Проверьте интернет и попробуйте перезапустить скрипт.

---

Что дальше?

Теперь вы можете:

• Добавить команду /help.
• Научить бота отвечать на любые сообщения.
• Сделать кнопки и меню.
• Связать с другими API (например, погода, курсы валют).

В общем экспериментируйте как вашей душе угодно!

---

P.S.
Это самый базовый пример. В реальности ботов можно делать сложнее, но сначала — научитесь не падать с /start

P.P.S. Если что-то сломалось — пишите, помогу собрать обратно))

Дело было вечером, делать было нечего. Сидел, играл в Oblivion Remastered, и в голову ударила мысль:
«А можно ли сделать бота, который скачивает ВК-клипы удаляет водный знак VK Clips и сразу отправляет их в Телеграм?»

Ответ: да, можно. И даже проще, чем я думал.

Ссылка на бота - https://t.me/vkclipssavebot

---

️ Что использовал?

• Python (хотел JS, но захотелось чего-то новенького)
• yt-dlp (скачивание видео)
• python-telegram-bot (общение с Телеграмом)
• dotenv (хранение токена)
• nest_asyncio (чтобы асинхронность не сломалась)

---

Пример кода: команда /start

Вот как выглядит простейший обработчик команды /start:

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "Привет! Отправь ссылку на ВК-клип, и я скачу его для тебя 🎬"
    )

Что делает этот код?

• Когда пользователь пишет /start — бот отвечает приветственным сообщением.
• Всё. Никаких секретов.

---

Запуск бота

А вот как запускается сам бот:

async def main():
    app = ApplicationBuilder().token("YOUR_BOT_TOKEN").build()
    app.add_handler(CommandHandler("start", start))
    await app.run_polling()

Главное:

• Укажите токен из @BotFather.
• Добавьте обработчики команд.
• Запустите через asyncio.run(main()).

---

Обработка ссылок

Если бот получает ссылку на ВК-клип, он:

1. Показывает кнопки с выбором разрешения (360p, 480p, 720p).
2. Скачивает видео через yt-dlp.
3. Проверяет размер (лимит Телеграма — 50 МБ для обычных ботов).
4. Отправляет видео обратно пользователю.

Пример кода для кнопок:

keyboard = [
    [InlineKeyboardButton(f"{res}p", callback_data=f"res_{res}") for res in ["360", "480", "720"]]
]
await update.message.reply_text("Выберите разрешение:", reply_markup=InlineKeyboardMarkup(keyboard))

---

🧵 Асинхронность и многопользовательность

Бот умеет работать с несколькими пользователями одновременно. Для этого я использовал Semaphore:

semaphore = asyncio.Semaphore(5)  # До 5 загрузок одновременно

async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    async with semaphore:
        # Логика загрузки и отправки видео

Зачем это нужно?
Чтобы бот не зависал, когда несколько человек лезут к нему с запросами.

---

Что дальше?

• Хочу обойти лимит Телеграма на 50 МБ (есть идеи, но это потом).
• Добавить поддержку других платформ (например, YouTube Shorts).
• Научить бота удалять водяные знаки (пока не разобрался, но над этим работаю).

---

Попробуйте сами!

Если кому-то интересно — пишите, поделюсь лайфхаками. А пока:
https://t.me/vkclipssavebot — качает ВК-клипы, пока ты играешь в Oblivion

---

P.S. Код не покажу — секрет фирмы Но если хотите повторить — начните с python-telegram-bot и yt-dlp. Всё работает))

Х*Я!!!

Valve снизили курс доллара в своих играх — теперь 1 доллар = 81 рубль (ранее было 96 рублей).

В первую очередь это коснулось Dota 2 и CS2:

Аркана — 2850 рублей (было 3400);
Dota+ — 325 рублей (было 385);
Сундуки — 245 рублей (было 290);
Ключи в CS2 — 204 рубля;
Пропуск «Арсенал» — 1300 рублей.

Ну что дотеры? Покупаем аркану?

Как перезагружать страницу с помощью JavaScript. Это пригодится для обновления контента, сброса формы или перезапуска приложения. Поехали!

---

1. Базовый метод: location.reload()

Самый простой способ — вызвать метод reload() объекта location:

// Перезагружает страницу с кеша  
location.reload();  

// Перезагружает страницу, игнорируя кеш (как Ctrl+F5)  
location.reload(true);  // Устаревший параметр, но работает в старых браузерах  

Где использовать:

• Кнопка «Обновить данные».
• После отправки формы для сброса состояния.

---

2. Перезагрузка через location.href

Можно перезаписать текущий URL, что также вызовет обновление:

// Перезагружает страницу, как при переходе по ссылке  
location.href = location.href;  

Плюсы: Работает даже если reload() заблокирован расширениями.

---

3. Автоматическая перезагрузка через setInterval

Чтобы страница обновлялась каждые N секунд:

// Обновление каждые 5 секунд  
setInterval(() => {  
    location.reload();  
}, 5000);  

Важно: Добавьте уведомление для пользователя, чтобы он не потерял введенные данные.

---

4. Перезагрузка при изменении хэша (#)

Если нужно обновить страницу при смене якоря:

window.addEventListener('hashchange', () => {  
    location.reload();  
});  

Пример: Перезагрузка при переходе с site.com#step1 на site.com#step2.

---

5. Принудительная перезагрузка с очисткой кеша

Чтобы избежать кеширования (например, после обновления стилей):

// Для современных браузеров  
location.reload(true);  

// Альтернатива через timestamp  
location.href = location.origin + location.pathname + '?v=' + Date.now();  

---

Как предотвратить случайную перезагрузку

Если пользователь пытается закрыть/перезагрузить страницу с несохраненными данными:

window.addEventListener('beforeunload', (e) => {  
    if (isDataChanged) {  
        e.preventDefault();  
        e.returnValue = 'У вас есть несохраненные изменения. Выйти?';  
    }  
});  

• location.reload() — универсальное решение.
• location.href — для обхода блокировок.
• beforeunload — защита от потери данных.