Explore Courses

Intermediate

AI Loop Development: Building Reliable Agentic Systems

A practical, engineering-first course on **AI loop development** — the discipline of building systems where a language model repeatedly plans, acts through tools, observes results, and decides what to do next. You will learn the anatomy of the agentic loop, tool-calling mechanics, context and state management, guardrails and error recovery, evaluation and observability, multi-agent orchestration, and what it takes to run loops in production. Every lesson includes worked code examples, a checklist, and a self-check quiz. The final lesson is a glossary of the field's core terminology. **Audience:** developers who have called an LLM API at least once and want to move from single prompts to autonomous, multi-step systems. Examples use Python-style pseudocode that maps directly onto any modern LLM SDK.

ai agents

Intermediate

Разработка AI-циклов: надёжные агентные системы

Практический инженерный курс по **разработке AI-циклов** — дисциплине построения систем, в которых языковая модель многократно планирует, действует через инструменты, наблюдает результаты и решает, что делать дальше. Вы изучите анатомию агентного цикла, механику вызова инструментов, управление контекстом и состоянием, ограничители и восстановление после ошибок, оценку и наблюдаемость, оркестрацию мультиагентных систем и требования продакшена. Каждый урок содержит разобранные примеры кода, чек-лист и тест для самопроверки. Завершающий урок — глоссарий ключевой терминологии. **Аудитория:** разработчики, которые хотя бы раз вызывали LLM API и хотят перейти от одиночных промптов к автономным многошаговым системам. Примеры написаны на Python-псевдокоде, который напрямую переносится на любой современный LLM SDK.

ai agents

Intermediate

System Design for Web Developers

A practical system design course for experienced web developers (mid-level+). You already ship features; this course teaches you to reason about what happens when your app meets real traffic: scaling, load balancing, caching, database replication and sharding, consistency trade-offs, message queues, API styles, service decomposition, CDNs, and production reliability. The capstone walks through a full interview-style design of a URL shortener, from capacity estimation to failure modes. Every lesson pairs theory with concrete numbers, code-level examples, architecture diagrams, a checklist, and a self-check quiz.

system-design architecture

Intermediate

System Design для веб-разработчиков

Практический курс по проектированию систем для опытных веб-разработчиков (уровень mid+). Вы уже умеете выпускать фичи; этот курс учит рассуждать о том, что происходит, когда приложение встречается с реальным трафиком: масштабирование, балансировка нагрузки, кэширование, репликация и шардирование баз данных, компромиссы согласованности, очереди сообщений, стили API, декомпозиция сервисов, CDN и надёжность в продакшене. Финальный урок проходит полный «собеседовательный» дизайн URL-шортенера — от оценки нагрузки до режимов отказа. Каждый урок сочетает теорию с конкретными числами, примерами на уровне кода, архитектурными диаграммами, чек-листом и вопросами для самопроверки.

system-design architecture

Beginner

Создай профессиональный курс на Oceanowledge

Полный практический курс по проектированию, написанию и упаковке профессионального курса для Oceanowledge. Он начинается с анализа аудитории и результата обучения, затем проводит автора через структуру программы, создание уроков, примеров, чек-листов, тестов и визуальных материалов. Отдельные уроки посвящены качеству объяснений, последовательности сложности, двуязычной адаптации, проверке Markdown и сборке ZIP-пакета. Итогом становится готовый курс, который соответствует формату платформы и может быть импортирован, проверен и опубликован без ручной перестройки.

oceanowledge создание курсов

Beginner

Thai Cuisine: A Complete 14-Day Course

A complete fourteen-day course in Thai cooking, moving from essential ingredients and flavor balance to curries, soups, noodles, salads, rice dishes, sauces, and desserts. The lessons explain not only recipes but the logic of Thai cooking: ingredient order, aromatic foundations, texture, and final flavor adjustment. Designed for a home kitchen, the course includes practical substitutions for ingredients that may be difficult to find. By the end, learners can plan a Thai menu, adjust heat levels, and prepare a range of dishes while preserving their characteristic balance of flavors.

thai cuisine cooking

Intermediate

Cloud, DevOps, and Kubernetes in Practice

A practical course on cloud, DevOps, and Kubernetes — from culture and containers to production operation of clusters. Aimed at a developer or engineer who wants to confidently deploy and operate services in a cloud-native environment: to understand containers, orchestration, configuration, storage, networking, observability, CI/CD, GitOps, infrastructure as code, and security. The course is built around the **declarative model**: you describe the desired state of the system, and the platform brings reality to it and holds it there. This is the through-line of all modern DevOps — from Kubernetes manifests to Terraform and GitOps. Once you master it, you stop "clicking buttons by hand" and start managing infrastructure as code: versioned, reproducible, reviewable. Topics build up: DevOps and cloud foundations, containers and Docker, Kubernetes architecture, workloads (Pod/Deployment/StatefulSet), networking and Service/Ingress, configuration and secrets, storage and state, packaging (Helm/Kustomize), observability, CI/CD and GitOps, infrastructure as code and security, production and scaling. Examples are given as of mid-2026 (Kubernetes 1.3x, ArgoCD/Flux, OpenTelemetry) — the principles matter more than the specific versions, which update constantly. Each lesson contains theory, examples (YAML manifests and `kubectl`/CLI commands), a checklist of practical tasks, and a quiz. It's convenient to practice on a local cluster (kind/minikube/k3s) or in a managed cloud. The main principle: infrastructure is code. Anything done "by hand" and not written down is technical debt and a source of drift between environments.

