Apakah pengetikan statis sepadan dengan trade-off?

Saya mulai coding di Python terutama di mana tidak ada jenis keamanan, kemudian pindah ke C # dan Java di mana ada. Saya menemukan bahwa saya bisa bekerja sedikit lebih cepat dan dengan sakit kepala yang lebih sedikit di Python, tetapi sekali lagi, aplikasi C # dan Java saya berada pada tingkat kompleksitas yang jauh lebih tinggi sehingga saya tidak pernah memberikan Python tes stress yang sebenarnya.

Java dan C # camp membuatnya seperti tanpa jenis keamanan di tempat, kebanyakan orang akan berlari ke segala macam bug mengerikan meninggalkan hak dan itu akan lebih banyak masalah daripada nilainya.

Ini bukan perbandingan bahasa, jadi tolong jangan membahas masalah seperti dikompilasi vs ditafsirkan. Apakah keamanan jenis sepadan dengan kecepatan perkembangan dan fleksibilitas? MENGAPA?

kepada orang-orang yang menginginkan contoh pendapat bahwa pengetikan dinamis lebih cepat:

"Gunakan bahasa yang diketik secara dinamis selama pengembangan. Ini memberi Anda umpan balik lebih cepat, waktu pembalikan, dan kecepatan pengembangan." - http://blog.jayway.com/2010/04/14/static-typing-is-the-root-of-all-evil/

Ini semacam mitos bahwa programmer tidak perlu khawatir tentang jenis-jenis dalam bahasa yang diketik secara dinamis.

Dalam bahasa yang diketik secara dinamis:

• Anda masih harus tahu apakah Anda bekerja dengan array, integer, string, tabel hash, referensi fungsi, kamus, objek, atau apa pun.

• Jika itu sebuah objek, Anda harus tahu kelasnya milik apa.

• Menetapkan salah satu dari tipe ini ke variabel atau parameter fungsi yang diharapkan menjadi tipe lain hampir selalu merupakan kesalahan.

• Pada tingkat yang lebih rendah, hal-hal seperti jumlah bit atau yang ditandatangani versus yang tidak ditandatangani sering masih harus diperhitungkan jika Anda mengisi paket TCP, misalnya.

• Anda dapat mengalami masalah di mana Anda mendapatkan nol di mana Anda benar-benar menginginkan string kosong. Dengan kata lain, Anda masih men-debug bug tipe ketidakcocokan. Satu-satunya perbedaan nyata adalah kompiler tidak menangkap kesalahan.

• Saya berpendapat bahwa Anda bahkan tidak menyimpan banyak pengetikan -, karena Anda cenderung ingin mendokumentasikan dalam komentar apa jenis parameter fungsi Anda daripada mendokumentasikannya dalam kode Anda. Inilah sebabnya mengapa blok komentar gaya oksigen jauh lebih populer dalam praktiknya di seluruh kode yang diketik secara dinamis, di mana dalam bahasa yang diketik secara statis Anda sebagian besar hanya melihatnya untuk perpustakaan.

Itu bukan untuk mengatakan bahwa pemrograman dalam bahasa yang diketik secara dinamis tidak terasa lebih menyenangkan karena kompiler tidak selalu ada di belakang Anda, dan programmer yang berpengalaman cenderung tidak mengalami kesulitan menemukan dan memperbaiki jenis bug yang akan diketik oleh pengetikan statis. , tapi itu masalah yang sama sekali terpisah dari dugaan peningkatan efisiensi atau pengurangan tingkat bug, di mana pengetikan dinamis adalah yang terbaik bahkan dengan pengetikan statis.

Saat tipe semakin kuat, mereka dapat membantu Anda lebih banyak - jika Anda menggunakannya dengan benar alih-alih melawannya. Rancang tipe Anda untuk mencerminkan ruang masalah Anda dan kesalahan logika lebih cenderung menjadi ketidakcocokan tipe waktu kompilasi alih-alih runtime crash atau hasil yang tidak masuk akal.

Penafian: Saya seorang pecinta tipe;)

Pertanyaan Anda sulit dijawab: Apa kompromi itu ?

Saya akan mengambil contoh ekstrem: Haskell , itu diketik secara statis. Mungkin salah satu dari bahasa yang diketik paling kuat yang ada, pada kenyataannya.

Namun, Haskell mendukung Pemrograman Generik , dalam arti bahwa Anda menulis metode yang bekerja dengan jenis apa pun yang sesuai dengan konsep (atau antarmuka) tertentu.

Selanjutnya, Haskell menggunakan Inferensi Tipe , sehingga Anda tidak perlu mendeklarasikan tipe variabel Anda. Mereka dihitung secara statis selama kompilasi, sama seperti Penerjemah Python akan menghitung mereka menjalankan program.

Saya telah menemukan bahwa kebanyakan orang berkelahi pada pengetikan statis, sebenarnya mengeluh tentang sesuatu yang lain (verbositas, rasa sakit beralih dari satu jenis ke yang lain), tetapi Haskell tidak menunjukkan satu pun dari masalah itu, ketika sedang diketik secara statis ...

Contoh singkatnya:

-- type
factorial :: Integer -> Integer

-- using recursion
factorial 0 = 1
factorial n = n * factorial (n - 1)

