Seperti apa alur kerja Lisp Anda? [Tutup]

Saya sedang belajar Lisp saat ini, datang dari perkembangan bahasa yaitu Lokomotif BASIC -> Z80 Assembler -> Pascal -> C -> Perl -> C # -> Ruby. Pendekatan saya adalah secara bersamaan:

• tulis scraper web sederhana menggunakan SBCL, QuickLisp, closure-html, dan drakma
• menonton kuliah SICP

Saya pikir ini bekerja dengan baik; Saya sedang mengembangkan 'kacamata Lisp' yang baik, karena sekarang saya dapat membaca Lisp dengan cukup mudah. Saya juga merasakan bagaimana ekosistem Lisp bekerja, misalnya Quicklisp untuk dependensi.

Namun, yang benar-benar saya lewatkan adalah perasaan bagaimana Lisper yang berpengalaman benar-benar bekerja .

Ketika saya sedang coding untuk .NET, saya memiliki Visual Studio yang diatur dengan ReSharper dan VisualSVN. Saya menulis tes, saya menerapkan, saya refactor, saya berkomitmen. Lalu ketika saya sudah cukup selesai untuk menyelesaikan sebuah cerita, saya menulis beberapa AUAT. Lalu saya memulai rilis Rilis di TeamCity untuk mendorong fungsionalitas baru kepada pelanggan untuk pengujian & semoga persetujuan. Jika ini adalah aplikasi yang membutuhkan pemasang, saya menggunakan WiX atau InnoSetup, yang jelas membangun pemasang melalui sistem CI.

Jadi, pertanyaan saya adalah: sebagai seorang Lisper yang berpengalaman, seperti apa alur kerja Anda ? Apakah Anda bekerja sebagian besar di REPL, atau di editor? Bagaimana Anda melakukan tes unit? Integrasi berkelanjutan? Kemasan & penyebaran? Ketika Anda duduk di meja Anda, mengukus cangkir kopi di satu sisi dan foto John McCarthy berbingkai di sisi lain, apa yang Anda lakukan ?

Saat ini, saya merasa saya mulai terbiasa dengan Lisp coding, tetapi tidak mengembangkan Lisp ...

Sebagian besar orang di comp.lang.lisp dan Lisp Forum merekomendasikan kombinasi Emacs dan SLIME, dengan asumsi Anda tidak ingin membayar untuk implementasi komersial seperti Allegro atau LispWorks. Video SLIME menggambarkan proses kerja. Saya menggunakan Emacs dan SLIME untuk mengembangkan program pribadi di rumah, dan kombinasinya bisa sangat efisien.

SLIME memberi Anda integrasi antara Emacs dan REPL. Apa yang biasanya saya lakukan adalah memuat semua file saya, lalu buka yang saya kerjakan di Emacs. Setelah saya mengetik atau mengubah setiap fungsi, saya menekan C-x C-e, yang mengeksekusi definisi fungsi dalam REPL. Lalu saya bisa beralih ke buffer REPL dan mencoba fungsinya. Semua riwayat REPL tersedia dan dapat diedit menggunakan urutan tombol Emacs standar, sehingga mudah untuk mengulang panggilan fungsi dengan parameter yang berbeda.

Saya bekerja terutama dengan Clojure, dan inilah pengaturan saya:

1. Eclipse IDE (Saya menggunakan ini karena saya juga melakukan banyak pekerjaan Java, kadang-kadang dalam proyek yang sama dengan Clojure)
2. Plugin berlawanan arah jarum jam untuk Clojure (ini termasuk REPL)
3. Maven untuk ketergantungan dan membangun manajemen
4. Egit untuk kontrol kode sumber

Alur kerja saat pengkodean umumnya seperti ini:

1. Buka REPL, muat semua file sumber saat ini
2. Kode dan tes dalam REPL
3. Ketika saya senang dengan beberapa kode, salin / tempel kembali ke file sumber
4. Kadang-kadang reboot REPL (baik ketika saya telah mengacaukan namespace tidak dapat dibatalkan, atau hanya untuk memeriksa semuanya masih bekerja di file sumber)
5. Juga tulis tes dalam file sumber, yang dijalankan secara otomatis oleh setiap build Maven. Kadang-kadang tes informal yang baru saja saya lakukan di REPL langsung berubah menjadi tes unit.
6. Berkomitmen dll pada titik ini - cukup banyak alur kerja pengembangan reguler

Secara keseluruhan itu tidak terlalu berbeda dari alur kerja Java / C # biasa selain dari penggunaan REPL yang lebih interaktif selama pengembangan.

