Modern web geliştirme süreçleri, özellikle büyük ve karmaşık uygulamalar söz konusu olduğunda, genellikle zorlu ve zaman alıcı olabiliyor. Frontend ve backend arasındaki yoğun JavaScript trafiği, API karmaşası ve sürekli bağlam geçişleri developer deneyimini olumsuz etkileyebilir. Bu makalede, Go, sqlc ve HTMX üçlüsünün bir araya geldiği, performans odaklı ve geliştirici dostu full stack web uygulamaları nasıl geliştirebileceğimizi adım adım inceleyeceğiz. Eğer SPA (Single Page Application) yaklaşımlarının getirdiği karmaşadan sıkıldıysanız ve daha basit, daha hızlı bir alternatif arıyorsanız, doğru yerdesiniz. Gelin, bu yeni nesil mimariye birlikte bir göz atalım!

Günümüz web uygulamaları, kullanıcı beklentilerinin artmasıyla birlikte giderek daha karmaşık hale geliyor. Özellikle geleneksel SPA mimarileri, frontend (genellikle React, Angular, Vue gibi JavaScript framework’leri) ve backend (API servisleri) arasındaki keskin ayrım nedeniyle kendine özgü zorlukları beraberinde getiriyor. Her ne kadar bu ayrım, büyük ekipler için iş bölümü avantajı sunsa da, pratik uygulamada birçok baş ağrısına yol açabilir. Örneğin, frontend ve backend’in ayrı ayrı geliştirilmesi, sürekli bir API kontrat yönetimi gerektirir. API versiyonlama, veri serileştirme/deserileştirme, hata yönetimi ve her iki taraf için ayrı ayrı test yazma süreçleri, geliştirme döngüsünü uzatabilir ve maliyeti artırabilir.

Ayrıca, JavaScript tabanlı frontend’lerde paket büyüklüğü, başlangıç yükleme süresi (initial load time) ve karmaşık durum yönetimi gibi konular performans üzerinde ciddi etkilere sahip olabilir. Tarayıcıda çalıştırılan JavaScript’in miktarı arttıkça, kullanıcının cihazında CPU ve bellek tüketimi de artar, bu da özellikle düşük donanımlı cihazlarda veya yavaş internet bağlantılarında kötü bir kullanıcı deneyimine yol açabilir. Geliştiriciler, sürekli olarak performans optimizasyonları ve kod bölme gibi tekniklerle bu sorunların üstesinden gelmeye çalışır, ancak bu da ek bir efor ve uzmanlık gerektirir. Backend tarafında ise, mikroservis mimarileri her ne kadar ölçeklenebilirlik avantajları sunsa da, servisler arası iletişim karmaşası, dağıtık işlem yönetimi ve izlenebilirlik gibi operasyonel yükleri beraberinde getirir. Birden fazla mikroservisi yönetmek, geliştiricilerin farklı teknolojiler ve diller arasında sürekli bağlam değiştirmesini gerektirebilir, bu da odaklanmayı zorlaştırır ve hata yapma olasılığını artırır.

İşte tam da bu noktada, Go, sqlc ve HTMX gibi araçlar devreye giriyor. Bu üçlünün sunduğu yaklaşım, frontend ve backend arasındaki ayrımı minimalize ederek, monolitik bir yapı içerisinde hızlı, performanslı ve bakımı kolay uygulamalar geliştirmeyi hedefliyor. Geleneksel yaklaşımların getirdiği API bağımlılığını azaltmak, JavaScript yükünü hafifletmek ve geliştirici verimliliğini artırmak bu kombinasyonun temel motivasyonları arasında yer alıyor. Bir düşünün; SQL sorgularınızı doğrudan Go kodunuzda tip güvenli bir şekilde yönetirken, kullanıcı arayüzünüzü neredeyse hiç JavaScript yazmadan dinamik hale getirebiliyorsunuz. Bu, modern web geliştirmenin getirdiği birçok zorluğa karşı oldukça cazip bir alternatif sunuyor.

Go, sqlc ve HTMX Üçlüsü: Neden Bu Kombinasyon Tercih Edilmeli?

Web geliştirmenin hızla değişen dünyasında, doğru teknoloji yığınını seçmek, projenin başarısı için kritik öneme sahiptir. Geleneksel yaklaşımların getirdiği karmaşıklıklara bir çözüm arayışında olan geliştiriciler için Go, sqlc ve HTMX kombinasyonu, taze bir nefes niteliğindedir. Peki, bu üçlü neden bu kadar güçlü ve neden tercih etmelisiniz? Bu sorunun cevabı, her bir bileşenin kendine özgü avantajlarında ve bu avantajların bir araya gelerek yarattığı sinerjide gizlidir. Öncelikle her birine kısaca göz atalım:

• Go: Performans ve Basitliğin Adresi
  Google tarafından geliştirilen Go (Golang), yüksek performans, eşzamanlılık ve ölçeklenebilirlik gerektiren backend sistemleri için tasarlanmış modern bir programlama dilidir. Statik tipli yapısı ve minimalist sözdizimi sayesinde güvenli, okunabilir ve hızlı kod yazmayı teşvik eder. Dahili goroutine’ler ve kanallar sayesinde eşzamanlı programlama Go’da oldukça kolaydır, bu da yüksek trafikli web servisleri veya API’ler geliştirmek için ideal bir seçenek haline gelir.
• sqlc: Type-Safe SQL Sorguları Yazmanın En Hızlı Yolu
  Veritabanı etkileşimleri, herhangi bir web uygulamasının belkemiğidir. sqlc, yazdığınız SQL sorgularından Go kodu üreten bir araçtır. Siz temiz ve standart SQL yazarsınız, sqlc bu SQL sorgularını analiz eder ve Go arayüzleri, modelleri ve fonksiyonları oluşturur. Bu sayede, veritabanı işlemleriniz tamamen tip güvenli hale gelir, derleme zamanı hataları yakalanır ve geliştirici, veritabanı ile etkileşimde bulunurken güvenle çalışır. sqlc’nin performansı, elle yazılmış SQL’e yakınken, developer deneyimi tip güvenliği sayesinde önemli ölçüde artar.
• HTMX: JavaScript’siz İnteraktif Arayüzler Mümkün mü?
  HTMX, HTML‘i doğrudan sunucuyla etkileşim kurabilecek yeteneklerle genişleten, küçük, bağımlılıksız bir JavaScript kütüphanesidir. Temel felsefesi, sunucudan yalnızca HTML parçacıkları alıp, DOM’u güncellemek için minimal JavaScript kullanmaktır. Bu sayede, büyük JavaScript framework’lerinin getirdiği karmaşıklıktan, bundle boyutlarından ve öğrenme eğrisinden kurtulmuş olursunuz. Form gönderimlerini, dinamik içerik yüklemeyi, sayfa yenileme olmadan listeleri güncellemeyi, sadece HTML öznitelikleri (hx-get, hx-post, hx-target, hx-swap vb.) kullanarak yapabilirsiniz.

Bu üçlünün bir araya gelmesiyle ortaya çıkan sinerji, geliştirici verimliliğini artırırken, son kullanıcıya daha hızlı ve daha duyarlı bir deneyim sunar. Go güçlü bir backend sağlarken, sqlc veritabanı etkileşimlerini güvenli hale getirir ve HTMX, minimal çabayla zengin kullanıcı deneyimleri sunar. Bu kombinasyon, özellikle hızlı prototipleme, düşük maliyetli bakım ve yüksek performans gerektiren projeler için ideal bir çözüm sunmaktadır. Böylece, SPA’ların getirdiği birçok karmaşıklığı aşarak, daha geleneksel ama modern bir yaklaşımla web uygulamaları geliştirebiliriz.

Proje Ortamını Kurma ve Veritabanı Etkileşimi: sqlc ile İlk Adımlar

Artık teorik bilgilere sahibiz; şimdi Go, sqlc ve HTMX üçlüsünü kullanarak ilk full stack web uygulamamızı oluşturmanın pratik adımlarına geçelim. Herhangi bir yazılım geliştirme projesinde olduğu gibi, öncelikle çalışma ortamımızı hazırlamamız ve gerekli araçları kurmamız gerekiyor. Bu bölümde, projemizin temel yapısını oluşturacak kurulumları adım adım ele alacak ve ardından sqlc ile tip güvenli veritabanı sorgularımızı oluşturacağız.

PostgreSQL Veritabanı Nasıl Hazırlanır ve Şema Oluşturulur?

Verilerimizi saklamak için güçlü ve güvenilir bir ilişkisel veritabanına ihtiyacımız var. PostgreSQL, bu tür projeler için mükemmel bir seçimdir. Kurulumu basitleştirmek ve yerel geliştirme ortamınızı kirletmemek için Docker kullanmayı tercih edeceğiz. Eğer Docker kurulu değilse, öncelikle Docker’ın resmi web sitesinden işletim sisteminize uygun sürümünü kurmanız gerekmektedir.