Terlepas dari dukungan bawaan, sulit untuk lebih singkat.

Contoh Pemrograman Generik:

> reverse "hell­o" -- Strings are list of Char in Haskell
=> "olleh"
> reverse [1, 2, 3, 4, 5]
=> [5,4,3,2,1]

Contoh Jenis Inferensi:

> :t rever­se "hell­o"
:: [Char]

yang dapat dihitung secara sederhana:

• "hello"adalah daftar Char(dinyatakan sebagai [Char])
• reversediterapkan pada tipe [A]mengembalikan tipe[A]

Cobalah di peramban Anda

Saya suka bahasa yang diketik secara statis dan diketik secara dinamis. Dua keuntungan terbesar dari keamanan tipe bagi saya adalah:

1) Anda sering dapat menyimpulkan apa yang dilakukan fungsi murni dari tanda tangan tipenya (ini terutama berlaku dalam bahasa fungsional seperti Haskell).

2) Ketika Anda melakukan refactor yang signifikan, kompiler secara otomatis memberi tahu Anda segala yang harus Anda lakukan untuk menjaga semuanya berfungsi. Ketika saya refactor sesuatu di C ++, prosedur saya sering hanya a) ubah satu bagian yang saya tahu ingin saya ubah, lalu b) perbaiki setiap kesalahan kompilasi.

Secara pribadi, saya menemukan bahwa keamanan jenis membantu saya berkembang lebih cepat dalam pekerjaan saya saat ini. Kompiler melakukan banyak kewarasan memeriksa saya hampir saat saya mengetik, memungkinkan saya untuk lebih fokus pada logika bisnis yang saya terapkan.

Intinya bagi saya adalah bahwa meskipun saya kehilangan fleksibilitas, saya mendapatkan waktu yang seharusnya dihabiskan untuk melacak masalah tipe.

Ada banyak pendapat kuat di seputar debat tapi jelas ini bukan soal pendapat, ini soal fakta . Jadi kita harus melihat penelitian empiris . Dan bukti dari itu jelas:

Ya , pengetikan statis sepadan dengan trade-off - dan tidak hanya sedikit, tetapi sebenarnya secara substansial . Faktanya, bukti kuat menunjukkan bahwa pengetikan statis dapat mengurangi jumlah bug dalam kode setidaknya 15% (dan ini adalah perkiraan rendah, persentase sebenarnya hampir pasti lebih besar). Itu adalah angka yang sangat tinggi : Saya pikir bahkan sebagian besar pendukung pengetikan statis tidak akan mengira bahwa itu membuat perbedaan yang drastis.

Pertimbangkan ini: jika seseorang mengatakan kepada Anda bahwa ada cara sederhana untuk mengurangi bug di proyek Anda sebesar 15% dalam semalam, itu harus menjadi no-brainer. ¹ Ini hampir seperti peluru perak.

Bukti disajikan dalam makalah Untuk Mengetik atau Tidak Mengetik: Mengukur Bug yang Dapat Dideteksi dalam JavaScript oleh Zheng Gao, Christian Bird dan Earl T. Barr. Saya mendorong semua orang untuk membacanya, ini adalah makalah yang ditulis dengan baik yang menyajikan penelitian teladan.

Sulit untuk meringkas secara ringkas seberapa ketat penulis melakukan analisis mereka, tetapi inilah garis besar (sangat kasar):

TypeScript dan Flow adalah dua bahasa pemrograman berdasarkan JavaScript yang, meskipun tetap kompatibel, menambahkan petunjuk jenis dan pemeriksaan tipe statis. Ini memungkinkan penambahan kode yang ada berdasarkan jenis, dan kemudian ketik periksa.

Para peneliti mengumpulkan proyek Open Source yang ditulis dalam JavaScript dari GitHub, melihat laporan bug yang diselesaikan dan berusaha untuk mengurangi setiap bug yang dilaporkan menjadi sepotong kode yang akan ditangkap oleh pemeriksa tipe statis TypeScript atau Flow. Ini memungkinkan mereka untuk memperkirakan batas bawah persentase bug yang dapat diperbaiki dengan menggunakan pengetikan statis.

Para peneliti mengambil tindakan pencegahan ketat untuk memastikan bahwa analisis mereka tidak akan menganggap bug terkait non-tipe sebagai terkait dengan tipe. ²

Dibandingkan dengan studi sebelumnya, studi baru ini memiliki kekuatan khusus:

