কেন গো ডিজাইন স্মার্ট প্রোগ্রামারদের জন্য খারাপ

গত কয়েক মাস ধরে আমি বাস্তবায়নের জন্য Go ব্যবহার করছি। ধারণার প্রমাণ (প্রায়.: একটি ধারণার কার্যকারিতা পরীক্ষা করার জন্য কোড) তার অবসর সময়ে, আংশিকভাবে প্রোগ্রামিং ভাষা নিজেই অধ্যয়ন করার জন্য। প্রোগ্রামগুলি নিজেই খুব সহজ এবং এই নিবন্ধের উদ্দেশ্য নয়, তবে Go ব্যবহার করার অভিজ্ঞতা এটি সম্পর্কে কয়েকটি শব্দের দাবি রাখে। যাওয়ার প্রতিশ্রুতি দিয়ে যান (প্রায়.: 2015 সালে লেখা নিবন্ধ) গুরুতর মাপযোগ্য কোডের জন্য একটি জনপ্রিয় ভাষা। ভাষাটি গুগল দ্বারা তৈরি করা হয়েছিল, যেখানে এটি সক্রিয়ভাবে ব্যবহৃত হয়। নীচের লাইন, আমি সত্যই মনে করি যে গো ভাষার ডিজাইন স্মার্ট প্রোগ্রামারদের জন্য খারাপ।

দুর্বল প্রোগ্রামারদের জন্য ডিজাইন করা হয়েছে?

গো শেখা খুব সহজ, এত সহজ যে পরিচয়টি আমাকে এক সন্ধ্যায় নিয়ে গিয়েছিল, যার পরে আমি ইতিমধ্যেই উত্পাদনশীলভাবে কোড করতে পারি। আমি যে বইটি গো শিখতাম তাকে বলা হয় গো-তে প্রোগ্রামিংয়ের একটি ভূমিকা (অনুবাদ), এটি অনলাইনে উপলব্ধ। বইটি, গো সোর্স কোডের মতোই, পড়া সহজ, ভাল কোড উদাহরণ রয়েছে এবং এতে প্রায় 150 পৃষ্ঠা রয়েছে যা এক বসায় পড়া যায়। এই সরলতা প্রথমে রিফ্রেশ করে, বিশেষ করে অতি-জটিল প্রযুক্তিতে ভরা একটি প্রোগ্রামিং জগতে। কিন্তু শেষ পর্যন্ত, শীঘ্রই বা পরে চিন্তা জাগে: "এটা কি সত্যিই তাই?"

Google দাবি করে যে Go-এর সরলতা হল এর বিক্রয় বিন্দু এবং ভাষাটি বড় দলগুলিতে সর্বাধিক উত্পাদনশীলতার জন্য ডিজাইন করা হয়েছে, কিন্তু আমি সন্দেহ করি। এমন বৈশিষ্ট্য রয়েছে যা হয় অনুপস্থিত বা অত্যধিক বিস্তারিত। এবং সবই ডেভেলপারদের প্রতি আস্থার অভাবের কারণে, এই ধারণার সাথে যে তারা কিছু করতে পারে না। সরলতার জন্য এই আকাঙ্ক্ষাটি ভাষার ডিজাইনারদের দ্বারা একটি সচেতন সিদ্ধান্ত ছিল এবং কেন এটির প্রয়োজন ছিল তা সম্পূর্ণরূপে বোঝার জন্য, আমাদের অবশ্যই বিকাশকারীদের অনুপ্রেরণা এবং তারা গো-তে কী অর্জন করার চেষ্টা করছে তা বুঝতে হবে।

তাহলে কেন এটা এত সহজ করা হল? এখানে উদ্ধৃতি একটি দম্পতি আছে রব পাইক (প্রায়.: গো ভাষার সহ-নির্মাতাদের একজন):

