📁 Folder Structure

hexagonal-go/
├── go.mod
├── cmd/
│   └── api/
│       └── main.go
└── internal/
    ├── domain/
    │   └── order/
    │       ├── money.go
    │       ├── order.go
    │       ├── order_id.go
    │       ├── order_status.go
    │       └── repository.go
    ├── application/
    │   └── order_service.go
    └── adapters/
        ├── http/
        │   └── order_handler.go
        └── persistence/
            └── memory/
                └── order_repository.go

1) go.mod

module example.com/hexagonal-go

go 1.22

2) Domain Layer

internal/domain/order/order_id.go

package order

type OrderID string

internal/domain/order/order_status.go

package order

type OrderStatus string

const (
    OrderStatusCreated   OrderStatus = "CREATED"
    OrderStatusCompleted OrderStatus = "COMPLETED"
)

internal/domain/order/money.go

package order

import "fmt"

type Money struct {
    Cents int64
}

func NewMoney(cents int64) (Money, error) {
    if cents < 0 {
        return Money{}, fmt.Errorf("money cannot be negative")
    }
    return Money{Cents: cents}, nil
}

func (m Money) Add(other Money) Money {
    return Money{Cents: m.Cents + other.Cents}
}

internal/domain/order/order.go

package order

import "fmt"

type OrderItem struct {
    ProductID string
    Quantity  int
    UnitPrice Money
}

type Order struct {
    id     OrderID
    items  []OrderItem
    status OrderStatus
}

func NewOrder(id OrderID) *Order {
    return &Order{
        id:     id,
        items:  make([]OrderItem, 0),
        status: OrderStatusCreated,
    }
}

func (o *Order) ID() OrderID {
    return o.id
}

func (o *Order) Status() OrderStatus {
    return o.status
}

func (o *Order) Items() []OrderItem {
    copied := make([]OrderItem, len(o.items))
    copy(copied, o.items)
    return copied
}

func (o *Order) AddItem(productID string, quantity int, unitPrice Money) error {
    if o.status != OrderStatusCreated {
        return fmt.Errorf("order cannot be modified after completion")
    }
    if productID == "" {
        return fmt.Errorf("product id cannot be empty")
    }
    if quantity <= 0 {
        return fmt.Errorf("quantity must be greater than zero")
    }

    o.items = append(o.items, OrderItem{
        ProductID: productID,
        Quantity:  quantity,
        UnitPrice: unitPrice,
    })

    return nil
}

func (o *Order) Complete() error {
    if len(o.items) == 0 {
        return fmt.Errorf("order must have at least one item")
    }
    o.status = OrderStatusCompleted
    return nil
}

func (o *Order) Total() Money {
    total := Money{Cents: 0}
    for _, item := range o.items {
        total = total.Add(Money{Cents: item.UnitPrice.Cents * int64(item.Quantity)})
    }
    return total
}

internal/domain/order/repository.go

package order

import "context"

type Repository interface {
    Save(ctx context.Context, order *Order) error
    FindByID(ctx context.Context, id OrderID) (*Order, error)
}

3) Application Layer

internal/application/order_service.go

package application

import (
    "context"
    "fmt"
    "time"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderService struct {
    repo order.Repository
}

func NewOrderService(repo order.Repository) *OrderService {
    return &OrderService{repo: repo}
}

func (s *OrderService) CreateOrder(ctx context.Context) (*order.Order, error) {
    id := order.OrderID(fmt.Sprintf("ord_%d", time.Now().UnixNano()))
    newOrder := order.NewOrder(id)

    if err := s.repo.Save(ctx, newOrder); err != nil {
        return nil, err
    }

    return newOrder, nil
}

func (s *OrderService) AddItem(ctx context.Context, orderID order.OrderID, productID string, quantity int, priceCents int64) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    price, err := order.NewMoney(priceCents)
    if err != nil {
        return nil, err
    }

    if err := o.AddItem(productID, quantity, price); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) CompleteOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    if err := o.Complete(); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) GetOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    return s.repo.FindByID(ctx, orderID)
}

4) Persistence Adapter (In-Memory)

internal/adapters/persistence/memory/order_repository.go

package memory

import (
    "context"
    "fmt"
    "sync"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderRepository struct {
    mu     sync.RWMutex
    orders map[order.OrderID]*order.Order
}

func NewOrderRepository() *OrderRepository {
    return &OrderRepository{
        orders: make(map[order.OrderID]*order.Order),
    }
}

func (r *OrderRepository) Save(ctx context.Context, o *order.Order) error {
    r.mu.Lock()
    defer r.mu.Unlock()

    r.orders[o.ID()] = o
    return nil
}

func (r *OrderRepository) FindByID(ctx context.Context, id order.OrderID) (*order.Order, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    o, ok := r.orders[id]
    if !ok {
        return nil, fmt.Errorf("order not found: %s", id)
    }

    return o, nil
}

5) HTTP Adapter

internal/adapters/http/order_handler.go

package httpadapter

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

    "example.com/hexagonal-go/internal/application"
    "example.com/hexagonal-go/internal/domain/order"
)

type OrderHandler struct {
    service *application.OrderService
}

func NewOrderHandler(service *application.OrderService) *OrderHandler {
    return &OrderHandler{service: service}
}

func (h *OrderHandler) RegisterRoutes(mux *http.ServeMux) {
    mux.HandleFunc("POST /orders", h.createOrder)
    mux.HandleFunc("GET /orders/", h.getOrder)
    mux.HandleFunc("POST /orders/{id}/items", h.addItem)
    mux.HandleFunc("POST /orders/{id}/complete", h.completeOrder)
}

