Java'nın neden farklı boyut numaraları için temel öğeleri var?

Java'da orada için ilkel türleridir byte, short, intve longve için aynı şey floatve double. Bir kişinin ilkel bir değer için kaç bayt kullanılması gerektiğini ayarlaması neden gereklidir? Geçilen sayının büyüklüğüne bağlı olarak boyut sadece dinamik olarak belirlenemedi mi?

Düşünebilmem için 2 neden var:

1. Verilerin boyutunu dinamik olarak ayarlamak, dinamik olarak da değiştirilebilmesi gerektiği anlamına gelir. Bu potansiyel olarak performans sorunlarına neden olabilir mi?
2. Belki de programcı birisinin belirli bir boyuttan daha büyük bir sayı kullanabilmesini istemez ve bu da onu sınırlandırmasına izin verir.

Hala tek intve floattür kullanarak basitçe kazanacak çok şey olabileceğini düşünüyorum , Java'nın bu rotaya gitmemeye karar vermesinin belirli bir nedeni var mıydı?

Dil tasarımının pek çok yönü gibi, performansa karşı zarafetin değiş tokuşuna gelir (önceki dillerden bazı tarihsel etkilerden bahsetmiyoruz).

Alternatifler

Tek tip doğal sayıya sahip bir programlama dili yapmak kesinlikle mümkündür (ve oldukça basittir) nat. Akademik çalışma için kullanılan hemen hemen tüm programlama dilleri (örn. PCF, Sistem F), tahmin ettiğiniz gibi daha zarif bir çözüm olan bu tek sayı tipine sahiptir. Ancak pratikte dil tasarımı sadece zarafetle ilgili değildir; performansı da göz önünde bulundurmalıyız (performansın dikkate alınma düzeyi dilin amaçlanan uygulamasına bağlıdır). Performans hem zaman hem de alan kısıtlamalarını içerir.

Alan kısıtlamaları

Programlayıcının ön taraftaki bayt sayısını seçmesine izin vermek, bellek kısıtlamalı programlarda yer tasarrufu sağlayabilir. Tüm sayılarınız 256'dan küçük olacaksa, bytes'nin 8 katını kullanabilir longveya kaydedilmiş depolamayı daha karmaşık nesneler için kullanabilirsiniz. Standart Java uygulama geliştiricisinin bu kısıtlamalar hakkında endişelenmesine gerek yoktur, ancak gelirler.

verim

Alanı görmezden gelsek bile, hala sabit sayıda bayt (64 bit mimaride 8 bayt) üzerinde çalışan talimatlara sahip CPU tarafından kısıtlanıyoruz. Bu, tek bir 8 baytlık longtipin sağlanması bile , aritmetik işlemleri doğrudan temeldeki tek bir CPU komutuyla eşleştirerek dilin sınırsız doğal sayı tipine göre çok daha basit hale geleceği anlamına gelir . Programlayıcının keyfi olarak büyük sayılar kullanmasına izin verirseniz, tek bir aritmetik işlem , programı yavaşlatacak bir dizi karmaşık makine komutuyla eşlenmelidir. Bu ortaya çıkardığınız nokta (1).

Kayan nokta türleri

Şu ana kadarki tartışma sadece tamsayılarla ilgiliydi. Kayan nokta türleri, son derece ince anlambilim ve kenar durumları olan karmaşık bir canavardır. Böylece, kolayca yerini alabilir rağmen int, long, shortve bytetek olan nattipi, o kayan noktalı sayıların tipi bile ne olduğu açık değildir olduğunu . Açıkçası, gerçek sayılar değildir, çünkü gerçek sayılar bir programlama dilinde var olamaz. Bunlar da oldukça rasyonel sayılar değildir (istenirse rasyonel bir tür oluşturmak basittir). Temel olarak, IEEE gerçek sayıları biraz sorta etmeye karar verdi ve o zamandan beri tüm diller (ve programcılar) onlarla sıkıştı.

En sonunda:

Belki de programcı birisinin belirli bir boyuttan daha büyük bir sayı kullanabilmesini istemez ve bu da onu sınırlandırmasına izin verir.

Bu geçerli bir neden değil. İlk olarak, türlerin doğal olarak sayısal sınırları kodlayabileceği herhangi bir durumu düşünemiyorum, programcının uygulamak istediği sınırların tam olarak ilkel türlerin boyutlarına tam olarak karşılık gelmesi ihtimalinin astronomik olarak düşük olduğundan bahsetmiyorum.

