---
title: 'Tek Depo ve Çok Depo'
source: 'https://academia.sh/tr/kurslar/ileri-git/tek-depo-ve-cok-depo'
course: 'İleri Git'
language: tr
updated: '2026-08-17T18:10:42+00:00'
license: 'CC BY-SA 4.0'
---

# Tek Depo ve Çok Depo

Aynı iş iki düzende: toplam nesne iki düzende de 22600'dür ama depo başına bedel 22600 ile 5650, ikili arama 11 ile 36 adım, ve bileşenler arası dört sorudan tek depo 4'ünü yanıtlarken çok depo 1'ini yanıtlar.

Bu konunun dört dersi aynı depoya dört ayrı müdahale yaptı: bağımlı depoyu gömdü, ikili
gövdeyi dışarı taşıdı, çalışma ağacını çoğalttı ve dönüşüm katmanını ayarladı. Dördü de bir
şeyi sabit tuttu — deponun **sınırını**.

Bu ders o sınırı değişken yapar. Aynı iş, aynı işlemeler ve aynı nesneler; tek fark, hepsinin
bir deponun içinde mi yoksa dört ayrı deponun içinde mi durduğu. Ölçek ve sahiplik
ödünleşimlerinin kurumsal tartışması Yazılım Mimarlığı kursundaki Kurumsal Bağlam ve
Tümleştirme ile DevOps ve Platform Mühendisliği kurslarında kuruldu ve burada
tekrarlanmıyor. Burada ölçülen tek şey şudur: **nesne, adım ve yanıtlanan soru.**

## İki Düzen, Aynı İş

**Tek depo (monorepo)**, birden çok bileşenin tek bir depoda ve tek bir tarihçede durduğu
düzendir. **Çok depo (polyrepo)**, her bileşenin kendi deposunda ve kendi tarihçesinde
durduğu düzendir.

Ayrımın ölçüme giren yanı tek cümleyle kurulur: **tek depoda bileşenler ortak bir sıra
paylaşır, çok depoda paylaşmaz.** Tek depoda iki bileşene aynı işlemede dokunulabilir ve
tarihçe bunu kaydeder; çok depoda her deponun kendi sırası vardır ve iki sıra arasında
karşılaştırılabilir bir ortak nokta yoktur.

Ölçüm bu yüzden bölmeyi bir yeniden yazma olarak değil, aynı işleme dizisinin ayrı
tarihçelere dağıtılması olarak modelliyor. Nesneler aynı, işlemeler aynı; değişen tek şey
sınır.

## Ölçümün Varsayımları

- **BD27** — Aynı iş ortak kurgunun **4000** işlemelik ölçeğidir. Çok depo düzeni bu diziyi
  **4** eşit parçaya böler ve her parçayı kendi içinde yeniden numaralandırır; hiçbir işleme
  eklenmez, çıkarılmaz ve değiştirilmez.
- **BD28** — Her parçadaki nesne sayısı bölünmeden etkilenmez; iki düzenin **toplam** nesnesi
  tanım gereği eşittir. Ölçülen şey toplam değil, **depo başına** ödenen bedeldir.
- **BD29** — Kâhin her tarihçede kendi kuralıyla çalışır: kusuru getiren işleme, o tarihçenin
  dörtte üçüncü noktasındadır. Bölünen düzende dört ayrı kâhin vardır.
- **BD30** — "Deposu bilinmiyor" satırı, kusurun hangi bileşende olduğunun önceden
  bilinmediği durumdur; arama her depoda ayrı ayrı yürütülür ve adımlar toplanır.
- **BD31** — Bir soru, gerektirdiği bileşenlerin **tümü tek bir tarihçede** duruyorsa
  yanıtlanır. Tek depoda bir tarihçede dört bileşen vardır, çok depoda bir.
- **BD32** — Birinci bölümün birimi **dokunulan nesne**, ikinci bölümün birimi **adımdır**.
  Üçüncü bölüm bedel ölçmez, yanıtlanabilirlik sayar.
- **BD33** — Ölçüm ekip büyüklüğü, sahiplik, izin ve yayımlama düzeni gibi eksenleri
  içermez; bunlar başka kursların konusudur ve bu tablodan bir örgütlenme sonucu çıkarılamaz.

