Değişkenleri bildirirken neden veri türünü belirtmeniz gerekiyor?

Çoğu kodlama dilinde (hepsi değilse) değişkenleri bildirmeniz gerekir. Örneğin C # 'da bir sayı alanıysa

int PhoneNumber

Normal İngilizce dilini kullanıyorum ben bir açıklamadan gerekmez PhoneNumberolarak intkullanmak için. Örneğin, arkadaşım Sam'in bana telefon numarasını vermesini rica edersem derim:

"Sam bana telefon numarasını ver"

Ben söylemem

"Char (20) Sam bana int telefon numarasını verdi"

Neden veri türü belirtmemiz gerekiyor?

Çoğu kodlama dilinde (hepsi değilse) değişkenleri bildirmeniz gerekir.

[...]

Neden veri türü belirtmemiz gerekiyor?

Bunlar iki bağımsız soru:

• Neden değişkenleri bildirmemiz gerekiyor?
• Neden tür bildirmemiz gerekiyor?

Bu arada, her ikisine de cevap: biz değiliz.

Türleri bildirmeniz gerekmeyen statik olarak yazılmış programlama dilleri vardır. Derleyici, türleri çevreleyen bağlamdan ve kullanımdan çıkarabilir.

Örneğin, Scala’da

val age: Int = 23

ya da sadece söyleyebilirsin

val age = 23

İkisi tam olarak eşdeğerdir: derleyici Int, başlatma ifadesinden gelecek olan türden çıkacaktır 23.

Aynı şekilde, C♯'de bunlardan herhangi birini söyleyebilirsiniz ve ikisi de aynı şeyi ifade eder:

int age = 23;
var age = 23;

Bu özelliğe tür çıkarımı denir ve Scala ve C♯ dışında birçok dilde bulunur: Haskell, Kotlin, Seylan, ML, F♯, C ++, siz onu isimlendirin. Java'nın bile sınırlı bir tür çıkarım biçimi vardır.

Dinamik olarak yazılmış programlama dillerinde, değişkenlerin bile tipleri yoktur. Türler yalnızca çalışma zamanında dinamik olarak bulunur, statik olarak değil. Yalnızca değerlerin ve ifadelerin türleri vardır ve yalnızca çalışma zamanında değişkenlerin türü yoktur.

Örneğin, ECMAScript'te:

const age = 23;
let age = 23;

Ve son olarak, birçok dilde, değişkenleri hiç açıklamanıza gerek yoktur. örneğin Ruby'de:

age = 23

Aslında, bu son örnek bir dizi programlama dilinde geçerlidir. Tam olarak aynı kod satırı Python'da da çalışacaktı.

Yani,

• değişkenlerin türlerinin bulunduğu statik olarak yazılmış dillerde bile, bunları bildirmek zorunda değilsiniz,
• Dinamik olarak yazılmış dillerde, değişkenlerin tipleri yoktur, bu yüzden onları açıkça söyleyemezsiniz.
• birçok dilde değişkenleri beyan etmeniz bile gerekmez

Bilgiye atıfta bulunmak için doğal dili kullandığınızda, bu çok kesin değildir ve özellikle niyetinizle ilgili başkalarıyla iletişim kurmaz. Doğal dilde matematik yapmaya çalışırken de benzer sorunlar ortaya çıkıyor: bu sadece yeterince kesin değil.

Programlama karmaşıktır; hataların gelmesi çok kolaydır. Tipler, hata koşullarını tespit ederek yasadışı program durumlarını önlemek için tasarlanmış bir kontrol sisteminin bir parçasıdır. Farklı diller farklı türleri kullanır: bazı diller derleme zamanında hataları algılamak için yoğun olarak türleri kullanır. Neredeyse tüm dillerin çalışma zamanı hatası olarak bazı uyumsuz türler kavramı vardır. Genellikle bir tür hata, programda bir tür hata olduğunu gösterir. Hatalara rağmen programların devam etmesine izin verdiğimizde, muhtemelen çok kötü cevaplar alıyoruz. Kötü veya yanlış cevaplar almak yerine programı durdurmayı tercih ediyoruz.

