Home on Alisher Musulmonov

Getting Started with Go

Sun, 08 Dec 2024 00:00:00 +0000

Go is a statically typed, compiled language designed for simplicity and efficiency. Here’s how to get started.

Installation

# macOS
brew install go

# Linux
wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

Hello World

package main

import "fmt"

func main() {
 fmt.Println("Hello, World!")
}

Run with go run main.go.

Why Go?

Simple syntax, fast compilation
Built-in concurrency with goroutines
Excellent standard library
Static binaries, easy deployment

Key Concepts

Variables

var name string = "Gopher"
age := 25 // type inference
const Pi = 3.14159

Functions

func add(a, b int) int {
 return a + b
}

// Multiple returns
func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, errors.New("division by zero")
 }
 return a / b, nil
}

Structs

type Person struct {
 Name string
 Age int
}

p := Person{Name: "Alice", Age: 30}

Next Steps

Go Tour — interactive tutorial
Effective Go — best practices
Build a CLI tool or HTTP server

Building REST APIs with Go

Sat, 07 Dec 2024 00:00:00 +0000

Go’s standard library is powerful enough for most HTTP servers, but Chi adds conveniences for real applications.

Setup

go mod init myapi
go get github.com/go-chi/chi/v5

Basic Server

package main

import (
 "encoding/json"
 "net/http"

 "github.com/go-chi/chi/v5"
 "github.com/go-chi/chi/v5/middleware"
)

func main() {
 r := chi.NewRouter()
 r.Use(middleware.Logger)
 r.Use(middleware.Recoverer)

 r.Get("/", func(w http.ResponseWriter, r *http.Request) {
 w.Write([]byte("ok"))
 })

 http.ListenAndServe(":8080", r)
}

RESTful Routes

r.Route("/api/v1/users", func(r chi.Router) {
 r.Get("/", listUsers)
 r.Post("/", createUser)
 r.Get("/{id}", getUser)
 r.Put("/{id}", updateUser)
 r.Delete("/{id}", deleteUser)
})

JSON Response Helper

func respondJSON(w http.ResponseWriter, status int, data interface{}) {
 w.Header().Set("Content-Type", "application/json")
 w.WriteHeader(status)
 json.NewEncoder(w).Encode(data)
}

Best Practices

Version your API (/api/v1/...)
Use proper HTTP status codes
Validate input data
Handle errors consistently
Add request timeouts

Введение в Go для бэкенд-разработчиков

Fri, 06 Dec 2024 00:00:00 +0000

Go — компилируемый язык со статической типизацией, разработанный для простоты и эффективности.

Установка

# macOS
brew install go

# Linux
wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

Привет, мир

package main

import "fmt"

func main() {
 fmt.Println("Привет, мир!")
}

Запуск: go run main.go

Почему Go?

Простой синтаксис, быстрая компиляция
Встроенная поддержка конкурентности (goroutines)
Отличная стандартная библиотека
Статические бинарники — легко деплоить

Основные концепции

Переменные

var name string = "Gopher"
age := 25 // вывод типа
const Pi = 3.14159

Функции

func add(a, b int) int {
 return a + b
}

// Множественные возвращаемые значения
func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, errors.New("деление на ноль")
 }
 return a / b, nil
}

Структуры

type Person struct {
 Name string
 Age int
}

p := Person{Name: "Алиса", Age: 30}

Следующие шаги

Go Tour — интерактивный туториал
Effective Go — лучшие практики

Go dasturlash tiliga kirish

Thu, 05 Dec 2024 00:00:00 +0000

Go — soddalik va samaradorlik uchun yaratilgan statik tipli, kompilyatsiya qilinadigan dasturlash tili.

O’rnatish

# macOS
brew install go

# Linux
wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

Salom, dunyo

package main

import "fmt"

func main() {
 fmt.Println("Salom, dunyo!")
}

Ishga tushirish: go run main.go

Nima uchun Go?

Oddiy sintaksis, tez kompilyatsiya
Goroutine’lar orqali o’rnatilgan parallellik
Ajoyib standart kutubxona
Statik binarlar — oson deployment

Asosiy tushunchalar

O’zgaruvchilar

var name string = "Gopher"
age := 25 // tip avtomatik aniqlanadi
const Pi = 3.14159

Funksiyalar

