package main

import (
  "fmt"
  "sync"
)

func joinChannels(chs ...<-chan int) <-chan int {
  mergedCh := make(chan int)

  go func() {
    wg := &sync.WaitGroup{}

    wg.Add(len(chs))

    for _, ch := range chs {
      go func(ch <-chan int, wg *sync.WaitGroup) {
        defer wg.Done()
        for id := range ch {
          mergedCh <- id
        }
      }(ch, wg)
    }

    wg.Wait()
    close(mergedCh)
  }()

  return mergedCh
}

func main() {

  a := make(chan int)
  b := make(chan int)
  c := make(chan int)

  go func() {
    for _, num := range []int{1, 2, 3} {
      a <- num
    }
    close(a)
  }()

  go func() {
    for _, num := range []int{20, 10, 30} {
      b <- num
    }
    close(b)
  }()

  go func() {
    for _, num := range []int{300, 200, 100} {
      c <- num
    }
    close(c)
  }()

  for num := range joinChannels(a, b, c) {
    fmt.Println(num)
  }

}

Основные характеристики SOAP:

Основные компоненты SOAP:

Пример SOAP-сообщения:

<soap:Envelope xmlns:soap="https://www.w3.org/2003/05/soap-envelope" xmlns:ns="https://example.com/">
   <soap:Header/>
   <soap:Body>
      <ns:GetUserInfo>
         <ns:UserID>123</ns:UserID>
      </ns:GetUserInfo>
   </soap:Body>
</soap:Envelope>

Пример SOAP-ответа:

<soap:Envelope xmlns:soap="https://www.w3.org/2003/05/soap-envelope" xmlns:ns="https://example.com/">
   <soap:Header/>
   <soap:Body>
      <ns:GetUserInfoResponse>
         <ns:UserName>John Doe</ns:UserName>
         <ns:Email>[email protected]</ns:Email>
      </ns:GetUserInfoResponse>
   </soap:Body>
</soap:Envelope>

Простота и легковесность:

Использование стандартных форматов данных:

Гибкость и масштабируемость:

Легкая связь между клиентом и сервером:

Следующим постом рассмотрим пример сравнения использования REST и SOAP

RESTful сервис:

GET /api/users/123 HTTP/1.1
Host: example.com
Accept: application/json

HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": 123,
  "name": "John Doe",
  "email": "[email protected]"
}

SOAP сервис:

POST /UserService HTTP/1.1
Host: example.com
Content-Type: text/xml; charset=utf-8
Content-Length: 250

<soap:Envelope xmlns:soap="https://www.w3.org/2003/05/soap-envelope" xmlns:ns="https://example.com/">
   <soap:Header/>
   <soap:Body>
      <ns:GetUserInfo>
         <ns:UserID>123</ns:UserID>
      </ns:GetUserInfo>
   </soap:Body>
</soap:Envelope>

HTTP/1.1 200 OK
Content-Type: text/xml; charset=utf-8

<soap:Envelope xmlns:soap="https://www.w3.org/2003/05/soap-envelope" xmlns:ns="https://example.com/">
   <soap:Header/>
   <soap:Body>
      <ns:GetUserInfoResponse>
         <ns:UserName>John Doe</ns:UserName>
         <ns:Email>[email protected]</ns:Email>
      </ns:GetUserInfoResponse>
   </soap:Body>
</soap:Envelope>

Маршалинг (Marshalling):

import json

# Преобразование объекта Python в JSON-строку (маршалинг)
data = {'name': 'John', 'age': 30, 'city': 'New York'}
json_string = json.dumps(data)
print(json_string)

Сериализация (Serialization):

import pickle

# Сериализация объекта Python в бинарный формат (pickle)
data = {'name': 'Alice', 'age': 25, 'city': 'Los Angeles'}
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)

Отличия между Маршалингом и Сериализацией:

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

Довольно частая задача, более подробно можно почитать тут: https://blog.golang.org/pipelines

package main

import (
  "fmt"
)

func main() {
  naturals := make(chan int)
  squares := make(chan int)

  go func() {
    for x := 0; x <= 10; x++ {
      naturals <- x
    }
    close(naturals)
  }()

  go func() {
    for x := range naturals {
      squares <- x * x
    }
    close(squares)
  }()

  for x := range squares {
    fmt.Println(x)
  }
}

Поддержка Node.js 22.x будет осуществляться до 30 апреля 2027 года. Сопровождение прошлой LTS-ветки Node.js 20.x продлится до апреля 2026 года, а позапрошлой LTS-ветки 18.x — до апреля 2025 года. Сопровождение промежуточной ветки Node.js 21.x будет прекращено 1 июня 2024 года.

Когда выбирать SQL:

CREATE TABLE Users (
    UserID INT PRIMARY KEY,
    Username VARCHAR(50),
    Email VARCHAR(100)
);

Когда выбирать NoSQL:

{
    "userID": 123,
    "username": "john_doe",
    "email": "[email protected]",
    "posts": [
        {"title": "Post 1", "content": "Content 1"},
        {"title": "Post 2", "content": "Content 2"}
    ]
}

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

