Pada titik manakah file konfigurasi menjadi bahasa pemrograman?

Saya telah merenungkan file konfigurasi dan hubungannya dengan kode untuk sementara waktu sekarang dan tergantung pada hari dan arah angin, pendapat saya tampaknya berubah. Semakin banyak meskipun saya terus kembali ke realisasi yang saya miliki pertama kali saat belajar Lisp: ada sedikit perbedaan antara data dan kode. Ini tampaknya benar ganda untuk file konfigurasi. Ketika dilihat dengan cahaya yang tepat, skrip Perl tidak lebih dari file konfigurasi untuk perl. Ini cenderung memiliki konsekuensi yang cukup berat untuk tugas-tugas seperti QA dan divisi kerja seperti siapa yang harus bertanggung jawab untuk mengubah file konfigurasi.

Merayap dari file konfigurasi ke bahasa lengkap umumnya lambat dan tampaknya didorong oleh keinginan untuk memiliki sistem generik. Sebagian besar proyek tampaknya dimulai dari yang kecil dengan beberapa item konfigurasi seperti di mana menulis log, di mana mencari data, nama pengguna dan kata sandi, dll. Namun kemudian mereka mulai berkembang: fitur mulai dapat dihidupkan atau dimatikan, pengaturan waktu dan urutan operasi mulai dikontrol, dan, tak terelakkan, seseorang ingin mulai menambahkan logika ke dalamnya (misalnya gunakan 10 jika mesin adalah X dan 15 jika mesin adalah Y). Pada titik tertentu, file konfigurasi menjadi bahasa khusus domain, dan ditulis dengan buruk pada saat itu.

Sekarang saya telah mengoceh untuk mengatur panggung, inilah pertanyaan saya:

1. Apa tujuan sebenarnya dari file konfigurasi?
2. Haruskah dilakukan upaya untuk menjaga file konfigurasi tetap sederhana?
3. Siapa yang harus bertanggung jawab untuk membuat perubahan pada mereka (pengembang, pengguna, admin, dll.)?
4. Haruskah mereka dikendalikan sumbernya (lihat pertanyaan 3)?

Seperti yang saya katakan sebelumnya, jawaban saya atas pertanyaan-pertanyaan ini terus berubah, tetapi sekarang saya berpikir:

1. untuk memungkinkan non-pemrogram mengubah sebagian besar perilaku dengan cepat
2. ya, apapun yang tidak berbutir kasar harus ada dalam kode
3. pengguna harus bertanggung jawab atas file konfigurasi dan pemrogram harus bertanggung jawab atas lapisan konfigurasi antara file konfigurasi dan kode yang memberikan kontrol aplikasi yang lebih baik
4. tidak, tapi lapisan tengah yang lebih halus seharusnya

Pertanyaan yang sangat menarik!

Saya cenderung membatasi file konfigurasi saya ke format "key = value" yang sangat sederhana, karena saya sepenuhnya setuju dengan Anda bahwa file konfigurasi dapat dengan cepat menjadi program yang lengkap. Misalnya, siapa pun yang pernah mencoba "mengkonfigurasi" OpenSER tahu perasaan yang Anda bicarakan: ini bukan konfigurasi, itu pemrograman (menyakitkan).

Ketika Anda membutuhkan aplikasi Anda untuk menjadi sangat "dapat dikonfigurasi" dengan cara yang tidak dapat Anda bayangkan hari ini, maka yang Anda butuhkan adalah sistem plugin . Anda perlu mengembangkan aplikasi Anda sedemikian rupa sehingga orang lain dapat mengkodekan plugin baru dan menghubungkannya ke aplikasi Anda di masa mendatang.

Jadi, untuk menjawab pertanyaan Anda:

1. Apa tujuan sebenarnya dari file konfigurasi?

   Saya ingin mengatakan, untuk memungkinkan orang yang akan menginstal aplikasi Anda dapat mengubah beberapa parameter terkait penerapan, seperti nama host, jumlah utas, nama plugin yang Anda butuhkan, dan parameter penerapan untuk plugin tersebut (periksa keluar dari konfigurasi FreeRadius sebagai contoh prinsip ini), dll. Jelas bukan tempat untuk mengekspresikan logika bisnis.

