JavaScript’te ReferenceError, SyntaxError ve TypeError Hatalarını Giderme Kılavuzu

JavaScript’te ReferenceError, SyntaxError ve TypeError Hatalarını Giderme Kılavuzu

Giriş

JavaScript, dinamik ve esnek yapısıyla web geliştirmenin temel taşlarından biridir. Ancak bu esneklik, beraberinde çeşitli hata türlerini de getirebilir. Bir geliştiricinin en önemli becerilerinden biri, kodundaki hataları hızlı ve etkili bir şekilde tespit edip giderebilmesidir. Bu makalede, JavaScript geliştiricilerinin en sık karşılaştığı üç temel hata türünü – ReferenceError, SyntaxError ve TypeError – derinlemesine inceleyeceğiz. Bu hataların ne anlama geldiğini, neden ortaya çıktıklarını ve adım adım nasıl giderilebileceklerini kapsamlı örneklerle açıklayacağız. Amacımız, bu hata türlerini daha iyi anlamanızı ve hata ayıklama süreçlerinizi hızlandırmanızı sağlamaktır.

Genel Hata Ayıklama İlkeleri

Hata türüne bakılmaksızın, her hata ayıklama sürecinde uygulayabileceğiniz bazı temel ilkeler vardır. Bu ilkeler, sorunları daha sistematik bir şekilde çözmenize yardımcı olur.

Konsolu Kullanma

Tarayıcı geliştirici araçları (örneğin Chrome DevTools, Firefox Developer Tools) veya Node.js ortamındaki terminal, hata mesajlarını ve yığın izlerini (stack trace) görüntülemek için en temel araçlardır. Hata mesajını dikkatlice okumak, sorunun kaynağına dair ilk ipucunu verir.

Hata Mesajını Anlama

Her hata mesajı, hatanın türünü (örneğin ReferenceError), kısa bir açıklamasını ve genellikle hatanın meydana geldiği dosya adını ve satır numarasını içerir. Bu bilgiler, hatanın nerede ve neden oluştuğunu anlamak için kritik öneme sahiptir.

Kodun İlgili Bölümünü Bulma

Hata mesajındaki satır numarası, sorunun yaşandığı kod bloğunu hızla bulmanızı sağlar. Ancak bazen hata, belirtilen satırda değil, o satırı etkileyen başka bir yerde olabilir.

Küçük Adımlarla İlerlemek

Karmaşık bir hata ile karşılaştığınızda, tüm kodu birden değiştirmeye çalışmak yerine, sorunu izole etmek için küçük, kontrollü değişiklikler yapın. Bu, hatanın gerçek nedenini daha kolay bulmanızı sağlar.

Yorum Satırları ve console.log

console.log() komutu, değişkenlerin değerlerini veya kodun belirli bir noktaya ulaşıp ulaşmadığını kontrol etmek için basit ama güçlü bir araçtır. Şüpheli kod bloklarını geçici olarak yorum satırı yapmak da sorunu daraltmaya yardımcı olabilir.

Hata Ayıklayıcı Kullanımı

Tarayıcıların veya IDE’lerin (örneğin VS Code) sunduğu hata ayıklayıcılar, kodunuzu adım adım çalıştırmanıza, değişkenlerin değerlerini izlemenize ve çağrı yığınını (call stack) incelemenize olanak tanır. Kırılma noktaları (breakpoints) belirleyerek kodun belirli bir noktada durmasını sağlayabilirsiniz.

ReferenceError Hatalarını Giderme

Nedir?

ReferenceError, tanımlanmamış bir değişkene veya fonksiyona erişmeye çalıştığınızda ortaya çıkar. JavaScript motoru, belirtilen ismi mevcut kapsamda (scope) veya zincirindeki herhangi bir üst kapsamda bulamadığında bu hatayı fırlatır. Basitçe söylemek gerekirse, “Böyle bir şey tanımadım!” demektir.

Ortaya Çıkış Nedenleri

ReferenceError genellikle aşağıdaki durumlar nedeniyle meydana gelir:

Yanlış Yazım (Typo)

En yaygın nedenlerden biridir. Bir değişkenin veya fonksiyonun adını yanlış yazmak, motorun onu bulamamasına neden olur.

// Hata
let message = "Merhaba Dünya";
console.log(messsage); // ReferenceError: messsage is not defined