Başka bir deyişle, türler programın davranışları üzerindeki kısıtlamaları ifade eder. Kısıtlamalar, bazı mekanizmalar tarafından uygulandığında, garantiler sağlar. Bu garantiler, program hakkında düşünmek için gereken gerekçenin miktarını sınırlar, böylece programcılar için programı okuma ve sürdürme görevini kolaylaştırır. Türler ve tür hatalarını algılayan araçların (yani derleyici) kullanımı, programlama yükü oldukça yüksektir ve dolayısıyla daha maliyetlidir.

Bir çok insanın Avrupalı, Birleşik Devletler ve uluslararası telefon numarası arasında kolayca ayırt ettiği doğrudur. Bununla birlikte, bilgisayar gerçekten "düşünmez" ve söylenirse, birleşik devletlerin telefon numaralarını Avrupa’da arayabilir veya bunun tersi de geçerlidir. Örneğin, türler, bilgisayara nasıl "düşünmeyi" öğretmek zorunda kalmadan bu durumlar arasında ayrım yapmanın iyi bir yoludur. Bazı dillerde, bir Amerikan telefon sisteminde bir Avrupa telefon numarasını karıştırmaya çalışırken derleme zamanı hatası alabiliriz. Bu hata bize, programı çalıştırmayı denemeden önce programımızı (belki de telefon numarasını uluslararası bir arama sırasına dönüştürerek veya bunun yerine Avrupa'da telefon numarasını kullanarak) değiştirmemiz gerektiğini söylüyor.

Ayrıca, bilgisayarın düşünmediği gibi, alanın veya değişkenin adı (örn. phonenumber), Bilgisayar için hiçbir şey ifade etmez. Bilgisayara göre, bu alan / değişken adı sadece "blah123" dür. Tüm değişkenler "blahxxx" olsaydı, programınızın nasıl olacağını düşünün. Amanın. Bilgisayarın gördüğü şey bu. Bir tür sağlamak, bilgisayara, yalnızca isminden çıkarıp alamayacağı değişkenin anlamını gösterir.

Ayrıca, @Robert’in dediği gibi, birçok modern dilde eski günlerde yaptığımız gibi türler belirtmek zorunda değiliz, çünkü C # gibi diller uygun türün belirlenmesi için bir dizi kural olan "tür çıkarımı" yapıyor. bağlamdaki bir değişken için. C # yalnızca yerel değişkenler üzerinde tip çıkarımı sağlar, ancak resmi parametrelerde veya sınıf veya örnek alanlarda olmaz.

Diğer cevaplara ek olarak, dahil edilmesi gereken bir şey var. Bilgisayarların sadece bit olduğunu unutmayın. Size baytları verdiğimi söyleyin:

26 3A 00 FF

Bu ne anlama geliyor ? Bu şekilde bilgisayar tarafından depolanır, ancak herhangi bir yorum yapmadan, sadece bit . 4 ascii karakter olabilir. Bir tamsayı olabilir. Bir dizideki bazı baytlar olabilir. Bir nesnenin parçası olabilir. Bu kedi videosunun arabelleğe alındığı yer için bir işaretçi olabilir. Meclisten sonraki tüm programlama dilleri, anlamlı bir hesaplama yapabilmeleri için bitlerin nasıl yorumlanacağını bilecek bir şeye ihtiyaç duyarlar .

Ve bilgisayar bu bitlerin anlamını bilmediğinden, açık bir şekilde yazım ek açıklamaları yoluyla veya dolaylı olarak diğer cevaplarda belirtilen yazım çıkarım mekanizmaları aracılığıyla söylemeniz gerekir.

Bilgisayarların neden bu bilgilere ihtiyaç duyduğunun cevabı Veri Temsilciliği ile ilgilidir .

"Veri türü" adı, bilgisayarın 0 ve 1 'lerin bilgisayar belleğindeki ham durumundan bilgi depolamasına ve almasına yardımcı olan kurallara referanstır.

Örneğin, normal 8 bitlik ASCII karakteriniz bilgisayar belleğinde (RAM veya Disk) 01000001(büyük harf "A" karakteri, ASCII kod 65) veya 00001000(yüzde işareti) veya 0 ve 1 tanesi bu 8 bitte.

Başka bir örnek için, bazı 8-bit işaretsiz tamsayılar 00000101(5 numaralı) veya 00001000(8 numaralı ) olarak saklanabilir.

% 8 ve% karakterinin ikili gösteriminin aynı olabileceğine dikkat edin, ancak türleri farklı olduğundan farklı anlamlara gelir.

Veri türünü çıkaran diller bile, "tüm değişkenlerin türlerinin programlayıcı tarafından bildirilmesi gerektiği" kuralına sahip olmayabilirler, "karakter dizileriniz tırnak içine alınmışsa, bir dizedir" ve Her veri türü için daha birçok kural.

Bu yüzden, 0'ların ve 1'lerin ne anlama geldiğini anlamak için bunlar bile veri tiplerine ihtiyaç duyar, bu nedenle, örneğin iki karakter "eklemeye" çalışırsanız, örneğin dizgiyi birleştirme işlevini yapabilir veya iki tam sayı eklemeye çalışıyorsanız tamsayı eklemesi yapabilirler. .

In Hikayen de izin Diyelim ki telefon numarasını Sam sormadım say ama Sam size "1123581321" Üzerinde yazılı sahip bir parça kağıt verir. Sam'in ilk sekiz Fibonacci sayısının hayranı olup olmadığı ya da telefon numarası olup olmadığından emin olamazsın. Bir tahminde bulunmak için, belki de bir gün önce Sam'den bir telefon numarası istemeniz veya notta "Beni Ara" yazması veya rakamları sayıp bulduğunuzda yazdığınız ipuçlarını ve mevcut ipuçlarını dikkate almanız gerekir. çoğu telefon numarasının modelleriyle eşleşir. Ancak o zaman bir hesap makinesinin içine gireceğiniz bazı rakamları değil, arayabileceğiniz bir telefon numarası olduğunu bilirsiniz.

Numaranın bir telefon numarası olduğunu tahmin etmenize yol açan bu ipuçlarının, ipuçlarının bir değerin türünü belirlemek için bildirim gerektirmeyen bir bilgisayar dilini nasıl yönlendirdiğine benzer olduğunu unutmayın.

Bazı dillerde, veri türünü belirtmeniz gerekmez.

Tür çıkarımını destekleyen diller genellikle kullanımınızdaki veri türünü çözebilir. Örneğin,

var name = "Ali"

dahili olarak bir dize olarak yazılır, çünkü değer tırnaklarla çevrilidir.

Bazı diller değişkeni de bildirmenizi gerektirmez; Değişken ilk kullanıldığında yaratılır. Bununla birlikte, bir takım önemli nedenlerden dolayı değişkenlerinizi özel olarak beyan etmek en iyi yöntem olarak kabul edilir; çünkü daha iyisini yapmak niyetini ifade ediyor.

Çünkü dil tasarımının belirttiği şey budur. Bu nedenle sorunuzu yanıtlamak için, C # ve C ++ gibi dillerde açıkça yazmanın arkasındaki amacına bakmamız gerekiyor. (C # yapar çünkü C ++ C yapar çünkü C yapar, o zaman niyet yoluna bakmamız gerekir).

İlk olarak, açık ve statik yazım kodlamada titizlik sağlar - bir tamsayı olacak bir değişken belirtmek, derleyiciye ve yazılımın şaşırması ve değişkene bir karakter veya dize atadığınızda bir hata atması gerektiği anlamına gelir. Dinamik yazma işlemi, istenmeyen kişiler için baş ağrısına neden olabilir (PHP'ye veya javascripts'e bakıp diziler ve boş dizeler gibi şeylerin gerçekliğine yaklaşma).

Örtülü yazarak statik olabilir - bir değişkeni bir dize olarak başlatmak, değişkenin yalnızca bir dize olması gerektiği anlamına gelir, ancak benim düşüncem bunun kod okuyan insanlar için sorunlara neden olabileceğidir (Örtülü yazma olduğunda dinamik yazmayı varsayma eğilimindeyim) ).