devops kubernetes

Intermediate

Data Science in Practice

A practical data science course — from the workflow and data preparation to machine learning and putting results into the real world. Aimed at a developer or analyst who wants to learn to extract value from data: to load and clean it, explore it, visualize it, build and evaluate models, and understand where data science ends and engineering begins. Basic Python is enough (the collection has a separate Python course); the whole stack is Python. The main principle of the course: **80% of a data scientist's work is the data, not the models.** Beautiful algorithms are useless on dirty data; "garbage in, garbage out." So the emphasis is on preparation, cleaning, exploration, and honest evaluation. The second through-line is **skepticism and rigor**: correlation isn't causation, a good metric on the training set means nothing, and a model that "works" in a notebook can fail in production because of data leakage. Data science is the discipline of drawing careful conclusions from noisy reality. Topics build up: the workflow and tooling, NumPy, pandas, data cleaning, transformation and aggregation, exploratory analysis and visualization, statistics, an introduction to machine learning, scikit-learn, model evaluation and working with features, and putting things into production. The 2026 stack: the core (NumPy, pandas, matplotlib/seaborn, scikit-learn, Jupyter) plus modern tools (Polars, DuckDB) — but the principles matter more than the specific libraries. Each lesson contains theory, code examples (Python), a checklist of practical tasks, and a quiz. It's convenient to practice in Jupyter/a notebook on real datasets. This course is the foundation of applied analysis; for the depth of machine learning proper and modern AI, see the ML/AI course, and for LLM applications, see the LLM course.

data-science python

Intermediate

ML, AI, and Agentic Development: From Foundations to Tools

A course about **how machine learning, deep learning, and modern AI actually work** — and how to build agentic systems on that foundation. Aimed at a developer who wants not just to "call an API" but to understand the engine under the hood: how models learn, what neural networks and transformers are, where large language models came from, and how to assemble an agent from a model that acts in the world through tools. The course deliberately **complements** two others in the collection. The Data Science course provides applied classical ML (pandas, scikit-learn, evaluation) — here we go deeper into the *principles*: optimization, neural networks, deep learning. The LLM course teaches you to *build applications* on top of ready-made models (prompting, RAG, API) — here we explain *why* those models work and rise to the engineering of agents as a discipline. Together, the three courses give the full picture: apply, understand, build. Two parts. **Foundation (lessons 1–7)**: the map of AI/ML/DL, how models learn (optimization), learning paradigms, neural networks, deep learning architectures, transformers and LLMs, foundation models and generative AI. **Agents and engineering (lessons 8–12)**: what an agent is, tools and the MCP protocol, patterns and frameworks for agentic systems, evaluation and safety, production. The tooling landscape is given as of mid-2026 (MCP, LangGraph, agent orchestration) — but the principles matter more than the specific libraries, which change monthly. Each lesson contains theory, examples (diagrams, pseudocode, Python), a checklist, and a quiz. The through-line: modern AI isn't magic but an understandable engineering tower of ideas, each of which can be mastered. Understanding the foundation distinguishes someone who deliberately builds reliable systems from someone who copies other people's code and hopes it works.

machine-learning ai

Intermediate

LLM: From Basics to Practical Use

A practical course on large language models (LLMs) — from how they're built to assembling real applications. Aimed at a developer who wants not to "play with a chatbot" but to deliberately embed LLMs into products: to understand what a model can and fundamentally cannot do, write reliable prompts, work with APIs, build embedding-based search and RAG, connect tools and agents, evaluate quality, and ship it all to production. The course is not about the mathematics of transformers or about training models from scratch — it's about engineering on top of ready-made models. Being able to program is enough; the examples are in Python (the lingua franca of the LLM ecosystem), but all communication with models goes over HTTP, so the approach applies on any stack. The key principle running through the whole course: **LLMs are non-deterministic and don't know the truth — they predict plausible text.** So engineering around them isn't "asking the model" but building a system: give it the right context, constrain the format, check the output, measure quality, and defend against failures and abuse. The model is a powerful but unreliable component; the engineer's job is to make the system reliable around an unreliable component. Pace 1–2 hours a day. Each lesson contains theory, code examples, a checklist of practical tasks, and a quiz. The model landscape changes monthly, so specific names and prices are given as an illustration as of mid-2026 — the principles of choosing matter more than the current benchmark champion.

llm ai

Intermediate

Python in Practice