func (h *OrderHandler) createOrder(w http.ResponseWriter, r *http.Request) {
    o, err := h.service.CreateOrder(r.Context())
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    respondJSON(w, http.StatusCreated, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) getOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.GetOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "items":  o.Items(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) addItem(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)

    var req struct {
        ProductID string `json:"product_id"`
        Quantity  int    `json:"quantity"`
        PriceCents int64  `json:"price_cents"`
    }

    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "invalid json", http.StatusBadRequest)
        return
    }

    o, err := h.service.AddItem(r.Context(), order.OrderID(id), req.ProductID, req.Quantity, req.PriceCents)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) completeOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.CompleteOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func extractID(path string) string {
    parts := strings.Split(strings.Trim(path, "/"), "/")
    if len(parts) >= 2 {
        return parts[1]
    }
    return ""
}

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

6) Application Entry Point

cmd/api/main.go

package main

import (
    "log"
    "net/http"

    httpadapter "example.com/hexagonal-go/internal/adapters/http"
    "example.com/hexagonal-go/internal/adapters/persistence/memory"
    "example.com/hexagonal-go/internal/application"
)

func main() {
    repo := memory.NewOrderRepository()
    service := application.NewOrderService(repo)
    handler := httpadapter.NewOrderHandler(service)

    mux := http.NewServeMux()
    handler.RegisterRoutes(mux)

    log.Println("server started on :8080")
    if err := http.ListenAndServe(":8080", mux); err != nil {
        log.Fatal(err)
    }
}

7) How It Works

• HTTP adapter receives the request
• Application service executes the use case
• Domain applies business rules
• Repository (port) is defined in the domain
• Adapter (memory) implements it

👉 The domain layer:

• does NOT know net/http
• does NOT know databases
• does NOT know frameworks

8) Simple Test Example

internal/domain/order/order_test.go

package order

import "testing"

func TestOrderCompleteWithoutItems(t *testing.T) {
    o := NewOrder("1")

    if err := o.Complete(); err == nil {
        t.Fatal("expected error when completing empty order")
    }
}

func TestOrderTotal(t *testing.T) {
    o := NewOrder("1")
    price, _ := NewMoney(500)

    if err := o.AddItem("p1", 2, price); err != nil {
        t.Fatal(err)
    }

    if o.Total().Cents != 1000 {
        t.Fatalf("expected 1000, got %d", o.Total().Cents)
    }
}

9) Run the Project

go run ./cmd/api

Example requests:

curl -X POST localhost:8080/orders

curl -X POST localhost:8080/orders/ord_xxx/items \
  -H 'Content-Type: application/json' \
  -d '{"product_id":"p1","quantity":2,"price_cents":500}'

curl -X POST localhost:8080/orders/ord_xxx/complete

hexagonal-go/
├── go.mod
├── cmd/
│   └── api/
│       └── main.go
└── internal/
    ├── domain/
    │   └── order/
    │       ├── money.go
    │       ├── order.go
    │       ├── order_id.go
    │       ├── order_status.go
    │       └── repository.go
    ├── application/
    │   └── order_service.go
    └── adapters/
        ├── http/
        │   └── order_handler.go
        └── persistence/
            └── memory/
                └── order_repository.go

1) go.mod

module example.com/hexagonal-go

go 1.22

2) Domain katmanı

internal/domain/order/order_id.go

package order

type OrderID string

internal/domain/order/order_status.go

package order

type OrderStatus string

const (
    OrderStatusCreated   OrderStatus = "CREATED"
    OrderStatusCompleted OrderStatus = "COMPLETED"
)

internal/domain/order/money.go

package order

import "fmt"

type Money struct {
    Cents int64
}

func NewMoney(cents int64) (Money, error) {
    if cents < 0 {
        return Money{}, fmt.Errorf("money cannot be negative")
    }
    return Money{Cents: cents}, nil
}

func (m Money) Add(other Money) Money {
    return Money{Cents: m.Cents + other.Cents}
}

internal/domain/order/order.go

package order

import "fmt"

type OrderItem struct {
    ProductID string
    Quantity  int
    UnitPrice Money
}

type Order struct {
    id     OrderID
    items  []OrderItem
    status OrderStatus
}

func NewOrder(id OrderID) *Order {
    return &Order{
        id:     id,
        items:  make([]OrderItem, 0),
        status: OrderStatusCreated,
    }
}

func (o *Order) ID() OrderID {
    return o.id
}

func (o *Order) Status() OrderStatus {
    return o.status
}

func (o *Order) Items() []OrderItem {
    copied := make([]OrderItem, len(o.items))
    copy(copied, o.items)
    return copied
}

func (o *Order) AddItem(productID string, quantity int, unitPrice Money) error {
    if o.status != OrderStatusCreated {
        return fmt.Errorf("order cannot be modified after completion")
    }
    if productID == "" {
        return fmt.Errorf("product id cannot be empty")
    }
    if quantity <= 0 {
        return fmt.Errorf("quantity must be greater than zero")
    }

    o.items = append(o.items, OrderItem{
        ProductID: productID,
        Quantity:  quantity,
        UnitPrice: unitPrice,
    })

    return nil
}

func (o *Order) Complete() error {
    if len(o.items) == 0 {
        return fmt.Errorf("order must have at least one item")
    }
    o.status = OrderStatusCompleted
    return nil
}

