Derleme zamanı garantileri için neden daha fazla araştırma yapmıyoruz?

Derleme zamanı olan her şeyi seviyorum ve bir programı derledikten sonra yürütülmesi hakkında birçok garanti verildiği fikrini seviyorum. Genel olarak konuşursak, statik tip bir sistem (Haskell, C ++, ...) herhangi bir dinamik tip sistemden daha güçlü derleme zamanı garantileri vermektedir.

Anladığım kadarıyla Ada, zaman kontrolünü derleme konusunda daha da ileri gidiyor ve yürütmeden önce çok daha fazla hata tespit edebiliyor. Ayrıca, belirli bir zamanda, hassas alanlar için (programlama hatalarının insan hayatına mal olabileceği zaman) seçildiği göz önüne alındığında, oldukça güvenli olarak kabul edilir.

Şimdi merak ediyorum: eğer daha güçlü statik garantiler, daha belgelenmiş ve güvenli bir koda yol açarsa, neden bu yönde daha fazla araştırma yapmıyoruz?

Eksik gibi görünen bir şeye örnek int, temeldeki mimarinin bit sayısı ile belirlenen bir aralığa sahip genel bir tür tanımlamak yerine , bir aralığın olabileceği bir dil olacaktır (aşağıdaki örnekte Int [a..b], a ve b dahil):

a : Int [1..24]
b : Int [1..12]
a + b : Int [2..36]
a - b : Int [-11..23]
b - a : Int [-23..11]

veya (Ada'dan alarak):

a : Int [mod 24]
b : Int [mod 24]
a + b : Int [mod 24]

Bu dil aralık için en iyi temel türü seçer ve ifadeler üzerinde derleme zamanı denetimi yapar. Böylece, örneğin, verilen:

a : Int [-3..24]
b : Int [3..10]

sonra:

a / b

asla tanımlanmayacak.

Bu sadece bir örnek ama derleme zamanında uygulayabileceğimiz çok daha fazla şey var gibi hissediyorum. Peki, neden bu kadar az araştırma var? Bu fikri açıklayan teknik terimler nelerdir (bu konu hakkında daha fazla bilgi bulabilmem için)? Sınırlar nelerdir?

Ben ne kadar anlatmak için bir konumda değilim daha konu üzerinde yapılmalıdır araştırma, ama orada ben söyleyebilirim olduğunu yapılıyor araştırma örneğin, Verisoft XT Alman hükümeti tarafından finanse edilen bir program.

Aradığınızı düşündüğüm kavramlara, resmi doğrulama ve sözleşmeye dayalı programlama denir ; burada ikincisi, ilkini programcı dostu bir yöntemdir. Sözleşmeye dayalı programlamada, önce kodunuzu normal şekilde yazar ve sonra sözleşmeye sözde sözleşmeler eklersiniz. Bu paradigmaya dayanan kolayca kullanılabilen bir dil Microsoft Research tarafından Spec # ve her ikisi de çevrimiçi deneyebileceğiniz C # için işlevsel olarak benzer ancak biraz daha az güzel Kod Sözleşmeleri uzantısıdır (diğer diller için benzer araçlara da sahiptirler, rise4fun'a bakın) ). Bahsettiğiniz "aralık türüne sahip int", bir işlevdeki iki sözleşmeyle yansıtılır:

Contract.Requires(-3 <= a && a <= 24);
Contract.Requires( 3 <= b && b <= 10);

Bu işlevi çağırmak istiyorsanız, bu ölçütleri karşılaması gereken parametreleri kullanmanız veya derleme zamanı hatası almanız gerekir. Yukarıdakiler çok basit sözleşmelerdir, değişkenler veya istisnalar ve bunların ilişkileri hakkında neredeyse her türlü varsayım veya gereksinimi ekleyebilir ve derleyici her gereksinimin bir varsayım veya sağlanabilecek bir şey tarafından karşılanıp karşılanmadığını kontrol eder, yani türetilmiş varsayımlardan. Bu nedenle ismin kaynaklandığı yer: Çağıran gereksinimi karşılar , arayan bir iş sözleşmesinde olduğu gibi bunların karşılanmasını sağlar .

$P(x_1,x_2,...,x_n)$$n$$P$kullanıldı. CS tarafından bakıldığında, bu ikisi sürecin kritik parçalarıdır - doğrulama koşullarının oluşturulması zordur ve SMT, düşünülen teorilere bağlı olarak NP tam veya kararsız bir sorundur. SMT çözücüler için bile bir rekabet var, bu yüzden kesinlikle bu konuda biraz araştırma var. Buna ek olarak, SMT'nin durum alanı numaralandırması, sembolik model kontrolü, sınırlı model kontrolü ve daha fazlası gibi resmi doğrulama için SMT kullanılmasına alternatif yaklaşımlar vardır, ancak SMT de şu anda en "modern" yaklaşımdır.

Genel fikrin sınırları ile ilgili olarak:

• Daha önce belirtildiği gibi, programın doğruluğunu kanıtlamak hesaplama açısından zor bir sorundur, bu nedenle sözleşmeli bir programın (veya başka bir spesifikasyon biçiminin) derleme zaman kontrolünün gerçekten uzun sürmesi veya hatta imkansız olması mümkün olabilir. Çoğu zaman iyi çalışan buluşsal yöntemler uygulamak, bu konuda yapabileceği en iyi şeydir.
• Programınız hakkında ne kadar çok belirlerseniz, belirtimin kendisinde hata olma olasılığı o kadar artar . Bu, programınızda hala hatalar olsa bile yanlış pozitiflere (her şey hatasız olsa bile derleme zamanı denetimi başarısız olur) veya güvenli olmanın yanlış izlenimine yol açabilir.
• Sözleşme veya şartname yazmak gerçekten sıkıcı bir iştir ve çoğu programcı bunu yapmak için çok tembeldir. Her yerde kod sözleşmeleri ile bir C # programı yazmaya çalışın, bir süre sonra "hadi, bu gerçekten gerekli mi?" Bu nedenle, resmi doğrulama genellikle donanım tasarımı ve uçak veya otomasyon kontrol yazılımı gibi güvenlik açısından kritik sistemler için kullanılır.

Yukarıdaki açıklamaya tam olarak uymayan bahsetmeye değer son şey, "Örtülü Karmaşıklık Teorisi", örneğin bu çalışma . Yazabileceğiniz her bir programın belirli bir karmaşıklık sınıfına, örneğin P'ye düştüğü programlama dillerini karakterize etmeyi amaçlamaktadır. Böyle bir dilde, yazdığınız her programın otomatik olarak "kontrol edilebilen" polinom çalışma zamanı olması "sağlanır". sadece programı derleyerek. Bununla birlikte, bu araştırmanın pratik olarak kullanılabilir herhangi bir sonucunu bilmiyorum, ama aynı zamanda bir uzman olmaktan çok uzakım.