Основные компоненты RabbitMQ:

Пример использования RabbitMQ:

import pika

# Подключение к RabbitMQ серверу
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# Создание очереди
channel.queue_declare(queue='orders')

# Отправка сообщения в очередь
channel.basic_publish(exchange='', routing_key='orders', body='New order: #123')

print(" [x] Sent 'New order: #123'")

# Закрытие соединения
connection.close()

Довольно распространенная задача, плюс подобные задачи встречаются на практике.

Решение:

package main

import (
  "fmt"
)

func worker(id int, f func(int) int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- f(j)
    }
}

func main() {

    const numJobs = 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    multiplier := func(x int) int {
  return x * 10
    }

    for w := 1; w <= 3; w++ {
        go worker(w,  multiplier, jobs, results)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    for i := 1; i <= numJobs; i++ {
        fmt.Println(<-results)
    }
}

Основные характеристики gRPC:

syntax = "proto3";

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

protoc -I=. --python_out=. --grpc_python_out=. example.proto

import grpc
import example_pb2
import example_pb2_grpc

class GreeterServicer(example_pb2_grpc.GreeterServicer):
    def SayHello(self, request, context):
        return example_pb2.HelloResponse(message=f"Hello, {request.name}!")

def serve():
    server = grpc.server(grpc.insecure_server())
    example_pb2_grpc.add_GreeterServicer_to_server(GreeterServicer(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

if name == 'main':
    serve()

import grpc
import example_pb2
import example_pb2_grpc

def run():
    channel = grpc.insecure_channel('localhost:50051')
    stub = example_pb2_grpc.GreeterStub(channel)
    response = stub.SayHello(example_pb2.HelloRequest(name='world'))
    print

JWT (JSON Web Token) и OAuth - это два распространенных стандарта для реализации аутентификации и авторизации в веб-приложениях.

Пример использования JWT и OAuth в веб-приложении:

from flask import Flask, jsonify, request
import jwt
from functools import wraps

app = Flask(name)
app.config['SECRET_KEY'] = 'secret'

def token_required(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        token = request.headers.get('Authorization')
        if not token:
            return jsonify({'message': 'Token is missing!'}), 401
        try:
            data = jwt.decode(token, app.config['SECRET_KEY'])
        except:
            return jsonify({'message': 'Token is invalid!'}), 401
        return f(*args, **kwargs)
    return decorated

@app.route('/login', methods=['POST'])
def login():
    auth = request.authorization
    if auth and auth.password == 'password':
        token = jwt.encode({'username': auth.username}, app.config['SECRET_KEY'])
        return jsonify({'token': token.decode('UTF-8')})
    return jsonify({'message': 'Could not verify!'}), 401

@app.route('/protected', methods=['GET'])
@token_required
def protected():
    return jsonify({'message': 'This is protected route!'})

if name == 'main':
    app.run(debug=True)

with new_table as (
select patient_id from patients
UNION
select null
)

select 
    count()
  , count(distinct patient_id)
  , count(patient_id) 

from new_table

Это может сбивать с толку при проверке, является ли столбец первичным ключом, поэтому я посчитал нужным упомянуть об этом.

Atomicity (Атомарность):

Consistency (Согласованность):

Isolation (Изоляция):

Durability (Долговечность):

Основные компоненты Clean Architecture включают в себя:

Пример применения Clean Architecture:

Clean Architecture способствует созданию гибких, модульных и легко поддерживаемых приложений, которые легко масштабировать и изменять.

# entities.py
class Task:
    def init(self, title, description, status):
        self.title = title
        self.description = description
        self.status = status

# repositories.py
class TaskRepository:
    def get_task_by_id(self, task_id):
        # код для получения задачи из базы данных
        pass
    
    def save_task(self, task):
        # код для сохранения задачи в базу данных
        pass

# use_cases.py
class TaskManager:
    def init(self, task_repository):
        self.task_repository = task_repository
    
    def create_task(self, title, description):
        task = Task(title=title, description=description, status='todo')
        self.task_repository.save_task(task)
    
    def get_task(self, task_id):
        return self.task_repository.get_task_by_id(task_id)

# app.py (Flask приложение)
from flask import Flask, request, jsonify
from entities import Task
from repositories import TaskRepository
from use_cases import TaskManager

app = Flask(name)
task_repository = TaskRepository()
task_manager = TaskManager(task_repository)

@app.route('/tasks', methods=['POST'])
def create_task():
    data = request.json
    title = data.get('title')
    description = data.get('description')
    task_manager.create_task(title, description)
    return jsonify({'message': 'Task created successfully'})

@app.route('/tasks/<task_id>', methods=['GET'])
def get_task(task_id):
    task = task_manager.get_task(task_id)
    return jsonify({'title': task.title, 'description': task.description, 'status': task.status})

if name == 'main':
    app.run(debug=True)

Этот пример демонстрирует, как Clean Architecture разделяет приложение на независимые слои, что делает его более гибким, легко поддерживаемым и тестируемым. Каждый компонент отвечает только за свою часть функциональности, что делает его более независимым и переносимым.