Tarihteki İlk Yazılım Bug’ı: Bir Güve Bilgisayar Tarihini Nasıl Değiştirdi?

Bugün bir web sitesinde, mobil uygulamada ya da bilgisayar programında beklenmedik bir sorunla karşılaştığımızda çoğumuz aynı kelimeyi kullanıyoruz: bug.

“Uygulamada bir bug var.”

“Bu hatayı debug etmemiz gerekiyor.”

Yazılım dünyasında o kadar sık kullandığımız bu kelimelerin arkasında ise oldukça ilginç bir hikâye bulunuyor. Üstelik bu hikâyenin başrolünde bir yazılımcı ya da karmaşık bir program değil, bir güve var.

1947 yılında dünyanın en önemli erken dönem bilgisayarlarından biri olan Harvard Mark II üzerinde çalışan mühendisler, bilgisayarın düzgün çalışmamasına neden olan bir sorunla karşılaştı. Sorunun kaynağını araştırdıklarında bilgisayarın rölelerinden birinin arasına sıkışmış gerçek bir güve buldular.

Güveyi çıkardılar.

Ardından böceği bilgisayarın kayıt defterine yapıştırdılar.

Yanına da şu notu düştüler:

“First actual case of bug being found.”

Yani kabaca, “Bir bug’ın gerçekten bulunduğu ilk durum.”

İşte bilgisayar tarihinin en meşhur hikâyelerinden biri böyle başladı.

Ama hikâyenin düşündüğümüzden biraz daha ilginç bir tarafı var: Bu güve aslında tarihteki ilk yazılım bug’ı değildi.

Her şey 9 Eylül 1947’de başladı

Takvimler 9 Eylül 1947'yi gösteriyordu.

Bilgisayar teknolojisi henüz emekleme dönemindeydi. Bugün masamızın üzerinde duran bilgisayarlarla karşılaştırıldığında o dönemin makineleri devasa boyutlardaydı ve çalışma prensipleri de oldukça farklıydı.

Harvard Mark II, elektromekanik bir bilgisayardı. İçerisinde çok sayıda kablo, elektrik devresi ve elektromanyetik röle bulunuyordu.

Bu röleler, bilgisayarın hesaplama işlemlerinin önemli bir bölümünü gerçekleştiriyordu. Bir anlamda bugünkü bilgisayarlarda bulunan elektronik anahtarların çok daha büyük ve mekanik çalışan öncülleri olarak düşünülebilirler.

Dolayısıyla sistemin içerisindeki küçük bir fiziksel problem bile bilgisayarın çalışmasını etkileyebiliyordu.

Tam da böyle bir problem ortaya çıktı.

Mühendisler bilgisayarın neden düzgün çalışmadığını araştırırken rölelerden birinin arasında sıkışmış bir güve keşfettiler.

Bugün kulağa komik geliyor olabilir.

Ancak o dönem için bu, çözülmesi gereken gerçek bir bilgisayar problemiydi.

Güve çıkarıldı ve bilgisayar tekrar çalışır hale getirildi.

Fakat mühendisler bununla yetinmedi.

Buldukları güveyi kayıt defterine yapıştırdılar.

Böylece tarihin en meşhur bilgisayar “bug”larından biri fiziksel olarak da kayıt altına alınmış oldu.

Peki gerçekten ilk bilgisayar bug’ı bu muydu?

Burada küçük ama önemli bir ayrıntı bulunuyor.

İnternette bu olay genellikle “tarihteki ilk yazılım bug’ı” olarak anlatılıyor.

Ancak bu ifade teknik olarak doğru değil.

Çünkü Harvard Mark II'de bulunan sorun bir yazılım hatası değildi.

Bilgisayarın içerisinde gerçekten bir böcek vardı ve bu böcek mekanik bir parçanın çalışmasını engelliyordu.

Yani yaşanan olay bir donanım problemiydi.

Üstelik “bug” kelimesi de 1947 yılında ortaya çıkmadı.

Mühendisler bu kelimeyi bilgisayarların ortaya çıkmasından çok önce teknik sistemlerdeki arızaları ve kusurları tanımlamak için kullanıyordu.

Hatta Thomas Edison'ın 19. yüzyılda elektrik sistemlerindeki problemlerden bahsederken “bug” kelimesini kullandığı biliniyor.

Dolayısıyla 1947'de yaşanan olayın asıl ilginç tarafı, “bug” kelimesinin icat edilmesi değil.

Bu kez gerçekten bir bug bulunmuş olmasıydı.

Kelimenin teknik anlamı ile gerçek anlamı aynı olayda buluşmuştu.

Bug kelimesi nereden geliyor?

İngilizcede “bug” kelimesi günlük kullanımda böcek anlamına geliyor.