Untuk melengkapi jawaban lain, saya melakukan kombinasi dari "Pikirkan keras tentang masalah, kemudian tulis solusi" jenis pengembangan dan "Mulai dengan repl, dan kalahkan program Anda menjadi bentuk iteratif" gaya. Biasanya di tengah. Apa yang saya lakukan adalah saya mulai dengan ide umum tentang apa yang saya ingin program saya terlihat, dan kemudian saya mulai menulisnya, mencoba untuk memperoleh pengetahuan baru tentang domain masalah saat saya pergi, untuk merevisi pendekatan saya. Dalam prakteknya itu berarti saya melakukan banyak eksperimen dan menulis banyak kode trow away. Saya mencoba berbagai pendekatan dan saya dapat beralih arah dengan sangat cepat. Lisp baik untuk pengembangan semacam ini. Itu sebabnya saya tidak terlalu menyukai TDD, saya harus tahu apa yang ingin saya lakukan pertama kali, agar TDD efektif.

Hal penting lain yang saya coba lakukan adalah memikirkan lebih lanjut tentang protokol di antara berbagai bagian program. Tidak seperti bahasa OO lainnya, In Common Lisp CLOS lebih berfokus pada konsep fungsi Generik, metode IOW hidup di luar kelas, dan mereka adalah fokus pengembangan. Kadang-kadang saya baru mulai dengan satu set GF mendefinisikan protokol yang saya inginkan, saya menulis implementasi sederhana dan menggunakannya untuk menyempurnakan protokol, sebelum saya menulis implementasi nyata. Katakanlah saya sedang menulis layer yang menyimpan banyak posting blog, saya mungkin memiliki satu set GF yang menentukan bagaimana posting blog dibuat, diedit dan dicari, dan saya akan menulis implementasi sederhana yang menyimpan posting blog dalam daftar di memori. , dan setelah saya puas dengan protokol saya, saya menulis implementasi yang menyimpan posting blog ke database, atau menulisnya ke file.

Lisp membuatnya sangat mudah untuk mengubah arah dan melakukan pendekatan yang berbeda ketika Anda tahu bahwa solusi Anda saat ini kurang optimal sehingga saya mencoba memaksimalkannya.

Juga poin penting: Gunakan lingkungan Anda sepenuhnya, belajar tentang menggunakan pengaturan kompilasi yang berbeda untuk mengkompilasi kode Anda dengan informasi debug yang lebih banyak, manfaatkan fakta bahwa lisp dapat dikompilasi dan diinterpretasikan. Gunakan fasilitas introspektif lisps, seperti MOP, gunakan fitur slimes untuk mencari dokumentasi, gunakan inspektur untuk melihat ke dalam objek, konsultasikan dengan hyperspec secara teratur, perlakukan sistem Anda lebih seperti OS, daripada kompiler statis untuk kode Anda, itu jauh lebih lebih kuat dari itu.

Untuk seorang pemula, lisp bukanlah kemenangan atas python dan ruby, tetapi saat Anda semakin berpengalaman, Anda mendapatkan kemenangan besar atas lingkungan yang lebih rendah.

Yang paling penting, Anda harus bersenang-senang dan menyukai bahasa ini, terkadang hanya untuk mudah berkecil hati dan menggunakan bahasa blub yang saat ini populer. Jika Anda tetap dengan cadel, itu akan membayar Anda.

Saya cenderung bekerja di editor yang memiliki koneksi ke REPL (biasanya, mengedit di emacs dan menggunakan SLIME sebagai jembatan ke lingkungan Common Lisp). Saya cenderung memulai kedua "di bagian bawah" dan "di bagian atas", bekerja ke arah tengah, merevisi desain saat saya pergi.

Adapun pengujian, itulah sebabnya saya memiliki REPL. Saya menemukan bahwa ini membantu pengujian kode ketika saya pergi. Terkadang saya akan menulis lebih banyak tes formal atau tolok ukur (biasanya setelah saya berada pada tahap optimasi). Memiliki implementasi fungsionalitas yang lebih lambat dan dikenal dengan baik (dalam jendela editor) dengan kode untuk versi yang dioptimalkan, mengirimkannya ke kode pelat yang terletak di bawah dan periksa apakah itu lebih cepat dan mengembalikan hasil yang sama dengan yang lebih lambat kode.

Sejauh pengemasannya, saya memiliki beberapa kode utilitas untuk membantu saya mengemas proyek yang dapat diinstal ASDF, menamparnya dalam repositori unduhan dan menangani versi.