• Ada perbandingan langsung dari pengetikan statis vs dinamis, dengan beberapa (jika ada) faktor pembaur, karena satu-satunya perbedaan antara JavaScript dan TypeScript / Flow adalah pengetikan.
• Mereka melakukan replikasi di berbagai dimensi dengan memeriksa TypeScript dan Flow (yaitu sistem tipe yang berbeda), dan dengan meminta orang yang berbeda mereproduksi anotasi tipe (manual) untuk memperbaiki bug. Dan mereka melakukan ini di sejumlah besar basis kode dari berbagai proyek.
• Makalah ini mengukur dampak langsung dari pengetikan statis pada bug yang dapat diperbaiki (bukan kualitas yang lebih samar).
• Para penulis mendefinisikan model yang ketat tentang apa yang harus diukur, dan bagaimana, di muka. Lebih jauh lagi, deskripsi mereka sangat jelas dan memudahkan untuk menganalisis kekurangan (selalu bagus ketika sebuah makalah penelitian membuka diri terhadap serangan: jika tidak ada serangan yang berhasil merusak argumennya, maka hasilnya akan semakin kuat). ³
• Mereka melakukan analisis kekuatan yang tepat sehingga ukuran sampel mereka cukup, dan analisis statistik berikutnya kedap udara.
• Mereka terlalu konservatif untuk mengecualikan penjelasan yang membingungkan, dan hanya mengukur satu bagian yang bergerak. Selain itu, mereka membatasi analisis mereka untuk bug yang dapat segera diperbaiki dengan memasukkan jenis, dan mengecualikan apa pun yang mungkin memerlukan refactoring lebih lanjut untuk mengakomodasi pengetikan. Jadi pada kenyataannya, efeknya masuk akal jauh lebih besar, tetapi tentu saja tidak lebih kecil dari apa yang mereka laporkan.
• Dan akhirnya, mereka tidak menemukan sedikit efek tetapi perbedaan yang mengejutkan . Meskipun prosedurnya terlalu konservatif, bahkan pada akhir rendah dari interval kepercayaan 95% mereka menemukan bahwa ada setidaknya 10% bug yang akan hilang dengan cek tipe tambahan minimal.

Kecuali ada kesalahan mendasar pada makalah yang belum ditemukan siapa pun, makalah tersebut secara meyakinkan menunjukkan manfaat besar dari pengetikan statis, hampir tanpa biaya. ⁴

Pada catatan sejarah, penelitian tentang pengetikan disiplin dalam pemrograman telah memiliki awal yang sulit karena, untuk waktu yang lama, bukti tidak jelas sama sekali. Alasan untuk ini adalah bahwa melakukan percobaan sistematis untuk memeriksa efek dari pengetikan statis vs dinamis tidak mudah: percobaan sistematis harus mengisolasi efek yang kami selidiki. Dan sayangnya kita tidak dapat mengisolasi efek dari disiplin pengetikan, karena itu terkait dengan bahasa pemrograman.

Sebenarnya ada bahasa pemrograman yang memungkinkan pengetikan statis dan dinamis dalam dialek yang berbeda (mis. VB dengan Option Strict Onatau Off, atau Lisp yang diketik secara statis). Namun, ini tidak cocok untuk perbandingan langsung, yang paling penting karena tidak ada basis kode yang cukup besar yang memungkinkan perbandingan langsung. Paling-paling kita dapat membandingkannya dalam “pengaturan laboratorium”, di mana subjek uji secara acak menyelesaikan tugas dalam varian bahasa yang diketik secara statis atau dinamis.

Sayangnya tugas pemrograman buatan ini tidak memodelkan penggunaan dunia nyata dengan baik. Secara khusus, banyak dari mereka yang kecil cakupannya dan memecahkan masalah yang jelas yang dapat diringkas pada setengah halaman teks.

Untungnya itu di masa lalu, karena TypeScript, Flow dan JavaScript memang bahasa yang sama kecuali untuk pengetikan statis, dan karena ada set data dunia nyata yang luas dari kode dan bug untuk diambil sampelnya.

_{¹ Terinspirasi oleh kutipan dari kertas aslinya.}

_{² Saya tidak sepenuhnya senang dengan ini: salah satu kekuatan utama dari bahasa yang diketik secara statis adalah bahwa masalah yang tampaknya tidak terkait tipe dapat diungkapkan dengan cara yang dapat diperiksa jenisnya secara statis. Ini mengubah banyak kesalahan logika menjadi kesalahan tipe, yang secara drastis meningkatkan tingkat bug yang dapat ditangkap oleh pengetikan statis. Bahkan, makalah ini secara kasar mengklasifikasikan bug yang tidak terkait jenis dan saya berpendapat bahwa sebagian besar dari mereka sebenarnya bisa ditangkap oleh pengetikan statis.}

_{³ Saya mengundang siapa pun, terutama pendukung pengetikan dinamis, untuk mencoba menemukan kekurangan yang belum terselesaikan dalam analisis. Saya tidak berpikir ada banyak (jika ada), dan saya yakin bahwa tidak ada cacat potensial secara material akan mengubah hasilnya.}

_{⁴ Saya menduga bahwa biaya aktual pengetikan statis dalam proyek berskala besar nyata tidak ada, karena kemudian menjadi bagian alami dari arsitektur dan bahkan mungkin menyederhanakan perencanaan. Memperbaiki kesalahan tipe statis membutuhkan waktu, tetapi jauh lebih sedikit daripada kesalahan yang ditemukan kemudian. Ini telah dipelajari secara empiris secara luas dan telah dikenal selama beberapa dekade (lihat misalnya Code Complete ).}

Apakah keamanan jenis sepadan dengan kecepatan perkembangan dan fleksibilitas?

Jadi sebenarnya ini adalah apa yang Anda lakukan. Jika Anda mengatakan pemrograman, sistem cadangan untuk pesawat terbang, keselamatan jenis mungkin cara untuk pergi.