Yazılım dünyasında ise bir programdaki hata veya beklenmeyen davranışı ifade ediyor.

Bu kullanım bilgisayarlardan çok daha eski.

Mühendislik dünyasında “bug” kelimesi uzun zamandır makinelerdeki küçük kusurları, arızaları veya sistemin düzgün çalışmasını engelleyen problemleri tanımlamak için kullanılıyordu.

Bilgisayarların ortaya çıkmasıyla birlikte bu ifade yeni bir anlam kazandı.

Artık sadece mekanik veya elektriksel sistemlerdeki problemler değil, programlardaki hatalar da bug olarak adlandırılmaya başladı.

1947'deki güve olayı ise bu kelimeyle bilgisayar dünyası arasındaki bağlantının hafızalara kazınmasını sağladı.

Grace Hopper'ın bu hikâyedeki rolü neydi?

Bu hikâyeyi anlatırken karşımıza sık sık Grace Hopper ismi çıkıyor.

Hopper, bilgisayar tarihinin en önemli isimlerinden biriydi ve Harvard Mark I ile Mark II projelerinde çalışan ekip içerisinde yer aldı.

Ancak internette zaman zaman “Grace Hopper bilgisayardaki güveyi buldu ve bug kelimesini icat etti” şeklinde anlatımlar görülebiliyor.

Bu anlatım fazla basitleştirilmiş durumda.

Grace Hopper'ın bu olayla bağlantısı olsa da “bug” kelimesini icat eden kişi değildi.

Ayrıca güveyi bizzat onun bulduğunu kesin bir gerçek olarak ifade etmek de doğru değil.

Asıl önemli olan, Hopper'ın bilgisayar tarihindeki çok daha büyük rolü.

Grace Hopper, bilgisayarların insanlar tarafından daha kolay programlanabilmesi konusunda önemli çalışmalar yaptı ve erken dönem derleyicilerin geliştirilmesine öncülük etti. Daha sonraki yıllarda COBOL'un gelişiminde de önemli bir rol oynadı.

Dolayısıyla onu yalnızca “bilgisayardaki güveyi bulan kadın” olarak hatırlamak, bilgisayar bilimine yaptığı katkıları oldukça küçültür.

O güve bugün nerede?

Belki de bu hikâyenin en şaşırtıcı taraflarından biri bu.

Güve atılmadı.

Bilgisayarın kayıt defterine yapıştırıldı.

Bu kayıt defteri bugün Smithsonian koleksiyonunda korunuyor.

Yani yaklaşık 80 yıl önce Harvard Mark II'nin içerisinde bulunan o küçük böcek, bugün bilgisayar tarihinin en ünlü fiziksel belgelerinden birinin parçası.

Bu nedenle 1947'deki olay yalnızca yıllar içerisinde anlatılan bir şehir efsanesi değil. Olayın gerçekten yaşandığını gösteren tarihi bir kayıt bulunuyor.

“Debug” kelimesi de buradan mı geliyor?

Bugün yazılım geliştiricilerin en sık kullandığı kelimelerden biri debug.

Bir program çalışmıyorsa geliştirici kodu inceler, problemi bulmaya çalışır ve hatayı düzeltir.

Bu sürece debugging, yani hata ayıklama denir.

Fakat “debug” kelimesinin de doğrudan 1947'deki güveden ortaya çıktığını söylemek doğru olmaz.

Bug ve benzeri ifadeler zaten daha eski dönemlerde kullanılıyordu.

Ancak Harvard Mark II'deki olay, bilgisayar dünyasında “bug” kavramının anlatılmasını sağlayan en ünlü hikâyelerden biri haline geldi.

Bir bakıma olay, bilgisayar tarihinin en güzel tesadüflerinden biriydi:

Bilgisayarın içinde gerçekten bir “bug” vardı.

1947'den bugüne bug kavramı nasıl değişti?

1940'larda bilgisayarların büyük bölümü fiziksel donanımlardan oluşuyordu.

Röleler, kablolar, vakum tüpleri ve mekanik parçalar kritik öneme sahipti.

Bu nedenle fiziksel bir arıza bilgisayarın çalışmasını doğrudan etkileyebiliyordu.

Yazılım geliştirme ilerledikçe ise hata kavramı da değişmeye başladı.

Bugün bir programdaki en küçük kod hatası bile büyük problemlere yol açabiliyor.

Örneğin bir internet sitesindeki yanlış bir hesaplama, bir bankacılık uygulamasındaki hatalı işlem, bir mobil uygulamadaki çökme veya bir oyundaki beklenmedik davranış birer yazılım bug'ı olabilir.

Üstelik günümüzde yazılımlar milyarlarca satır koda ulaşabiliyor.