A practical Python course for an experienced developer (mid-level+) who wants to confidently write server-side code, scripts, CLI tools, and work with data. Pace: 1-2 hours a day, ~3 weeks. Python is a dynamic, expressive language with a "explicit is better than implicit" philosophy and one of the richest ecosystems around. Key features: significant whitespace, comprehensions, generators and iterators, context managers, type hints, async/await, and one of the widest library ecosystems in the world. Each lesson includes theory with visual diagrams, code examples, a checklist, and a quiz.

python backend

Advanced

Phoenix: Production SaaS on Elixir

A practical Phoenix course for building secure, modern SaaS services. A continuation of the Elixir course — solid command of the language is assumed (immutability, pattern matching, processes, OTP, GenServer/Supervisor). Targeted at Phoenix 1.8 (scopes, magic links, updated security headers, LiveView 1.1). The course is built around what you actually need to ship a SaaS to production: layered architecture (thin web, thick contexts), Ecto (schemas, changesets, queries, transactions), authentication and authorization with scopes, multi-tenancy, LiveView for interactive UI, full testing (ExUnit, LiveViewTest, Mox, factories, E2E), background jobs with Oban, security (OWASP, Sobelow, MixAudit, CSP, encryption), and production operations (releases, config, observability, deployment). As in the series' language courses, parallels are drawn for a developer from the Rails world: Phoenix ≈ Rails (but functional and explicit), Ecto ≈ ActiveRecord (but without magic, changesets explicit), contexts ≈ service objects, LiveView ≈ Hotwire/Turbo (but on the server, over WebSocket), Oban ≈ Sidekiq (but in PostgreSQL, transactional), ExUnit ≈ RSpec/Minitest. Pace 1–2 hours a day, roughly 3–4 weeks. Each lesson contains theory, Phoenix 1.8 code examples, a checklist of practical tasks, and a quiz. The main 1.8 principle: security by default — scopes make data isolation the default, not something you have to remember to add later.

phoenix elixir

Intermediate

Ecto: From Zero to Advanced

A complete Ecto course — from your first query to advanced techniques. Ecto is not an ORM but a tandem of a data mapper and a query language: explicit, composable, without magic. Knowledge of Elixir is assumed (pattern matching, pipe, structs). Ecto is used in Phoenix, but it's a standalone library and works without it — the course accounts for that. Examples are on PostgreSQL (the ecosystem's main database), but most applies to MySQL/SQLite. The course covers Ecto's four pillars — Repo (database access), Schema (table mapping), Changeset (data validation and transformation), Query (a composable query DSL) — and moves from basics to advanced: associations and the fight against N+1, complex queries (joins, subqueries, window functions, CTEs, dynamic queries), transactions via Ecto.Multi, embedded and schemaless changesets, upserts and bulk operations, multi-tenancy via prefixes, custom types, plus testing, performance, and safe migrations in production. For a developer from Rails, parallels are drawn: Ecto ≈ ActiveRecord, but without magic and with explicit changesets; `Repo` ≈ what's spread across models in AR; migrations are similar, but fully reversible. The key difference from AR — Ecto separates data (schema), its modification (changeset), and access (Repo), rather than mixing everything into an "active record." Pace 1–2 hours a day. Each lesson contains theory, code examples, a checklist of tasks, and a quiz. The main principle: Ecto makes database work explicit — you always see what SQL will run, which fields are accepted from input, and when a database access happens.

ecto elixir

Intermediate

Elixir in Practice

A practical Elixir course for an experienced developer (mid-level+) who wants to master a functional language on the BEAM VM with fault-tolerant concurrency. Pace: 1–2 hours a day, ~3 weeks. Elixir is a functional language on the BEAM virtual machine (the Erlang VM), built for telecommunications. Main advantages: millions of lightweight processes with isolated GC, hot code upgrades, the "let it crash" philosophy, and OTP — fault-tolerance patterns proven over decades. Elixir adds to BEAM's power a modern syntax, a macro system, and an ecosystem (Phoenix, Ecto, LiveView). Topics build up: Mix and syntax basics, pattern matching and immutability, collections, functions and the pipe operator, Enum/Stream and error handling, processes and the actor model, OTP (GenServer, Supervisor), protocols and tests, Phoenix and the ecosystem. Each lesson contains theory with visual diagrams, code examples, a checklist, and a quiz. The main principle: Elixir's strength isn't its syntax but immutability, processes, and OTP.

elixir beam

Intermediate

Rust in Practice

A practical Rust course for an experienced developer (mid-level+) who wants to master a systems language with memory-safety guarantees without a garbage collector. Pace: 1–2 hours a day, ~3 weeks. Rust occupies the C/C++ niche but offers compile-time safety: the ownership system and borrow checker eliminate use-after-free, data races, and memory leaks before the program even runs. The philosophy: zero-cost abstractions — high-level code compiles into code as efficient as hand-written low-level. Topics build up: Cargo and syntax basics, ownership and borrowing, structs and enums (algebraic types), error handling (Result/Option), collections and a mini-project, traits and generics, iterators and modules, concurrency and a final project, async and the ecosystem. Each lesson contains theory with visual diagrams, code examples, a checklist, and a quiz. The main principle: the compiler is your ally, not your adversary. Every compile error is a bug that won't exist in production.