Bahasa dinamis vs pemrograman bahasa statis benar-benar dua binatang yang berbeda. Keduanya membutuhkan pendekatan yang berbeda secara mendasar satu sama lain. Anda sebagian besar dapat mem-porting suatu metode pendekatan antara statis dan dinamis, tetapi Anda akan kehilangan keunggulan yang lain.

Benar-benar pola pikir. Apakah yang satu lebih baik dari yang lain? Itu benar-benar tergantung pada siapa Anda dan bagaimana Anda berpikir. Sebagian besar orang yang bekerja dengan saya tidak akan pernah menyentuh bahasa yang dinamis jika mereka tidak perlu, karena mereka merasa ada terlalu banyak ruang untuk kesalahan. Apakah mereka salah memikirkan hal ini? Tidak, tentu saja tidak, tetapi itu berarti bahwa mereka telah menyadari bahwa pendekatan mereka dalam menerapkan gaya pengkodean mereka tidak akan bekerja dalam lingkungan yang dinamis. Orang lain yang saya kunjungi dengan grup pengguna adalah kebalikannya. Mereka menemukan pengetikan statis terlalu rumit, karena membatasi pendekatan mereka untuk memecahkan beberapa jenis masalah.

Jujur saya bisa mengatakan, saya melompat antara JavaScript dan C # banyak. Sekarang, mengetahui dan bekerja dalam kedua bahasa memang mempengaruhi yang lain sampai batas tertentu, tetapi sebenarnya, kode yang saya tulis di masing-masing terlihat sangat berbeda dari yang lain. Mereka memerlukan pendekatan yang berbeda, karena mereka secara fundamental berbeda. Apa yang saya temukan adalah bahwa jika Anda mendapati diri Anda berpikir, "Ya ampun, ini jauh lebih sulit untuk melakukan ini dalam bahasa X," pendekatan Anda mungkin sedikit kurang. Ini sebuah contoh, orang berbicara tentang cara "Pythonic" dalam melakukan sesuatu. Artinya adalah bahwa ada cara bahasa Python bekerja untuk membuat masalah lebih mudah. Melakukannya dengan cara lain umumnya lebih sulit, dan lebih rumit. Anda harus melupakan cara mengetahui bagaimana suatu bahasa berfungsi untuk benar-benar bekerja untuk Anda. Saya t'

Ada pertanyaan serupa yang baru saja diajukan: Bahasa dinamis yang diketik vs statis untuk situs web

Untuk menyatakan kembali inti dari jawaban saya:

Ketika sistem tumbuh lebih besar, bahasa yang diketik secara statis memastikan ketahanan pada tingkat komponen dan dengan demikian fleksibilitas pada tingkat sistem.

Ya, Java benar-benar diketik dan ya, Java menyebalkan (jangan tersinggung. Itu mengerikan. Platform & ekosistem yang hebat, tetapi salah satu bahasa terburuk yang pernah (benar-benar digunakan)).
Tetapi menyimpulkan dari itu, bahwa mengetik ketat menyebalkan hanyalah kesalahan. Ini seperti menunjuk pada PHP dan menyimpulkan mengetik dinamis itu menyebalkan (sekali lagi, jangan tersinggung. Ini perlahan membaik, saya berikan itu).

Secara pribadi, saya melakukan sebagian besar pengembangan saya di haXe , yang memiliki sistem tipe statis. Tidak hanya secara signifikan lebih ekspresif, daripada di Jawa dan tidak membutuhkan banyak usaha karena inferensi tipe, tetapi juga opsional. Jika itu menghalangi Anda, Anda cukup memintasnya.

Keamanan jenis adalah fitur (ini adalah sesuatu yang banyak bahasa tingkat tinggi yang seharusnya tidak beres) untuk membantu Anda mencegah pengambilan gambar sendiri di kaki .
Dan tentang setiap bahasa yang diketik secara sukses akan lebih baik, jika Anda memiliki opsi untuk memeriksa jenis kode Anda sesuka hati.
Sebagai contoh, saya tentu saja senang bereksperimen dengan Ruby, tetapi itu terutama karena Ruby sepenuhnya berorientasi objek, yang sepenuhnya ortogonal dengan keberadaan sistem tipe waktu kompilasi.

Saya pikir klaim, bahwa sistem tipe statis obstrusif hanya didasarkan pada kurangnya pengetahuan tentang sistem tipe statis yang baik. Ada sejumlah bahasa yang melakukannya dengan benar, sudah menjadi salah satu dari mereka, dan bahkan bisa dibilang bukan yang terbaik dalam hal itu.

Contoh kode haXe:

class Car {
    public function new();
    public function wroom() trace('wroooooooom!')
}
class Duck {
    public function new();
    public function quack(at) trace('quackquack, ' + at + '!')
}

function letQuack(o) o.quack();
letQuack(new Car());
letQuack(new Duck());

Ini akan menghasilkan kesalahan waktu kompilasi:

Car should be { quack : Void -> Unknown<0> }
Car has no field quack
For function argument 'o'
Duck should be { quack : Void -> Unknown<0> }
Invalid type for field quack :
to : String -> Void should be Void -> Unknown<0>
For function argument 'o'

Anda tidak dapat benar-benar mengklaim bahwa saya harus melakukan banyak upaya dalam keamanan jenis.