func (o *Order) Total() Money {
    total := Money{Cents: 0}
    for _, item := range o.items {
        total = total.Add(Money{Cents: item.UnitPrice.Cents * int64(item.Quantity)})
    }
    return total
}

internal/domain/order/repository.go

package order

import "context"

type Repository interface {
    Save(ctx context.Context, order *Order) error
    FindByID(ctx context.Context, id OrderID) (*Order, error)
}

3) Application katmanı

internal/application/order_service.go

package application

import (
    "context"
    "fmt"
    "time"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderService struct {
    repo order.Repository
}

func NewOrderService(repo order.Repository) *OrderService {
    return &OrderService{repo: repo}
}

func (s *OrderService) CreateOrder(ctx context.Context) (*order.Order, error) {
    id := order.OrderID(fmt.Sprintf("ord_%d", time.Now().UnixNano()))
    newOrder := order.NewOrder(id)

    if err := s.repo.Save(ctx, newOrder); err != nil {
        return nil, err
    }

    return newOrder, nil
}

func (s *OrderService) AddItem(ctx context.Context, orderID order.OrderID, productID string, quantity int, priceCents int64) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    price, err := order.NewMoney(priceCents)
    if err != nil {
        return nil, err
    }

    if err := o.AddItem(productID, quantity, price); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) CompleteOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    o, err := s.repo.FindByID(ctx, orderID)
    if err != nil {
        return nil, err
    }

    if err := o.Complete(); err != nil {
        return nil, err
    }

    if err := s.repo.Save(ctx, o); err != nil {
        return nil, err
    }

    return o, nil
}

func (s *OrderService) GetOrder(ctx context.Context, orderID order.OrderID) (*order.Order, error) {
    return s.repo.FindByID(ctx, orderID)
}

4) Persistence adapter (in-memory)

internal/adapters/persistence/memory/order_repository.go

package memory

import (
    "context"
    "fmt"
    "sync"

    "example.com/hexagonal-go/internal/domain/order"
)

type OrderRepository struct {
    mu     sync.RWMutex
    orders map[order.OrderID]*order.Order
}

func NewOrderRepository() *OrderRepository {
    return &OrderRepository{
        orders: make(map[order.OrderID]*order.Order),
    }
}

func (r *OrderRepository) Save(ctx context.Context, o *order.Order) error {
    r.mu.Lock()
    defer r.mu.Unlock()

    r.orders[o.ID()] = o
    return nil
}

func (r *OrderRepository) FindByID(ctx context.Context, id order.OrderID) (*order.Order, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    o, ok := r.orders[id]
    if !ok {
        return nil, fmt.Errorf("order not found: %s", id)
    }

    return o, nil
}

5) HTTP adapter

internal/adapters/http/order_handler.go

package httpadapter

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

    "example.com/hexagonal-go/internal/application"
    "example.com/hexagonal-go/internal/domain/order"
)

type OrderHandler struct {
    service *application.OrderService
}

func NewOrderHandler(service *application.OrderService) *OrderHandler {
    return &OrderHandler{service: service}
}

func (h *OrderHandler) RegisterRoutes(mux *http.ServeMux) {
    mux.HandleFunc("POST /orders", h.createOrder)
    mux.HandleFunc("GET /orders/", h.getOrder)
    mux.HandleFunc("POST /orders/{id}/items", h.addItem)
    mux.HandleFunc("POST /orders/{id}/complete", h.completeOrder)
}

func (h *OrderHandler) createOrder(w http.ResponseWriter, r *http.Request) {
    o, err := h.service.CreateOrder(r.Context())
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    respondJSON(w, http.StatusCreated, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) getOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.GetOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "items":  o.Items(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) addItem(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)

    var req struct {
        ProductID string `json:"product_id"`
        Quantity  int    `json:"quantity"`
        PriceCents int64  `json:"price_cents"`
    }

    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "invalid json", http.StatusBadRequest)
        return
    }

    o, err := h.service.AddItem(r.Context(), order.OrderID(id), req.ProductID, req.Quantity, req.PriceCents)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func (h *OrderHandler) completeOrder(w http.ResponseWriter, r *http.Request) {
    id := extractID(r.URL.Path)
    o, err := h.service.CompleteOrder(r.Context(), order.OrderID(id))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    respondJSON(w, http.StatusOK, map[string]any{
        "id":     o.ID(),
        "status": o.Status(),
        "total":  o.Total().Cents,
    })
}

func extractID(path string) string {
    parts := strings.Split(strings.Trim(path, "/"), "/")
    if len(parts) >= 2 {
        return parts[1]
    }
    return ""
}

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

6) Uygulama başlangıcı

cmd/api/main.go

package main

import (
    "log"
    "net/http"

    httpadapter "example.com/hexagonal-go/internal/adapters/http"
    "example.com/hexagonal-go/internal/adapters/persistence/memory"
    "example.com/hexagonal-go/internal/application"
)

func main() {
    repo := memory.NewOrderRepository()
    service := application.NewOrderService(repo)
    handler := httpadapter.NewOrderHandler(service)

    mux := http.NewServeMux()
    handler.RegisterRoutes(mux)

    log.Println("server started on :8080")
    if err := http.ListenAndServe(":8080", mux); err != nil {
        log.Fatal(err)
    }
}

7) Akış nasıl çalışıyor?

• HTTP adapter isteği alır.
• Application service use-case’i yürütür.
• Domain iş kurallarını uygular.
• Repository port domain tarafından tanımlanır.
• Memory adapter bu portu implement eder.