rust systems

Intermediate

Go in Practice

A practical Go course for an experienced developer (mid-level+) who wants to confidently write server code, CLI tools, and concurrent services in Go. Pace: 1–2 hours a day, ~3 weeks. Go was designed at Google for large server systems: simplicity, readability, fast compilation into static binaries, powerful concurrency (goroutines and channels). The language is deliberately minimal — fewer features, but each one thought through; one obvious way to do things. This makes Go ideal for backends, microservices, and infrastructure tools (Docker, Kubernetes, Terraform are written in Go). Topics build up: the toolchain and syntax basics, the type system (pointers, structs, slices, maps), methods and interfaces (duck typing), error handling as values, a mini-project, concurrency (goroutines, channels, select), the standard library and HTTP servers, testing and a final project, the ecosystem and next steps. Each lesson contains theory with visual diagrams (PNG diagrams and mermaid), code examples, a checklist of practical tasks, and a quiz. Go's main principle: simplicity over cleverness — if code can't be understood in 30 seconds, rewrite it simpler.

go golang

Intermediate

TypeScript in Practice

A practical TypeScript course — from "why types at all" to the advanced type system and production setup. Aimed at a developer who already writes JavaScript and wants to add static typing: catch errors before running, get autocompletion and refactoring, document interfaces with types. Knowledge of JavaScript is a prerequisite: TypeScript is a superset of JS, meaning all JS stays valid, with a type system added on top. The course isn't about relearning from scratch but about how to think in types. The main idea: types aren't bureaucracy for the compiler but a design tool. A well-described type makes invalid states unrepresentable, turns a whole class of bugs into editor errors, and serves as living documentation. TypeScript is **erased at compile time** — at runtime it's ordinary JavaScript, and types exist only for checking. Understanding this boundary (compile-time checking vs runtime behavior) is the key to the whole course. Topics build up: basic types and type inference, typing functions, interfaces and object types, union types and narrowing, generics, classes and modules, utility and advanced types (mapped, conditional, template literal), `tsconfig` configuration and tooling, and the ecosystem. Lessons 9–10 cover real project setup and where to go next. Each lesson contains theory, code examples, a checklist of practical tasks, and a quiz. Examples are checked by the `tsc` compiler. It's most convenient to work in an editor with TS support (VS Code) — half of TypeScript's value shows up precisely in the hints and errors while you write the code.

typescript javascript

Intermediate

JavaScript in Practice

A practical JavaScript course for an experienced developer (mid-level+) who wants to confidently write modern JS for the frontend, the backend (Node.js), and understand the async model. Pace: 1-2 hours a day, ~3 weeks. JavaScript is the only language that runs both in the browser and on the server. Its defining trait is single-threadedness + the event loop + asynchrony. Key features: prototypal inheritance, closures, arrow functions, destructuring, async/await, and a vast ecosystem (npm). Each lesson includes theory with visual diagrams, code examples, a checklist, and a quiz.

javascript frontend

Beginner

Как эффективно учиться после 30

Короткий практический курс о том, как учиться после 30 лет без перегрузки и ощущения постоянной нехватки времени. Уроки объясняют работу внимания, памяти, повторения и привычек, а также помогают встроить обучение в занятый взрослый график. Вместо мотивационных лозунгов курс предлагает небольшие регулярные занятия, активное воспроизведение, интервальное повторение и работу над конкретным проектом. В результате участник составляет реалистичный личный план обучения и получает инструменты для устойчивого прогресса.

обучение самообразование

Beginner

«Теогония» Гесиода: полная иллюстрированная история богов и мира

Иллюстрированное путешествие по «Теогонии» Гесиода — от Хаоса, Геи и первых поколений богов до власти Зевса и установления олимпийского порядка. Книга помогает разобраться в сложных родословных, конфликтах титанов и олимпийцев, происхождении природных сил, чудовищ и божественных династий. Каждая глава соединяет понятное повествование с генеалогическими схемами, картами космоса и объяснением символики. Читатель увидит, как древние греки представляли происхождение мира, почему смена поколений богов связана с вопросом власти и закона и как «Теогония» стала основой огромной части европейской мифологической традиции.

гесиод теогония

Beginner

«Труды и дни» Гесиода — Definitive Edition

«Труды и дни» Гесиода — книга о том, как жить в мире нехватки, тяжёлого труда, семейных конфликтов и несовершенного правосудия. Издание раскрывает мифы о Прометее и Пандоре, пять поколений человечества, две Эриды, спор с Персом и образ справедливого города. Вторая половина книги превращает поэзию в практический календарь: пахота, зима, жатва, хранение урожая, виноделие, морская торговля и выбор подходящего времени. Исторические комментарии помогают отличать условия архаической Беотии от универсальных идей Гесиода о мере, ответственности, взаимности и устойчивой жизни.