Mengatakan bahwa Anda tidak memerlukan keamanan jenis, karena Anda menjalani tes bahkan lebih bodoh. Tes menulis itu membosankan dan berulang-ulang. Dan saya benar-benar tidak ingin menulis tes, hanya untuk mencari tahu, bahwa sebuah instance dari Mobil tidak akan dukun dan Bebek membutuhkan seseorang untuk dukun.

Pada akhirnya, Anda akan menemukan, tidak peduli berapa banyak biaya jenis keamanan yang dikenakan pada Anda, pada akhirnya akan diamortisasi (bahkan di Jawa - walaupun mungkin tidak secepat itu).

Untuk alasan apa pun, saya tidak membuat kesalahan terkait dengan jenis objek yang sering lagi. Dalam bahasa-bahasa seperti C #, saya lebih cenderung membuat kesalahan yang terkait dengan cetakan runtime daripada saya cenderung membuat kesalahan keamanan jenis yang dapat dideteksi oleh kompiler, yang, saya yakinkan, biasanya disebabkan oleh kebutuhan sesekali untuk bekerja di sekitar statis dari sistem statis. bahasa yang diketik. Ketika saya menulis ruby, kode cenderung mengisyaratkan cukup kuat pada jenis objek dan ketersediaan REPL berarti bahwa saya telah secara eksperimental memverifikasi bahwa metode / atribut yang diinginkan ada, atau saya akan memiliki unit test yang tidak pada dasarnya hal yang sama, jadi saya juga jarang mengalami masalah keamanan tipe di ruby.

Tapi itu bukan berarti sistem yang diketik secara statis tidak bisa lebih baik daripada mereka.

Dalam bahasa yang diketik secara statis, sistem tipe sebenarnya sangat penting juga. Sebagai contoh, dengan sesuatu seperti monad Some dalam bahasa fungsional (ketik <Some>: = yes x | no), Anda memperoleh pemeriksaan waktu kompilasi yang pada dasarnya mencegah NullReferenceException yang ditakuti, yang umum di kebanyakan sistem tipe; ketika kode pencocokan pola berjalan, Anda mendapatkan kesalahan waktu kompilasi yang memberitahu Anda bahwa Anda gagal menangani kondisi nol (jika Anda menggunakan mekanisme itu untuk mendeklarasikan jenisnya). Anda juga mengurangi jenis kesalahan serupa ketika Anda menggunakan hal-hal seperti operator pipa | | di F #.

Dalam tradisi Hindley – Milner dalam pengetikan statis, Anda dapat membangun hal-hal yang memberi Anda jauh lebih banyak daripada jaminan bahwa suatu tipe mengklaim untuk mendukung antarmuka X, dan begitu Anda memilikinya, saya akan mengatakan bahwa sistem yang diketik secara statis menjadi jauh lebih banyak. lebih berharga.

Ketika itu bukan pilihan, ekstensi Design By Contract ke C # dapat menambahkan satu set mekanisme yang meningkatkan nilai sistem tipe statis, tetapi mereka masih membutuhkan lebih banyak disiplin daripada beberapa paradigma fungsional tersebut.

Tergantung.

Mode kegagalan manusia sering bersifat statistik. Pengecekan tipe yang kuat mengurangi kemungkinan beberapa tipe kegagalan manusia (menyebabkan kode buggy). Tetapi hanya karena Anda bisa gagal tidak selalu berarti Anda akan gagal (Murphy tidak tahan).

Apakah pengurangan kemungkinan kegagalan potensial ini sepadan dengan biayanya?

Jika Anda menulis kode untuk pembangkit listrik tenaga nuklir atau sistem ATC, pengurangan mode kegagalan manusia mungkin sangat penting. Jika Anda membuat prototipe cepat beberapa ide situs web yang tidak memiliki spesifikasi dan dengan konsekuensi kegagalan hampir nol, maka pengurangan mode kegagalan atau probabilitas mungkin atau mungkin tidak membeli apa pun untuk Anda, tetapi mungkin akan dikenakan biaya dalam waktu pengembangan (lebih banyak penekanan tombol, dll.), dan di sel-sel otak terganggu dengan mengingat jenis saat ini yang diperlukan.

Ada banyak sistem yang sangat rumit yang ditulis dalam Lisp, dan saya belum pernah mendengar Lisper mengeluh bahwa mereka menginginkan pengetikan statis. Ketika saya bekerja dengannya, saya tidak ingat masalah apa pun yang memperlambat saya sampai-sampai sistem tipe statis (dan Anda dapat menentukan tipe secara statis di Common Lisp) akan tertangkap.

Terlebih lagi, bahasa mainstream yang diketik secara statis sepertinya tidak cocok untuk menangkap kesalahan. Dalam merancang sebuah layout, apa yang penting adalah bahwa jumlah tertentu adalah pengukuran vertikal pada halaman, bukan apakah itu int, unsigned, float, atau double. Sebaliknya, kompiler akan sering menandai konversi jenis yang dianggapnya tidak aman, dan dengan senang hati saya tambahkan pengukuran vertikal dan jumlah karakter dalam sebuah string. Kelemahan dari sistem tipe statis ini adalah ide asli di balik notasi Simonyi Hungaria, sebelum dibastardisasi menjadi ketidakgunaan yang buruk.