Ayrıca, bazı dillerde, bir dize girişinden bir sınıfı başlatmak için bu sözde kod gibi bir şey yazmak mümkündür:

PhoneNumber phoneNumber = "(61) 8 8000 8123";

İkinci olarak, açık yazma da bellek ayırma ile el ele gider. Bir int her zaman çok sayıda bayttır. Bir PhoneNumber , çok fazla bayttır. Derleyici, daha sonra bir değer atadığınızda ne kadar alana ihtiyaç duyulacağını görmenize gerek kalmadan kullanılabilecek uygun büyüklükte bir bellek bloğu atayabilir.

PhoneNumber phoneNumber;
...
phoneNumber = "some value from somewhere";

Sonunda, karmaşayı giderir ... 123 bir tam sayı mı yoksa imzasız bir tam sayı mı? Aynı bayt sayısına ihtiyaçları var, ancak her iki türdeki değişkenlerde depolanan maksimum değer çok farklı ...

Bu, açık olanın örtük olmaktan daha iyi olduğu söylenemez - ancak dil tasarımı bu tür seçeneklere dayanır ve C # da örtük yazarak farklı şekilde çalışır. PHP ve javascript açık bir şekilde yazarak farklı şekilde çalışacaktır.

Çünkü Sam derleyicilerden daha akıllıdır. Örneğin, bana telefon numarasını verdiğinizde, ülke ön ekini veya alan kodunu sadece son 4 hanenin gerekli olduğu iş numarası olup olmadığını belirtmezsiniz. Ayrıca, yerel pizza ortaklarının sayısını sorarsanız, "pizza4u" cevabını ele alabilirsiniz.