func add(a, b int) int {
 return a + b
}

// Ko'p qiymat qaytarish
func divide(a, b float64) (float64, error) {
 if b == 0 {
 return 0, errors.New("nolga bo'lish")
 }
 return a / b, nil
}

Strukturalar

type Person struct {
 Name string
 Age int
}

p := Person{Name: "Ali", Age: 30}

Keyingi qadamlar

Go Tour — interaktiv qo’llanma
Effective Go — eng yaxshi amaliyotlar

Docker Best Practices

Wed, 04 Dec 2024 00:00:00 +0000

Docker has become essential for modern deployment. Here are practices I follow.

Multi-Stage Builds

Keep images small:

# Build
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o server

# Run
FROM alpine:3.19
RUN apk --no-cache add ca-certificates
COPY --from=builder /app/server /server
EXPOSE 8080
CMD ["/server"]

Use Specific Tags

# Bad
FROM node:latest

# Good
FROM node:20.10-alpine3.19

Run as Non-Root

RUN addgroup -S app && adduser -S app -G app
USER app

Health Checks

HEALTHCHECK --interval=30s --timeout=3s \
 CMD wget -q --spider http://localhost:8080/health || exit 1

.dockerignore

node_modules
.git
.env
*.md
Dockerfile

Checklist

Multi-stage builds
Non-root user
Specific tags
Health checks
No secrets in images
Minimal base images

Основы распределённых систем

Tue, 03 Dec 2024 00:00:00 +0000

Распределённые системы — это системы, компоненты которых находятся на разных машинах и взаимодействуют через сеть.

Основные вызовы

Сетевые сбои — сеть ненадёжна
Частичные отказы — часть системы может упасть
Отсутствие глобального времени — часы не синхронизированы

CAP-теорема

Нельзя одновременно гарантировать:

C (Consistency) — согласованность
A (Availability) — доступность
P (Partition tolerance) — устойчивость к разделению

При разделении сети нужно выбирать между C и A.

Консенсус

Алгоритмы консенсуса (Raft, Paxos) позволяют узлам договориться о значении.

JavaScript Async Patterns

Mon, 02 Dec 2024 00:00:00 +0000

Asynchronous programming is core to JavaScript. Here are the patterns I use.

From Callbacks to Async/Await

// Callbacks
fetchUser(1, (err, user) => {
 if (err) return console.error(err);
 console.log(user);
});

// Promises
fetchUser(1)
 .then(user => console.log(user))
 .catch(err => console.error(err));

// Async/Await
const user = await fetchUser(1);

Promise Combinators

Promise.all

const [users, posts] = await Promise.all([
 fetchUsers(),
 fetchPosts()
]);

Promise.allSettled

const results = await Promise.allSettled([
 fetchUsers(),
 fetchPosts() // might fail
]);

Promise.race

const result = await Promise.race([
 fetchFromCache(),
 fetchFromNetwork()
]);

Retry Pattern

async function retry(fn, attempts = 3) {
 for (let i = 0; i < attempts; i++) {
 try {
 return await fn();
 } catch (err) {
 if (i === attempts - 1) throw err;
 await new Promise(r => setTimeout(r, 1000 * (i + 1)));
 }
 }
}

Error Handling

async function safeAsync(fn) {
 try {
 return [await fn(), null];
 } catch (error) {
 return [null, error];
 }
}

const [data, error] = await safeAsync(() => fetchUser(1));

Modern CSS Techniques

Sun, 01 Dec 2024 00:00:00 +0000

CSS has evolved significantly. Here are features I use regularly.

CSS Custom Properties

:root {
 --color-primary: #171717;
 --spacing: 1rem;
}

.button {
 background: var(--color-primary);
 padding: var(--spacing);
}

[data-theme="dark"] {
 --color-primary: #fafafa;
}

CSS Grid

.grid {
 display: grid;
 grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
 gap: 1rem;
}

Container Queries

.card-container {
 container-type: inline-size;
}

@container (min-width: 400px) {
 .card {
 display: flex;
 }
}

:has() Selector

/* Style parent based on child */
.card:has(img) {
 padding: 0;
}

.form:has(input:invalid) {
 border-color: red;
}

Logical Properties

.element {
 margin-inline: auto;
 padding-block: 1rem;
 border-inline-start: 2px solid;
}