Jenis adalah kendala pada antarmuka, jadi mereka adalah bagian dari apa yang mungkin ingin Anda uji dengan unit test, dan banyak pertukaran yang serupa:

• Tipe statis memberikan umpan balik lebih awal tentang apakah kode memenuhi persyaratan yang dapat diungkapkan oleh sistem tipe, sebagai imbalan untuk menunda umpan balik dari membangun sesuatu yang berfungsi minimal (seperti umpan balik pelanggan atau tes tingkat yang lebih tinggi).
• Mengetahui bahwa kode memenuhi persyaratan tertentu dapat memudahkan refactoring dan debugging, tetapi juga menambah biaya tambahan untuk mengubah antarmuka dan mengubah persyaratan.
• Khususnya jika bahasa yang diketik secara statis tidak memiliki paksaan, itu memberikan keamanan tambahan terhadap kode yang digunakan pada data yang akan menyebabkan bug (mengurangi kebutuhan untuk persyaratan dan pernyataan), tetapi kendala yang terlalu ketat mengharuskan pengguna untuk menulis lebih banyak kode untuk memijat data mereka ke dalam formulir yang dapat diterima (seperti casting tipe eksplisit).
• Anotasi jenis eksplisit dapat membantu pemahaman saat membaca kode, atau dapat mengacaukan kode dengan informasi yang berlebihan atau tidak perlu.
• Bergantung pada implementasinya, hal ini dapat mengurangi kesulitan. Ini tergantung pada hal-hal seperti apakah anotasi jenis diperlukan atau disimpulkan, seberapa baik sistem tipe dapat mengekspresikan tipe generik / antarmuka, sintaksis, dan apakah Anda bermaksud menguji kendala yang dapat diekspresikan oleh sistem tipe (yaitu, tes yang sama kemungkinan lebih singkat sebagai fitur bahasa daripada sebagai tes unit, tetapi Anda mungkin tidak bermaksud mengujinya).
• Selain itu (tetapi tidak terkait dengan TDD), tipe statis dapat membantu menyusun waktu optimasi, dengan mengorbankan mengharuskan tipe memeriksa (dan meluangkan waktu untuk memeriksanya dan melakukan optimasi), dan optimasi yang lebih baik dapat dilakukan jika data terbatas pada tipe peta itu dengan baik untuk perangkat keras. Ini memudahkan pengembangan pada kode dengan persyaratan kinerja, tetapi dapat menyebabkan masalah untuk kode yang tidak sesuai dengan kendala ini dengan baik (sesuai poin 3).

Untuk meringkas, saya berpendapat bahwa bahasa dinamis sangat berguna untuk membuat prototipe, sedangkan jika Anda perlu memastikan bahwa kode Anda benar, Anda harus mendukung sistem tipe yang kuat.

Iya tentu saja. Satu hal yang akan Anda temukan ketika Anda menggunakan kedua bahasa yang sangat diketik dan Python (Python sangat diketik) lebih banyak adalah bahwa sebagian besar kode yang ditulis dengan baik dalam bahasa dinamis cenderung mengikuti banyak konvensi yang sama seperti kode yang diketik dengan kuat pula. Pengetikan dinamis sangat berguna untuk serialisasi dan deserialisasi, tetapi untuk sebagian besar hal lainnya itu benar-benar tidak berkontribusi banyak keuntungan. Dan kecuali sebagian besar kode Anda terkait dengan serialisasi, mengapa membuang pengecekan kesalahan gratis?

Morgan, saya punya ide menarik untuk Anda coba: statis + pengetikan dinamis. Anda menyebutkan Python, C # dan Java. Apakah Anda sadar bahwa ada beberapa port Python yang cukup bagus untuk .NET dan Java? Dalam kedua kasus, port memungkinkan Anda menggunakan pustaka platform tersebut dan / atau beroperasi dengan kode yang ada. Ini memberi Anda beberapa kemungkinan:

1. Simpan kode lawas dalam bahasa statis dan tidak fleksibel. Gunakan Python untuk hal baru.
2. Gunakan Python untuk membuat prototipe barang baru di atas platform dewasa. Kode ulang komponen yang ingin Anda simpan dalam bahasa yang lebih matang.
3. Gunakan bahasa dinamis untuk bagian yang sering Anda ubah.
4. Mungkin menggunakan bahasa dinamis untuk bermain dengan ide-ide seperti memodifikasi kode yang sedang berjalan.
5. Lakukan segala sesuatu dalam bahasa dinamis kecuali untuk bagian-bagian penting di mana Anda menggunakan bahasa yang sangat diketik.

Saya menggunakan pendekatan ini sejauh 90-an untuk mengatasi rasa sakit berkembang di C / C ++. Saya membutuhkan perpustakaan asli dan terkadang kinerja. Namun, saya menginginkan sintaks yang lebih baik, fleksibilitas, keamanan, dll. Jadi, triknya adalah menggabungkan mereka secara hati-hati untuk mendapatkan pengorbanan yang tepat. Itu sering lebih baik dalam praktik daripada membuang seluruh bahasa dan kode warisan untuk bahasa / platform lain.