Bu yapı sayesinde domain katmanı:

• net/http bilmez,
• database bilmez,
• framework bilmez.

8) Kısa test örneği

internal/domain/order/order_test.go

package order

import "testing"

func TestOrderCompleteWithoutItems(t *testing.T) {
    o := NewOrder("1")

    if err := o.Complete(); err == nil {
        t.Fatal("expected error when completing empty order")
    }
}

func TestOrderTotal(t *testing.T) {
    o := NewOrder("1")
    price, _ := NewMoney(500)

    if err := o.AddItem("p1", 2, price); err != nil {
        t.Fatal(err)
    }

    if o.Total().Cents != 1000 {
        t.Fatalf("expected 1000, got %d", o.Total().Cents)
    }
}

9) Çalıştırma

go run ./cmd/api

Örnek istek:

curl -X POST localhost:8080/orders

curl -X POST localhost:8080/orders/ord_xxx/items \
  -H 'Content-Type: application/json' \
  -d '{"product_id":"p1","quantity":2,"price_cents":500}'

curl -X POST localhost:8080/orders/ord_xxx/complete

However, there are two critical security nuances to consider:

Residual Risks in Open Tabs

If a malicious extension was active and you disabled it while having several tabs open, its “content scripts” might still be running in those specific pages until they are refreshed. stackoverflow

• These scripts could potentially leak data through indirect methods like hidden images or CSS if the site’s Content Security Policy (CSP) is weak. stackoverflow
• Solution: You must refresh all open tabs or restart your browser after disabling an extension to ensure all its scripts are fully cleared. stackoverflow

Previously Stolen Data

Disabling an extension only stops future data collection; it does not “undo” what was already stolen while the extension was active. youtube

• If a malicious extension captured your passwords, session cookies, or personal data while it was enabled, that information is likely already stored on the attacker’s server (C2 server). linkedin
• Attackers often use stolen session tokens to maintain access to your accounts even after the extension is deleted. thehackernews

Extension Status Comparison

The following table illustrates the capabilities of an extension based on its state:

If you suspect an extension is malicious, simply disabling it is not enough. You should remove it entirely, clear your browser cookies, and change your passwords for sensitive accounts. support.google

Which specific extension are you concerned about?

Ancak güvenlik açısından dikkat edilmesi gereken iki önemli istisna bulunmaktadır:

Aktif Sekmelerdeki Kalıntı Riskler

Bir eklentiyi devre dışı bıraktığınız an, o sırada açık olan sekmelerde halihazırda enjekte edilmiş olan “içerik betikleri” (content scripts) çalışmaya devam edebilir. stackoverflow

• Bu betikler eklenti merkezine veri gönderemez ancak sitenin kendi güvenlik politikası (CSP) zayıfsa, verileri gizli görseller veya CSS üzerinden dışarı sızdırmaya çalışabilir. stackoverflow
• Çözüm: Eklentiyi kapattıktan sonra açık olan tüm sekmeleri yenilemek (Refresh) bu riski tamamen ortadan kaldırır. stackoverflow

Geçmişte Toplanan Veriler

Eklentinin devre dışı bırakılması sadece gelecekteki veri akışını keser.

• Eğer eklenti aktif olduğu süre boyunca şifrelerinizi, çerezlerinizi (cookies) veya kişisel verilerinizi uzak bir sunucuya (C2 server) gönderdiyse, bu veriler saldırganın elinde kalmaya devam eder. youtube
• Kötü niyetli eklentiler genellikle oturum jetonlarını (session tokens) çalarak, siz eklentiyi silseniz bile hesaplarınıza erişim sağlamaya devam edebilir. linkedin

Güvenli Kullanım Tablosu

Eklenti durumuna göre yetki ve risk dağılımı şu şekildedir:

Şüphelendiğiniz bir eklenti varsa sadece devre dışı bırakmak yerine doğrudan kaldırmanız ve ardından tarayıcı çerezlerini temizleyerek şifrelerinizi değiştirmeniz en güvenli yoldur. thehackernews

Hangi eklenti hakkında bu endişeyi taşıyorsunuz?

Eğitim Sistemi Sorunları

Yıllarca İngilizce dersi alınmasına rağmen konuşma becerisi düşük çünkü sistem ezber ve gramer odaklı; sınav baskısı (test-tost arasında sıkışma) üretken becerileri (konuşma-yazma) engelliyor. youtube Hazırlık sınıflarının kaldırılması ve kalitesiz materyaller/hocalar yeterliliği düşürüyor; 1000 saat ders sonrası %90 konuşamama oranı görülüyor. tepav.org

Diğer Etkenler

Sınıf ortamında yeterli maruziyet ve pratik eksikliği var; gençlerde pandemi sonrası toparlanma yok, 40+ yaşta ise gerileme belirgin. tr.investing Psikolojik nedenler (motivasyon kaybı) ve ana dilde eğitim tartışmaları İngilizceyi gölgeliyor; TOEFL skorları Sudan’la aynı seviyede. tepav.org

High‑level summary

For a growing, medium‑sized business that expects to automate more and more over time:

• Choose n8n if you have developers/DevOps, care about data control, and want the lowest long‑term total cost of ownership.
• Choose Make if you want powerful visual workflows and good pricing but prefer not to run your own infrastructure.
• Use Zapier sparingly for very simple, low‑volume automations or where its huge app catalog is a hard requirement.

parseur

Quick comparison table

Cost and scalability over the long term