гесиод труды и дни

Beginner

«Илиада» Гомера: война, герои и цена славы

Большое иллюстрированное издание «Илиады» о нескольких неделях десятого года Троянской войны. В центре книги — гнев Ахилла, его спор с Агамемноном, бедствия ахейского войска, гибель Патрокла, возвращение героя в бой, смерть Гектора и встреча Ахилла с Приамом. Книга охватывает все 24 песни и дополняет их главами о героическом кодексе, богах, судьбе, военном обществе и памяти бронзового века. Повествование показывает войну не только как поле славы, но и как разрушение семей, дружбы и человеческого достоинства, а финал объясняет, почему сострадание становится высшей точкой эпоса.

гомер илиада

Intermediate

ML, AI и агентная разработка: от основ до инструментов

Курс о том, **как на самом деле работают** машинное обучение, глубокое обучение и современный AI — и как на этом фундаменте строить агентные системы. Ориентирован на разработчика, который хочет не просто «дёргать API», а понимать движок под капотом: как модели учатся, что такое нейросети и трансформеры, откуда взялись большие языковые модели, и как из модели собрать агента, действующего в мире через инструменты. Курс намеренно **дополняет** два других в коллекции. Курс по Data Science даёт прикладной классический ML (pandas, scikit-learn, оценка) — здесь мы идём глубже в *принципы*: оптимизация, нейросети, глубокое обучение. Курс по LLM учит *строить приложения* поверх готовых моделей (промптинг, RAG, API) — здесь мы объясняем, *почему* эти модели работают, и поднимаемся до инженерии агентов как дисциплины. Вместе три курса дают полную картину: применять, понимать, строить. Две части. **Фундамент (уроки 1–7)**: карта AI/ML/DL, как модели учатся (оптимизация), парадигмы обучения, нейросети, архитектуры глубокого обучения, трансформеры и LLM, фундаментальные модели и генеративный AI. **Агенты и инженерия (уроки 8–12)**: что такое агент, инструменты и протокол MCP, паттерны и фреймворки агентных систем, оценка и безопасность, продакшн. Ландшафт инструментов дан на середину 2026 года (MCP, LangGraph, оркестрация агентов) — но принципы важнее конкретных библиотек, которые меняются ежемесячно. Каждый урок содержит теорию, примеры (диаграммы, псевдокод, Python), чеклист и квиз. Сквозная идея: современный AI — это не магия, а понятная инженерная башня из идей, каждую из которых можно освоить. Понимание фундамента отличает того, кто осознанно строит надёжные системы, от того, кто копирует чужой код и надеется, что сработает.

machine-learning ai

Intermediate

LLM: от основ до практики

Практический курс по большим языковым моделям (LLM) — от того, как они устроены, до сборки реальных приложений. Ориентирован на разработчика, который хочет не «поиграться с чат-ботом», а осознанно встраивать LLM в продукты: понимать, что модель может и чего принципиально не может, писать надёжные промпты, работать с API, строить поиск по эмбеддингам и RAG, подключать инструменты и агентов, оценивать качество и выводить всё в прод. Курс не про математику трансформеров и не про обучение моделей с нуля — он про инженерию поверх готовых моделей. Достаточно уметь программировать; примеры на Python (лингва-франка экосистемы LLM), но всё общение с моделями идёт по HTTP, поэтому подход применим на любом стеке. Ключевой принцип, проходящий через весь курс: **LLM недетерминированы и не знают правды — они предсказывают правдоподобный текст.** Поэтому инженерия вокруг них — это не «попросить модель», а построить систему: дать нужный контекст, ограничить формат, проверить вывод, измерить качество и защититься от сбоев и злоупотреблений. Модель — мощный, но ненадёжный компонент; задача инженера — сделать систему надёжной вокруг ненадёжного компонента. Темп 1–2 часа в день. Каждый урок содержит теорию, примеры кода, чеклист практических заданий и квиз. Ландшафт моделей меняется ежемесячно, поэтому конкретные названия и цены даны как иллюстрация на середину 2026 года — принципы выбора важнее, чем текущий чемпион бенчмарков.

llm ai

Intermediate

Python на практике

Практический курс по Python для опытного разработчика (уровень middle+), который хочет уверенно писать серверный код, скрипты, CLI-инструменты и работать с данными. Темп — 1–2 часа в день, ~3 недели. Python — динамический, выразительный язык с философией «явное лучше неявного» и богатейшей экосистемой. Ключевые особенности: значимые отступы, comprehensions, генераторы и итераторы, контекстные менеджеры, подсказки типов, async/await и один из самых широких наборов библиотек в мире. Каждый урок содержит теорию с визуальными схемами, примеры кода, чеклист и квиз.

python backend

Intermediate

Ecto: от нуля до продвинутого