2. Haruskah dilakukan upaya untuk menjaga file konfigurasi tetap sederhana?

   Pastinya. Seperti yang Anda sarankan, "pemrograman" dalam file konfigurasi sangat buruk. Saya yakin itu harus dihindari.

3. Siapa yang harus bertanggung jawab untuk membuat perubahan pada mereka (pengembang, pengguna, admin, dll.)?

   Secara umum, saya akan mengatakan admin, yang menerapkan aplikasi.

4. Haruskah mereka dikendalikan sumbernya (lihat pertanyaan 3)?

   Saya biasanya tidak kontrol-sumber file-file konfigurasi sendiri, tapi saya melakukan kontrol-sumber file konfigurasi template yang, dengan semua parameter dan nilai standar, dan komentar menggambarkan apa yang mereka lakukan. Misalnya, jika file konfigurasi diberi nama database.conf, saya biasanya mengontrol sumber file bernama database.conf.template. Sekarang tentu saja saya berbicara tentang apa yang saya lakukan sebagai pengembang . Sebagai admin , saya mungkin ingin mengontrol sumber pengaturan sebenarnya yang saya pilih untuk setiap instalasi. Misalnya, kami mengelola beberapa ratus server dari jarak jauh, dan kami perlu melacak konfigurasinya: kami memilih untuk melakukan ini dengan kontrol sumber.

Edit: Meskipun saya yakin hal di atas berlaku untuk sebagian besar aplikasi, tentu saja selalu ada pengecualian. Aplikasi Anda mungkin mengizinkan penggunanya untuk secara dinamis mengonfigurasi aturan yang kompleks, misalnya. Sebagian besar klien email mengizinkan pengguna untuk menentukan aturan untuk pengelolaan email mereka (misalnya, "semua email yang datang dari 'john doe' dan tidak memasukkan saya ke kolom Kepada: harus dibuang"). Contoh lainnya adalah aplikasi yang memungkinkan pengguna untuk menentukan penawaran komersial baru yang kompleks. Anda juga dapat memikirkan aplikasi seperti Cognos yang memungkinkan penggunanya membuat laporan database yang kompleks. Klien email mungkin akan menawarkan antarmuka sederhana kepada pengguna untuk menentukan aturan, dan ini akan menghasilkan file konfigurasi yang kompleks (atau bahkan mungkin sedikit kode). Di samping itu, konfigurasi yang ditentukan pengguna untuk penawaran komersial mungkin disimpan dalam database, dengan cara terstruktur (baik struktur key = value sederhana maupun bagian kode). Dan beberapa aplikasi lain bahkan mungkin memungkinkan pengguna untuk membuat kode dalam python atau VB, atau bahasa lain yang mendukung otomatisasi. Dengan kata lain ... jarak tempuh Anda mungkin berbeda.

Baik. Anda akan memiliki beberapa pengguna yang menginginkan konfigurasi yang sangat sederhana, Anda harus memberikannya kepada mereka. Pada saat yang sama, Anda akan memiliki permintaan konstan "Bisakah Anda menambahkan ini? Bagaimana saya melakukannya di file konfigurasi?", Saya tidak mengerti mengapa Anda tidak dapat mendukung kedua grup.

Proyek yang sedang saya kerjakan menggunakan Lua untuk file konfigurasinya. Lua adalah bahasa scripting, dan bekerja cukup baik dalam skenario ini. Tersedia contoh konfigurasi default kami .

Anda akan mencatat bahwa ini terutama pernyataan key = value, di mana value dapat berupa tipe bawaan Lua apa pun. Hal yang paling rumit adalah daftar, dan tidak terlalu rumit (ini hanya masalah sintaks).

Sekarang saya hanya menunggu seseorang untuk bertanya bagaimana mengatur port server mereka ke nilai acak setiap kali mereka memulainya ...

Baru-baru ini saya sedang mengerjakan sebuah proyek dan saya menyadari bahwa saya ingin memiliki persyaratan di dalam file konfigurasi saya - yang sebelumnya merupakan salah satu bentuk yang cukup sederhana:

key = val
key2 = val
name = `hostname`

Saya tidak ingin menulis bahasa mini, karena kecuali saya melakukannya dengan sangat hati-hati, saya tidak dapat membiarkan fleksibilitas yang akan berguna.