Zapier counts every step as a task, including filters, formatters, and branches, so any non‑trivial workflow multiplies your task usage. That makes it very predictable but also very expensive once you hit thousands or tens of thousands of records per month; many reviews show Zapier becoming the costliest of the three at medium–high scale. lumberjack

Make’s operation‑based billing is significantly more forgiving. The free tier gives 1,000 operations, and around 9–10 USD/month buys you 10,000 operations, often 40–60% cheaper than a comparable Zapier workload. However, it is still consumption‑based: badly designed or very chatty workflows (especially with AI modules) can burn through credits faster than expected. neondigitalmedia

With n8n, self‑hosting removes per‑task licensing altogether: you pay for infrastructure only, and execution‑based counting (in cloud plans) means a 5‑step flow and a 200‑step AI agent can both cost “1 execution” if they run once. At medium and high complexity, this often translates into order‑of‑magnitude savings versus Zapier and clear savings versus Make, especially if you’re comfortable tuning your own server. xcloud

Technical flexibility, self‑hosting, and data control

Zapier and Make are pure SaaS: you get vendor‑managed security, uptime, and scaling, but your data must flow through their cloud and remain within their compliance boundaries. For many SMBs this is fine; for regulated industries, strict data‑residency requirements, or customers who require on‑prem options, this can be a blocker. summarizemeeting

n8n’s biggest differentiator is self‑hosting: you can run it on your own infrastructure (or a dedicated VPS), keep data within your own network/VPC, and control latency, retention, and throughput limits yourself. That makes it very attractive for medium‑sized companies that either already run containers/servers or are willing to invest in that capability, because you are no longer locked into a vendor’s rate limits and roadmaps. contabo

Integrations and UX

Zapier has the widest app catalog, so for very niche SaaS tools it often “just works” without custom HTTP work. Its linear trigger‑→‑action model and library of templates let marketing, sales, and ops teams build simple flows (like “when a new lead is created, send a Slack message and add to a sheet”) with almost no guidance. digidop

Make’s canvas‑style editor is much better for visually complex flows: you can see branches, error paths, and parallel routes on a single diagram, which is extremely useful for medium‑sized businesses with tangled processes. Connectors often expose deeper object fields than the Zapier equivalents, and built‑in transformers make it easy to massage data without code. lumberjack

n8n’s editor also uses a node‑based graph, but leans more toward a developer‑friendly tool: custom JavaScript, HTTP nodes, and advanced logic are standard, and you can extend it with your own nodes or packages. The trade‑off is that non‑technical users generally need some enablement; n8n is superb as a central automation “platform” owned by engineering, less so as a self‑service toy for every department. reddit

AI and advanced automation

Zapier focuses on making AI easy, not deep: natural‑language automation builders and simple ChatGPT/OpenAI steps that any user can drop into flows. This works well for simple classification or content‑generation tasks but offers limited control over advanced agent‑style patterns. parseur

Make gives you strong AI connectors (OpenAI and others) and lets you wire them into complex routes and transformations; however, AI modules consume operations, which can push bills up for heavy usage. thinkpeak

n8n currently leads on technical AI depth: LangChain nodes, support for multiple LLM providers, and the ability to compose RAG pipelines and agents directly in workflows. Combined with execution‑based pricing and self‑hosting, this makes n8n particularly attractive for medium‑sized companies planning to run serious AI workloads (document QA, routing, enrichment, ticket triage, etc.) through automation. blog.n8n

Practical guidance for medium‑sized businesses

• If you have real dev/DevOps capacity and automation is strategic
  Use n8n as your core automation layer, preferably self‑hosted. You get long‑term cost control, strong AI capabilities, and full data sovereignty, at the price of some infra and governance work. xcloud

• If your technical capacity is limited but business teams want complex workflows
  Make is usually the sweet spot: far cheaper and more powerful than Zapier for medium‑complexity flows, but still SaaS and relatively easy to onboard power users onto. neondigitalmedia

• If you mainly need a few simple automations and ultra‑fast non‑technical adoption
  Zapier can still be the right choice, especially in the early stage or for isolated use cases—just be aware that if volume and complexity grow, migration to Make or n8n is a likely future step. digidop

Given your background (strong engineering, comfortable with Docker and backends), for any company you build or advise, a hybrid of “n8n as the backbone + Make for certain visual/no‑code friendly flows” will almost always give the best long‑term mix of cost, control, and usability. summarizemeeting

Temel tablo özeti

Maliyet ve ölçeklenebilirlik

Zapier, her adımı ayrı “task” olarak fiyatladığı için (filtreler, formatter’lar, dallanmalar dahil) karmaşık iş akışlarında ve binlerce işlem/ay seviyesinde maliyet çok hızlı yukarı tırmanıyor. 10.000 task/ay civarında dahi, Zapier’in toplam maliyeti 200 $/ay ve üzeri seviyelere çıkabildiği belirtiliyor. stackby

Make, operasyon/credit bazlı modeliyle başlangıçta oldukça ucuz: 10.000 operasyon için Core plan ~10–11 $/ay bandında, bu da Zapier’e göre büyük avantaj. Ancak 2026 itibarıyla kredi modeline geçiş, AI modülleri için ek kredi tüketimi ve “complexity billing” yüzünden kötü tasarlanmış senaryolar ölçek büyüdükçe beklenenden pahalı hâle gelebiliyor. thinkpeak