## Ölçüm

```python
"""Tek depo ve cok depo: ayni is iki duzende.

Bolum 1 - klon bedeli, birim dokunulan nesne.
Bolum 2 - arama ve suclama, birim adim.
Bolum 3 - bilesenler arasi sorulardan kaci yanitlaniyor.
"""
TOHUM = 20260814
DOSYALAR = ("olcum.py", "rapor.py", "kimlik.py", "ayar.py", "belge.md")
TOPLAM = 4000
BILESEN = 4


def uretec(tohum):
    d = tohum % 2147483646 + 1

    def r(n):
        nonlocal d
        d = (d * 48271) % 2147483647
        return d % n
    return r


def tarihce(n, tohum=TOHUM):
    """n islemelik dogrusal tarihce; her isleme bir dosyaya dokunuyor."""
    r, liste = uretec(tohum), []
    for i in range(n):
        dosya = DOSYALAR[r(5)]
        ikili = r(11) == 0
        liste.append({"no": i + 1, "dosya": dosya, "ikili": ikili,
                      "nesne": 2 + (40 if ikili else 0)})
    return liste


def kusurlu_isleme(t):
    """Kahin: kusuru getiren isleme, kurguyu biz yazdigimiz icin bilinir."""
    return len(t) * 3 // 4


def dogrusal_arama(t):
    hedef, adim = kusurlu_isleme(t), 0
    for x in t:
        adim += 1
        if x["no"] >= hedef:
            return adim
    return adim


def ikili_arama(t):
    hedef, alt, ust, adim = kusurlu_isleme(t), 1, len(t), 0
    while alt < ust:
        orta = (alt + ust) // 2
        adim += 1
        if orta >= hedef:
            ust = orta
        else:
            alt = orta + 1
    return adim


def suclama(t, dosya):
    return sum(1 for x in t if x["dosya"] == dosya)


def klon_bedeli(t, ikili_dahil=True):
    return sum(x["nesne"] for x in t if ikili_dahil or not x["ikili"])


def parcala(t, adet):
    """Ayni is, adet ayri depoya bolunmus: nesneler ayni, tarihceler ayri."""
    boy = len(t) // adet
    return [[{**x, "no": i + 1} for i, x in enumerate(t[p * boy:(p + 1) * boy])]
            for p in range(adet)]


SORULAR = (("tek bilesende kusurun yalitimi", 1),
           ("iki bilesenin birlikte degismesi", 2),
           ("bir degisikligin uc bilesene yayilimi", 3),
           ("butun bilesenlerin ortak durumu", 4))


def yanitlanir(gereken, depodaki_bilesen):
    """Soru, gerektirdigi bilesenlerin tumu tek tarihcede duruyorsa yanitlanir."""
    return gereken <= depodaki_bilesen


tek = tarihce(TOPLAM)
cok = parcala(tek, BILESEN)

print("duzen      depo  depo basina nesne  1 bilesen  2 bilesen  tum bilesenler")
print(f"  tek depo    1 {klon_bedeli(tek):18d} {klon_bedeli(tek):10d} "
      f"{klon_bedeli(tek):10d} {klon_bedeli(tek):15d}")
bir = klon_bedeli(cok[0])
iki = sum(klon_bedeli(p) for p in cok[:2])
tum = sum(klon_bedeli(p) for p in cok)
print(f"  cok depo  {BILESEN:3d} {tum // BILESEN:18d} {bir:10d} {iki:10d} {tum:15d}")
print()
print("duzen                             ikili arama  dogrusal arama"
      "  suclama (ayar.py)")
ARAMA = (("tek depo, 4000 isleme", ikili_arama(tek), dogrusal_arama(tek),
          suclama(tek, "ayar.py")),
         ("cok depo, kusurun deposu belli", ikili_arama(cok[0]),
          dogrusal_arama(cok[0]), suclama(cok[0], "ayar.py")),
         ("cok depo, deposu bilinmiyor", sum(ikili_arama(p) for p in cok),
          sum(dogrusal_arama(p) for p in cok),
          sum(suclama(p, "ayar.py") for p in cok)))
for ad, ia, da, su in ARAMA:
    print(f"  {ad:31s} {ia:11d} {da:15d} {su:18d}")
print()
print("soru                                   gereken bilesen  tek depo  cok depo")
for ad, gereken in SORULAR:
    t = "evet" if yanitlanir(gereken, BILESEN) else "hayir"
    c = "evet" if yanitlanir(gereken, 1) else "hayir"
    print(f"  {ad:38s} {gereken:14d} {t:>9s} {c:>9s}")
print()
print(f"tek depo yanitlanan {sum(yanitlanir(g, BILESEN) for _, g in SORULAR)}/"
      f"{len(SORULAR)}, cok depo yanitlanan "
      f"{sum(yanitlanir(g, 1) for _, g in SORULAR)}/{len(SORULAR)}")
print(f"toplam nesne iki duzende de {tum}; degisen sey depo basina bedel: "
      f"{klon_bedeli(tek)} ve {tum // BILESEN}")
```