এখানে মূল বিষয় হল আমাদের প্রোগ্রামাররা (প্রায়.: Googlers) গবেষক নন। তারা, একটি নিয়ম হিসাবে, বেশ তরুণ, অধ্যয়ন করার পরে আমাদের কাছে আসে, সম্ভবত তারা জাভা, বা C/C++, বা পাইথন অধ্যয়ন করেছে। তারা একটি দুর্দান্ত ভাষা বুঝতে পারে না, তবে একই সাথে আমরা চাই তারা ভাল সফ্টওয়্যার তৈরি করুক। সেজন্য তাদের ভাষা তাদের বোঝা ও শেখার জন্য সহজ হওয়া উচিত।
 
তার পরিচিত হওয়া উচিত, মোটামুটিভাবে সি-এর মতো কথা বলা। গুগলে কর্মরত প্রোগ্রামাররা তাদের কর্মজীবন খুব তাড়াতাড়ি শুরু করে এবং বেশিরভাগ পদ্ধতিগত ভাষাগুলির সাথে পরিচিত, বিশেষ করে সি পরিবারের। একটি নতুন প্রোগ্রামিং ভাষায় দ্রুত উত্পাদনশীলতার প্রয়োজনীয়তার অর্থ হল ভাষাটি খুব বেশি আমূল হওয়া উচিত নয়।

কি? তাই রব পাইক মূলত বলছেন যে গুগলের বিকাশকারীরা ততটা ভালো নয়, তাই তারা বোকাদের জন্য একটি ভাষা তৈরি করেছে (প্রায়.: dumbed down) যাতে তারা কিছু করতে সক্ষম হয়। নিজের সহকর্মীদের প্রতি কেমন অহংকারী দৃষ্টি? আমি সবসময় বিশ্বাস করি যে Google এর বিকাশকারীরা পৃথিবীর সবচেয়ে উজ্জ্বল এবং সেরাদের থেকে বেছে নেওয়া হয়েছে৷ নিশ্চয় তারা আরও কঠিন কিছু সামলাতে পারে?

অত্যধিক সরলতার শিল্পকর্ম

যেকোন ডিজাইনে সহজ হওয়া একটি যোগ্য লক্ষ্য এবং সহজ কিছু করার চেষ্টা করা কঠিন। যাইহোক, জটিল সমস্যাগুলি সমাধান করার (বা এমনকি প্রকাশ করার) চেষ্টা করার সময়, কখনও কখনও একটি জটিল সরঞ্জামের প্রয়োজন হয়। জটিলতা এবং জটিলতা একটি প্রোগ্রামিং ভাষার সেরা বৈশিষ্ট্য নয়, তবে একটি মাঝারি স্থল রয়েছে যেখানে ভাষাটি মার্জিত বিমূর্ততা তৈরি করতে পারে যা বোঝা এবং ব্যবহার করা সহজ।

খুব অভিব্যক্তিপূর্ণ নয়

সরলতার প্রতি অঙ্গীকারের কারণে, গো-তে এমন নির্মাণের অভাব রয়েছে যা অন্যান্য ভাষায় প্রাকৃতিক হিসাবে বিবেচিত হয়। এটি প্রথমে একটি ভাল ধারণার মতো মনে হতে পারে, কিন্তু বাস্তবে এটি ভার্বস কোডে পরিণত হয়। এর কারণটি সুস্পষ্ট হওয়া উচিত - বিকাশকারীদের জন্য অন্য লোকের কোড পড়তে সহজ হওয়া দরকার, কিন্তু আসলে এই সরলীকরণগুলি কেবল পঠনযোগ্যতার ক্ষতি করে। Go-তে কোনো সংক্ষিপ্ত রূপ নেই: হয় অনেক বা কিছুই না।

উদাহরণস্বরূপ, একটি কনসোল ইউটিলিটি যা stdin পড়ে বা কমান্ড লাইন আর্গুমেন্ট থেকে একটি ফাইল এইরকম দেখাবে:

package main

import (
    "bufio"
    "flag"
    "fmt"
    "log"
    "os"
)