n8n tarafında, self‑host kurulumda yazılım lisans bedeli yok; sadece sunucu masrafı (çoğu orta ölçekli senaryo için ~20 $/ay seviyesinde bir VPS yeterli) söz konusu ve execution bazlı model, 2 adımlık bir akışla 200 adımlık bir AI ajanını aynı “1 execution” olarak saydığı için yüksek karmaşıklıkta %90+ maliyet avantajı sağlayabildiği örneklerle anlatılıyor. Cloud sürümünde 10.000 execution için ~60 $/ay civarı, hâlâ Zapier’den ucuz ama Make’in bazı planlarına göre daha pahalı; buna karşılık self‑host seçeneği sayesinde toplam sahip olma maliyeti, teknik ekibi olan işletmelerde uzun vadede en düşük olma eğiliminde. summarizemeeting

Teknik esneklik, self‑hosting ve veri kontrolü

Zapier ve Make tamamen SaaS olduğundan, verileriniz onların altyapısından geçmek zorunda; buna karşılık SOC2/ISO gibi sertifikalarla güvenlik sunuyorlar ama veri egemenliği konusundaki son söz sizde değil. n8n ise açık kaynak/fair‑code yapısı ve self‑hosting seçeneği ile, özellikle GDPR/HIPAA benzeri regülasyon hassasiyeti olan veya müşteri datasını ülkede tutmak isteyen işletmelere tam veri kontrolü veriyor. parseur

Self‑host n8n senaryosunda; ölçeklendirme stratejilerini (kuyruk, worker sayısı, trigger sıklığı vs.) tamamen kendi SRE/DevOps yaklaşımınıza göre ayarlayabiliyor, gerektiğinde sadece altyapı büyüterek sınırsız workflow çalıştırabiliyorsunuz. Buna karşılık, bu özgürlük operasyonel yük getiriyor: sunucu yönetimi, yedekleme, güncelleme ve izleme için ya içerde bir ekip ya da dışarıdan managed hizmet almak gerekiyor; bu da teknik kapasitesi zayıf işletmeler için dezavantaj. contabo

Entegrasyon kapsaması ve kullanım deneyimi

Zapier, ~8.700+ uygulamayla en geniş entegrasyon kütüphanesine sahip ve özellikle niş SaaS ürünlerine bağlanmak gerektiğinde “en güvenli seçim” olabiliyor. Arayüz, lineer “trigger–action” mantığında olduğu için pazarlama/operasyon gibi teknik olmayan ekiplerin bile birkaç saat içinde kendi otomasyonlarını kurabilmesini sağlıyor. neondigitalmedia

Make, canvas tabanlı görsel builder’ı ve router, error route, paralel path gibi gelişmiş özellikleriyle daha karmaşık iş süreçlerini kullanıcıya çok net görselleştiriyor; bu da orta ölçekli işletmelerde “iş analisti + power user” profili için oldukça ideal. n8n’in node tabanlı mimarisi de benzer şekilde gelişmiş dallanma, hata yönetimi ve custom code node’ları sunuyor; ancak kurulum ve temel JavaScript bilgisi gerektirdiğinden teknik olmayan son kullanıcılar için learning curve belirgin şekilde daha yüksek. summarizemeeting

AI ve ileri seviye otomasyon

Zapier, AI tarafında daha çok “herkes için kolaylaştırma”yı hedefliyor; doğal dil ile otomasyon yaratma, ChatGPT entegrasyonu vb. var ama derin özelleştirme ve ajan mimarileri sınırlı. Make, OpenAI/Anthropic modülleri ve AI destekli veri dönüşümleriyle orta seviye esneklik sunuyor; fakat AI modüllerinin kredi tüketimi toplam maliyeti yukarı çekebiliyor. thinkpeak

n8n ise LangChain entegrasyonu, onlarca AI node’u ve farklı model sağlayıcılarıyla daha çok “teknik ekiplerin AI ajanları ve RAG tabanlı sistemler kurduğu” bir platform hâline gelmiş durumda. Orta ölçekte ciddi AI iş yükü olan, örneğin ticket sınıflandırma, doküman bazlı soru‑cevap, müşteri etkileşim otomasyonu gibi senaryolarda, execution bazlı model ve self‑host imkânı maliyet/performans dengesini n8n lehine çeviriyor. nicksaraev

Orta ölçekli işletmeler için pratik öneri

• Teknik ekibiniz (dev/DevOps) VAR ve otomasyon sizin için stratejik bir katman olacaksa:
  Çekirdek otomasyon altyapısını n8n (özellikle self‑host) üzerine kurmak uzun vadede genellikle en avantajlı seçenek; hem maliyet hem de esneklik/veri egemenliği açısından. latenode

• Teknik ekibiniz sınırlı ama iş birimleri karmaşık akışlar istiyor, Zapier maliyeti gözünüze batmaya başladıysa:
  Çoğu orta ölçekli işletme için Make, Zapier’e göre çok daha sürdürülebilir maliyet ve daha zengin workflow tasarım imkânı sunuyor; bakım yükü de n8n self‑host kadar ağır değil. parseur

• Tamamen non‑technical, az sayıda basit otomasyon ve düşük hacim planlıyorsanız:
  Küçük/başlangıç senaryosunda Zapier hâlâ “en hızlı sonuç veren”, iş birimlerinin en rahat adapte olduğu çözüm; ama orta vadede hacmin artacağı öngörülüyorsa, ilk günden Zapier’e kilitlenmek yerine Make veya n8n tarafını stratejik platform olarak düşünmek genelde daha sağlıklı. thatapicompany