Sam, bağlamdan çözüyor. Derleyici bağlamdan da çıkarsa da, Sam bu konuda daha iyi olacak (ve açıklama için süreci durdurabilecek durumda).

Türler ve değişkenler için iki temel yaklaşım vardır; değişken, bir türe sahiptir, bu durumda tür tarafından izin verilmeyen eylemler yasaklanır ve derlemeyi önler veya değerin izin vermediği bir tür ve eylemleri vardır. tür çalışma zamanında yakalandı.

Her yaklaşımın kendine göre avantajları ve dezavantajları vardır. Genel olarak, derleyici yazarları dezavantajları en aza indirmeye ve avantajları en üst düzeye çıkarmaya çalışır. Bu nedenle C #, izin verir var phoneNumber = GetPhoneNumber();ve phoneNumber türünü GetPhoneNumber imzasından algılar. Bu, yöntemin türünü belirtmeniz gerektiği anlamına gelir, ancak sonucu alan değişkeni değil. Öte yandan, javascript için çeşitli ipucu / zorlayıcı projeler bulunmaktadır. Her şey bir tradeoff.

Verilerin saklanma şekli meselesidir. Sam'le olan ilişkiniz daha iyi bir karşılaştırma yapardı, eğer yazabildiniz, ancak yalnızca sekiz karakterlik kağıda sahiptiniz.

"Sam, bana telefon numarasını ver."

"5555555555"

“Ah hayır kağıt bitti. Keşke vaktinden önceden ne kadar veri istediğimi bilseydim daha iyi hazırlayabilirdim!”

Bunun yerine, çoğu dil size bir tür bildirir, bu nedenle önceden bilecek ve hazırlayacaktır:

"Sam, telefon numarası ne kadar?"

"On karakter."

“Tamam, o zaman daha büyük bir kağıt almama izin verin. Şimdi bana telefon numarasını verin.”

"5555555555"

"Anladım! Teşekkürler Sam!"