(Catatan: Sebuah jawaban sudah mengatakannya, tetapi saya juga ingin menekankan kembali bahwa pengetikan dinamis! = Tidak / pengetikan lemah. Banyak sistem tipe dinamis menggunakan pengetikan yang kuat di dalam. Cara saya berpikir tentang apa yang membuat dinamika tipe adalah bahwa tipe variabel ditentukan pada saat runtime, tidak memerlukan anotasi tipe, dan / atau mungkin berubah pada saat runtime.

Anda tidak akan mendapatkan jawaban yang benar-benar objektif untuk itu, tetapi pengalaman saya adalah bahwa keamanan jenis sangat berharga sampai Anda menguasai TDD. Setelah Anda memiliki cakupan unit-tes yang berat, di mana tes telah ditulis sebelum kode, pemeriksaan kompiler menjadi sakit dan benar-benar mulai menghalangi Anda.

Saya melihat pertanyaan ini muncul banyak, dan saya pikir bahwa kualitas perangkat lunak Anda (dan kurangnya bug) lebih berkaitan dengan proses pengembangan Anda, bagaimana sistem Anda dirancang, dan komitmen Anda dan rekan Anda terhadap kualitas kode.

Pekerjaan terakhir saya kebanyakan pengembangan python. Saya bekerja untuk perusahaan web hosting internasional yang besar dan kami memiliki tim pengembang di AS, Kanada, dan Korea Selatan. Kerangka kerja web python khusus untuk aplikasi pelanggan front end yang memungkinkan pengguna untuk mengelola nama domain dan akun hosting web mereka. Backend: semua python juga. Layanan web Python untuk berbicara dengan masing-masing server untuk melakukan hal-hal seperti menyediakan situs web hosting baru, membuat blog baru, membuat entri dns dalam sistem layanan nama kami; dll, dll. Dalam pekerjaan saya saat ini, aplikasi klien kami semua di java; produk utama kami adalah campuran java dan flash. Kerangka kerja web java khusus untuk aplikasi lama kami, gawang untuk alat internal kami yang lebih baru.

Setelah bekerja di keduanya, saya harus mengatakan pertanyaan ini mengganggu saya setiap kali melihatnya. Jika Anda menggunakan bahasa yang diketik secara dinamis dan benar-benar menguji kode Anda, Anda akan baik-baik saja. Jika sistem dirancang dengan baik, dan Anda mengikuti standar, Anda akan baik-baik saja. Tidak pernah ada banyak bug yang muncul karena kurangnya jenis pemeriksaan kompiler. Sebagian besar bug adalah kesalahan logis, sama seperti pekerjaan java saya hari ini.

Apakah keamanan jenis sepadan dengan kecepatan perkembangan dan fleksibilitas? MENGAPA?

Pengetikan statis adalah peningkatan bersih dalam kecepatan dan fleksibilitas pengembangan sepanjang siklus hidup perangkat lunak. Ini mengurangi upaya total dan ketidaknyamanan, tetapi menggerakkan banyak upaya dan ketidaknyamanan di muka, di mana itu lebih terlihat. Penghalang entri untuk memiliki kode kerja lebih tinggi, tetapi begitu Anda melewati penghalang itu (dengan memuaskan pemeriksa tipe), memperluas dan mempertahankan kode itu membutuhkan lebih banyak pekerjaan.

Akan selalu ada beberapa sakit kepala dalam pengembangan perangkat lunak karena:

• Kompleksitas inheren dari apa yang Anda coba capai

• Kekeliruan yang melekat pada manusia, terutama mengingat bahwa kita membuat lebih banyak kesalahan ketika kita mencoba melakukan sesuatu yang lebih kompleks

Cepat atau lambat, Anda perlu meluangkan waktu untuk mengatasi tantangan ini. Tidak ada jalan keluarnya. Pengetikan statis hanya mengatasi tantangan ini lebih cepat daripada nanti. Lebih cepat lebih baik daripada nanti, karena nanti Anda menemukan kesalahan (bukan pertanyaan jika , tapi kapan ), semakin banyak biaya untuk memperbaiki kesalahan itu.

Biayanya jauh lebih murah untuk memperbaiki kesalahan yang dilaporkan oleh pemeriksa tipe daripada biayanya untuk men-debug pengecualian terkait jenis yang muncul saat runtime. Menunda pengecekan tipe ke runtime hanya menyapu masalah di bawah permadani.

Ini hanya pendapat saya sendiri, tetapi tidak, saya tidak berpikir bahwa keamanan jenis sepadan. Bahkan untuk sedetik pun.

Saya sudah lama menjadi pengembang. Mulai dengan c ++, c #, kemudian pindah ke javascript (frontend dan backend via node.js). Karena saya telah mengembangkan javascript, produktivitas saya meroket, hingga saya benar-benar diperburuk dengan menggunakan bahasa berbasis tipe. Saya juga menentang kompilasi, saya ingin semuanya berjalan saat ini. Bahasa yang ditafsirkan adalah tempat saya menemukan kecintaan saya pada pemrograman.

Sejauh jenis, saya hanya tidak melihat manfaat apa pun. Saya melihat jenis sekarang dengan cara yang sama saya melihat manajemen memori. Sama sekali tidak perlu. Bahasa masa depan harus sepenuhnya melindungi pengembang dari mengetahui apa pun tentang jenis. Komputer harus memahami tipe dan meninggalkan pengembang dari itu.

Ini sebuah contoh. Saya hanya menggunakan Swift (bahasa baru Apple) berharap itu benar-benar sesuai dengan namanya sehari yang lalu dan coba lakukan: var n = 1/2 tidak bekerja. Saya seperti, apa yang terjadi di sini. dan kemudian dengan sedih menyadari aku harus melakukan var n: Float = 1/2. Ini mengingatkan saya betapa saya membenci sistem tipe dan seberapa besar kejengkelan yang tidak perlu itu.

Saya bahkan akan berusaha lebih jauh untuk mengatakan bahwa saya bahkan tidak ingin tipe yang ditentukan pengguna (seperti Kelas). Saya tidak ingin mengetik sama sekali. Yang saya inginkan adalah var dan objek. Di mana benda apa pun bisa digunakan sebagai benda apa pun. Dan benda-benda itu dinamis dan terus berubah. Di mana itu menjadi masalah runtime tentang apa yang berhasil dan yang tidak.

Pengembang senang mengatakan betapa longgarnya bahasa yang diketik tidak baik untuk proyek besar. Tapi saya katakan sebaliknya. Bahasa yang diketik sangat buruk untuk proyek besar. Dan jika Anda mengatakan javascript tidak berfungsi untuk proyek-proyek besar, tanyakan kepada Uber perusahaan 40billion + yang menjalankan semua backendnya pada node.js / javascript, atau Facebook yang dimulai dengan PHP.

Sejauh bahasa yang diketik secara statis, itu tidak baik untuk iterasi cepat hari ini. inilah contoh sederhana, Anda memiliki 10 pengembang yang mengerjakan proyek .net dengan server integrasi berkelanjutan, satu pengembang mengajukan kesalahan dan seluruh build rusak, meskipun 10 pengembang sedang mengerjakan hal-hal yang berbeda mereka sekarang semua berhenti dan menunggu bagi pengembang yang menyinggung untuk memperbaiki kesalahannya. Bicara tentang efisien ya? Ketik bahasa sistem / statis saling bergantung dengan cara itu dan buat kode Anda saling bergantung. Namun, file skrip tidak pernah saling bergantung. Jika ada masalah dengan salah satu skrip yang tidak menghentikan produksi, semua masalah yang Anda lihat akan dibiarkan runtime. Dan runtime tidak pernah berhenti. Tidak pernah putus. Mungkin menghasilkan output yang salah tetapi tidak

IYA.

Saya telah bekerja di aplikasi PHP, di mana tipenya tidak sekuat Java atau C #. Biasanya saya selesai "mensimulasikan tipe", karena, untuk menghindari konversi otomatis yang buruk, atau memvalidasi data.

Bahasa Jenis Dinamis baik untuk skrip OS dan aplikasi kecil cepat, bukan aplikasi kompleks.

Ringkasan: Jika saya harus memilih antara bahasa pemrograman "Tipe Lemah" atau "Tipe Dinamis", atau Bahasa Pemrograman "Tipe Kuat" untuk aplikasi bisnis yang kompleks, saya memilih Bahasa Pemrograman "Tipe Kuat" .

Saya pikir membayar untuk mengambil langkah mundur dan mempertimbangkan kapan pengetikan dinamis menyebabkan masalah.

Satu kasus adalah di mana cabang kode tidak diuji sama sekali, tetapi kode jujur ​​yang tidak pernah diuji kemungkinan akan bermasalah apakah mengetik dinamis sedang digunakan atau tidak.

Masalah lain yang lebih halus adalah substitusi yang tidak sempurna.

Jika suatu tipe benar-benar salah maka kecuali jalur kode tertentu tidak pernah digunakan yang kemungkinan terdeteksi dengan cepat.

Di sisi lain, jika suatu jenis adalah pengganti yang tidak sempurna maka sebagian besar kode mungkin berfungsi tetapi pecah dengan cara halus yang tidak akan terdeteksi sampai nanti.

Dua tipe yang paling umum dalam pemrograman adalah angka dan string. Dalam banyak bahasa dinamis mereka adalah pengganti yang tidak sempurna satu sama lain. Di katakan javascript atau php jika Anda memberikan nomor di mana string diharapkan atau sebaliknya program Anda berjalan tanpa meningkatkan kesalahan tetapi dapat berperilaku tidak pantas dalam cara yang agak subtil.

Python menghindari masalah tertentu, angka dan string sama sekali tidak bisa menggantikan satu sama lain dan mencoba untuk menggunakan satu di mana yang lain biasanya akan mengarah pada kegagalan yang cepat.

Namun itu tidak sepenuhnya menghindari masalah susbstituibility. Berbagai jenis nomor dapat menjadi pengganti yang tidak sempurna satu sama lain, demikian juga berbagai jenis urutan.

Apa yang saya dapatkan di sini adalah saya pikir tidak mungkin untuk membandingkan manfaat dan biaya pengetikan statis dan dinamis dengan cara yang umum, karena saya pikir baik manfaat maupun biayanya tergantung pada variasi tertentu dari pengetikan statis atau dinamis suatu bahasa. menggunakan.