Sebaliknya saya memutuskan bahwa saya akan memiliki dua bentuk:

1. Jika file dimulai dengan "#!" dan dapat dieksekusi, saya akan mengurai hasil menjalankannya.

2. Kalau tidak, saya akan membacanya sebagaimana adanya

Artinya, sekarang saya dapat mengizinkan orang untuk menulis "file konfigurasi" yang terlihat seperti ini:

 #!/usr/bin/perl
if ( -x /bin/foo ) 
{
   print <<EOF;
foo=me
bar=you
EOF
}
else
{
   print <<EOF;
foo=bar
bar=foo
EOF
}

Dengan cara ini saya mendapatkan kekuatan dari file konfigurasi dinamis jika pengguna ingin menggunakannya, dan kesederhanaan tidak harus menulis bahasa mini saya sendiri.

Setiap skema file konfigurasi (berumur cukup panjang) pada akhirnya menjadi bahasa pemrograman. Karena semua implikasi yang Anda jelaskan, adalah bijaksana bagi perancang file konfigurasi untuk menyadari bahwa dia sedang membuat bahasa pemrograman dan merencanakannya sesuai, jangan sampai dia membebani pengguna di masa mendatang dengan warisan yang buruk.

Saya memiliki filosofi yang berbeda tentang file konfigurasi. Data tentang bagaimana aplikasi harus dijalankan masih berupa data , dan oleh karena itu termasuk dalam penyimpanan data, bukan dalam kode (file konfigurasi IMO adalah kode). Jika pengguna akhir harus dapat mengubah data, maka aplikasi harus menyediakan antarmuka untuk melakukannya.

Saya hanya menggunakan file konfigurasi untuk menunjuk ke penyimpanan data.

Anda bisa beralih ke teori komputasi untuk mendefinisikan apa yang dianggap sebagai bahasa pemrograman. Jika format file konfigurasi Anda adalah Turing Complete, maka itu dianggap sebagai bahasa pemrograman. Menurut definisi ini, format file untuk menggambarkan level Sokoban dihitung sebagai bahasa pemrograman (lihat di sini ). Ada tingkat kerumitan lain di bawah Turing Complete yang mungkin juga dihitung, seperti Tata Bahasa Reguler dan Otomata Pushdown .

Cara lain untuk melihatnya adalah banyak file konfigurasi yang hanya mampu melakukan markup data, sedangkan bahasa pemrograman yang tepat harus dapat menerapkan algoritme . Misalnya JSON adalah format file config, sedangkan ECMA Script adalah bahasa pemrograman.

Inilah pikiran saya:

1. Untuk memungkinkan perilaku runtime aplikasi dimodifikasi dengan mudah. Ini bisa oleh programmer atau non programmer, tergantung kebutuhan. Ini bisa terjadi selama pengembangan, tetapi saya sering melihat file konfigurasi sebagai cara untuk membantu membuat program lebih fleksibel kapan saja.

2. Iya. Saya pikir file konfigurasi harus sesederhana mungkin, mengingat batasan bahwa Anda mungkin memerlukan berbagai opsi untuk mengontrol perilaku runtime yang berbeda. Saya lebih suka mengelompokkan pengaturan konfigurasi, dan menyederhanakannya sebanyak mungkin.

3. Tergantung pada apa dan mengapa perubahan itu dilakukan. Jika pengguna akan mengubahnya, front-end harus dibuat untuk menyembunyikannya dari detail. Hal yang sama sering terjadi pada non-pengembang pada umumnya.

4. Saya sering mengontrol sumber konfigurasi "default", tetapi memiliki cara untuk menimpa konfigurasi ini per sistem untuk runtime yang sebenarnya.

Adapun menambahkan logika ke file konfigurasi - saya akan menghindari ini. Saya pikir lebih baik jika file konfigurasi mengaktifkan logika di aplikasi Anda. Perilaku dalam file konfigurasi menyebabkan kurangnya pemeliharaan dan pemahaman, menurut pengalaman saya. Saya sangat suka menyimpan file konfigurasi sesederhana mungkin.

Saya cenderung setuju dengan premis pertanyaan ini. Saya menghindari masalah dengan memprediksi lebih awal bahwa ini akan terjadi, dan oleh karena itu tidak pernah menggulung sistem konfigurasi saya sendiri.