Verilerin depolandığı asıl temel yollara baktığınızda daha da belirginleşir. Eğer benim gibiyseniz, çeşitli notlar, sayılar sadece karalanmış, hiçbir şey için bağlam veya etiket bulunmayan bir defteriniz var ve üç gün sonra ne anlama geldiği hakkında hiçbir fikriniz yok. Bu, bilgisayarlar için de bir çok sorundur. Birçok dil "int" tipine (int, uzun, kısa, bayt) ve "float" (float, double) tiplerine sahiptir. Bu neden gerekli?

İlk önce bir tamsayı nasıl depolandığını ve genel olarak bilgisayarın içinde nasıl temsil edildiğini araştıralım. Muhtemelen, temel düzeyde, tamamen ikili olduğunu biliyorsunuzdur (1 ve 0). İkili aslında tam olarak ondalık sayı sistemimiz gibi çalışan bir sayı sistemidir. Ondalık olarak, 0 ile 9 arasında sayın (sonsuz olmayan ima edilen satır sıfırlarıyla birlikte yazmazsınız), sonra 0'a geri dönersiniz ve bir sonraki basamağı yükseltirsiniz, böylece 10'unuz olur. 99 - 100 arasında geçiş yapana kadar tekrarlayın.

İkili değer farklı değildir, 0 - 9 yerine 0 - 1 arasında sayılır. 0, 1, 10, 11, 100, 101, 110, 111, 1000. 9'u yazdığınızda, ikili olarak kaydedilen hafızaya 1001 olarak. Bu gerçek bir sayıdır. Tam olarak bu şekilde eklenebilir, çıkarılabilir, çarpılabilir, vb. 10 + 1 = 11. 10 + 10 = 100 (1'den 0'a kadar yuvarlayın ve 1'i taşıyın). 11 x 10 = 110 (ve eşdeğer olarak, 11 + 11 = 110).

Şimdi asıl hafızada (kayıtlar dahil), hemen yan yana gelmek için bitlerin (potansiyel 1'ler veya 0 ') yanlarında bir liste, dizi var, bu bitleri yapmak için mantıklı bir şekilde düzenlenmiş durumda. 1'den büyük sayı. Sorun, ondalık sayılarla ne yaparsınız? Kayıttaki iki bit arasına bir donanım parçası ekleyemezsiniz ve her bit çifti arasına "ondalık bitler" eklemek çok pahalıya mal olur. Peki ne yapmalı?

Sen kodladın. Genel olarak, CPU veya yazılımın mimarisi bunun nasıl yapıldığını belirleyecektir, ancak ortak yollardan biri, kaydın ilk bitinde bir işaret (+ veya -, genellikle 1 negatif), bir mantis (numaranız değişmiş ) depolamaktır . bununla birlikte birçok kez aşağıdaki X bit sayısı için ondalıktan kurtulmak gerekir ve kalan kısım için bir üs (onu kaydırmak zorunda kaldığınız sayı). Bilimsel gösterime benzer.

Yazma, derleyicinin neye baktığını bilmesini sağlar. 1.3 değerini sicil 1'de sakladığınızı hayal edin. Burada sadece kendi fantezi kodlama şemasını göreceğiz, burada işaret için 1 bit, mantissa için 4, üs için 3 (işaret için 1 bit, büyüklük için 2). Bu pozitif bir sayıdır, bu nedenle işaret pozitifdir (0). Mantisimiz 13 (1101) ve üssümüz -1 (101 (negatif için 1, 01 = 1)) olacaktı. Bu yüzden 01101101 numaralı sicili 1 numaralı depoda saklıyoruz. Şimdi bu değişkeni girmedik, bu nedenle çalışma zamanı onu kullanmaya başladığında, "kesinlikle, neden olmasın bir tamsayıdır" yazıyor. 32 + 8 + 4 + 1) açıkçası doğru değil.

Yine de her dil açıkça yazmanızı gerektirmez. C #, bir değişkenin türünün derleme zamanında yorumlanmasına neden olan bir "var" anahtar sözcüğüne sahiptir ve Javascript gibi diğer diller, bir tam sayıyı bir değişkende saklayabileceğiniz noktaya, sonra bir booleya atadıktan sonra tamamen dinamik bir şekilde yazılır, ardından bir dizeye tekrar atayın ve dil hepsini izler.