PostgreSQL konteynerini başlatmak için terminalinizde aşağıdaki komutu çalıştırabilirsiniz:

docker run --name go-fullstack-postgres -e POSTGRES_PASSWORD=mysecretpassword -p 5432:5432 -d postgres:13

Bu komut, PostgreSQL konteynerini arka planda başlatacak ve ana bilgisayarınızın 5432 portuna eşleyecektir. Konteynerin çalışıp çalışmadığını kontrol etmek için docker ps komutunu kullanabilirsiniz. Şimdi Go projemiz için bir dizin oluşturalım ve bu dizine geçelim:

mkdir go-fullstack-app
cd go-fullstack-app
go mod init go-fullstack-app
go get github.com/lib/pq
mkdir -p db/migration db/query db/sqlc

Ardından, kullanıcı bilgilerini saklayacak bir tabloya ihtiyacımız var. db/migration dizininde 001_create_users_table.sql adında bir dosya oluşturalım ve içine aşağıdaki SQL kodunu ekleyelim:

-- db/migration/001_create_users_table.sql

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

Bu şemayı veritabanımıza uygulamak için psql kullanabiliriz (şifre mysecretpassword):

psql -h localhost -p 5432 -U postgres -d postgres -f db/migration/001_create_users_table.sql

sqlc Konfigürasyonu ve Tip Güvenli Sorgu Üretimi

sqlc'nin çalışabilmesi için bir yapılandırma dosyasına ihtiyacı var. Proje dizininizin kökünde sqlc.yaml adında bir dosya oluşturalım:

version: "2"
sql:
  - engine: "postgresql"
    queries: "./db/query/"
    schema: "./db/migration/"
    gen:
      go:
        package: "db"
        out: "./db/sqlc"
        sql_package: "database/sql"

Bu yapılandırma, sqlc'ye PostgreSQL kullanacağını, SQL sorgularımızın ./db/query/ içinde olduğunu ve Go kodunu ./db/sqlc/ dizinine db paketi olarak üreteceğini söyler. Şimdi sorgularımızı yazalım. db/query/users.sql adında bir dosya oluşturalım:

-- db/query/users.sql

-- name: CreateUser :one
INSERT INTO users (username, email, password_hash)
VALUES ($1, $2, $3)
RETURNING id, username, email, created_at;

-- name: ListUsers :many
SELECT id, username, email, created_at FROM users
ORDER BY created_at DESC;

Bu dosyada iki temel sorgu tanımladık: yeni kullanıcı oluşturmak (CreateUser) ve tüm kullanıcıları listelemek (ListUsers). Her sorgunun başındaki -- name: SorguAdı :tip yorumları, sqlc'nin Go fonksiyonlarını üretmesi için kullanılır. Son olarak, sqlc'den Go kodunu üretmesini isteyelim:

sqlc generate

Bu komut, db/sqlc dizini altına models.go, query.sql.go ve db.go dosyalarını oluşturacaktır. Artık Go kodunuzda db/sqlc paketini içe aktararak, veritabanı işlemlerinizi tamamen tip güvenli bir şekilde gerçekleştirebilirsiniz. Bu sayede, SQL sözdizimi hataları veya yanlış parametre kullanımı gibi sorunlar derleme zamanında tespit edilebilir, bu da geliştirme sürecini hızlandırır ve hataları azaltır.

Go Backend'i Oluşturma: Sunucu, Handler'lar ve Veri İşlemleri

Proje ortamımızı hazırladığımıza ve sqlc ile tip güvenli veritabanı etkileşimlerimizi kurduğumuza göre, şimdi uygulamamızın backend tarafını Go ile inşa edelim. Bu bölümde, basit bir HTTP sunucusu kuracak, PostgreSQL veritabanına bağlanacak ve sqlc tarafından üretilen kodları kullanarak kullanıcı verilerini okuyup yazmak için temel HTTP handler'ları oluşturacağız. Amacımız, Go'nun hızını ve basitliğini kullanarak, HTMX ile etkileşime girecek sağlam bir API katmanı oluşturmak.

Temel Sunucu ve Veritabanı Bağlantısı Nasıl Yapılır?