Полный курс по Ecto — от первого запроса до продвинутых техник. Ecto это не ORM, а тандем data mapper и языка запросов: явный, композируемый, без магии. Предполагается знание Elixir (pattern matching, pipe, структуры). Ecto используется в Phoenix, но это самостоятельная библиотека и работает без него — курс это учитывает. Примеры на PostgreSQL (основная СУБД экосистемы), но большинство применимо к MySQL/SQLite. Курс охватывает четыре столпа Ecto — Repo (доступ к БД), Schema (отображение таблиц), Changeset (валидация и преобразование данных), Query (композируемый DSL запросов) — и ведёт от основ к продвинутому: ассоциации и борьба с N+1, сложные запросы (join'ы, подзапросы, оконные функции, CTE, динамические запросы), транзакции через Ecto.Multi, embedded и schemaless changeset'ы, upsert'ы и bulk-операции, мультитенантность через prefixes, кастомные типы, а также тестирование, производительность и безопасные миграции в проде. Для разработчика из Rails проведены параллели: Ecto ≈ ActiveRecord, но без магии и с явными changeset'ами; `Repo` ≈ то, что в AR размазано по моделям; миграции похожи, но полностью обратимы. Ключевое отличие от AR — Ecto разделяет данные (schema), их изменение (changeset) и доступ (Repo), а не смешивает всё в «активной записи». Темп 1–2 часа в день. Каждый урок содержит теорию, примеры кода, чеклист заданий и квиз. Главный принцип: Ecto делает работу с БД явной — ты всегда видишь, какой SQL выполнится, какие поля принимаются из ввода и когда происходит обращение к базе.

ecto elixir

Advanced

Phoenix: продакшн-SaaS на Elixir

Прикладной курс по Phoenix для построения безопасных современных SaaS-сервисов. Продолжение курса по Elixir — предполагается уверенное владение языком (иммутабельность, pattern matching, процессы, OTP, GenServer/Supervisor). Ориентирован на Phoenix 1.8 (scopes, magic links, обновлённые security headers, LiveView 1.1). Курс построен вокруг того, что реально нужно, чтобы вывести SaaS в прод: слоистая архитектура (тонкий web, толстые контексты), Ecto (схемы, changeset'ы, запросы, транзакции), аутентификация и авторизация со scopes, мультитенантность, LiveView для интерактивного UI, полноценное тестирование (ExUnit, LiveViewTest, Mox, фабрики, E2E), фоновые задачи на Oban, безопасность (OWASP, Sobelow, MixAudit, CSP, шифрование) и продакшн-эксплуатация (релизы, конфиг, наблюдаемость, деплой). Как и в языковых курсах серии, для разработчика из Rails-мира проведены параллели: Phoenix ≈ Rails (но функциональный и явный), Ecto ≈ ActiveRecord (но без магии, changeset'ы явные), контексты ≈ сервисные объекты, LiveView ≈ Hotwire/Turbo (но на сервере, через WebSocket), Oban ≈ Sidekiq (но в PostgreSQL, транзакционно), ExUnit ≈ RSpec/Minitest. Темп 1–2 часа в день, ориентировочно 3–4 недели. Каждый урок содержит теорию, примеры кода на Phoenix 1.8, чеклист практических заданий и квиз. Главный принцип 1.8: безопасность по умолчанию — scopes делают изоляцию данных дефолтом, а не тем, что нужно не забыть добавить потом.

phoenix elixir

Intermediate

Elixir на практике

Практический курс по Elixir для опытного разработчика (уровень middle+), который хочет освоить функциональный язык на BEAM VM с отказоустойчивой конкурентностью. Темп — 1–2 часа в день, ~3 недели. Elixir — функциональный язык на виртуальной машине BEAM (Erlang VM), созданной для телекоммуникаций. Главные преимущества: миллионы лёгких процессов с изолированным GC, горячее обновление кода, философия «let it crash» и OTP — паттерны отказоустойчивости, проверенные десятилетиями. Elixir добавляет к мощи BEAM современный синтаксис, макросистему и экосистему (Phoenix, Ecto, LiveView). Темы по нарастанию: Mix и основы синтаксиса, pattern matching и иммутабельность, коллекции, функции и pipe-оператор, Enum/Stream и обработка ошибок, процессы и акторная модель, OTP (GenServer, Supervisor), протоколы и тесты, Phoenix и экосистема. Каждый урок содержит теорию с визуальными схемами, примеры кода, чеклист и квиз. Главный принцип: Elixir силён не синтаксисом, а иммутабельностью, процессами и OTP.

elixir beam

Intermediate

TypeScript на практике

Практический курс TypeScript — от «зачем вообще типы» до продвинутой системы типов и продакшн-настройки. Ориентирован на разработчика, который уже пишет на JavaScript и хочет добавить статическую типизацию: ловить ошибки до запуска, получать автодополнение и рефакторинг, документировать интерфейсы типами. Знание JavaScript — обязательное условие: TypeScript это надмножество JS, то есть весь JS остаётся валидным, а сверху добавляется система типов. Курс не про переучивание с нуля, а про то, как думать типами. Главная мысль: типы — это не бюрократия ради компилятора, а инструмент проектирования. Хорошо описанный тип делает неверные состояния непредставимыми, превращает целый класс багов в ошибки редактора и служит живой документацией. TypeScript **стирается при компиляции** — в рантайме это обычный JavaScript, типы существуют только для проверки. Понимание этой границы (compile-time проверка vs runtime поведение) — ключ ко всему курсу. Темы по нарастанию: базовые типы и вывод типов, типизация функций, интерфейсы и объектные типы, union-типы и сужение (narrowing), дженерики, классы и модули, utility- и продвинутые типы (mapped, conditional, template literal), конфигурация `tsconfig` и тулинг, экосистема. Уроки 9–10 — реальная настройка проекта и куда двигаться дальше. Каждый урок содержит теорию, примеры кода, чеклист практических заданий и квиз. Примеры проверяются компилятором `tsc`. Работать удобнее всего в редакторе с поддержкой TS (VS Code) — половина ценности TypeScript проявляется именно в подсказках и ошибках прямо во время написания кода.

typescript javascript

Intermediate

Rust на практике

Практический курс по Rust для опытного разработчика (уровень middle+), который хочет освоить системный язык с гарантиями безопасности памяти без сборщика мусора. Темп — 1–2 часа в день, ~3 недели. Rust занимает нишу C/C++, но предлагает безопасность на уровне компиляции: система ownership и borrow checker устраняют use-after-free, data races и утечки памяти ещё до запуска программы. Философия — zero-cost abstractions: высокоуровневый код компилируется в столь же эффективный, как написанный вручную низкоуровневый. Темы по нарастанию: Cargo и основы синтаксиса, ownership и borrowing, структуры и enum (алгебраические типы), обработка ошибок (Result/Option), коллекции и мини-проект, трейты и дженерики, итераторы и модули, конкурентность и итоговый проект, async и экосистема. Каждый урок содержит теорию с визуальными схемами, примеры кода, чеклист и квиз. Главный принцип: компилятор — ваш союзник, а не противник. Каждая ошибка компиляции — это баг, которого не будет в продакшене.

rust systems

Intermediate

Go на практике

Практический курс по Go для опытного разработчика (уровень middle+), который хочет уверенно писать серверный код, CLI-инструменты и конкурентные сервисы на Go. Темп — 1–2 часа в день, ~3 недели. Go спроектирован в Google для больших серверных систем: простота, читаемость, быстрая компиляция в статические бинарники, мощная конкурентность (горутины и каналы). Язык намеренно минималистичен — меньше возможностей, но каждая продумана; один очевидный способ сделать дело. Это делает Go идеальным для бэкендов, микросервисов, инфраструктурных инструментов (Docker, Kubernetes, Terraform написаны на Go). Темы по нарастанию: тулчейн и основы синтаксиса, система типов (указатели, структуры, слайсы, карты), методы и интерфейсы (утиная типизация), обработка ошибок как значений, мини-проект, конкурентность (горутины, каналы, select), стандартная библиотека и HTTP-серверы, тестирование и итоговый проект, экосистема и дальнейшие шаги. Каждый урок содержит теорию с визуальными схемами (PNG-диаграммы и mermaid), примеры кода, чеклист практических заданий и квиз. Главный принцип Go — простота ценнее умности: если код нельзя понять за 30 секунд, его стоит переписать проще.

go golang

Intermediate

JavaScript на практике

Практический курс по JavaScript для опытного разработчика (уровень middle+), который хочет уверенно писать современный JS для фронтенда, бэкенда (Node.js) и понимать асинхронную модель. Темп — 1–2 часа в день, ~3 недели. JavaScript — единственный язык, работающий и в браузере, и на сервере. Его определяющая черта — однопоточность + event loop + асинхронность. Ключевые особенности: прототипное наследование, замыкания, стрелочные функции, деструктуризация, async/await и обширная экосистема (npm). Каждый урок содержит теорию с визуальными схемами, примеры кода, чеклист и квиз.

javascript frontend

Intermediate

Data Science на практике

Практический курс по data science — от рабочего процесса и подготовки данных до машинного обучения и вывода результатов в жизнь. Ориентирован на разработчика или аналитика, который хочет научиться извлекать из данных пользу: загружать и чистить их, исследовать, визуализировать, строить и оценивать модели, и понимать, где заканчивается наука о данных и начинается инженерия. Достаточно базового Python (в коллекции есть отдельный курс по Python); весь стек — Python. Главный принцип курса: **80% работы data scientist'а — это данные, а не модели.** Красивые алгоритмы бесполезны на грязных данных; «мусор на входе — мусор на выходе». Поэтому упор на подготовку, очистку, исследование и честную оценку. Второй сквозной мотив — **скепсис и строгость**: корреляция не равна причинности, хорошая метрика на обучающей выборке ничего не значит, а модель, «работающая» на ноутбуке, может провалиться в проде из-за утечки данных. Наука о данных — это дисциплина осторожных выводов из шумной реальности. Темы по нарастанию: рабочий процесс и инструменты, NumPy, pandas, очистка данных, трансформация и агрегация, разведочный анализ и визуализация, статистика, введение в машинное обучение, scikit-learn, оценка моделей и работа с признаками, вывод в продакшн. Стек 2026 года: ядро (NumPy, pandas, matplotlib/seaborn, scikit-learn, Jupyter) плюс современные инструменты (Polars, DuckDB) — но принципы важнее конкретных библиотек. Каждый урок содержит теорию, примеры кода (Python), чеклист практических заданий и квиз. Практиковаться удобно в Jupyter/ноутбуке на реальных датасетах. Этот курс — фундамент прикладного анализа; за глубиной именно машинного обучения и современного AI загляните в курс по ML/AI, а за LLM-приложениями — в курс по LLM.

data-science python

Beginner

Тайская кухня: расширенный курс за 14 дней

Расширенный четырнадцатидневный курс по тайской кухне — от базовых ингредиентов и вкусового баланса до карри, супов, лапши, салатов, рисовых блюд, соусов и десертов. Уроки объясняют не только рецепты, но и логику тайского приготовления: порядок добавления продуктов, работу с ароматикой и корректировку вкуса. Курс рассчитан на домашнюю кухню и предлагает понятные замены для ингредиентов, которые сложно найти. К концу программы участник сможет самостоятельно планировать тайское меню, адаптировать остроту и уверенно готовить блюда с сохранением их характерного вкусового профиля.

тайская кухня кулинария

Beginner

«Одиссея» Гомера — Definitive Edition

Полное иллюстрированное издание «Одиссеи» о возвращении Одиссея после Троянской войны и восстановлении его дома на Итаке. Книга охватывает Телемахию, остров Калипсо, феаков, циклопа Полифема, Кирку, царство мёртвых, сирен, Скиллу и Харибду, а затем — тайное возвращение, испытание луком и узнавание Пенелопой. В центре повествования находится не просто путешествие, а вопрос о том, что делает дом домом: семья, память, имя, власть и взаимное узнавание. Главы подробно объясняют nostos, xenia, kleos, metis и oikos, показывая Одиссея, Пенелопу и Телемаха как трёх самостоятельных стратегов одной истории.

гомер одиссея

Beginner

«Одиссея» Гомера: большое иллюстрированное путешествие

Доступное иллюстрированное знакомство с «Одиссеей» Гомера для читателей, которые впервые открывают античный эпос. Книга последовательно рассказывает о Телемахе и Пенелопе, странствиях Одиссея, встречах с циклопом, Киркой, сиренами и обитателями подземного мира, а затем о возвращении героя на Итаку. Короткие главы, крупные иллюстрации и понятные объяснения помогают удерживать маршрут, персонажей и основные темы. Издание показывает, почему хитрость Одиссея одновременно спасает и создаёт новые опасности, как гостеприимство становится нравственным испытанием и почему подлинное возвращение заканчивается не прибытием на остров, а восстановлением отношений с семьёй.

гомер одиссея

Intermediate

Cloud, DevOps и Kubernetes на практике

Практический курс по облакам, DevOps и Kubernetes — от культуры и контейнеров до продакшн-эксплуатации кластеров. Ориентирован на разработчика или инженера, который хочет уверенно деплоить и эксплуатировать сервисы в облачно-нативной среде: понимать контейнеры, оркестрацию, конфигурацию, хранилища, сеть, наблюдаемость, CI/CD, GitOps, инфраструктуру как код и безопасность. Курс строится вокруг **декларативной модели**: вы описываете желаемое состояние системы, а платформа приводит реальность к нему и удерживает. Это сквозная идея всего современного DevOps — от Kubernetes-манифестов до Terraform и GitOps. Освоив её, вы перестаёте «нажимать кнопки руками» и начинаете управлять инфраструктурой как кодом: версионируемым, воспроизводимым, проверяемым. Темы по нарастанию: основы DevOps и облаков, контейнеры и Docker, архитектура Kubernetes, рабочие нагрузки (Pod/Deployment/StatefulSet), сеть и Service/Ingress, конфигурация и секреты, хранилища и состояние, упаковка (Helm/Kustomize), наблюдаемость, CI/CD и GitOps, инфраструктура как код и безопасность, продакшн и масштабирование. Примеры даны на середину 2026 года (Kubernetes 1.3x, ArgoCD/Flux, OpenTelemetry) — принципы важнее конкретных версий, которые обновляются постоянно. Каждый урок содержит теорию, примеры (YAML-манифесты и команды `kubectl`/CLI), чеклист практических заданий и квиз. Практиковаться удобно на локальном кластере (kind/minikube/k3s) или в управляемом облаке. Главный принцип: инфраструктура — это код. Всё, что делается «руками» и не записано, — технический долг и источник расхождений между окружениями.

devops kubernetes