• Entah saya menggunakan fasilitas konfigurasi sistem operasi (seperti plist, atau gconf atau apa pun yang sesuai),
• Atau file datar sederhana, karena dapat ditangani oleh sesuatu seperti parser dari rak INI.
• Gigit peluru dan colokkan pengurai bahasa ringan, biasanya lua, terkadang tcl ke dalam aplikasi,
• Atau simpan data dalam SQLite atau database relasional serupa.

Dan mengundurkan diri untuk hidup dengan keputusan apa pun yang saya buat, atau jika tidak bisa, refactor untuk menggunakan salah satu pilihan di atas yang lebih sesuai dengan aplikasi.

Intinya adalah, sebenarnya tidak ada alasan untuk menggunakan solusi konfigurasi yang dibuat sendiri. Untuk satu hal, lebih sulit bagi pengguna Anda untuk mempelajari format konfigurasi khusus aplikasi yang baru. Di sisi lain, Anda mendapatkan keuntungan dari banyak perbaikan bug dan pembaruan yang datang gratis saat menggunakan solusi off-the-shelf. Akhirnya, fitur creep dihentikan, karena, Anda sebenarnya tidak bisa menambahkan satu fitur lagi tanpa benar-benar melakukan perombakan besar karena sistem konfigurasi tidak benar-benar ada di tangan Anda.

Itu tergantung pada apa yang Anda setujui dengan pengembang lain di tim. Apakah Anda menggunakan file konfigurasi hanya sebagai file konfigurasi atau Anda sedang membuat aplikasi Model Driven .

Gejala file config menjadi bahasa pemrograman:

• pasangan name = nilai mulai bergantung satu sama lain
• Anda merasa perlu memiliki kontrol aliran (mis. jika (ini) dari itu )
• dokumentasi untuk file konfigurasi menjadi penting untuk melakukan pengembangan lebih lanjut (daripada hanya menggunakan aplikasi)
• sebelum nilai dari config dibaca, perlu memiliki beberapa konteks (yaitu nilai bergantung pada sesuatu di luar file konfigurasi itu sendiri)

File config selalu beringsut menjadi "bahasa pemrograman penuh" yang jelek dan tidak logis. Dibutuhkan seni dan keterampilan untuk merancang bahasa pemrograman yang baik, dan bahasa config yang berubah menjadi bahasa pemrograman cenderung menghebohkan.

Pendekatan yang baik adalah dengan menggunakan bahasa yang dirancang dengan baik, misalnya python atau ruby, dan menggunakannya untuk membuat DSL untuk konfigurasi Anda. Dengan cara itu bahasa konfigurasi Anda dapat tetap sederhana di permukaan tetapi sebenarnya menjadi bahasa pemrograman yang lengkap.

Saya yakin pertanyaan Anda sangat relevan mengingat perpindahan ke "antarmuka fasih". Banyak pengembang telah "melihat cahaya" sehubungan dengan aplikasi yang dikonfigurasi XML. Penggunaan XML bisa sangat bertele-tele dan sulit untuk diedit dengan benar (terutama jika tidak ada skema yang disediakan). Memiliki antarmuka yang lancar memungkinkan pengembang untuk mengonfigurasi aplikasi dalam bahasa khusus domain dengan bantuan beberapa pasangan nilai kunci dari file konfigurasi teks biasa (atau mungkin parameter baris perintah). Itu juga membuatnya sangat mudah untuk mengatur dan mengonfigurasi contoh aplikasi baru untuk pengujian atau apa pun.

Inilah jawaban saya untuk pertanyaan Anda:

• Apa tujuan sebenarnya dari file konfigurasi?

File konfigurasi adalah cara untuk memungkinkan pengguna menyesuaikan perilaku program mereka pada saat run-time.

• Haruskah dilakukan upaya untuk menjaga file konfigurasi tetap sederhana?

Idealnya, saya akan berpikir bahwa file konfigurasi setidaknya harus dilengkapi dengan antarmuka yang lancar untuk mengkonfigurasi program (ini berguna dalam banyak hal). Jika Anda memang memerlukan file konfigurasi, maka file itu harus dibuat sangat sederhana, tidak lain adalah pasangan nilai kunci.