```
duzen      depo  depo basina nesne  1 bilesen  2 bilesen  tum bilesenler
  tek depo    1              22600      22600      22600           22600
  cok depo    4               5650       5640      11280           22600

duzen                             ikili arama  dogrusal arama  suclama (ayar.py)
  tek depo, 4000 isleme                    11            3000                787
  cok depo, kusurun deposu belli            9             750                209
  cok depo, deposu bilinmiyor              36            3000                787

soru                                   gereken bilesen  tek depo  cok depo
  tek bilesende kusurun yalitimi                      1      evet      evet
  iki bilesenin birlikte degismesi                    2      evet     hayir
  bir degisikligin uc bilesene yayilimi               3      evet     hayir
  butun bilesenlerin ortak durumu                     4      evet     hayir

tek depo yanitlanan 4/4, cok depo yanitlanan 1/4
toplam nesne iki duzende de 22600; degisen sey depo basina bedel: 22600 ve 5650
```

## Toplam Aynı, Depo Başına Farklı

Birinci tablonun birimi **dokunulan nesnedir** ve sağ sütun iki düzende de **22600** veriyor.
Bu bir tesadüf değil, kurgunun kuralıdır: bölmek nesne üretmez ve nesne yok etmez.

Fark soldaki sütunlardadır. Tek depoda tek bir bileşende çalışan biri de **22600** nesne
klonlar, çünkü klonun daha küçük bir birimi yoktur. Çok depoda aynı kişi **5640** nesne
klonlar — dörtte biri. İki bileşen gerekiyorsa **11280**, dördü birden gerekiyorsa yine
**22600**.

Kesişme noktası tablodan doğrudan okunur: **çok depo, ancak çalışanların çoğu tek bileşene
dokunuyorsa ucuzdur.** Dördüne birden dokunan biri için iki düzen aynı bedeli öder, üstelik
çok depoda bu bedel dört ayrı işlemle ödenir. Kısmi ve seyrek klon seçenekleri tek depoda
aynı daralmayı depoyu bölmeden sağlar; bu ölçüm onları kullanmıyor.

## Bölünme Aramayı Bozar

İkinci tablonun birimi **adımdır** ve satırlar arasındaki fark dersin en keskin sonucudur.

Kusurun hangi bileşende olduğu **biliniyorsa** çok depo kazanır: ikili arama **11** adımdan
**9**'a, doğrusal arama **3000**'den **750**'ye, suçlama **787**'den **209**'a iner. Arama
küçük bir tarihçede yürüyor ve bedel küçülüyor.

Bilinmiyorsa tablo tersine dönüyor. İkili arama **36** adıma çıkıyor — tek depodakinin üç
katından fazlası. Neden açıktır: ikili arama tek bir sıralı küme üzerinde çalışır, dört ayrı
tarihçe ise dört ayrı kümedir ve her biri **9** adımlık dört arama yapılır. Bölünme, ikili
aramanın tek gücünü — büyüyen kümede yavaş büyümesini — parçalayarak yok eder.

Aynı satırın öbür iki sütunu **3000** ve **787** veriyor; tek depodaki değerlerin aynısı.
Doğrusal tarama ve suçlama bölünmeden etkilenmez, çünkü ikisi de zaten her işlemeye
dokunuyordu ve toplam işleme sayısı değişmedi. **Bölünmenin zarar verdiği tek arama biçimi,
kümeyi ikiye bölerek çalışandır.**

