Apakah ada yang tahu mengapa Scala diimplementasikan di Java dan .NET, bukan C atau C ++? Sebagian besar bahasa diimplementasikan dengan Cor C ++ [yaitu Erlang, Python, PHP, Ruby, Perl]. Apa keuntungan untuk Scala diimplementasikan di Jawa dan .NET selain memberikan akses ke perpustakaan Java dan .NET?

MEMPERBARUI

Bukankah Scala akan mendapatkan lebih banyak manfaat jika diimplementasikan dalam C karena dapat disetel lebih baik daripada mengandalkan JVM?

Pertanyaannya membingungkan, karena C dan C ++ adalah bahasa , sedangkan JVM adalah mesin virtual dan .Net adalah platform . Scala dapat diimplementasikan dalam C atau C ++, dan itu bisa menghasilkan kode mesin, bukan bytecode untuk mesin virtual.

Menjawab pertanyaan yang diajukan:

Scala tidak diimplementasikan dalam C atau C ++ karena Scala, bahasa di mana ia benar-benar diterapkan, adalah bahasa yang jauh lebih baik.

Kenapa lebih baik? Nah, bacalah tentang tujuan Odersky untuk bahasa Scala .

Menjawab pertanyaan yang mungkin dimaksudkan:

Scala menghasilkan bytecode JVM terutama karena itu memberikan portabilitas yang hebat serta fitur-fitur seperti pengumpul sampah yang andal dan efisien, optimalisasi run-time dan kompilasi just-in-time oleh JVM .

Biarkan saya ulangi hal terakhir: JVM akan mengkompilasi ke hot spot kode mesin dalam kode yang sedang berjalan. Itu kompilasi seperti halnya kompiler C dan C ++.

Ada mesin virtual lain yang tersedia, tetapi Odersky, pencipta Scala, sudah sangat akrab dengan JVM. Dia berniat menjadikan CLR sebagai alternatif, tetapi upaya untuk mewujudkannya belum mencapai kesuksesan.

Menjawab pertanyaan yang seharusnya / seharusnya ditanyakan:

Mengkompilasi ke kode mesin tidak memberikan manfaat yang cukup dibandingkan mengkompilasi ke bytecode JVM.

Tentu saja dimungkinkan untuk menghasilkan microbenchmark di C atau C ++ yang mengalahkan JVM-equivalents. Juga benar bahwa kode yang sangat optimal dalam C atau C ++ akan mengalahkan kode yang sangat optimal di Jawa atau Scala. Namun, perbedaannya tidak terlalu bagus untuk program jangka panjang.

Perhatikan bahwa Scala bukan bahasa scripting yang sangat baik justru karena overhead untuk program jangka pendek terlalu besar.

Namun, dalam kebanyakan kasus kecepatan pengembangan dan kemudahan pemeliharaan lebih penting daripada kecepatan eksekusi . Dalam kasus tersebut, di mana orang lebih peduli dalam menulis kode tingkat sangat tinggi yang mudah dipahami dan diubah, optimisasi run-time yang disediakan oleh JVM dapat dengan mudah mengalahkan optimisasi waktu kompilasi yang dibuat oleh kompiler C atau C ++, membuat JVM (dan CLR ) target yang benar-benar akan mengeksekusi lebih cepat.

Jadi, tidak peduli apakah pertanyaannya tentang kompiler Scala menjadi kode mesin yang dapat dieksekusi, atau program Scala menjadi kode mesin, potensi peningkatan kecepatan tidak, tentu saja, diterjemahkan menjadi peningkatan kecepatan nyata .

Dan ngomong-ngomong,

Saya akan memberi Anda contoh tandingan: Haskell. Haskell menghasilkan kode mesin, dan, namun, program Haskell berjalan lebih buruk pada baku tembak Debian daripada Scala. Karena itu, adakah yang bisa memastikan program Scala akan lebih cepat jika dikompilasi langsung ke kode mesin?

Salah satu kendala terbesar yang dihadapi bahasa saat diperkenalkan ke dunia luas adalah ketersediaan perpustakaan. Respons tradisional terhadap hal ini adalah menyediakan FFI berbasis-C (antarmuka fungsi asing) untuk memungkinkan Anda mengakses perpustakaan berbasis-C. Ini tidak ideal karena berbagai alasan, kepala di antaranya:

• Ada banyak cara perpustakaan ingin berinteraksi yang tidak kompatibel dengan banyak bahasa tingkat tinggi. Misalnya jika perpustakaan ingin pointer ke struct, bagaimana bahasa tanpa pointer DAN tanpa structs mengatasinya?
• Ada interaksi yang keras antara model memori perpustakaan dan bahasa yang berbeda yang sering tidak dapat diatasi atau, jika dapat diselesaikan, sangat rawan kesalahan dan bug.
• Kode lem untuk banyak FFI adalah non-sepele dan mengasumsikan pengetahuan yang mungkin tidak bersifat universal. (Percaya atau tidak, tidak semua programmer adalah guru C, dan mereka juga tidak ingin menjadi seperti itu atau seharusnya!)

Ini semakin buruk dengan C ++. C ++ bahkan tidak kompatibel dengan C ++ (pada tingkat biner, maksud saya) dari kompiler ke kompiler pada platform yang sama (!), Belum lagi dengan bahasa lain.

Menargetkan JVM memecahkan banyak masalah ini sambil memberi Anda akses ke rangkaian perpustakaan berbasis Java yang sangat besar . (Seberapa besar? Cakupan hanya dari pilihan besar Apache Software Foundation sebagai permulaan.)

• Konvensi panggilan dan kepemilikan Java lebih teratur dari pada C.
• JVM juga menyediakan model memori tunggal (termasuk pengumpulan sampah) untuk bahasa dan pustaka untuk digunakan. Tidak perlu melacak siapa yang memiliki apa dan mana yang harus dibersihkan di mana. Runtime melakukannya untuk Anda.
• Kode lem untuk FFI, untuk sebagian besar bahasa yang dibangun di JVM, tidak ada (seperti di dalamnya disediakan sebagai kerangka kerja di belakang layar dalam bahasa). Tidak perlu memprogram di Jawa, misalnya, untuk mengakses perpustakaan Java di Scala, Clojure, JRuby, dll. Anda mengakses objek Java dengan cara yang sama seperti Anda mengakses "objek" asli (menakut-nakuti tanda kutip karena, misalnya, Clojure tidak memiliki objek aktual dalam arti OOP) dan dalam bahasa ibu Anda.

Di atas semua kelebihan ini, Anda juga memiliki kelebihan tambahan untuk menjalankan di mana saja Java berjalan tanpa kompilasi ulang (tetapi dengan pengujian !: tulis sekali, uji di mana-mana) dan memiliki akses ke teknologi JIT yang agak mengesankan di Jawa.

CLR memberikan kekuatan yang sama, tetapi menambahkan apa kelemahan IMO: itu cukup banyak lingkungan vendor-in. (Ya saya tahu tentang Mono. Saya masih berpikir itu adalah lingkungan vendor-lock.)

Menurut wawancara ini , akses ke infrastruktur dan perpustakaan Java yang ada adalah alasan utama.

... Java adalah bahasa yang ada dengan kendala yang sangat sulit. Akibatnya, saya tidak bisa melakukan banyak hal seperti yang saya inginkan — cara saya yakin akan menjadi cara yang tepat untuk melakukannya. Jadi setelah waktu itu, ketika pada dasarnya fokus pekerjaan saya adalah untuk membuat Jawa lebih baik, saya memutuskan bahwa sudah waktunya untuk mengambil langkah mundur. Saya ingin memulai dengan clean sheet, dan melihat apakah saya bisa merancang sesuatu yang lebih baik daripada Java. Tetapi pada saat yang sama saya tahu bahwa saya tidak bisa memulai dari awal. Saya harus terhubung ke infrastruktur yang ada, karena kalau tidak, hanya tidak praktis untuk bootstrap sendiri tanpa apa-apa tanpa perpustakaan, alat, dan hal-hal seperti itu.

Jadi saya memutuskan bahwa meskipun saya ingin merancang bahasa yang berbeda dari Jawa, ia akan selalu terhubung ke infrastruktur Java - ke JVM dan perpustakaannya . Itulah idenya ...

Semua bahasa lain yang Anda sebutkan, Erlang, Python, PHP, Ruby, Perl - ini semua dibuat sebelum Java & .NET. Jika pembuat bahasa-bahasa tersebut memiliki lingkungan runtime Java atau .NET tersedia untuk mereka pada saat itu, maka mungkin mereka mungkin memanfaatkannya saat membangun bahasa mereka.