Nedeni çok basit: verimlilik . Birden çok şekilde.

1. Yerel veri türleri: Bir dilin veri türleri, donanımın temel veri türleriyle ne kadar yakın olursa, dilin o kadar verimli olduğu düşünülür. (Programlarınızın mutlaka etkili olacağı anlamına gelmez, ancak ne yaptığınızı gerçekten biliyorsanız, donanımın çalıştırabileceği kadar verimli çalışacak bir kod yazabilirsiniz.) Sunulan veri türleri Java tarafından, en popüler donanımın baytlarına, kelimelerine, çift kelimelerine ve dört kelimelerine karşılık gelir. Bu en etkili yol.

2. 32 bit sistemlerde haksız yük: Her şeyi sabit boyutlu 64 bit uzunluğa eşleme kararı verilmiş olsaydı, bu, 64 bit gerçekleştirmek için çok daha fazla saat döngüsüne ihtiyaç duyan 32 bit mimarilere büyük bir ceza verebilirdi. 32-bit bir işlemden daha fazla bit işlemi.

3. Bellek israfı: Bellek hizalama konusunda çok seçici olmayan çok fazla donanım var, (Intel x86 ve x64 mimarileri buna örnektir,), bu donanımdaki 100 baytlık bir dizi sadece 100 bayt bellek kaplayabilir. Bununla birlikte, artık bir baytınız yoksa ve bunun yerine uzun bir süre kullanmanız gerekiyorsa, aynı dizi daha fazla bellek büyüklüğüne sahip olacaktır. Bayt dizileri çok yaygındır.

4. Sayı boyutlarını hesaplama: Geçirilen sayının ne kadar büyük olduğuna bağlı olarak bir tamsayının boyutunu dinamik olarak belirleme fikriniz çok basittir; bir sayının "geçilmesi" için tek bir nokta yoktur; bir sayının ne kadar büyük olması gerektiğinin hesaplanmasında, daha büyük bir boyutun sonucunu gerektirebilecek her bir işlemde gerçekleştirilmesi gerekir: bir sayıyı her artırdığınızda, her iki sayı eklediğinizde, her iki çarptığınızda sayılar vb.

5. Farklı boyutlardaki sayılardaki işlemler: Daha sonra, bellekte yüzen potansiyel olarak farklı boyutlarda sayılara sahip olmak tüm işlemleri zorlaştıracaktır : İki sayıyı karşılaştırmak için bile, çalışma zamanının önce karşılaştırılacak her iki sayının aynı olup olmadığını kontrol etmesi gerekir. boyut ve değilse, daha küçük olanı daha büyük olanın boyutuna uyacak şekilde yeniden boyutlandırın.

6. Belirli işlenen boyutları gerektiren işlemler : Bazı bit-bilge işlemleri belirli bir boyuta sahip tamsayıya dayanır. Önceden belirlenmiş spesifik bir boyuta sahip olmayan bu işlemlerin taklit edilmesi gerekir.