Ancak derleyici, tercüman veya çalışma zamanı için çok daha kolaydır - ve genellikle daha hızlı bir programla sonuçlanır, çünkü her şeyi yazarak değerli kaynakları harcamak zorunda kalmaz - size, programcıya, ne tür bir soru sormak için Verdiğiniz veri.

Değişkenleriniz için veri tiplerini beyan etmeniz gerekmeyen programlama dilleri vardır . Değişkenleri önceden bildirmek zorunda olmadığınız programlama dilleri bile vardır; Sadece yapabilirsiniz kullanmak hemen o kişiyi.

Değişken isimlerini bildirmeme konusundaki sorun, bir değişkenin adını yanlışlıkla yanlış yazmanız durumunda, yanlışlıkla yeni ve tamamen alakasız bir değişken yaratmış olmanızdır. Böylece, programınızı çalıştırdığınızda, neden kurduğunuz cehennemin aniden hiçbir şeyi olmadığını anlayamazsınız ... Saatlerce süren hata ayıklamadan sonra, lanet olası adı yanlış yazdığınızı fark edersiniz! Grrr !!

Böylece yaptılar, böylece önceden kullanacağınız değişken isimlerini bildirmeniz gerekiyor. Ve şimdi yanlış bir ad yazdığınızda , programınız bile çalışmaya başlamadan önce derhal tam olarak hatanın nerede olduğunu bildiren bir derleme zamanı hatası alırsınız . Bu o kadar kolay değil mi?

Veri tipleri ile aynı anlaşma. Ne tür şeyler olması gerektiğini bildirmek zorunda olmadığınız programlama dilleri vardır . customerAslında, sadece müşterinin adı olan bir değişkeniniz varsa , tüm müşteri nesnesini değil, düz bir sıradan dizeden müşteri adresini almaya çalışmak ... işe yaramayacak. Statik yazmanın bütün noktası programın derlenmeyeceğidir; Sorunun tam olarak bulunduğu yere işaret ederek yüksek sesle şikayet edecektir. Bu , kodunuzu çalıştırıp neden işe yaramadığını anlamaya çalışmaktan çok daha hızlı.

Bunların hepsi özellikleri ne derleyici anlatmak için vardır isteyen o ne kontrol edebilirsiniz, yapmak aslında yaptım ve emin mantıklı olun. Bu, derleyicinin sizin için otomatik olarak büyük bir anlaşma olan hataları bulmasını mümkün kılar .

(Uzak geçmişe geri döndüğünüzde, alt rutinleri bildirmek zorunda kalmadınız . Sadece GOSUBbelirli bir satır numarasına gidecektiniz . Eğer alt rutinler arasında bilgi iletmek isteseydiniz, belirli global değişkenleri belirlerdiniz, alt rutininizi arayın ve sonra diğerlerini inceleyin. alt yordamın döndüğü zamanki değişkenler.Ama bu , parametrelerden birini başlatmayı unutmayı korkutucu bir şekilde kolaylaştırır , bu yüzden şimdi neredeyse tüm modern programlama dilleri, bir alt yordamın hangi gerçek parametreleri alacağını belirtmenizi talep eder; )

Normal İngilizce kullanıyorsanız, PhoneNumber'ı kullanmak için int olarak bildirmem gerekmez. Örneğin, arkadaşım Sam'in bana telefon numarasını vermesini rica edersem derim:

"Sam bana telefon numarasını ver"

Söylemem>

"Char (20) Sam bana int telefon numarasını verdi"

Neden veri türü belirtmemiz gerekiyor?

Yanına Pop MathOverflow veya Teorik Bilgisayar Bilimi ve yanlış anlama olasılığı yoktur olmasını garanti etmek istediğinizde insanlar birbirleriyle alogrithms tebliğ nasıl bir fikir edinmek için bir süre okuyun. Veya bazı olgun programlama dili için standardı okuyun.