• Siapa yang harus bertanggung jawab untuk membuat perubahan pada mereka (pengembang, pengguna, admin, dll.)?

Saya pikir jawabannya tergantung pada organisasi Anda. Ini harus menjadi tanggung jawab orang yang menyebarkan perangkat lunak untuk memastikan bahwa itu dikonfigurasi dengan benar.

• Haruskah mereka dikendalikan sumbernya (lihat pertanyaan 3)?

Saya akan mencuri jawaban ini dari orang lain :) Saya suka ide menyimpan konfigurasi template di kontrol sumber dan memodifikasinya untuk setiap kebutuhan pengguna lokal. Kemungkinan file konfigurasi salah satu pengembang adalah mimpi buruk pengembang lain, jadi sebaiknya biarkan hal-hal yang bervariasi menurut pengguna berada di luar kendali sumber. Memiliki templat juga merupakan cara yang bagus untuk membiarkan orang yang menerapkan aplikasi (atau pengembang lain) melihat dengan tepat nilai apa yang valid untuk file konfigurasi.

Saya telah melihat program python dimana file config adalah kode. Jika Anda tidak perlu melakukan sesuatu yang khusus (bersyarat, dll.), Tampilannya tidak jauh berbeda dari gaya konfigurasi lainnya. misalnya saya bisa membuat file config.pydengan hal-hal seperti:

num_threads = 13
hostname = 'myhost'

dan satu-satunya beban pada pengguna, dibandingkan dengan file (katakanlah) INI, adalah mereka harus meletakkan '' di sekitar string. Tidak diragukan Anda dapat melakukan hal yang sama dalam bahasa tafsir lainnya. Ini memberi Anda kemampuan tak terbatas untuk mempersulit file konfigurasi Anda jika perlu, dengan risiko mungkin membuat pengguna takut.

Ya, file konfigurasi seharusnya sederhana. Mereka seharusnya tidak mengandung 'logika' itu sendiri - anggaplah mereka sebagai daftar ekspresi dalam pernyataan if, bukan pernyataan bersyarat secara keseluruhan.

Mereka ada di sana untuk memungkinkan pengguna memutuskan opsi mana yang dikodekan dalam aplikasi yang harus digunakan, jadi jangan mencoba membuatnya rumit, itu akan berakhir dengan merugikan diri sendiri - Anda mungkin akan menulis file konfigurasi sederhana untuk mengontrol bagaimana file konfigurasi asli harus dikonfigurasi jika tidak!

Salah satu tujuan pekerjaan "Oslo" di Microsoft adalah untuk mengizinkan (meskipun tidak mensyaratkan) penyelesaian masalah ini.

1. Aplikasi akan dikirimkan dengan model komponen baru yang disertakan. Itu juga akan menggunakan model yang ada. Misalnya, ini mungkin termasuk layanan web, sehingga dapat menggunakan kembali model sistem layanan web.
2. Model akan menyertakan metadata yang mendeskripsikannya, termasuk informasi yang cukup bagi alat untuk mengaksesnya, baik secara tekstual maupun grafis.
3. Bagian dari model akan sesuai dengan "konfigurasi"

Ini berarti bahwa file konfigurasi yang setara saat ini mungkin cukup kaya untuk mendukung pengeditan tekstual dan grafis dari konfigurasinya. Alat grafis akan dilengkapi dengan "Oslo" (nama kode "Kuadran").

Saya akan menjadi pelawan dan mengirimkan itu hanya bahasa ketika itu mewujudkan lebih dari yang dapat diwakili oleh XML; atau jika XML dianggap sebagai bahasa.

Alternatifnya, sebagian besar file konfigurasi dapat dianggap sebagai kelas, tetapi hanya dengan properti dan tanpa metode. Dan tanpa metode, menurut saya itu bukan bahasa.

Pada akhirnya, "bahasa" adalah abstraksi yang licin, tapi ya, tepinya ambigu.