Senin profilini (geliştirici geçmişin, Docker/sunucu yönetimine alışık olman vb.) düşününce, kendi şirketinde ya da danışmanlık vereceğin orta ölçekli firmalarda n8n + gerektiğinde Make kombinasyonu uzun vadede hem maliyet hem kontrol açısından büyük olasılıkla en mantıklı mimari olacaktır. nicksaraev

Nasıl Kullanılır

n8n’i kullanmak için öncelikle Docker ile yerel kurulum yapın veya resmi siteden (n8n.io) bulut hesabı oluşturun. Görsel arayüzde “node”ları sürükle-bırak ile ekleyin: tetikleyici (örneğin webhook veya zamanlama), işlem (HTTP istek, OpenAI entegrasyonu) ve çıktı node’larını bağlayın. JavaScript/Python kodu ekleyerek özelleştirin, workflow’u test edin ve aktif hale getirin; hata yönetimi için Error Trigger node’u kullanın. eksisozluk

Faydaları

n8n, tekrar eden görevleri otomatikleştirerek zaman tasarrufu sağlar ve manuel hataları azaltır. Geniş entegrasyon kataloğu (Google Sheets, Slack, CRM’ler) ile veri senkronizasyonu ve AI ajanları oluşturmayı kolaylaştırır, self-hosted seçenekle veri güvenliği sunar. No-code/low-code yaklaşımıyla geliştiriciler ve citizen developer’lar için idealdir, kurumsal ölçekte RBAC ve audit log gibi özelliklerle verimliliği artırır. uretkenzeka

How to Use

To use n8n, first set up a local installation with Docker or create a cloud account from the official website (n8n.io). In the visual interface, add “nodes” with drag‑and‑drop: a trigger (for example a webhook or a schedule), processing nodes (HTTP requests, OpenAI integration), and output nodes, then connect them together. You can add JavaScript/Python code for customization, test the workflow, and then activate it; for error handling, use the Error Trigger node. eksisozluk

Benefits

n8n saves time by automating repetitive tasks and reduces manual errors. With its wide catalog of integrations (Google Sheets, Slack, CRMs), it simplifies data synchronization and building AI agents, while the self‑hosted option improves data security. Its no‑code/low‑code approach makes it ideal for both developers and citizen developers, and at an enterprise scale it increases efficiency with features such as RBAC and audit logs. uretkenzeka

According to the official n8n resources, the platform indeed offers 400+ integrations and can be deployed either self‑hosted or in the cloud, confirming the points above. github

Historical firsts
In 1843, Ada Lovelace wrote an algorithm for calculating Bernoulli numbers for Charles Babbage’s Analytical Engine; many historians regard this as the first program designed to be executed by a computer and, indirectly, as the first example of a programming language. talentgrid
Some sources give the title of a programming language in the true sense to Plankalkül, developed in the 1940s by Konrad Zuse; this language is more systematic and general‑purpose, like modern languages. talentgrid

The first high‑level languages
The first widely accepted high‑level and commercially successful language is FORTRAN, developed in the mid‑1950s at IBM by John Backus’s team; it is considered one of the oldest languages still in use today. talentgrid
Languages such as LISP and COBOL, developed in the same period, are also counted among the early high‑level languages and are still used in certain domains. talentgrid

Summary answer
For the beginning of the recorded “first program” and the idea of a programming language: Ada Lovelace’s 1843 algorithm. talentgrid
For the first general‑purpose programming language in the modern sense: Konrad Zuse’s Plankalkül language. talentgrid
For the first widely used high‑level language in practice: FORTRAN. talentgrid

With which language was the first language developed, was it assembly?
No, the first programming languages were not developed with assembly; assembly emerged in the late 1940s as a low‑level language closer to machine code. talentgrid

Early period languages
The history of programming begins in 1843 with Ada Lovelace’s algorithm written for Charles Babbage’s Analytical Engine; this is considered the first program containing machine instructions, but it is not a complete language. talentgrid
In the 1940s, Konrad Zuse’s Plankalkül was designed as the first general‑purpose programming language to carry high‑level concepts, but it was not implemented in practice. talentgrid

The place of assembly
Assembly‑like languages were used on early electronic computers such as the ARC Assembly in 1947 and the short codes developed for ENIAC in 1948; these were symbolic instructions close to machine language. emirhankabakci
Truly widespread assembly appeared in the early 1950s with the commercialization of computers and provided the infrastructure for compilers of high‑level languages such as FORTRAN. talentgrid

Chronological order
1843: Ada Lovelace’s algorithm (first program). talentgrid
1944–45: Plankalkül (first high‑level design). talentgrid
1947–49: Short Code and early assemblies. emirhankabakci
1957: FORTRAN (first commercial high‑level language). talentgrid

What are the differences between Plankalkül and assembly?
Plankalkül and assembly languages were developed in the early period of programming history, but they show distinct differences in level, abstraction, and usage. reddit

Level and abstraction
Plankalkül (1940s, Konrad Zuse) is a high‑level language design; it contains modern concepts such as loops, conditionals, subprograms, and data structures, and is independent of machine architecture. talentgrid
Assembly, on the other hand, is a low‑level (machine‑close) language; it directly represents processor instructions with mnemonic codes and provides access to registers and memory addresses. muhammedaygun

Usage and historical implementation
Plankalkül remained theoretical; it was designed in 1945 but was not implemented in practice and no compiler was developed. talentgrid
Assembly was used practically on electronic computers in the late 1940s and early 1950s (for example ENIAC, 1947); it is translated into machine code by assemblers and is common in high‑performance systems. emirhankabakci