## Yanıtsız Kalan Soru

Üçüncü tablo bedel değil, **yanıtlanabilirlik** sayıyor. Tek depo dört sorunun **4**'ünü
yanıtlıyor, çok depo **1**'ini.

Yanıtlanan tek soru, tek bir bileşenin içinde kalanıdır. Kalan üçü iki, üç ve dört bileşene
birden bakıyor ve çok depoda bunu yapacak bir tarihçe yoktur. Bu bir araç eksikliği değil,
sınırın tanımıdır: iki bileşenin birlikte değiştiğini kaydeden bir işleme yoksa, o soruyu
sonradan soracak hiçbir sorgu yoktur.

Boşluğu kapatmanın bir yolu vardır ve bedeli bu konunun ilk dersinde ölçüldü: dört bileşeni
birlikte sabitleyen bir kayıt deposu kurmak. Bu, dört bileşeni alt modül olarak bağlar ve
"bütün bileşenlerin ortak durumu" sorusunu yeniden yanıtlanabilir yapar. Karşılığında bir
işlemenin ağacını kurmak için gereken kimlik **1**'den **5**'e çıkar ve özyinelemeli klon
yine **22600** nesneye döner. Çok depo düzeni, kaybettiği soruyu geri almak istediğinde tek
deponun bedelini geri ödemeye başlar.

## Özet

- Bölmek nesne üretmez: toplam nesne iki düzende de **22600**'dür. Değişen tek şey **depo
  başına** ödenen bedeldir — **22600** ve **5650**.
- Tek bileşene dokunan biri çok depoda **5640** nesne klonlar, dördüne dokunan **22600**;
  çok depo ancak çalışanların çoğu tek bileşende kalıyorsa ucuzdur.
- Kusurun deposu biliniyorsa ikili arama **11**'den **9** adıma iner; bilinmiyorsa **36**
  adıma çıkar. Bölünme, kümeyi ikiye bölerek çalışan aramayı bozar.
- Doğrusal tarama **3000** ve suçlama **787** adımda kalır: bölünme bu iki biçimi etkilemez,
  çünkü ikisi de zaten her işlemeye dokunuyordu.
- Bileşenler arası dört sorudan tek depo **4**'ünü, çok depo **1**'ini yanıtlar; kayıp bir
  araç eksikliği değil, sınırın tanımıdır ve geri alınması alt modülün bedelini geri getirir.

## Kurs Kapanışı

Kurs tek bir ölçüyle yürüdü: bir işlemin bedeli **tarihçenin uzunluğu değil, dokunduğu nesne
sayısıdır** — ve bedel iki birimle sayılır, **adım** ya da **dokunulan nesne**. On iki ders
bu ölçüyü ayrı yerlere uyguladı.