Kode aplikasi kita menjadi kurang penting ... Ada skrip, ada semua jenis atribut yang menentukan perilaku kelas, metode, argumen metode, dan properti. Pengguna dapat menentukan pemicu database dan batasan database. Mungkin ada file konfigurasi yang sangat rumit. Terkadang pengguna dapat menentukan stylsheets XSLT untuk memanipulasi input dan output karena sistem kami harus terbuka (SOA). Dan ada hal-hal seperti BizzTalk yang membutuhkan konfigurasi yang rumit juga. Pengguna dapat menentukan alur kerja yang kompleks.

Kita harus menulis kode yang lebih baik untuk menghadapi lingkungan yang kompleks ini, sehingga kode aplikasi kita menjadi lebih penting ...

Saya penggemar berat menggunakan program python sebagai file konfigurasi, terutama untuk daemon. Saya suka mengambil taktik membuat daemon benar-benar kosong dari konfigurasi kecuali untuk "port konfigurasi". Program python kemudian terhubung ke daemon dan melanjutkan untuk membuat objek di daemon dan menyambungkannya untuk membuat konfigurasi yang diinginkan. Setelah semuanya diatur, daemon kemudian dapat dibiarkan berjalan sendiri. Manfaatnya, tentu saja, Anda mendapatkan bahasa pemrograman yang lengkap untuk menulis file konfigurasi dan karena Anda sudah memiliki cara untuk berbicara dengan daemon dari program lain, Anda dapat menggunakannya untuk debugging dan mendapatkan statistik. Kelemahan utama harus berurusan dengan pesan dari program lain yang masuk kapan saja.

File konfigurasi : "Apa tujuan saya?"
Anda : "Konfigurasi mentega."
File konfigurasi : "Ok ..."
File konfigurasi : "Apa tujuan saya?"
Anda : "Anda mengonfigurasi mentega."
File konfigurasi : "Ya Tuhan."

1. Tidak ada "tujuan sebenarnya" dari file konfigurasi. Apapun yang masuk akal untuk aplikasi Anda. Secara umum, hal-hal yang berbeda (atau mungkin berbeda) di antara mesin dan tidak berubah di tengah-tengah aplikasi Anda berjalan mungkin harus berada dalam file konfigurasi. Default, port, dan alamat untuk layanan lain semuanya adalah kandidat yang bagus. Kunci dan rahasia juga merupakan kandidat yang bagus tetapi harus ditangani secara terpisah dari konfigurasi normal Anda untuk alasan keamanan. Saya tidak setuju bahwa tujuan file konfigurasi adalah untuk memungkinkan dilakukannya perubahan cepat. Tujuannya adalah untuk memungkinkan fleksibilitas dalam pengaturan aplikasi Anda. Jika file konfigurasi adalah cara yang cepat dan mudah untuk memungkinkan fleksibilitas itu, itu jauh lebih baik - tetapi Anda seharusnya tidak bermaksud file konfigurasi Anda sering berubah.

2. Iya dan tidak. Haruskah Anda mencoba membuat kode aplikasi Anda sederhana? Iya. Anda harus berusaha membuat semua yang Anda tulis menjadi sederhana dan langsung ke sasaran. Tidak lebih rumit dari yang seharusnya. Hal yang sama berlaku untuk konfigurasi Anda. Namun, ini sangat spesifik untuk aplikasi. Melakukan hardcode apa yang harus ada di konfigurasi karena akan membuat konfigurasi Anda "terlalu rumit" adalah desain yang buruk. Faktanya, mencoba untuk "menjaga semuanya tetap sederhana" adalah mengapa file konfigurasi akhirnya menjadi sangat berantakan. Terkadang langkah paling sederhana adalah memodularisasi. Inilah sebabnya mengapa file konfigurasi Anda harus ditulis dalam bahasa pemrograman tujuan umum yang terkenal - bukan bahasa konfigurasi yang buruk (baca: semua "bahasa konfigurasi" payah ).

3. Sekali lagi, siapa yang harus memodifikasi file konfigurasi bergantung sepenuhnya pada aplikasi. Tetapi saya setuju dengan miniquark, siapa pun yang menerapkan aplikasi harus bertanggung jawab atas konfigurasinya.

4. Sumber mengontrol semua yang Anda bisa. Kontrol sumber sangat bagus. Anda dapat mengembalikan barang dengan sangat mudah dan Anda memiliki riwayat lengkap tentang perubahan yang Anda buat dan catatan siapa yang membuat perubahan tersebut. Jadi kenapa tidak?