func main() {

    flag.Parse()
    flags := flag.Args()

    var text string
    var scanner *bufio.Scanner
    var err error

    if len(flags) > 0 {

        file, err := os.Open(flags[0])

        if err != nil {
            log.Fatal(err)
        }

        scanner = bufio.NewScanner(file)

    } else {
        scanner = bufio.NewScanner(os.Stdin)
    }

    for scanner.Scan() {
        text += scanner.Text()
    }

    err = scanner.Err()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(text)
}

যদিও এই কোডটি যতটা সম্ভব সাধারণ হওয়ার চেষ্টা করে, Go এর জোরপূর্বক শব্দচয়ন বাধাগ্রস্ত হয় এবং ফলস্বরূপ, একটি সাধারণ সমস্যা সমাধানের ফলে প্রচুর পরিমাণে কোড আসে।

এখানে, উদাহরণস্বরূপ, একই সমস্যার সমাধান D:

import std.stdio, std.array, std.conv;

void main(string[] args)
{
    try
    {
        auto source = args.length > 1 ? File(args[1], "r") : stdin;
        auto text   = source.byLine.join.to!(string);

        writeln(text);
    }
    catch (Exception ex)
    {
        writeln(ex.msg);
    }
}

আর এখন কে বেশি পাঠযোগ্য? আমি আমার ভোট ডি কে দেব। তার কোড অনেক বেশি পাঠযোগ্য কারণ তিনি ক্রিয়াগুলি আরও স্পষ্টভাবে বর্ণনা করেছেন। D অনেক জটিল ধারণা ব্যবহার করে (প্রায়.: বিকল্প ফাংশন কল и টেমপ্লেট) Go উদাহরণের তুলনায়, তবে সেগুলি বোঝার ক্ষেত্রে সত্যিই জটিল কিছু নেই।

নকল করার নরক

Go-এর উন্নতির জন্য একটি জনপ্রিয় পরামর্শ হল সাধারণতা। এটি কমপক্ষে সমস্ত ডেটা প্রকারকে সমর্থন করার জন্য কোডের অপ্রয়োজনীয় অনুলিপি এড়াতে সহায়তা করবে। উদাহরণ স্বরূপ, পূর্ণসংখ্যার একটি তালিকা যোগ করার জন্য একটি ফাংশন প্রতিটি পূর্ণসংখ্যার প্রকারের জন্য এর মৌলিক ফাংশন কপি-পেস্ট করা ছাড়া অন্য কোনো উপায়ে প্রয়োগ করা যায় না; অন্য কোনো উপায় নেই:

package main

import "fmt"