Proje kök dizininde main.go adında bir dosya oluşturalım. Bu dosya, uygulamamızın başlangıç noktasını içerecek ve sunucumuzu, veritabanı bağlantımızı ve route'larımızı barındıracak. Go'nun net/http paketi, web sunucusu oluşturmak için son derece yeteneklidir ve bu örnek için yeterlidir.

// main.go

package main

import (
	"context"
	"database/sql"
	"fmt"
	"html/template" // HTML şablonları için
	"log"
	"net/http"
	"os"

	"go-fullstack-app/db/sqlc" // sqlc tarafından üretilen kodlar
	_ "github.com/lib/pq"     // PostgreSQL sürücüsü
)

var templates = template.Must(template.ParseFiles("templates/index.html")) // Şablonu global olarak yüklüyoruz

func main() {
	dbURL := os.Getenv("DATABASE_URL")
	if dbURL == "" {
		dbURL = "postgresql://postgres:mysecretpassword@localhost:5432/postgres?sslmode=disable"
	}

	conn, err := sql.Open("postgres", dbURL)
	if err != nil {
		log.Fatalf("Veritabanına bağlanırken hata oluştu: %v", err)
	}
	defer conn.Close()

	if err = conn.Ping(); err != nil {
		log.Fatalf("Veritabanı bağlantısı kontrolünde hata oluştu: %v", err)
	}
	log.Println("Veritabanı bağlantısı başarılı!")

	queries := sqlc.New(conn) // sqlc Query nesnesini oluştur

	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
		usersHandler(w, r, queries)
	})
	http.HandleFunc("/register", func(w http.ResponseWriter, r *http.Request) {
		registerHandler(w, r, queries)
	})

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	log.Printf("Sunucu http://localhost:%s adresinde çalışıyor...", port)
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
	err := templates.ExecuteTemplate(w, "index.html", nil)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

// ... usersHandler ve registerHandler fonksiyonları aşağıda tanımlanacak ...

Yukarıdaki kodda, PostgreSQL bağlantısını kuruyoruz ve sqlc'nin ürettiği Queries nesnesini kullanarak veritabanı işlemlerini gerçekleştirecek bir temel hazırlıyoruz. homeHandler, ilk etapta ana HTML şablonumuzu servis edecek. /users ve /register yolları için handler'ları tanımladık, ancak detaylarını şimdi ekleyeceğiz.

Kullanıcı Kayıt ve Listeleme Handler'ları Nasıl Geliştirilir?

Şimdi usersHandler ve registerHandler fonksiyonlarını main.go içine ekleyelim. Bu handler'lar, gelen HTTP isteklerini işleyecek ve sqlc ile veritabanıyla etkileşime geçecek:

// main.go (önceki kodun devamı)