Sen değerlerin türlü bir dönem izin ne tanımlayan olduğunu göreceksiniz olduğunu gerçekten hassas iletişimin parçası bile insandan insana alıştırması.

Fark ettiğiniz şey, günlük etkileşimlerin oldukça düzenli olduğu ve insanların oldukça hataya dayanıklı oldukları, bu nedenle telefon numaraları hakkında yanlış anlaşılmaya katılımcılar tarafından paylaşılan bilgilerden kaçınılır.

Ama hiç başka bir ülkedeki biri için bir telefon numarası almayı denediniz mi? Uluslararası adreslemeye gitmek için kaç kere sıfır kullanmanız gerektiğini açıkça söylediler mi? Size ülke kodunu söylediler mi? Bunu böyle tanıdın mı? Kaç basamak beklediniz? Kaç tane aldın? Rakamların nasıl gruplandığını biliyor muydunuz? Hatta eğer gruplaşma önemi vardır?

Birdenbire sorun çok daha zor ve muhtemelen alınan numaranın gönderenin istediği şekilde anlaşıldığını açıkça kontrol etmek için çok daha fazla özen gösterdiniz.

Tür bildirmek için başka bir neden verimliliktir. Bir tam sayı 1 bayt veya 2 bayt veya 4'te saklanabilse de, çok sayıda değişken kullanan bir program, ne yapıldığına bağlı olarak gerekli belleğin 4 katını kullanabilir. Yalnızca programcı daha küçük bir depolama alanının uygun olup olmadığını bilir, bu yüzden türü bildirerek bunu söyleyebilir.

Ayrıca, dinamik olarak yazılan nesneler anında birçok olası tür için izin verir. Bu, baştan sona "başlık altında" bir miktar eklenebilir ve programı tek bir türle yapıştırmaya kıyasla yavaşlatır.

Bazı erken programlama dilleri (özellikle Fortran), kullanmadan önce değişkenleri bildirmenizi gerektirmedi.

Bu bir dizi soruna yol açtı. Gerçekten aşikâr olan bir tanesi, derleyicinin artık neredeyse yazım hataları gibi basit tipografik hataları yakalayamamasıdır. Mevcut bir değişkeni değiştirmesi gereken, ancak yazım hatası olan bir kodunuz varsa, yeni bir değişkeni yeni oluşturan (ve buna bir değer atayan) yine de tamamen meşru bir kodunuz vardır:

longVariableName = 1

// ...

longVaraibleName = longvariableName + anotherLongVariableName

Şimdi, buna yalıtılmış bir şekilde bakarken, problemin kaynağı olarak bir yazım hatası söylediğimde, yazım hatası ve sorunu burada bulmak oldukça kolaydır. Bunun birçok başka kodun ortasına gömülü olduğu uzun bir programda kaçırılması çok daha kolay.

Halen dinamik olarak yazılmış birçok dilde bile, aynı temel problemi oldukça kolay bir şekilde alabilirsiniz. Bazılarının bir değişkene atarsanız sizi uyarması için bazı imkânları vardır, ancak bunu asla okumazsınız (ki bununla (bunun gibi bir kaç problemi yakalar)) ikisinde de böyle şeyler yoktur.

Herhangi bir değişkeni tanımladığınızda hafızada bir miktar alan tahsis edilir, ancak makine (bu durumda bilgisayar) zaten bu değişken için ne kadar alan ayrılması gerektiğini bilmiyor.

Örnek: - kullanıcıdan herhangi bir sayı girmesini isteyen bir program oluşturursunuz, bu durumda bu numarayı saklamak için bir veri türü belirtmeniz gerekir, aksi takdirde makine, denerse 2 bayt veya 2 gigabayt tahsis etmesi gerektiğini kendiliğinden yargılayamaz. kendi kendine tahsisat yapmak o zaman verimsiz bellek kullanımına neden olabilir. Diğer taraftan, programınızdaki veri tipini belirtirseniz, derlemeden sonra makine ihtiyaca göre uygun yer tahsis eder.