| ders | ölçülen işlem | bedelin büyüme biçimi |
|---|---|---|
| Etkileşimli Yeniden Temellendirme | ortadan yeniden yazmanın dokunduğu nesne | 252 / 362 / 3002 / 11322 nesne; oran 0,520'den 0,500'e — ölçek seksen kat büyürken oran sabit kalır |
| Toplu Tarihçe Dönüşümü | ilk işlemeden dönüşümün dokunduğu nesne | 380 / 920 / 5640 / 22600 nesne, oran her ölçekte 1,000; paylaşılan önek 0'a iner ve bedel tarihçenin tamamıdır |
| Zorlayıcı İtme Disiplini | yeniden yazmanın kopyalara ödettiği | yazan 2 ile 5640 nesne arasında öder, kopyalar 14 ile 39480 arasında — her zaman yedi katı; kopya sayısıyla ölçeklenir |
| Referans Günlüğü | yeniden yazmadan sonra erişilebilir kalan | erişilebilir 1000 sabit, erişilemez 3 / 500 / 701 / 1000; kurtarma ufka bağlı ve 3 / 50 / 500 / 1000'de kapanır |
| İkili Arama ile Hata Avı | kusuru bulmanın adımı | doğrusal 37 / 150 / 750 / 3000 adım, ikili 6 / 7 / 9 / 11; seksen kat tarihçede ikili arama iki kat bile artmaz |
| Suçlama ve Satır Tarihçesi | bir dosyanın satır geçmişinin adımı | 8 / 36 / 209 / 787 adım; dosyaya dokunan işleme sayısıyla büyür ve yanıt 40 işlemede sabitlenir |
| Kancalar | engelin konduğu andaki bedel | işlemeden önce 0 nesne, itmeden önce 140, kabulden altı yüz işleme sonra 3522 nesne ve yedi kopya; geç kapı bedeli dağıtır |
| Alt Modüller | sabitlenmiş sürümün bağladığı tarihçe | 76 nesne 378 işleme bağlar; klon 920'den 4540'a (4,93 kat) çıkar ve alt modül sayısıyla toplanır |
| Büyük Dosya Depolama | nesne türünün toplam içindeki payı | 91 işleme (0,0910) nesnenin 0,6777'sini üretir; klon 5640'tan 2131'e iner — bedel işleme sayısını izlemez |
| Çoklu Çalışma Ağacı | ek çalışma alanının kopyaladığı nesne | ek ağaç her ölçekte 0 nesne; dört dal için 22560 yerine 5640 — bedel ağaç sayısıyla hiç büyümez |
| Depo Öznitelikleri | ayarsızlığın yazdırdığı gereksiz nesne | satır sonu 162, birleştirme sürücüsü 86, toplam 248 nesne ve oran 0,0421; ölçek büyüdükçe azalmaz |
| Tek Depo ve Çok Depo | aynı işin iki düzendeki bedeli | toplam 22600 nesne değişmez, depo başına 22600 ve 5650; ikili arama 11 ve 36 adım, yanıtlanan soru 4/4 ve 1/4 |

Tablodan üç okuma çıkar. **Birincisi: aynı tarihçede bedeller ayrışır.** Ölçek seksen kat
büyürken doğrusal arama seksen kat, suçlama yüz kat, klon altmış kat büyür; ikili arama iki
kat bile artmaz ve ek çalışma ağacı hiç artmaz. Bir deponun "büyük" olması tek başına bir şey
söylemez — hangi işlemin hangi kümeye dokunduğu söyler.

**İkincisi: bedeli belirleyen sayı çoğu zaman işleme sayısı değildir.** Nesne türü onda
birinden az işlemeyle nesnelerin üçte ikisini üretir; kopya sayısı, değişikliğin büyüklüğünden
bağımsız olarak yeniden eşitlemeyi zorunlu kılar; sınırın nerede çizildiği aramanın adımını
üç katına çıkarır. Üç durumda da yanlış değişkene bakmak yanlış sonuç verir.

**Üçüncüsü: bu kursun araçlarının çoğu geri alınamaz ve bedeli yazan ödemez.** Toplu dönüşüm
paylaşılan öneki sıfırlar, zorlayıcı itme kimsenin haberi olmadan siler, geriye dönük temizlik
her kopyayı yeniden klonlatır. Her birinin yanında bir kurtarma yolu sayıldı — yedek dal,
referans günlüğü, ayrı klon, kuru çalışma — ve hepsinin ortak yanı **işlemden önce**
kurulmaları gerektiğidir.

Buradan sonraki kurs — Kod İnceleme ve Ekip Süreci — aynı araçları başka bir soruyla ele alır.
Bu kurs boyunca ölçülen her şey aracın yaptığı işti: kaç nesneye dokunduğu, kaç adım harcadığı,
hangi soruyu yanıtsız bıraktığı. Hiçbir ölçüm, işlemin **yapılması gerekip gerekmediğini**
söylemedi. Tarihçeyi yeniden yazmanın 5640 nesneye dokunduğunu bilmek, o tarihçenin yeniden
yazılıp yazılmayacağına karar vermez; kancanın hangi anda engel koyduğunu bilmek, hangi
değişikliğin engellenmesi gerektiğini söylemez. Ayrım baştan konmalıdır: **araç tarihçeyi
değiştirir, kararı insan verir.** Sonraki kursun konusu o kararın nasıl verildiğidir — kimin
baktığı, neye baktığı ve kararın nerede kaydedildiği. Bu kursun bıraktığı sayılar, orada
verilecek kararların maliyetini hesaplamakta kullanılacak birimdir.