Bu nedenle modern yazılım geliştirmede debugging başlı başına önemli bir mühendislik süreci haline gelmiş durumda.

Geliştiriciler hata kayıtlarını inceliyor, kodu adım adım çalıştırıyor, değişkenlerin değerlerini kontrol ediyor, testler yazıyor ve problemin kaynağını bulmaya çalışıyor.

1947'de ise çözüm çok daha basitti:

Güveyi çıkar.

Bir güveden milyonlarca satır koda

Harvard Mark II'nin yaşadığı problem ile günümüzde bir yazılım geliştiricinin karşılaştığı bug arasında yaklaşık 80 yıllık teknoloji farkı bulunuyor.

O zamanlar bir bilgisayarın çalışmasını bir böcek engelleyebiliyordu.

Bugün ise tek bir karakter, yanlış yazılmış bir koşul veya beklenmeyen bir kullanıcı girdisi milyonlarca kullanıcıyı etkileyebiliyor.

Örneğin:

if (user.isAdmin = true)

ile

if (user.isAdmin === true)

arasındaki küçük fark bile bir programın davranışını tamamen değiştirebilir.

Bugün geliştiricilerin yaptığı debugging işlemi de aslında 1947'deki mühendislerin yaptığı işin modern versiyonu.

Önce problem fark ediliyor.

Sonra kaynağı araştırılıyor.

Hatanın nereden geldiği bulunuyor.

Ardından çözüm uygulanıyor ve sistem tekrar test ediliyor.

Tek fark, artık bilgisayarın kapağını açıp içeride güve aramıyor olmamız.

Tarihteki ilk yazılım bug'ı hangisiydi?

Bu sorunun kesin bir cevabını vermek aslında oldukça zor.

Çünkü bilgisayarların ilk dönemlerinde hem donanım hem de yazılım hataları yaşanıyordu ve bunların tamamı bugünkü anlamda kayıt altına alınmış değil.

Bu nedenle Harvard Mark II'deki güveyi “tarihteki ilk yazılım bug'ı” olarak adlandırmak doğru olmaz.

Daha doğru ifade şudur:

1947 yılında Harvard Mark II bilgisayarında bulunan güve, tarihte belgelenmiş ve en çok bilinen gerçek bilgisayar bug'larından biridir.

Olayı önemli yapan şey de güveye “bug” denilmesi değil.

Zaten teknik bir terim olarak kullanılan “bug” kelimesinin, bu kez kelimenin gerçek anlamıyla bilgisayarın içinde bulunmuş olmasıdır.

Bugün hâlâ neden bu hikâyeyi anlatıyoruz?

Çünkü teknoloji ne kadar gelişirse gelişsin, bilgisayar sistemlerinde hatalar olmaya devam ediyor.

Bugün yapay zekâ sistemlerinde, mobil uygulamalarda, web sitelerinde, işletim sistemlerinde ve oyunlarda sürekli yeni bug'lar ortaya çıkıyor.

Geliştiriciler de bunları bulup düzeltmeye devam ediyor.

Belki de bu nedenle 1947'deki küçük güve hikâyesi hâlâ güncelliğini koruyor.

O gün bir mühendis bilgisayarın içerisinde fiziksel bir böcek buldu.

Bugün ise bir yazılımcı milyonlarca satır kodun arasında görünmeyen bir hata arıyor.

Araçlar değişti.

Bilgisayarlar değişti.

Yazılımlar inanılmaz derecede karmaşık hale geldi.

Ama temel amaç hâlâ aynı:

Sorunu bul, nedenini anla ve düzelt.

Bilgisayar tarihinin en meşhur “bug”ı

1947'de Harvard Mark II'nin içerisinde bulunan güve, bilgisayar tarihinin en ilginç olaylarından biri olarak hafızalara kazındı.

Bu olay aslında ilk yazılım hatası değildi ve “bug” kelimesinin doğuşu da bu olayla gerçekleşmedi.

Fakat tarihte ilk kez bir bilgisayar bug'ının gerçek anlamda bir böcek olması, olayı unutulmaz hale getirdi.

Üstelik güve bilgisayarın kayıt defterine yapıştırıldı ve olay belgelenmiş oldu.

Bugün bir yazılımcı “debugging yapıyorum” dediğinde aklına muhtemelen bir güve gelmiyor.

Ama bilgisayar tarihinin en meşhur debugging hikâyelerinden birinin başlangıcında gerçekten bir güve bulunuyor.

Belki de bu hikâyeden çıkarılabilecek en güzel sonuç şu:

Bazen bir bilgisayardaki en büyük problemi çözmek için milyonlarca satır kodu incelemeniz gerekmez. Önce bilgisayarın içinde gerçekten bir böcek olup olmadığına bakmak yeterli olabilir.