Apakah sejumlah kecil pemrograman fungsional dapat dipahami oleh orang-orang non-FP? [Tutup]

Kasus : Saya bekerja di sebuah perusahaan, menulis aplikasi dengan Python yang menangani banyak data dalam array. Saya satu-satunya pengembang program ini saat ini, tetapi mungkin akan digunakan / dimodifikasi / diperpanjang di masa depan (1-3 tahun) oleh beberapa programmer lain, pada saat ini tidak saya kenal. Saya mungkin tidak akan ada di sana secara langsung untuk membantu, tetapi mungkin memberikan dukungan melalui email jika saya punya waktu untuk itu.

Jadi, sebagai pengembang yang telah mempelajari pemrograman fungsional (Haskell), saya cenderung menyelesaikan, misalnya, memfilter seperti ini:

filtered = filter(lambda item: included(item.time, dur), measures)

Sisa kode adalah OO, hanya beberapa kasus kecil di mana saya ingin menyelesaikannya seperti ini, karena jauh lebih sederhana dan lebih indah menurut saya.

Pertanyaan : Apakah boleh hari ini menulis kode seperti ini?

• Bagaimana pengembang yang belum menulis / mempelajari FP bereaksi terhadap kode seperti ini?
• Apakah bisa dibaca?
• Dapat dimodifikasi?

• Haruskah saya menulis dokumentasi seperti menjelaskan kepada seorang anak apa garis itu?

   # Filter out the items from measures for which included(item.time, dur) != True

Saya telah bertanya kepada bos saya, dan dia hanya mengatakan "FP adalah ilmu hitam, tetapi jika itu berhasil dan merupakan solusi yang paling efisien, maka boleh saja menggunakannya."

Apa pendapat Anda tentang ini? Sebagai programmer non-FP, bagaimana Anda bereaksi terhadap kode? Apakah kode itu "googable" sehingga Anda dapat mengerti apa fungsinya? Saya ingin umpan balik tentang ini.

Apakah bisa dibaca?

Bagi saya: Ya, tetapi saya mulai mengerti, bahwa komunitas Python sering menganggap daftar pemahaman sebagai solusi yang lebih bersih daripada menggunakan map()/ filter().

Bahkan, GvR bahkan mempertimbangkan untuk menjatuhkan fungsi-fungsi itu sama sekali.

Pertimbangkan ini:

filtered = [item for item in measures if included(item.time, dur)]

Lebih lanjut, ini memiliki manfaat bahwa pemahaman daftar akan selalu mengembalikan daftar. map()dan filter()di sisi lain akan mengembalikan iterator dengan Python 3.

Catatan: Jika Anda ingin memiliki iterator, gantinya sesederhana mengganti []dengan ():

filtered = (item for item in measures if included(item.time, dur))

Sejujurnya, saya melihat sedikit atau tidak ada alasan untuk menggunakan map()atau filter()dengan Python.

Apakah bisa dimodifikasi?

Ya, tentu saja, ada satu hal untuk membuatnya lebih mudah: Jadikan fungsi, bukan lambda.

def is_included(item):
    return included(item.time, dur)
filtered = filter(is_included, measures)
filtered = [item for item in measures if is_included(item)]

Jika kondisi Anda menjadi lebih kompleks, skala ini akan jauh lebih mudah, memungkinkan Anda untuk menggunakan kembali cek Anda. (Perhatikan bahwa Anda dapat membuat fungsi di dalam fungsi lain, ini dapat membuatnya lebih dekat ke tempat di mana ia digunakan.)

Bagaimana seorang pengembang yang belum menulis / belajar FP bereaksi pada kode seperti ini?

Dia mencari dokumentasi Python dan tahu cara kerjanya lima menit kemudian. Kalau tidak, dia seharusnya tidak pemrograman dengan Python.

map()dan filter()yang sangat sederhana. Bukannya Anda meminta mereka untuk memahami monad. Itu sebabnya saya pikir Anda tidak perlu menulis komentar seperti itu. Gunakan nama variabel dan fungsi yang baik, maka kodenya hampir jelas. Anda tidak dapat mengantisipasi fitur bahasa mana yang tidak diketahui pengembang. Sejauh yang Anda tahu, pengembang berikutnya mungkin tidak tahu apa itu kamus.

Apa yang tidak kita mengerti biasanya tidak dapat dibaca oleh kita. Dengan demikian, Anda bisa berargumen itu tidak lebih mudah dibaca daripada pemahaman daftar jika Anda belum pernah melihat salah satu dari mereka sebelumnya. Tetapi seperti yang disebutkan Joshua dalam komentarnya, saya juga percaya bahwa penting untuk konsisten dengan apa yang digunakan pengembang lain - setidaknya jika alternatifnya tidak memberikan keuntungan substansial.