Tentu saja, saya tidak dapat berbicara untuk pengembang bahasa-bahasa itu, jadi saya tidak bisa mengatakan dengan pasti bahwa mereka akan menggunakan. ide bagus. Lagi pula, dengan merancang bahasa Anda untuk dikompilasi ke Java / .NET bytecode, Anda mendapatkan semua keuntungan dari kompiler / optimisator JIT, bahasa Anda secara otomatis berjalan di semua platform yang dijalankan Java / .NET, Anda memiliki akses ke semua perpustakaan Java / .NET dan sebagainya.

Kode C dikompilasi secara statis ke kode asli (kode mesin).

Scala dikompilasi secara statis ke bytecode java dan kemudian, sebagaimana diperlukan, dikompilasi secara dinamis ke kode asli yang dioptimalkan. Proses:

Kode skala --- dikompilasi secara statis ke ---> kode byte JVM --- dikompilasi secara dinamis oleh-JVM-Hotspot-ke ---> kode asli

Opsi umum untuk membangun / menjalankan bahasa apa pun:

• a) menafsirkan kode sumber langsung melalui mesin juru bahasa runtime
• b) mengkompilasi kode secara statis ke kode asli (mungkin melalui tahap peralihan misalnya sumber -> C -> asli)
• c) mengkompilasi kode sumber secara statis ke kode perantara tingkat rendah, dan menafsirkannya saat runtime
• d) mengkompilasi kode sumber secara statis ke kode perantara tingkat rendah, kemudian menggunakan interpretasi awal, diikuti oleh kompilasi dinamis dan teknik optimasi untuk mengkonversi ke kode asli. Kode ditafsirkan sampai jalur eksekusi dan kemacetan ditemukan, kemudian kode dikompilasi untuk eksekusi tercepat dalam kondisi umum. Ini dikompilasi ulang / dikembalikan lagi ketika kondisi eksekusi berubah cukup untuk menjamin ini

Pertanyaan Anda: "Mengapa Java menggunakan (d) dengan JVM, daripada (b) dengan kode perantara C?"

Menjawab:

Pertama, amati bahwa Scala banyakbahasa tingkat yang lebih tinggi dari C, memberikan kekuatan pemrograman, kemudahan pemrograman dan keringkasan. Ini tentang '1 tingkat lebih tinggi' dari Jawa karena fungsi kelas pertama & tatanan tinggi, fungsi implisit, fungsi sebagai objek, penutupan dan kari, dukungan untuk pengulangan pengulangan ekor ke loop penumpukan tumpukan cepat, semuanya sebagai objek, semua operator sebagai metode yang dapat (didefinisikan kembali) di perpustakaan, kelas kasus dan pengurangan (pencocokan pola), derivasi tipe implisit, polimorfisme yang lebih kuat melalui sifat multi-warisan yang diperluas dan generik yang diperluas, sintaksis bawaan untuk pasangan & tupel & kontra (daftar & pohon) ) & peta, dukungan untuk struktur data tidak bergerak, dukungan untuk komputasi paralel dan konkuren 'reaktif' yang kuat dengan penyalinan dan perpindahan pesan antar aktor, dukungan lanjutan untuk DSL khusus domain sewenang-wenang, skripibilitas, dan REPL. Java tentang '1 level lebih tinggi' dari C karena orientasi objek, manajemen pointer dan pengumpulan sampah, dukungan string, dukungan multi-threading dan kontrol konkurensi, ditambah pustaka API standar.