// Doğru
let message = "Merhaba Dünya";
console.log(message); // Merhaba Dünya

Değişkenin Tanımlanmamış Olması

let, const veya var anahtar kelimeleriyle tanımlanmamış bir değişkene erişmeye çalışmak.

// Hata
console.log(myVariable); // ReferenceError: myVariable is not defined
let myVariable = 10; // Değişken tanımlanmadan önce kullanıldı

Bu örnekte, myVariable let ile tanımlanmasına rağmen, tanımından önce erişildiği için ReferenceError verir. var ile tanımlanan değişkenlerde hoisting (yukarı çekme) mekanizması nedeniyle bu durum undefined sonucunu verebilir, ancak let ve const “temporal dead zone” (geçici ölü bölge) nedeniyle ReferenceError verir.

Kapsam Dışı Erişim (Out-of-Scope Access)

Bir değişkenin tanımlandığı kapsamın dışından erişmeye çalışmak. Özellikle blok kapsamlı (let, const) değişkenlerde sık görülür.

function greet() {
  const name = "Alice";
}
// Hata
console.log(name); // ReferenceError: name is not defined (name sadece greet fonksiyonu içinde tanımlı)

// Doğru
function greet() {
  const name = "Alice";
  console.log(name); // Alice
}
greet();

Hoisting Yanlış Anlaşılması

var ile tanımlanan değişkenler ve fonksiyon bildirimleri (function declarations) hoisting’e tabidir. Ancak let ve const ile tanımlanan değişkenler hoisting olsa da, tanımlanmadan önce erişildiğinde “temporal dead zone” nedeniyle ReferenceError verirler.

// Hata (let için)
console.log(x); // ReferenceError: Cannot access 'x' before initialization
let x = 5;

// Hata (const için)
console.log(y); // ReferenceError: Cannot access 'y' before initialization
const y = 10;

// var için undefined (hata değil, ama yanlış anlama)
console.log(z); // undefined
var z = 15;

Modül İçe Aktarma Sorunları (Module Import Issues)

ES Modülleri kullanırken, bir modülden dışa aktarılmamış bir öğeyi içe aktarmaya çalışmak veya yanlış bir dışa aktarma adı kullanmak.

// module.js
// export const data = "some data"; // data'yı dışa aktarmayı unuttuk

// main.js
// Hata
import { data } from './module.js'; // ReferenceError: The requested module './module.js' does not provide an export named 'data'
console.log(data);

// Doğru (module.js içinde export eklendikten sonra)
// module.js
export const data = "some data";

// main.js
import { data } from './module.js';
console.log(data); // some data

Nasıl Giderilir?

ReferenceError gidermek için aşağıdaki adımları izleyebilirsiniz:

1. Değişken/Fonksiyon Adını Kontrol Etme: Hata mesajındaki ismi, kodunuzdaki tanımlı isimlerle karşılaştırın. Yazım hatası olup olmadığını kontrol edin.
2. Tanımlama Yapıldığından Emin Olma: Erişmeye çalıştığınız değişkenin veya fonksiyonun let, const, var veya function anahtar kelimeleriyle tanımlandığından emin olun.
3. Kapsam Kontrolü: Değişkenin erişmeye çalıştığınız kapsamda (global, fonksiyon, blok) tanımlı olup olmadığını kontrol edin. Eğer başka bir kapsamda tanımlıysa, doğru bir şekilde erişim sağladığınızdan emin olun (örneğin, bir fonksiyonun dönüş değeri olarak).
4. Modül Yollarını ve İçe Aktarmaları Doğrulama: Modül kullanıyorsanız, dışa aktarılan isimlerin ve içe aktarma yollarının doğru olduğundan emin olun.
5. Global Değişkenlere Dikkat: Global bir değişkene erişmeye çalışıyorsanız, tarayıcı ortamında window nesnesinin veya Node.js ortamında global nesnesinin bir özelliği olarak tanımlanıp tanımlanmadığını kontrol edin.

SyntaxError Hatalarını Giderme

Nedir?

SyntaxError, JavaScript kodunuzun dilin gramer kurallarına uymadığını belirtir. Yani, JavaScript motoru kodunuzu “okuyamıyor” veya “anlayamıyor” demektir. Bu hata, kodunuz çalışmaya başlamadan önce (derleme/parsing aşamasında) tespit edilir. Bu nedenle, bir SyntaxError ile karşılaştığınızda, kodunuzun hiçbir kısmı çalışmaz.