func int64Sum(list []int64) (uint64) {
    var result int64 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int32Sum(list []int32) (uint64) {
    var result int32 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int16Sum(list []int16) (uint64) {
    var result int16 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func int8Sum(list []int8) (uint64) {
    var result int8 = 0
    for x := 0; x < len(list); x++ {
        result += list[x]
    }
    return uint64(result)
}

func main() {

    list8  := []int8 {1, 2, 3, 4, 5}
    list16 := []int16{1, 2, 3, 4, 5}
    list32 := []int32{1, 2, 3, 4, 5}
    list64 := []int64{1, 2, 3, 4, 5}

    fmt.Println(int8Sum(list8))
    fmt.Println(int16Sum(list16))
    fmt.Println(int32Sum(list32))
    fmt.Println(int64Sum(list64))
}

এবং এই উদাহরণ এমনকি স্বাক্ষরিত ধরনের জন্য কাজ করে না. এই পদ্ধতিটি সম্পূর্ণরূপে নিজেকে পুনরাবৃত্তি না করার নীতি লঙ্ঘন করে (শুকনো), সবচেয়ে বিখ্যাত এবং সুস্পষ্ট নীতিগুলির মধ্যে একটি, উপেক্ষা করে যা অনেক ত্রুটির উৎস। কেন গো এই কাজ করে? এটা ভাষার একটা ভয়ানক দিক।

ডি-তে একই উদাহরণ:

import std.stdio;
import std.algorithm;

void main(string[] args)
{
    [1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}

সরল, মার্জিত এবং সরাসরি পয়েন্টে। এখানে ব্যবহৃত ফাংশন হল reduce টেমপ্লেট টাইপ এবং predicate জন্য. হ্যাঁ, এটি আবার গো সংস্করণের চেয়ে আরও জটিল, তবে স্মার্ট প্রোগ্রামারদের পক্ষে বোঝা ততটা কঠিন নয়। কোন উদাহরণ বজায় রাখা সহজ এবং পড়া সহজ?

সহজ টাইপ সিস্টেম বাইপাস

আমি কল্পনা করি যে গো প্রোগ্রামাররা এটি পড়ছে তাদের মুখে ফেনা উঠবে এবং চিৎকার করবে, "আপনি এটা ভুল করছেন!" ভাল, একটি জেনেরিক ফাংশন এবং প্রকারগুলি তৈরি করার আরেকটি উপায় আছে, তবে এটি সম্পূর্ণরূপে টাইপ সিস্টেমকে ভেঙে দেয়!

সমস্যাটির চারপাশে কাজ করার জন্য একটি বোকা ভাষার সমাধানের এই উদাহরণটি দেখুন:

package main

import "fmt"
import "reflect"

func Reduce(in interface{}, memo interface{}, fn func(interface{}, interface{}) interface{}) interface{} {
    val := reflect.ValueOf(in)

    for i := 0; i < val.Len(); i++ {
        memo = fn(val.Index(i).Interface(), memo)
    }

    return memo
}

func main() {

    list := []int{1, 2, 3, 4, 5}

    result := Reduce(list, 0, func(val interface{}, memo interface{}) interface{} {
        return memo.(int) + val.(int)
    })

    fmt.Println(result)
}

এই বাস্তবায়ন Reduce নিবন্ধ থেকে ধার করা হয়েছে গো-তে ইডিওম্যাটিক জেনেরিক (প্রায়.: আমি অনুবাদটি খুঁজে পাইনি, আপনি যদি এটিতে সহায়তা করেন তবে আমি খুশি হব)। ঠিক আছে, যদি এটি বাগধারার হয়, আমি একটি অ-বাক্যমূলক উদাহরণ দেখতে ঘৃণা করব। ব্যবহার interface{} - একটি প্রহসন, এবং ভাষায় এটি শুধুমাত্র টাইপিং বাইপাস করার জন্য প্রয়োজন। এটি একটি খালি ইন্টারফেস এবং সকল প্রকার এটি বাস্তবায়ন করে, প্রত্যেকের জন্য সম্পূর্ণ স্বাধীনতার অনুমতি দেয়। প্রোগ্রামিং এই শৈলী ভয়ঙ্কর কুৎসিত, এবং যে সব না. এই ধরনের অ্যাক্রোব্যাটিক কৃতিত্বের জন্য রানটাইম প্রতিফলন ব্যবহার করা প্রয়োজন। এমনকি রব পাইক এমন ব্যক্তিদের পছন্দ করেন না যারা এটির অপব্যবহার করেন, যেমন তিনি তার একটি প্রতিবেদনে উল্লেখ করেছেন।

এটি একটি শক্তিশালী হাতিয়ার যা সতর্কতার সাথে ব্যবহার করা উচিত। কঠোরভাবে প্রয়োজন না হলে এটি এড়ানো উচিত।

আমি এই বাজে কথার পরিবর্তে ডি টেমপ্লেট নিতে চাই। এটা কেউ কিভাবে বলতে পারে interface{} আরো পঠনযোগ্য বা এমনকি টাইপ নিরাপদ?

নির্ভরতা ব্যবস্থাপনার দুর্দশা

Go-তে জনপ্রিয় হোস্টিং প্রদানকারীদের উপরে নির্মিত একটি অন্তর্নির্মিত নির্ভরতা সিস্টেম রয়েছে VCS. Go-এর সাথে আসা টুলগুলি এই পরিষেবাগুলি সম্পর্কে জানে এবং সেগুলি থেকে কোড ডাউনলোড, তৈরি এবং ইনস্টল করতে পারে। যদিও এটি দুর্দান্ত, সংস্করণে একটি বড় ত্রুটি রয়েছে! হ্যাঁ, এটা সত্য যে আপনি Go টুল ব্যবহার করে গিথুব বা বিটবাকেটের মতো পরিষেবাগুলি থেকে সোর্স কোড পেতে পারেন, কিন্তু আপনি সংস্করণটি নির্দিষ্ট করতে পারবেন না। এবং আবার উপযোগিতার মূল্যে সরলতা। এমন সিদ্ধান্তের যৌক্তিকতা আমি বুঝতে পারছি না।

এই সমস্যার সমাধান সম্পর্কে প্রশ্ন জিজ্ঞাসা করার পরে, গো ডেভেলপমেন্ট টিম তৈরি করেছে ফোরাম থ্রেড, যা রূপরেখা দেয় কিভাবে তারা এই সমস্যাটি পেতে যাচ্ছে। তাদের সুপারিশ ছিল একদিন আপনার প্রোজেক্টে সম্পূর্ণ সংগ্রহস্থলটি অনুলিপি করুন এবং এটিকে "যেমন আছে" রেখে দিন। তারা কী চিন্তা করা হয়? আমাদের কাছে দুর্দান্ত ট্যাগিং এবং সংস্করণ সমর্থন সহ আশ্চর্যজনক সংস্করণ নিয়ন্ত্রণ ব্যবস্থা রয়েছে যা Go নির্মাতারা উপেক্ষা করে এবং কেবল উত্স কোডটি অনুলিপি করে।

Xi থেকে সাংস্কৃতিক লাগেজ

আমার মতে, গো এমন লোকদের দ্বারা তৈরি করা হয়েছে যারা সারাজীবন C ব্যবহার করেছে এবং যারা নতুন কিছু চেষ্টা করতে চায় না তাদের দ্বারা। অতিরিক্ত চাকার সাথে ভাষাটিকে C হিসাবে বর্ণনা করা যেতে পারে(মূল: প্রশিক্ষণ চাকা) সমান্তরালতার সমর্থন ব্যতীত এতে কোনও নতুন ধারণা নেই (যা, যাইহোক, দুর্দান্ত) এবং এটি লজ্জাজনক। আপনি একটি সবে ব্যবহারযোগ্য, খোঁড়া ভাষায় চমৎকার সমান্তরালতা আছে.

আরেকটি চাঞ্চল্যকর সমস্যা হল গো একটি পদ্ধতিগত ভাষা (সি এর নীরব ভয়ের মতো)। আপনি একটি পদ্ধতিগত শৈলীতে কোড লেখা শেষ করেন যা পুরাতন এবং পুরানো মনে হয়। আমি জানি অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং একটি সিলভার বুলেট নয়, তবে বিশদ বিবরণগুলিকে প্রকারগুলিতে বিমূর্ত করতে এবং এনক্যাপসুলেশন সরবরাহ করতে সক্ষম হওয়া দুর্দান্ত হবে।

আপনার নিজের সুবিধার জন্য সরলতা

Go সহজ হতে ডিজাইন করা হয়েছিল এবং এটি সেই লক্ষ্যে সফল হয়। এটি দুর্বল প্রোগ্রামারদের জন্য লেখা হয়েছিল, একটি টেমপ্লেট হিসাবে একটি পুরানো ভাষা ব্যবহার করে। এটি সহজ জিনিসগুলি করার জন্য সহজ সরঞ্জামগুলির সাথে সম্পূর্ণ আসে। এটি পড়া সহজ এবং ব্যবহার করা সহজ।

এটি স্মার্ট প্রোগ্রামারদের জন্য অত্যন্ত ভার্বস, অপ্রীতিকর এবং খারাপ।

Спасибо mersinvald সম্পাদনার জন্য

উত্স: www.habr.com