Karena komunitas pengembang mendapatkan kembali minat dalam pemrograman fungsional, tidak jarang melihat beberapa pemrograman fungsional dalam bahasa yang awalnya sepenuhnya berorientasi objek. Contoh yang baik adalah C #, di mana tipe anonim dan ekspresi lambda memungkinkan untuk menjadi lebih pendek dan ekspresif melalui pemrograman fungsional.

Ini dikatakan, pemrograman fungsional aneh untuk pemula. Sebagai contoh, ketika selama kursus pelatihan, saya menjelaskan kepada para pemula bagaimana mereka dapat meningkatkan kode mereka melalui pemrograman fungsional dalam C #, beberapa dari mereka tidak yakin, dan beberapa mengatakan bahwa kode asli lebih mudah dimengerti untuk mereka. Contoh yang saya berikan kepada mereka adalah sebagai berikut:

Kode sebelum refactoring:

var categorizedProducts = new Dictionary<string, List<Product>>();

// Get only enabled products, filtering the disabled ones, and group them by categories.
foreach (var product in this.Data.Products)
{
    if (product.IsEnabled)
    {
        if (!categorizedProducts.ContainsKey(product.Category))
        {
            // The category is missing. Create one.
            categorizedProducts.Add(product.Category, new List<Product>());
        }

        categorizedProducts[product.Category].Add(product);
    }
}

// Walk through the categories.
foreach (var productsInCategory in categorizedProducts)
{
    var minimumPrice = double.MaxValue;
    var maximumPrice = double.MinValue;

    // Walk through the products in a category to search for the maximum and minimum prices.
    foreach (var product in productsInCategory.Value)
    {
        if (product.Price < minimumPrice)
        {
            minimumPrice = product.Price;
        }

        if (product.Price > maximumPrice)
        {
            maximumPrice = product.Price;
        }
    }

    yield return new PricesPerCategory(category: productsInCategory.Key, minimum: minimumPrice, maximum: maximumPrice);
}

Kode yang sama setelah refactoring dengan menggunakan FP:

return this.Data.Products
    .Where(product => product.IsEnabled)
    .GroupBy(product => product.Category)
    .Select(productsInCategory => new PricesPerCategory(
              category: productsInCategory.Key, 
              minimum:  productsInCategory.Value.Min(product => product.Price), 
              maximum:  productsInCategory.Value.Max(product => product.Price))
    );

Ini membuat saya berpikir bahwa:

• Anda tidak perlu khawatir jika Anda tahu bahwa pengembang berikutnya yang akan menjaga kode Anda akan memiliki pengalaman keseluruhan yang cukup dan beberapa pengetahuan tentang pemrograman fungsional, tetapi:

• jika tidak, hindari pemrograman fungsional, atau berikan komentar verbose yang menjelaskan sintaksis, kelebihan, dan kemungkinan peringatan dari pendekatan Anda pada saat yang bersamaan dibandingkan dengan pemrograman non-fungsional.

Saya seorang programmer non-FP dan baru-baru ini saya memodifikasi kode kolega saya dalam JavaScript. Ada permintaan-Http dengan panggilan balik yang sangat mirip dengan pernyataan yang disertakan oleh Anda. Saya harus mengatakan bahwa saya butuh waktu (seperti setengah jam) untuk menyelesaikannya (kode semuanya tidak terlalu besar).

Tidak ada komentar, dan saya pikir tidak ada keharusan untuk itu. Saya bahkan tidak meminta kolega saya untuk membantu saya memahami kodenya.

Dengan mempertimbangkan bahwa saya bekerja selama sekitar 1,5 tahun, saya pikir sebagian besar programmer akan dapat memahami dan memodifikasi kode seperti itu, sejak saya melakukannya.

Selain itu, seperti yang dikatakan Joachim Sauer dalam komentarnya, sering ada potongan-potongan FP dalam banyak bahasa, seperti C # (indexOf, misalnya). Begitu banyak programmer non-FP menangani hal ini cukup sering, dan potongan kode yang Anda masukkan bukanlah sesuatu yang mengerikan atau tidak dapat dipahami.

Saya akan mengatakan ya!

Ada banyak aspek pemrograman fungsional, dan menggunakan fungsi tingkat tinggi, seperti dalam contoh Anda, hanya salah satunya.

Sebagai contoh, saya menganggap menulis fungsi murni menjadi sangat penting untuk setiap perangkat lunak yang ditulis dalam bahasa apa pun (di mana "murni" maksud saya tidak ada efek samping), karena:

• mereka lebih mudah untuk unit test
• mereka jauh lebih mudah dikomposisikan daripada fungsi efek samping
• mereka lebih mudah di-debug

Saya juga sering menghindari mutasi nilai dan variabel - konsep lain yang dipinjam dari FP.

Kedua teknik ini berfungsi dengan baik dalam Python dan bahasa lain yang umumnya tidak diklasifikasikan sebagai fungsional. Mereka bahkan sering didukung oleh bahasa itu sendiri (yaitu finalvariabel di Jawa). Dengan demikian, programmer pemeliharaan di masa depan tidak akan menghadapi hambatan besar untuk memahami kode.

Kami melakukan diskusi yang sama tentang perusahaan tempat saya bekerja tahun lalu.

Diskusi tersebut membahas "kode magis" dan apakah itu didorong atau tidak. Ketika melihat lebih dalam lagi, tampaknya orang memiliki pandangan yang sangat berbeda tentang apa yang sebenarnya merupakan "kode magis". Orang-orang yang mengemukakan diskusi tampaknya sebagian besar berarti bahwa ekspresi (dalam PHP) yang menggunakan gaya fungsional adalah "kode magis" sedangkan pengembang yang berasal dari bahasa lain yang menggunakan lebih banyak gaya FP dalam kode mereka tampaknya berpikir bahwa kode magis agak ketika Anda membuat inklusi dinamis file melalui nama file dan sebagainya.

Kami tidak pernah sampai pada kesimpulan yang bagus tentang hal ini, lebih dari itu kebanyakan orang berpikir kode yang terlihat asing adalah "ajaib" atau sulit dibaca. Jadi, apakah itu ide yang baik untuk menghindari kode yang tampaknya asing bagi pengguna lain? Saya pikir itu tergantung di mana ia digunakan. Saya akan menahan diri dari menggunakan ekspresi fp-style (inklusi file dinamis dan sebagainya) dalam metode utama (atau bagian sentral penting dari aplikasi) di mana data harus berupa terowongan dengan cara yang jelas dan mudah dibaca, intuitif, cara. Di sisi lain, saya tidak berpikir seseorang harus takut untuk mendorong amplop, pengembang lain mungkin akan belajar FP dengan cepat jika mereka dihadapkan dengan kode FP dan mungkin memiliki sumber daya yang baik di rumah untuk berkonsultasi tentang masalah tersebut.

TL; DR: Hindari di bagian tengah aplikasi tingkat tinggi (yang perlu dibaca untuk tinjauan umum fungsionalitas aplikasi). Kalau tidak gunakan itu.

Komunitas C ++ baru-baru ini mendapatkan lambda juga, dan saya percaya mereka memiliki pertanyaan yang kira-kira sama. Namun, jawabannya mungkin tidak sama. Setara dengan C ++ adalah:

std::copy_if(measures.begin(), measures.end(), inserter(filter),
  [dur](Item i) { return included(i, dur) } );

Sekarang std::copybukan hal baru, dan _ifvariasinya juga tidak baru, tetapi lambda adalah. Namun itu didefinisikan dengan cukup jelas dalam konteks: durditangkap dan karenanya konstan, Item ibervariasi dalam loop, dan returnpernyataan tunggal melakukan semua pekerjaan.

Ini terlihat dapat diterima oleh banyak pengembang C ++. Saya belum mencicipi pendapat tentang lambda tingkat tinggi, dan saya berharap penerimaan jauh lebih sedikit.

Posting potongan kode ke sesama dev yang tidak lancar menggunakan python, dan tanyakan padanya apakah dia bisa menghabiskan 5 menit memeriksa kode untuk melihat apakah dia memahaminya.

Jika ya, Anda mungkin baik untuk pergi. Jika tidak, Anda harus membuatnya lebih jelas.

Bisakah kolega Anda menjadi bodoh dan tidak mengerti sesuatu yang harus jelas? Ya, tetapi Anda harus selalu memprogram sesuai dengan KISS.

Mungkin kode Anda lebih efisien / tampan / elegan daripada pendekatan yang lebih mudah, idiot-bukti? Maka Anda perlu bertanya pada diri sendiri: apakah saya perlu melakukan ini? Sekali lagi, jika jawabannya tidak, maka jangan lakukan itu!

Jika setelah semua ini, Anda masih berpikir Anda perlu dan ingin melakukannya dengan cara FP, maka tentu saja lakukanlah. Percayai insting Anda, mereka lebih cocok untuk kebutuhan Anda daripada kebanyakan orang di forum apa pun :)