1. Kinerja: Untuk bahasa tingkat tinggi, (d) memberikan kinerja yang lebih cepat daripada (a) - (c).
   Kode C yang langsung ditulis dan dioptimalkan dengan tangan cepat. Namun, bahasa tingkat tinggi yang dikompilasi secara statis ke C relatif lambat. Desainer java tahu ini dengan baik. Desain "Hotspot" mereka saat ini meningkatkan kinerja hingga urutan besarnya. Pada satu inti, kode Java HotSpot rata-rata '50% lebih cepat 'daripada C yang dioptimalkan oleh manusia (dalam kasus terbaik' 120% lebih cepat ', dalam kasus terburuk '30% lebih cepat'). Tapi tentu saja itu membandingkan apel dengan jeruk - kode tingkat rendah v kode tingkat tinggi. Dan itu akan banyaklebih buruk jika pengoptimalan Hotspot tidak digunakan. Untuk mengonfirmasi, cukup nonaktifkan kompilasi hotspot melalui JVM args! Atau pertimbangkan kinerja java 1 & 2, ketika hotspot tidak ada atau belum matang. Atau coba kompilasi bahasa lain melalui C - misalnya perlcc. Jadi di atas adalah hasil yang bagus untuk bahasa yang kuat dan produktif. Dengan pengembangan lebih lanjut, dimungkinkan (atau bahkan mungkin) bahwa JVM akan segera melebihi rata-rata kode tangan C. Scala hanya 70-80% lambat seperti rata-rata java. Tapi scala sangat menskala di beberapa core (dengan perbaikan lebih lanjut sedang berlangsung), sedangkan java melakukan sebagian dan C tidak. Kinerja Core tunggal untuk bahasa tingkat tinggi seperti itu dinilai:

   ditafsirkan <dikompilasi secara statis <dikompilasi secara dinamis

   Kinerja / skalabilitas Multi-Core dinilai:

   ditafsirkan kode dinamis <kode imperatif terkompilasi secara statis <kode fungsional / deklaratif yang disusun secara statis <kode fungsional / deklaratif yang disusun secara dinamis

   Ini menempatkan scala di kursi pemenang karena kecepatan prosesor telah mencapai batasnya dan sekarang jumlah core meningkat berdasarkan hukum Moore. Scala sangat cepat pada multi-core dan di masa depan, bisa menjadi beberapa kali lebih cepat daripada C atau java. Mengkompilasi secara statis ke C jelas bukan pilihan tercepat.

2. Interoperabilitas: bahasa pada VM yang didukung secara luas memiliki interoperabilitas bahasa yang lebih baik daripada bahasa 'terisolasi'. Scala "secara otomatis bermain dengan" kelas java, antarmuka dan objek hanya dengan mengimpornya dan menggunakannya seolah-olah mereka adalah kelas scala, sifat dan objek. Serupa mungkin dengan bahasa JVM lainnya seperti Groovy, Clojure, JRuby dan JPython - dengan mudah interoperabilitas tergantung pada seberapa bersih setiap bahasa dibuat untuk dikompilasi ke kelas / antarmuka / objek runtime java yang dapat dimengerti & dapat digunakan. Itu banyak datang untuk 'gratis' (seperti dalam 'dekat dengan'). Scala bekerja sama dengan C via JNA, penerus JNI - yang dilengkapi dengan beberapa upaya, tetapi alat-alatnya telah dirampingkan dengan baik seiring waktu. JNA sebenarnya dapat beroperasi dengan kode asli yang dikompilasi dari bahasa arbitrer apa pun - tetapi Anda harus tahu struktur yang tepat dari tipe data dan fungsi yang dikompilasi. Jika tidak,

3. Portabilitas: JVM berjalan pada lusinan platform / versi sistem operasi 'out of the box'. Scala secara otomatis porting ke ini. Pengecualian yang dicatat adalah iOS (iPad / iPhone / iPod) - diblokir 'secara komersial', bukan 'secara teknis' oleh Apple. Ini tidak bisa diantisipasi 12 tahun sebelumnya, selama desain awal JVM. JVM berjalan dengan baik di lusinan server lain, desktop, ponsel, dan perangkat yang disematkan, termasuk yang tidak mendukung C - termasuk Android dengan Google yang diadaptasi Dalvik VM (50% lebih dari telepon baru yang terjual). Tentu saja, kode C berfungsi pada banyak platform, jadi mungkin diberi peringkat 'di sana dengan atau mungkin di luar' Java (terutama, C adalah bagian dari Objective-C). Tetapi C akan datang dengan biaya (1), (2) & (3). Tentu saja, lapisan presentasi HTML5 / javascript / webkit (atau objektif-C) di iOS dapat berinteroperasi dengan aplikasi scala jarak jauh - jadi pengembang harus melakukannya. Tentu saja, mereka akan kurang produktif.

4. Alat dan Perpustakaan : Jelas ada ribuan perpustakaan dan alat Java komersial dan open-source yang dapat memanfaatkan / dimanfaatkan oleh Scala - lebih dari untuk C.