func usersHandler(w http.ResponseWriter, r *http.Request, queries *sqlc.Queries) {
	ctx := r.Context()
	users, err := queries.ListUsers(ctx) // sqlc tarafından üretilen fonksiyon
	if err != nil {
		http.Error(w, fmt.Sprintf("Kullanıcılar listelenirken hata oluştu: %v", err), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	// HTMX sadece bu HTML parçacığını bekliyor
	fmt.Fprintf(w, "
")
	if len(users) == 0 {
		fmt.Fprintf(w, "
Henüz kayıtlı kullanıcı bulunmuyor.
")
	} else {
		fmt.Fprintf(w, "
")
		for _, user := range users {
			fmt.Fprintf(w, "
ID: %d, Kullanıcı Adı: %s, E-posta: %s
",
				user.ID, user.Username, user.Email)
		}
		fmt.Fprintf(w, "
")
	}
	fmt.Fprintf(w, "
")
}

func registerHandler(w http.ResponseWriter, r *http.Request, queries *sqlc.Queries) {
	if r.Method != http.MethodPost {
		http.Error(w, "Sadece POST metodu kabul edilir.", http.StatusMethodNotAllowed)
		return
	}

	if err := r.ParseForm(); err != nil {
		http.Error(w, fmt.Sprintf("Form verileri parse edilirken hata oluştu: %v", err), http.StatusBadRequest)
		return
	}

	username := r.FormValue("username")
	email := r.FormValue("email")
	password := r.FormValue("password") // Gerçek uygulamada şifreyi hash'lemelisiniz!

	if username == "" || email == "" || password == "" {
		http.Error(w, "Tüm alanları doldurmanız gerekmektedir.", http.StatusBadRequest)
		return
	}

	passwordHash := password // Şimdilik basitleştiriyoruz, GERÇEK UYGULAMADA GÜVENLİK İÇİN HASH KULLANIN!

	ctx := r.Context()
	newUserParams := sqlc.CreateUserParams{
		Username:    username,
		Email:       email,
		PasswordHash: passwordHash,
	}

	user, err := queries.CreateUser(ctx, newUserParams)
	if err != nil {
		log.Printf("Kullanıcı oluşturulurken hata oluştu: %v", err)
		http.Error(w, "
Kullanıcı kaydı başarısız! E-posta veya kullanıcı adı zaten mevcut olabilir.
", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	fmt.Fprintf(w, "
")
	fmt.Fprintf(w, "
Kullanıcı %s başarıyla kaydedildi! ID: %d
", user.Username, user.ID)
	fmt.Fprintf(w, "
")
}

usersHandler, sqlc'nin ListUsers fonksiyonunu çağırarak veritabanındaki tüm kullanıcıları çeker ve bunları bir HTML listesi olarak döndürür. registerHandler ise, POST isteğiyle gelen form verilerini ayrıştırır, yeni bir sqlc.CreateUserParams oluşturur ve CreateUser fonksiyonu ile kullanıcıyı veritabanına kaydeder. Başarılı veya başarısız durumlarda, HTMX'in hedefleyeceği bir HTML parçacığı döndürürüz. Bu noktada Go backend'imiz temel veritabanı işlemlerini gerçekleştirmeye hazır. Bir sonraki adımda, HTMX ile bu handler'larımızı nasıl etkileşimli hale getireceğimize odaklanacağız.

HTMX ile Frontend'i Canlandırma: JavaScript'siz Dinamik Arayüzler

Go backend'imiz ve sqlc ile tip güvenli veritabanı etkileşimlerimiz hazır olduğuna göre, sıra geldi kullanıcı arayüzüne. HTMX, modern web uygulamalarında JavaScript karmaşasından kaçınmak isteyenler için güçlü ve basit bir alternatiftir. Bu bölümde, Go'nun html/template paketiyle birlikte HTMX'i kullanarak, neredeyse hiç JavaScript yazmadan dinamik ve interaktif arayüzler oluşturacağız.

HTML Şablonunu Hazırlama ve HTMX Entegrasyonu Nasıl Yapılır?

Go, HTML şablonlarını işlemek için yerleşik ve güvenli bir html/template paketi sunar. Bu paket, sunucudan dinamik HTML oluşturmak için kullanılır ve XSS (Cross-Site Scripting) gibi güvenlik açıklarına karşı otomatik koruma sağlar. İlk olarak, bir HTML şablon dosyası oluşturalım. Proje dizinimizin kökünde templates adında bir dizin açalım ve içine index.html adında bir dosya oluşturalım:

    

        
Yeni Kullanıcı Kaydı
        

            

                Kullanıcı Adı:
                
            
            

                E-posta:
                
            
            

                Şifre:
                
            
            Kaydol
        

        

            
        

        

            
Mevcut Kullanıcılar
            Kullanıcıları Yükle / Yenile
            

                
            
        
    

Yukarıdaki HTML dosyasında, HTMX kütüphanesini CDN üzerinden dahil ettik ve form ile butonlara HTMX öznitelikleri (hx-post, hx-get, hx-target, hx-swap, hx-on::after-request) ekledik. Bu öznitelikler sayesinde, form gönderimleri ve kullanıcı listesi yükleme işlemleri sayfa yenilenmeden, arka planda AJAX istekleriyle gerçekleşecek. Ayrıca, basit bir @media (max-width: 600px) kuralı ile mobil uyumlu tasarım için CSS örneklerini de dahil ettik.

Go Sunucusunda Şablonları Servis Etme

main.go dosyamızda zaten şablonu yüklemiştik ve homeHandler içerisinde index.html'i servis ediyoruz. usersHandler ve registerHandler fonksiyonlarımız da HTMX'in beklediği HTML parçacıklarını döndürecek şekilde zaten düzenlenmişti. Bu sayede, Go sunucumuz HTMX ile sorunsuz bir şekilde etkileşime geçebiliyor.

Uygulamayı tekrar çalıştırın (go run main.go) ve http://localhost:8080/ adresine gidin. Kullanıcı kayıt formunu doldurun ve "Kaydol" butonuna tıklayın. Sayfa yenilenmeden, "Kaydol" butonunun altında kayıt sonucunu göreceksiniz. Ardından "Kullanıcıları Yükle / Yenile" butonuna tıklayarak güncel kullanıcı listesini görebilirsiniz. Bu, HTMX'in gücünü gösteren basit ama etkili bir örnektir. JavaScript yazmadan, sunucu tarafında oluşturulan HTML ile dinamik arayüzler elde ettik!

Sıkça Sorulan Sorular

Go, sqlc ve HTMX kullanmak, geleneksel SPA framework'lerinden (React/Vue) daha mı iyi?

"Daha iyi" demek yerine "farklı bir yaklaşım" demek daha doğru olur. Geleneksel SPA'lar, zengin client-side etkileşimler ve karmaşık durum yönetimi gerektiren uygulamalar için hala güçlüdür. Ancak bu üçlü, geliştirici verimliliğini artırmak, JavaScript bağımlılığını azaltmak, daha hızlı başlangıç yükleme süreleri sunmak ve backend tarafında daha fazla kontrol sahibi olmak isteyen projeler için mükemmel bir alternatiftir. Özellikle SEO'nun kritik olduğu veya ekibin JavaScript uzmanlığının sınırlı olduğu durumlarda çok avantajlı olabilir.

sqlc, bir ORM (Object-Relational Mapping) aracı mıdır?

Hayır, sqlc bir ORM değildir. sqlc, yazılı SQL sorgularınızdan tip güvenli Go kodu üreten bir araçtır. Yani, veritabanı şemanız ve sorgularınız üzerinde tam kontrolünüz olur. ORM'ler ise genellikle veritabanı tablolarını kod objelerine eşler ve SQL'i soyutlar. sqlc, ORM'lerin aksine "SQL first" yaklaşımını benimser ve SQL'in tüm gücünü ve esnekliğini korumanızı sağlar.

HTMX, tüm JavaScript ihtiyaçlarımı karşılayabilir mi?

HTMX, birçok yaygın interaktif web özelliği için yeterli olabilir (form gönderimleri, dinamik içerik yükleme, sıralama, filtreleme vb.). Ancak, karmaşık animasyonlar, özel grafikler, client-side durum yönetimi gerektiren detaylı bileşenler veya tarayıcı API'leriyle yoğun etkileşimler gibi durumlarda saf JavaScript veya daha kapsamlı bir JavaScript framework'ü kullanmanız gerekebilir. HTMX, JavaScript'i tamamen ortadan kaldırmak yerine, gerektiğinde kullanma felsefesini destekler.

Sonuç: Gelecek Bölüm İçin Bir Bakış

Bu makalede, Go, sqlc ve HTMX üçlüsünün modern web geliştirme süreçlerinde karşılaşılan karmaşıklıklara nasıl şık ve performanslı bir çözüm sunduğunu adım adım inceledik. Geleneksel SPA yaklaşımlarının getirdiği API karmaşası ve JavaScript yükü gibi zorluklara karşı, bu kombinasyonun daha basit, daha hızlı ve daha güvenli bir alternatif oluşturabileceğini gördük. PostgreSQL veritabanımızı Docker ile hızlıca kurduk, Go projemizi yapılandırdık ve sqlc için gerekli konfigürasyonları yaptık. Veritabanı şemamızı oluşturup sqlc ile sorgularımızı Go koduna çevirdikten sonra, Go sunucumuzda temel HTTP handler'ları yazarak backend'imizi ayağa kaldırdık. En nihayetinde, html/template ile birlikte HTMX'i entegre ederek, kullanıcı kayıt formu ve dinamik kullanıcı listesi gibi interaktif özellikleri minimal çabayla hayata geçirdik.

Bu, "Go full stack web app tutorial with sqlc and htmx" serimizin yalnızca ilk bölümüydü. İkinci bölümde, bu temel yapıyı daha da geliştireceğiz. Kullanıcı kimlik doğrulama (authentication) ve yetkilendirme (authorization) sistemlerini Go tarafında nasıl uygulayabileceğimizi, oturum yönetimini veya JWT (JSON Web Tokens) kullanımını HTMX ile nasıl entegre edebileceğimizi inceleyeceğiz. Ayrıca, daha karmaşık form işlemleri, canlı arama (live search) gibi gelişmiş HTMX özelliklerini ve uygulamanın genel mimarisini daha modüler hale getirme yollarını keşfedeceğiz. Şimdilik, bu güçlü kombinasyonun temellerini attınız ve full stack Go geliştirmenin keyfini çıkarmaya hazırsınız. Gelecek bölümde görüşmek üzere!