Feature comparison: Plankalkül vs. assembly
Feature – Plankalkül – Assembly reddit
Level: High (abstract concepts) – Low (processor instructions)
Independence: Architecture‑independent – Architecture‑dependent (x86, ARM, etc.)
Complexity: Algorithmic structures (loops, functions) – Simple instructions (MOV, ADD, etc.)
Implementation: Theoretical, not implemented – Practical, works with assemblers

What is the historical development of assembly language and its first applications?
Assembly language developed in the late 1940s as a low‑level programming language that represents machine code (binary instructions) with mnemonic symbols. tr.wikipedia

First applications
The first assembly‑like systems began with the EDSAC order code developed by Maurice Wilkes for the Cambridge EDSAC in 1947 and with Short Code in 1949; these made it possible to write machine instructions using abbreviated symbols. emirhankabakci
In 1948, shortened codes were used for ENIAC by programmers such as Kathryn Kleiman and Betty Holberton, but a full assembler appeared in 1951 in IBM’s EDVAC project. tr.wikipedia

Historical development
In the early 1950s, commercial assemblers became widespread with Grace Hopper’s A‑0 and A‑2 assemblers; these formed the infrastructure for high‑level languages such as FORTRAN. talentgrid
By the 1960s, standard assembly languages (for example BAL) were developed for architectures such as the IBM System/360, and today they have been adapted to architectures such as x86 and ARM. muhammedaygun

1947: EDSAC order code (first symbolic assembly). tr.wikipedia
1949: Short Code (for ENIAC). emirhankabakci
1951: First full assembler (EDVAC). tr.wikipedia
1952: A‑2 (commercial assembler). talentgrid

With what language was C developed, with which language?
Historically, the C language was developed by deriving it from the B language; B is a language influenced by BCPL. tr.wikipedia

Origins of C
Around 1972, C was created by Dennis Ritchie at AT&T Bell Laboratories by extending and improving the B language in order to develop the UNIX operating system. tr.wikipedia
Therefore, the short answer to the question “With what was C developed?” is: The C language is a systems programming language built on top of B and influenced by ideas coming from BCPL. tr.wikipedia

Writing of the C compiler
The first C compilers and the early versions of the UNIX kernel were written largely in assembly language and partly in earlier languages (for example B), depending on the architecture of the target hardware; later, most of the UNIX kernel was rewritten in C. tr.wikipedia
Over time, C became the primary language used to write both its own compilers and the compilers of other languages; most C compilers in use today have been developed in C or C++. tr.wikipedia

With what language was BCPL developed?
BCPL (Basic Combined Programming Language) was developed in 1967 by Martin Richards as a simplified version of a more complex language called the Cambridge Programming Language (CPL). tr.wikipedia

Origin and development process
BCPL was designed to eliminate the compilation difficulties of CPL; CPL had been developed in the early 1960s, and BCPL emerged by simplifying the features of this language. en.wikipedia
Ken Thompson used BCPL to bootstrap‑develop the B language; that is, the first implementation of B was written with a BCPL compiler, and then the BCPL compiler was rewritten in B. reddit

Technical details
BCPL is an untyped language; all data are handled as “words” and it is suitable for low‑level system programming close to the machine. en.wikipedia
The first BCPL compiler was written for the IBM 7094 in 1967 and generated an intermediate language called O‑code to provide portability. en.wikipedia

With what language was CPL written?
CPL (Cambridge Programming Language) was developed in the early 1960s and was not written directly in a preceding programming language; at the design stage it was heavily influenced by ALGOL 60. en.wikipedia

Design and development origin
CPL was designed at the Cambridge University Mathematical Laboratory by Christopher Strachey, David Barron, and others; its first paper was published in 1963, and it was implemented on Titan and Atlas computers. en.wikipedia
Unlike the simplicity of ALGOL 60, CPL was planned as an extended language for industrial control, data processing, and low‑level programming, but because of its complexity its first compiler was completed in the 1970s. en.wikipedia

Implementation details
The first CPL compiler was most likely written in assembly language or low‑level machine‑specific code of that period, because high‑level compilers were not yet widespread. en.wikipedia
BCPL, as a simplified version of CPL, was developed in 1967 by Martin Richards using the bootstrap method (with its own compiler) and became CPL’s practical successor. en.wikipedia

How was assembly language developed?
Assembly language was developed in the late 1940s by using mnemonic symbols and symbolic addresses to make machine code (binary instructions) readable to programmers. tr.wikipedia

Development process
Early computers (ENIAC, EDSAC) were programmed only with binary machine code; to overcome this difficulty, in 1947 Maurice Wilkes designed the first symbolic assembly system (order code) for EDSAC. emirhankabakci
In 1949, Short Code and, in 1951, full assemblers for IBM EDVAC appeared; assembler programs were the first tools that automatically translated symbolic code into machine code. tr.wikipedia

Key steps
1947: EDSAC order code – Mnemonic instructions (e.g., ADD instead of 101). tr.wikipedia
1949: ENIAC Short Code – Numeric abbreviations. emirhankabakci
1951: EDVAC assembler – Symbolic addressing and labels. tr.wikipedia
1952: Grace Hopper’s A‑0/A‑2 – Commercial assemblers, infrastructure for FORTRAN. talentgrid
Assemblers themselves were written in assembly or machine code and formed the basis for high‑level languages. tr.wikipedia

This is the English translation of your original Turkish text.