5. Keamanan: - berjalan pada server aplikasi yang dikendalikan atau lingkungan JVM memberikan dukungan yang lebih kuat untuk kebijakan dan pembatasan keamanan, yang dapat sangat berharga di lingkungan perusahaan.

JVM / CLR

JVM (dan CLR) memberikan keuntungan unik dalam hal optimasi dan portabilitas kode.

Sejauh yang saya tahu, hanya versi JVM dari Scala yang terus diperbarui, versi .NET tidak.

Sepertinya Anda mencampur dua hal yang tidak terkait.

Yang pertama adalah, bahasa pemrograman mana yang digunakan oleh penulis Scala untuk mengimplementasikan Scala?

Untuk jawabannya, Scala sendiri. Dan itu satu-satunya jawaban yang dapat diterima, sungguh, karena jika Anda telah menemukan bahasa baru ini, tetapi jangan menggunakannya sendiri untuk mengimplementasikannya - apa gunanya?

Yang kedua adalah, apa platform target untuk menjalankan program yang ditulis dalam Scala?

Di sini pilihan menjadi lebih menarik, tetapi untuk saat ini, satu-satunya target yang berfungsi 100% adalah JVM. Dukungan untuk .NET masih bekerja dalam proses. Juga, beberapa orang bekerja untuk membuat Scala dikompilasi ke javacsript. Secara teori, tidak ada yang mencegah seseorang menambahkan lebih banyak 'backend' untuk dikompilasi ke C, C ++, LLVM, kode asli atau apa pun.

Mengapa JVM dipilih sebagai platform utama? Dugaan saya adalah karena

• semua orang menginginkan pengumpulan sampah
• sejumlah besar perpustakaan yang baik siap digunakan
• sejumlah besar programmer bosan dengan Java siap untuk melompat ke sesuatu yang baru, tetapi tetap dengan batas JVM (tidak ada yang mau memigrasi kode mereka yang ada ke platform lain)

Pertama-tama - yang saya kira Anda benar-benar ingin tanyakan adalah mengapa Scala tidak dikompilasi dalam bahasa yang ketat. Aku akan memberitahumu aku tidak tahu. Tetapi saya juga akan memberi tahu Anda bahwa tidak ada alasan untuk mendukung JVM daripada kode asli.

Mengapa? Alasannya sederhana: teknologi virtualisasi apa pun adalah memori haus, menghasilkan overhead yang tidak perlu dan lapisan tipuan lainnya. Ini bukan masalah implementasi mereka - ini adalah masalah fakta, dari logika yang ada di balik konsep inti dari virtualisasi. Apa pun yang Anda lakukan, Anda akan SELALU berakhir dengan karakteristik yang lebih rendah. Terutama JVM yang haus memori. Ini tidak lagi begitu lambat, karena ia memiliki kompiler runtime itu sendiri yang berjalan di belakang, tetapi masih - ia harus menjalankan proses kompiler untuk dapat melihat bagian-bagian kode yang paling padat dan mengubahnya menjadi kode biner.

Mengatakan itu - satu-satunya alasan saya pikir ada di sana untuk membuat Scala berbasis JVM mungkin adalah popularitas bahasa. Saya juga menebak bahwa beberapa kemalasan ada di balik keputusan ini karena lebih mudah untuk mengimplementasikan bahasa di atas JVM daripada mencari tahu bagaimana hal-hal yang seharusnya terlihat seperti dirakit untuk bekerja lintas platform - dan bahkan menggunakan backend C yang ada memerlukan lebih banyak pekerjaan karena fakta bahwa hal-hal yang tidak selaras dengan JVM.

Itulah alasan yang dapat saya pikirkan, tetapi perlu diingat bahwa mungkin ada alasan lain - seperti masalah perizinan dan politik yang terlibat di sana (yang merupakan hal-hal kotor yang tidak ingin saya bahas).

Tidak jelas bahwa memiliki kemampuan untuk penyetelan yang lebih baik akan menjadi tradeoff yang baik. JVM dapat melakukan optimasi saat runtime, dan itu biasanya paling tidak cukup baik, jika tidak lebih baik dari apa yang biasanya terjadi dengan kompilasi statis. (Jelas pada prinsipnya untuk aplikasi dan beban kerja tertentu, Anda harus mengalahkan JIT dengan optimasi statis, tetapi pada praktiknya Anda tidak sering memiliki beban kerja yang tepat atau bahkan seluruh aplikasi.)