7. Polimorfizmin yükü: Çalışma zamanında bir sayının boyutunu değiştirmek esasen polimorfik olması gerektiği anlamına gelir. Bu da, yığına tahsis edilmiş sabit boyutlu bir ilkel olamayacağı, yığın üzerine tahsis edilen bir nesne olması gerektiği anlamına gelir. Bu çok verimsiz. (Yukarıdaki # 1'i tekrar okuyun.)

Diğer cevaplarda tartışılan noktaları tekrarlamaktan kaçınmak için, bunun yerine birden çok perspektifi ana hatlarıyla anlatmaya çalışacağım.

Dil tasarımı açısından

• Makine genişliğine sığmayan tamsayı işlemlerinin sonuçlarını otomatik olarak barındıracak bir programlama dili ve yürütme ortamı tasarlamak ve uygulamak kesinlikle mümkündür.
• Bu tür dinamik genişlikli tamsayıların bu dil için varsayılan tamsayı türü haline getirilip getirilmeyeceği dil tasarımcısının seçimidir.
• Ancak, dil tasarımcısı aşağıdaki dezavantajları dikkate almalıdır:
  • CPU daha fazla kod yürütmek zorunda kalacak ve bu da daha fazla zaman alacaktır. Bununla birlikte, tamsayı tek bir makine kelimesine sığdığı en sık durum için optimizasyon yapmak mümkündür. Etiketli işaretçi gösterimine bakın .
  • Bu tamsayının boyutu dinamik hale gelir.
  • Dinamik genişlik tamsayısının bellekten okunması birden fazla açma gerektirebilir.
  • Alanlarının / öğelerinin içinde dinamik genişlik tamsayıları içeren yapılar (nesneler) ve diziler de dinamik olan toplam (işgal edilmiş) boyuta sahip olur.

Tarihsel nedenler

Bu, Java'nın tarihi hakkındaki Wikipedia makalesinde zaten tartışılmıştır ve ayrıca Marco13'ün cevabında kısaca tartışılmaktadır .

Şunu işaret ediyorum:

• Dil tasarımcıları estetik ve pragmatik bir zihniyet arasında dengelemelidir. Estetik zihniyet, tamsayı taşmaları gibi iyi bilinen sorunlara eğilimli olmayan bir dil tasarlamak istiyor. Pragmatik zihniyet tasarımcıya, programlama dilinin yararlı yazılım uygulamaları uygulamak ve farklı dillerde uygulanan diğer yazılım parçaları ile etkileşime girmek için yeterince iyi olması gerektiğini hatırlatır.
• Eski programlama dillerinden pazar payını yakalamak isteyen programlama dilleri pragmatik olmaya daha yatkındır. Olası bir sonuç, mevcut programlama yapılarını ve stillerini bu eski dillerden birleştirmeye veya ödünç almaya daha istekli olmalarıdır.

Verimlilik nedenleri

Verimlilik ne zaman önemlidir?

• Bir programlama dilini büyük ölçekli uygulamaların geliştirilmesine uygun olarak tanıtmak istediğinizde.
• Her verimliliğin katlandığı milyonlarca ve milyarlarca küçük öğe üzerinde çalışmanız gerektiğinde.
• Başka bir programlama diliyle rekabet etmeniz gerektiğinde, dilinizin iyi performans göstermesi gerekir - en iyi olması gerekmez, ancak kesinlikle en iyi performansa yakın kalmanıza yardımcı olur.

Depolama verimliliği (bellekte veya diskte)

• Bilgisayar belleği bir zamanlar kıt bir kaynaktı. Bu eski günlerde, bir bilgisayar tarafından işlenebilecek uygulama verilerinin boyutu, bilgisayar belleği miktarıyla sınırlıydı, ancak bu, akıllı programlama (uygulanması daha pahalıya mal olacak) kullanılarak çözülebilir.

Yürütme verimliliği (CPU içinde veya CPU ile bellek arasında)

• Zaten gardenhead'in cevabında tartışıldı .
• Bir programın art arda depolanan çok sayıda küçük sayı dizisini işlemesi gerekiyorsa, bellek içi sunumun verimliliğinin yürütme performansı üzerinde doğrudan bir etkisi vardır, çünkü büyük miktarda veri CPU ve bellek arasındaki verimin bir darboğaz haline gelmesine neden olur. Bu durumda, verilerin daha yoğun bir şekilde paketlenmesi, tek bir önbellek satırı getirmesinin daha fazla veri parçası alabileceği anlamına gelir.
• Ancak, veriler ardışık olarak saklanmazsa veya işlenmezse bu mantık geçerli değildir.

Belirli bağlamlarla sınırlı olsa bile, küçük tamsayılar için bir soyutlama sağlamak üzere programlama dillerine duyulan ihtiyaç

• Bu ihtiyaçlar genellikle, dilin kendi standart kütüphaneleri dahil olmak üzere yazılım kütüphanelerinin geliştirilmesinde ortaya çıkar. Aşağıda bu tür birkaç durum vardır.

Birlikte çalışabilirlik

• Genellikle, üst düzey programlama dillerinin işletim sistemi veya diğer alt düzey dillerde yazılmış yazılım parçaları (kütüphaneler) ile etkileşime girmesi gerekir. Bu alt düzey diller genellikle farklı türlerdeki alanlardan oluşan bir kaydın bellek düzeninin katı bir özelliği olan "yapılar" kullanarak iletişim kurar .
• Örneğin, daha üst düzey bir dilin belirli bir yabancı fonksiyonun char256 boyutunda bir diziyi kabul edeceğini belirtmesi gerekebilir . (Örnek.)
• İşletim sistemleri ve dosya sistemleri tarafından kullanılan bazı soyutlamalar bayt akışlarının kullanılmasını gerektirir.
• Bazı programlama dilleri BitConverter, dar tam sayıların bit akışlarına ve bayt akışlarına paketlenmesine ve paketinin açılmasına yardımcı olmak için yardımcı işlevler sağlamayı (örn. ) Seçer.
• Bu durumlarda, daha dar tam sayı türlerinin dile yerleşik ilkel bir tür olması gerekmez. Bunun yerine, kitaplık türü olarak sağlanabilirler.

Dize işleme

• Ana tasarım amaçları dizeleri manipüle etmek olan uygulamalar vardır. Bu nedenle, dize işlemenin verimliliği bu tür uygulamalar için önemlidir.

Dosya biçimi işleme

• C benzeri bir zihniyetle birçok dosya formatı tasarlandı. Bu nedenle, dar genişlikteki alanların kullanımı yaygındı.

Arzu edilebilirlik, yazılım kalitesi ve programcının sorumluluğu

• Birçok uygulama türü için, tamsayıların otomatik olarak genişletilmesi aslında istenen bir özellik değildir. Ne doygunluk ne de etrafı saran (modül).
• Birçok uygulama türü, programcının API düzeyinde olduğu gibi yazılımdaki çeşitli kritik noktalarda izin verilen en büyük değerlerin açık spesifikasyonundan faydalanacaktır.

Aşağıdaki senaryoyu düşünün.

• Bir yazılım API'sı bir JSON isteğini kabul eder. İstek bir dizi alt istek içeriyor. Tüm JSON isteği Deflate algoritması ile sıkıştırılabilir.
• Kötü niyetli bir kullanıcı, bir milyar alt istek içeren bir JSON isteği oluşturur. Tüm alt istekler aynıdır; kötü niyetli kullanıcı sistemi işe yaramaz bir iş yaparak bazı CPU döngülerini yakmaya çalışır. Sıkıştırma nedeniyle, bu özdeş alt istekler çok küçük bir toplam boyuta sıkıştırılır.
• Verilerin sıkıştırılmış boyutu üzerinde önceden tanımlanmış bir sınırın yeterli olmadığı açıktır. Bunun yerine, API'nin içinde bulunabilecek alt isteklerin sayısına önceden tanımlanmış bir sınır ve / veya verilerin sönük boyutuna önceden tanımlanmış bir sınır koyması gerekir.

Genellikle, birçok büyüklük sırasını güvenli bir şekilde arttırabilen yazılımlar, bu amaç için artan karmaşıklık ile tasarlanmalıdır. Tamsayı taşması sorunu giderilse bile otomatik olarak gelmez. Bu, dil tasarımı perspektifine cevap veren tam bir daireye gelir: genellikle, istenmeyen bir tamsayı taşması meydana geldiğinde (bir hata veya istisna atarak) bir işi gerçekleştirmeyi reddeden yazılım, astronomik olarak büyük işlemlere otomatik olarak uyan yazılımdan daha iyidir.

Bu OP'nin bakış açısı,

Bir kişinin ilkel bir değer için kaç bayt kullanılması gerektiğini ayarlaması neden gereklidir?

Doğru değil. Programlayıcının , yazılımın kritik bölümlerinde bir tamsayı değerinin alabileceği maksimum büyüklüğü belirlemesine izin verilmeli ve bazen de gerekli olmalıdır . Olarak Gardenhead cevabı işaret, temel tür tarafından uygulanan doğal sınırlar, bu amaç için yararlı değildir; dil, programcıların büyüklüklerini beyan etmeleri ve bu tür sınırları uygulaması için yollar sağlamalıdır.

Her şey donanımdan geliyor.

Bayt, çoğu donanımdaki adreslenebilir en küçük bellek birimidir.

Az önce bahsettiğiniz her tür, birkaç bayttan oluşur.

Bir bayt 8 bittir. Bununla 8 boolean ifade edebilirsin ama tek seferde sadece bir tane arayamazsın. 1 adresiniz, 8 adresinin tümünü ele alıyorsunuz.

Eskiden bu kadar basitti ama sonra 8 bitlik bir otobüsten 16, 32 ve şimdi 64 bitlik bir otobüse geçtik.

Bu, bayt düzeyinde hala adresleme yapabiliyor olsak da, komşu baytlarını almadan artık tek bir baytı bellekten alamayacağımız anlamına gelir.

Bu donanımla karşı karşıya olan dil tasarımcıları, donanıma uyan tipleri seçmemize izin veren türleri seçmemize izin vermeyi seçti.

Böyle bir detayın, özellikle herhangi bir donanımda çalışmayı amaçlayan bir dilde soyutlanabileceğini ve kaldırılabileceğini iddia edebilirsiniz. Bunun gizli performans endişeleri olacaktır, ancak haklı olabilirsiniz. Sadece bu şekilde olmadı.

Java aslında bunu yapmaya çalışır. Baytlar otomatik olarak Ints'e yükseltilir. İçinde herhangi bir ciddi biraz vites değiştirme işi yapmaya çalıştığınızda sizi deli edecek bir gerçek.

Peki neden iyi çalışmadı?

Java'nın büyük satış noktası, bilinen iyi bir C algoritmasıyla oturabileceğiniz, Java'ya yazabileceğiniz ve küçük ayarlarla işe yarayabileceği şekilde geri dönüyor. Ve C donanıma çok yakın.

Bu gidiş ve soyutlama büyüklüğünü ayrılmaz türlerden uzak tutmak birlikte çalışmadı.

Böylece alabilirlerdi. Sadece vermediler.

Belki de programcı birisinin belirli bir boyuttan daha büyük bir sayı kullanabilmesini istemez ve bu da onu sınırlandırmasına izin verir.

Bu geçerli bir düşünce. Bunu yapmanın yöntemleri var. Kelepçe fonksiyonu biri için. Bir dil, türlerine keyfi sınırlar getirecek kadar ileri gidebilir. Ve bu sınırlar derleme zamanında bilindiğinde, bu sayıların nasıl saklandığına dair optimizasyonlara izin verir.

Java sadece o dil değil.

Muhtemelen, bu türlerin Java'da var olmasının önemli bir nedeni basit ve üzücü bir şekilde teknik değildir:

C ve C ++ da bu türlere sahipti!

Bunun nedeni olduğuna dair bir kanıt sağlamak zor olsa da, en azından bazı güçlü kanıtlar vardır: Meşe Dili Spesifikasyonu (Sürüm 0.2) aşağıdaki pasajı içerir:

3.1 Tamsayı Türleri

Meşe dilindeki tamsayılar, iki istisna dışında C ve C ++ ile aynıdır: tüm tamsayı türleri makineden bağımsızdır ve geleneksel tanımların bazıları, C'nin tanıtılmasından bu yana dünyadaki değişiklikleri yansıtacak şekilde değiştirilmiştir. Dört tamsayı türünün genişliği 8, 16, 32 ve 64 bittir ve unsigneddeğiştirici tarafından önek olarak belirtilmedikçe imzalanır .

Böylece soru şu şekilde kaybolabilir:

C'de neden kısa, int ve uzun icat edildi?

Soru sorusunun cevabının burada sorulan soru bağlamında tatmin edici olup olmadığından emin değilim. Ancak buradaki diğer cevaplarla birlikte, bu türlere sahip olmanın yararlı olabileceği açık olabilir (Java'daki varlıklarının sadece C / C ++ 'dan miras kalmasına bakılmaksızın).

Düşünebileceğim en önemli nedenler

• Bir bayt adreslenebilir en küçük bellek birimidir (daha önce CandiedOrange'da belirtildiği gibi). A byte, bir dosyadan veya ağ üzerinden okunabilen temel veri bloğudur. Bunun açık bir temsili mevcut olmalıdır (ve çoğu zaman, gizlenmiş olsa bile, çoğu dilde mevcuttur).

• Uygulamada, tüm alanları ve yerel değişkenleri tek bir tür kullanarak temsil etmenin ve bu tür olarak adlandırmanın mantıklı olacağı doğrudur int. Stackoverflow ile ilgili bir soru var: Java API neden kısa veya bayt yerine int kullanıyor? . Orada cevabımda belirttiğim gibi, daha küçük türlere ( byteve short) sahip olmanın bir gerekçesi , bu türlerden diziler oluşturabilmenizdir : Java hala "donanıma yakın" dizileri temsil eder. Diğer dillerin aksine (ve Integer[n]dizi gibi nesnelerin dizilerinin aksine ), int[n]dizi değerlerin yığın boyunca dağıldığı bir referans koleksiyonu değildir. Bunun yerine, olacakpratikte ardışık bir n*4bayt bloğu olmalıdır - bilinen bir boyut ve veri düzenine sahip bir bellek yığını. 1000 bayt'ı rasgele boyutlu tamsayı değeri nesneleri koleksiyonunda veya (1000 bayt alan) bir koleksiyonda saklama seçeneğiniz varsa, byte[1000]ikincisi gerçekten biraz bellek tasarrufu sağlayabilir. (Bunun diğer bazı avantajları daha incelikli olabilir ve yalnızca Java'yı yerel kütüphanelerle arayüzlendirirken belirginleşebilir)

Özellikle sorduğunuz noktalar hakkında:

Geçilen sayının büyüklüğüne bağlı olarak boyut sadece dinamik olarak belirlenemedi mi?

Verilerin boyutunu dinamik olarak ayarlamak, dinamik olarak da değiştirilebilmesi gerektiği anlamına gelir. Bu potansiyel olarak performans sorunlarına neden olabilir mi?

Sıfırdan tamamen yeni bir programlama dili tasarladığı düşünülürse, değişkenlerin boyutunu dinamik olarak ayarlamak mümkün olabilir. Derleyici yapımında uzman değilim, ancak dinamik olarak değişen türlerin koleksiyonlarını mantıklı bir şekilde yönetmenin zor olacağını düşünün - özellikle de güçlü bir şekilde yazılmış bir diliniz olduğunda. Bu yüzden, muhtemelen performans etkileri olacak bir "genel, keyfi hassas sayı veri türünde" depolanan tüm sayılara kaybolacaktır. Tabii ki, orada olan kesinlikle yazılı ve / veya keyfi büyüklükte sayı türlerini sunmaktadır programlama dilleri, ama bu tarafa gitti gerçek genel amaçlı programlama dili olduğunu düşünmüyorum.

Yan notlar:

• unsignedOak spesifikasyonunda belirtilen değiştiriciyi merak etmiş olabilirsiniz . Aslında, bir açıklama da içeriyor: " unsignedhenüz uygulanmadı; asla olmayabilir." . Ve haklıydılar.

• C / C ++ 'ın neden bu farklı tamsayı türlerine sahip olduğunu merak etmenin yanı sıra, neden bu kadar korkunç bir şekilde dağınık olduklarını merak edebilirsiniz, kaç tane bitin olduğunu asla bilemezsiniz int. Bunun gerekçeleri genellikle performansla ilgilidir ve başka bir yere bakılabilir.

Kesinlikle performans ve mimariler hakkında henüz bilgi sahibi olmamanızı gösteriyor.

• İlk olarak, her işlemci büyük tipleri işleyemez, bu yüzden sınırlamaları bilmeniz ve bununla çalışmanız gerekir.
• İkincisi, daha küçük tipler işlem yaparken daha fazla performans anlamına gelir.
• Ayrıca, boyut önemlidir, eğer verileri bir dosyada veya veritabanında saklamanız gerekiyorsa, boyut tüm verilerin hem performansını hem de son boyutunu etkileyecektir, örneğin diyelim ki 15 sütunlu bir tablonuz var ve birkaç milyonlarca kayıt. Her bir sütun için gereken boyut kadar küçük veya sadece en büyük tip seçilen arasındaki fark, işlemlerin performansındaki olası veri ve zaman farkı olacaktır.
• Ayrıca, işlenen verilerin boyutunun, örneğin oyunlarda olduğu gibi, büyük etkisi olacağı karmaşık hesaplamalarda geçerlidir.

Veri boyutunun önemini göz ardı etmek her zaman performansa çarpıyor, gerektiği kadar çok kaynak kullanmalısınız, ama daha fazla değil, her zaman!

Bu, gerçekten basit şeyler yapan ve çok fazla kaynak gerektiren ve bu sistemin kullanımını gerçekten maliyetli kılan inanılmaz verimsiz bir program veya sistem arasındaki farktır; ya da çok şey yapan, ancak diğerlerinden daha hızlı çalışan ve çalıştırılması gerçekten ucuz bir sistem.

Birkaç iyi neden var

(1) bir bayt değişkeninin bir uzun ayet depolanması önemsiz olmakla birlikte, bir dizide milyonların depolanması çok önemlidir.

(2) belirli tamsayı boyutlarına dayanan "donanım yerel" aritmetiği çok daha verimli olabilir ve bazı platformlardaki bazı algoritmalar için bu önemli olabilir.