Ortaya Çıkış Nedenleri

SyntaxError genellikle aşağıdaki durumlardan kaynaklanır:

Eksik/Fazla Parantezler, Köşeli Parantezler, Küme Parantezleri

En yaygın nedenlerden biridir. Açılan her parantezin ( (, [, { ) kapanan bir karşılığı olmalıdır.

// Hata (eksik kapanış parantezi)
const func = (a, b => {
  return a + b;
}); // SyntaxError: Expected ')' but found '=>'

// Doğru
const func = (a, b) => {
  return a + b;
};

// Hata (eksik küme parantezi)
if (true)
  console.log("Doğru"); // SyntaxError: Expected '{' but found 'console'
  console.log("Bu da çalışır"); // if bloğu tek satırsa süslü parantez zorunlu değil, ama burada mantık hatasına yol açar.
                               // Genellikle, birden fazla satırda işlem yapılıyorsa süslü parantez kullanılır.
                               // Yukarıdaki hata, if bloğunun tek satır olması ve sonraki satırın if'ten bağımsız olması durumunda oluşmaz.
                               // Hata genellikle başka bir bağlamda, örneğin bir fonksiyon tanımında veya nesne literalinde eksik parantezden kaynaklanır.

// Doğru
if (true) {
  console.log("Doğru");
  console.log("Bu da çalışır");
}

Noktalı Virgül Eksikliği

Bazı durumlarda JavaScript motoru otomatik noktalı virgül ekleme (Automatic Semicolon Insertion – ASI) yapabilse de, bazen eksik noktalı virgüller beklenmedik SyntaxErrorlara yol açabilir, özellikle bir sonraki satırda yeni bir ifade başladığında.

// Hata (ASI, bu durumda yanlış yorumlayabilir)
let a = 10
let b = 20
[a, b].forEach(item => console.log(item)) // SyntaxError: Unexpected token '['
                                          // JavaScript motoru 'let b = 20[a, b]' olarak yorumlamaya çalışır.

// Doğru
let a = 10;
let b = 20;
[a, b].forEach(item => console.log(item));

Yanlış Anahtar Kelime Kullanımı

Reserved anahtar kelimeleri (örneğin if, for, function, class, const, let) değişken adı olarak kullanmak veya bunları yanlış bağlamda kullanmak.

// Hata
let function = "myFunction"; // SyntaxError: 'function' is a reserved word

// Doğru
let myFunction = "myFunction";

Dizelerdeki Tırnak İşaretleri

Bir dizenin başlangıç ve bitiş tırnak işaretlerinin eşleşmemesi veya dizenin içinde özel karakterlerin (örneğin tek tırnak içinde tek tırnak) doğru bir şekilde kaçış karakteriyle (\) belirtilmemesi.

// Hata
let str = 'Bu bir 'hatalı' dize'; // SyntaxError: Unexpected identifier 'hatalı'

// Doğru
let str1 = "Bu bir 'doğru' dize";
let str2 = 'Bu bir \'doğru\' dize';
let str3 = Bu bir 'doğru' dize; // Template literals ile daha kolay

Geçersiz Değişken Adları

Değişken adlarının sayı ile başlaması, boşluk içermesi veya özel karakterler ( $ ve _ hariç) içermesi.

// Hata
let 1variable = 10; // SyntaxError: Invalid or unexpected token
let my-variable = 20; // SyntaxError: '-' is not a valid identifier character

// Doğru
let variable1 = 10;
let my_variable = 20;
let myVariable = 30;

ES Sürümü Uyumsuzluğu

Kullandığınız JavaScript motorunun (tarayıcı veya Node.js) desteklemediği yeni bir ES (ECMAScript) özelliğini kullanmaya çalışmak.

// Hata (Eski bir tarayıcıda veya Node.js sürümünde)
const obj = {
  a: 1,
  b: 2,
  ...rest // Spread syntax for object literals (ES2018)
}; // SyntaxError: Unexpected token '...'

// Bu hata genellikle bir transpiler (örneğin Babel) kullanılarak veya daha güncel bir ortamda çalıştırılarak çözülür.

JSON.parse Hataları

JSON.parse() fonksiyonuna geçersiz bir JSON dizesi iletmek de bir SyntaxErrora yol açar.

// Hata
const invalidJson = "{'name': 'Alice'}"; // Tek tırnaklar JSON'da geçersizdir
JSON.parse(invalidJson); // SyntaxError: Unexpected token ' in JSON at position 1

// Doğru
const validJson = '{"name": "Alice"}';
JSON.parse(validJson); // { name: 'Alice' }

Nasıl Giderilir?

SyntaxError gidermek için aşağıdaki yaklaşımları kullanabilirsiniz:

1. Hata Mesajındaki Satır Numarasına Odaklanma: SyntaxError mesajı genellikle hatanın tam olarak nerede olduğunu gösteren bir satır numarası ve sütun bilgisi içerir. Bu noktaya ve çevresine dikkatlice bakın.
2. Parantez Eşleşmelerini Kontrol Etme: Kod editörünüzün parantez eşleştirme özelliğini kullanarak tüm ( ), [ ], { } parantezlerinin doğru bir şekilde kapatıldığından emin olun.
3. Tırnak İşaretlerini Kontrol Etme: Dizelerdeki tek ve çift tırnakların doğru kullanıldığından ve kaçış karakterlerinin gerektiği yerlerde olduğundan emin olun.
4. Anahtar Kelime Kullanımını Doğrulama: Değişken adlarınızın JavaScript’in reserved anahtar kelimeleriyle çakışmadığından emin olun.
5. Linting Araçları Kullanma: ESLint gibi linting araçları, kodunuzu yazarken olası SyntaxErrorları ve stil sorunlarını otomatik olarak tespit edebilir. Bu araçlar, hataları daha kod çalışmadan önce yakalamanıza yardımcı olur.
6. Kod Editörü Desteği: Modern kod editörleri (VS Code, Sublime Text vb.) syntax highlighting ve otomatik tamamlama özellikleriyle syntax hatalarını görsel olarak belirtir.
7. ES Sürümü Uyumluluğu: Eğer yeni bir ES özelliği kullanıyorsanız, hedef ortamınızın (tarayıcılar, Node.js sürümü) bu özelliği desteklediğinden emin olun. Gerekirse Babel gibi bir transpiler kullanın.

TypeError Hatalarını Giderme

Nedir?

TypeError, bir değerin beklenen türde olmaması veya desteklenmeyen bir işlem yapmaya çalıştığınızda ortaya çıkar. Bu, genellikle bir değişkenin null veya undefined olması durumunda bir özelliğine veya metoduna erişmeye çalışmak, bir sayıyı fonksiyon olarak çağırmak gibi durumları kapsar. SyntaxErrordan farklı olarak, TypeError kod çalışırken (runtime) ortaya çıkar.

Ortaya Çıkış Nedenleri

TypeError genellikle aşağıdaki durumlar nedeniyle meydana gelir:

Tanımlanmamış (undefined) veya Boş (null) Değer Üzerinde İşlem Yapma

Bir değişkenin değeri null veya undefined iken, o değişkenin bir özelliğine erişmeye veya bir metodunu çağırmaya çalışmak. Bu, TypeError: Cannot read properties of undefined (reading 'propertyName') veya TypeError: Cannot read properties of null (reading 'propertyName') şeklinde görülebilir.

// Hata (undefined)
let user;
console.log(user.name); // TypeError: Cannot read properties of undefined (reading 'name')

// Hata (null)
let car = null;
console.log(car.model); // TypeError: Cannot read properties of null (reading 'model')

// Doğru (kontrollerle)
let user = { name: "Alice" };
if (user) { // veya user?.name
  console.log(user.name); // Alice
}

let car = null;
if (car) {
  console.log(car.model); // Bu kısım çalışmaz, hata da vermez.
}

Sayı Olmayan Bir Değeri Fonksiyon Olarak Çağırma

Bir değişkenin veya özelliğin beklenen bir fonksiyon yerine başka bir veri türü (sayı, dize, nesne vb.) içermesi ve onu bir fonksiyon gibi çağırmaya çalışmak.

// Hata
let num = 10;
num(); // TypeError: num is not a function

// Doğru
let greet = () => "Merhaba!";
greet(); // Merhaba!

Nesne Olmayan Bir Değerin Özelliğine Erişme

Bir ilkel veri türünün (sayı, dize, boolean) veya null/undefined değerinin bir nesne gibi işlem görmesini beklemek ve bir özelliğine erişmeye çalışmak. (Bazı ilkel türler (string, number, boolean) geçici olarak nesneye dönüştürülüp özelliklerine erişilebilir, ancak null ve undefined için bu geçerli değildir.)

// Hata
let myString = "hello";
myString.toUpperCase.call(); // TypeError: Cannot read properties of undefined (reading 'call')
                             // toUpperCase bir fonksiyon, ancak onu çağırmadan .call() yapmaya çalışıyoruz.
                             // Doğrusu myString.toUpperCase().call() değil, doğrudan myString.toUpperCase()

// Doğru
let myString = "hello";
console.log(myString.toUpperCase()); // HELLO

Read-only Özelliği Değiştirmeye Çalışma

Bir nesnenin salt okunur (read-only) bir özelliğini değiştirmeye çalışmak. Bu, genellikle Object.defineProperty ile yapılandırılmış özelliklerde veya bazı yerleşik nesnelerin özelliklerinde görülür.

// Hata (strict mode'da)
"use strict";
const obj = {};
Object.defineProperty(obj, 'prop', { value: 10, writable: false });
obj.prop = 20; // TypeError: Cannot assign to read only property 'prop' of object '#'

// Doğru
// Ya writable: true olarak tanımlayın ya da değiştirmeye çalışmayın.

this Bağlamı Sorunları (Context Issues)

Bir fonksiyonun this bağlamının beklenenden farklı olması ve bu nedenle this üzerinden erişilmeye çalışılan özelliğin bulunamaması. Özellikle sınıf metotlarında veya callback fonksiyonlarında sıkça görülür.

class Counter {
  constructor() {
    this.count = 0;
  }

  increment() {
    this.count++;
    console.log(this.count);
  }
}

const counter = new Counter();
// Hata (setTimeout içindeki this, Counter nesnesi değil, global (window) nesnesini gösterir)
setTimeout(counter.increment, 1000); // TypeError: Cannot read properties of undefined (reading 'count')
                                    // strict mode'da this undefined olur, non-strict mode'da window.

// Doğru (this'i bağlama)
setTimeout(counter.increment.bind(counter), 1000); // 1
// veya arrow function kullanarak
setTimeout(() => counter.increment(), 1000); // 1

Yanlış Veri Türü Beklentisi

Bir fonksiyonun belirli bir veri türünü beklerken farklı bir türde veri alması ve bu veri üzerinde desteklenmeyen bir işlem yapmaya çalışması. Örneğin, bir dizi bekleyen bir fonksiyona bir nesne göndermek.

function processArray(arr) {
  arr.forEach(item => console.log(item));
}

// Hata
processArray("bir dize"); // TypeError: arr.forEach is not a function

// Doğru
processArray([1, 2, 3]); // 1, 2, 3

Nasıl Giderilir?

TypeError gidermek için aşağıdaki stratejileri uygulayabilirsiniz:

1. Değişkenlerin Türünü Kontrol Etme: typeof operatörünü veya instanceof operatörünü kullanarak değişkenlerin beklenen türde olup olmadığını kontrol edin.

let data = "hello";
    if (typeof data === 'string') {
      console.log(data.toUpperCase());
    } else {
      console.error("Beklenmeyen veri türü!");
    }

2. null ve undefined Kontrolleri: Bir özelliğe veya metoda erişmeden önce değişkenin null veya undefined olup olmadığını kontrol edin.
* Koşullu Kontroller: if (myVar) veya if (myVar !== null && myVar !== undefined)
* İsteğe Bağlı Zincirleme (Optional Chaining – ?.): ES2020 ile gelen bu özellik, bir özelliğe veya metoda güvenli bir şekilde erişmenizi sağlar. Eğer zincirdeki bir öğe null veya undefined ise, ifade hemen undefined döner ve hata oluşmaz.

let user = null;
        console.log(user?.name); // undefined (hata yok)

* Nullish Coalescing (??): ES2020 ile gelen bu operatör, null veya undefined olan değerler için varsayılan bir değer sağlamanıza olanak tanır.

let userName = user?.name ?? "Misafir"; // Misafir

3. Fonksiyon Çağrılarının Doğruluğunu Sağlama: Bir değişkenin gerçekten bir fonksiyon olup olmadığını kontrol edin (typeof myVar === 'function') ve ardından çağırın.
4. this Bağlamını Anlama: Fonksiyonlarınızın this bağlamını doğru bir şekilde yönettiğinizden emin olun. Arrow fonksiyonları, bind(), call(), apply() metotları bu konuda yardımcı olabilir.
5. API Yanıtlarını Doğrulama: Harici API’lerden gelen verilerin yapısını ve türlerini her zaman doğrulayın. Beklenmedik bir veri türü veya eksik bir özellik, TypeErrora yol açabilir.

Gelişmiş Hata Ayıklama Teknikleri

Yukarıda belirtilen temel ilkelerin ötesinde, daha karmaşık hataları gidermek için kullanabileceğiniz bazı gelişmiş teknikler bulunmaktadır:

Tarayıcı Geliştirici Araçları

Modern tarayıcıların sunduğu geliştirici araçları, sadece konsol çıktılarını değil, aynı zamanda Ağ (Network) isteklerini, Bellek (Memory) kullanımını, Performans (Performance) analizini ve en önemlisi Hata Ayıklayıcı (Debugger) özelliğini sunar.

Hata Ayıklayıcıda Kırılma Noktaları (Breakpoints)

Kodunuzun belirli bir satırında yürütmeyi durdurmak için kırılma noktaları ayarlayabilirsiniz. Kod bu noktaya ulaştığında durur ve o anki tüm değişkenlerin değerlerini, çağrı yığınını ve kapsamı inceleyebilirsiniz.

İzleme Noktaları (Watchpoints)

Belirli bir değişkenin değerini sürekli olarak izlemek için izleme noktaları kullanabilirsiniz. Değişkenin değeri her değiştiğinde bu size gösterilir.

debugger Anahtar Kelimesi

Kodunuzun içine debugger; anahtar kelimesini eklemek, tarayıcı geliştirici araçları açık olduğunda o noktada otomatik olarak bir kırılma noktası oluşturur. Bu, hızlı bir şekilde belirli bir kod bloğuna atlamak için kullanışlıdır.

Stack Trace Analizi

Hata mesajında gördüğünüz “stack trace” (yığın izi), hatanın nerede başladığını ve hangi fonksiyon çağrıları zincirinden geçtiğini gösteren bir yol haritasıdır. En üstteki satır genellikle hatanın meydana geldiği yerdir, ancak altındaki satırlar hataya yol açan olaylar zincirini anlamanıza yardımcı olur.

Linting Araçları (ESLint, Prettier)

Bu araçlar, kodunuzu yazarken potansiyel hataları (SyntaxError dahil), stil tutarsızlıklarını ve best practice ihlallerini otomatik olarak tespit eder. Hataları erken aşamada yakalayarak zaman kazandırırlar.

Unit Testler

Kodunuzun belirli parçaları (unit’leri) için testler yazmak, değişiklikler yaptığınızda mevcut işlevselliğin bozulmadığından emin olmanızı sağlar. Yeni bir hata ortaya çıktığında, testleriniz size hangi bölümün etkilendiğini gösterebilir.

Sonuç

JavaScript’te ReferenceError, SyntaxError ve TypeError en sık karşılaşılan hata türleridir ve her biri farklı nedenlerden kaynaklanır. SyntaxError dilbilgisi kurallarına uyumsuzluktan kaynaklanırken, ReferenceError tanımlanmamış bir şeye erişimle ilgilidir ve TypeError ise değerlerin yanlış türde olması veya desteklenmeyen işlemlerle ilişkilidir.

Bu hataları etkili bir şekilde gidermek için hata mesajlarını dikkatlice okumak, tarayıcı geliştirici araçlarını ustaca kullanmak ve kodunuzu sistematik bir şekilde incelemek kritik öneme sahiptir. Hata ayıklama, yazılım geliştirme sürecinin ayrılmaz bir parçasıdır ve bu beceriyi geliştirmek, daha sağlam, güvenilir ve sürdürülebilir JavaScript uygulamaları yazmanızın anahtarıdır. Unutmayın, her hata bir öğrenme fırsatıdır ve hata ayıklama sürecinde sabırlı ve metodik olmak, sizi daha iyi bir geliştirici yapacaktır.