บทความนี้เขียนขึ้นเพื่อตอบสนองต่อบทความที่เผยแพร่ก่อนหน้านี้ บทความต่อต้าน.

ในช่วงสองปีที่ผ่านมา ฉันใช้ Go เพื่อใช้งานเซิร์ฟเวอร์ RADIUS เฉพาะทางพร้อมระบบการเรียกเก็บเงินที่พัฒนาขึ้น ระหว่างทาง ฉันกำลังเรียนรู้ความซับซ้อนของภาษา ตัวโปรแกรมเองนั้นเรียบง่ายมากและไม่ใช่จุดประสงค์ของบทความนี้ แต่ประสบการณ์การใช้งาน Go เองก็สมควรได้รับคำสองสามคำในการป้องกัน Go กำลังกลายเป็นภาษากระแสหลักมากขึ้นสำหรับโค้ดที่จริงจังและปรับขนาดได้ ภาษานี้สร้างขึ้นโดย Google ซึ่งมีการใช้งานอย่างแข็งขัน สรุปแล้ว ฉันคิดว่าการออกแบบภาษา Go นั้นไม่ดีสำหรับโปรแกรมเมอร์ที่ไม่ฉลาด

ออกแบบมาสำหรับโปรแกรมเมอร์ที่อ่อนแอใช่ไหม?

ผู้อ่อนแอมักพูดถึงปัญหา พูดคุยแรงถึงความคิดและความฝัน...

Go นั้นง่ายต่อการเรียนรู้ ง่ายมากจนคุณสามารถอ่านโค้ดได้โดยไม่ต้องมีการฝึกอบรมใดๆ เลย คุณลักษณะของภาษานี้ใช้ในบริษัทระดับโลกหลายแห่งเมื่อมีการอ่านโค้ดร่วมกับผู้เชี่ยวชาญที่ไม่ใช่ธุรกิจหลัก (ผู้จัดการ ลูกค้า ฯลฯ) ซึ่งสะดวกมากสำหรับวิธีการต่างๆ เช่น Design Driven Development
แม้แต่โปรแกรมเมอร์มือใหม่ก็ยังเริ่มสร้างโค้ดที่ดีได้หลังจากผ่านไปหนึ่งหรือสองสัปดาห์ หนังสือที่ฉันศึกษาคือ “Go Programming” (โดย Mark Summerfield) หนังสือเล่มนี้ดีมากมันสัมผัสได้ถึงความแตกต่างของภาษามากมาย หลังจากภาษาที่ซับซ้อนโดยไม่จำเป็นเช่น Java, PHP การขาดเวทย์มนตร์ก็สดชื่น แต่ไม่ช้าก็เร็วโปรแกรมเมอร์ที่มีข้อจำกัดจำนวนมากก็มีความคิดที่จะใช้วิธีการเก่าในสาขาใหม่ นี่จำเป็นจริงๆเหรอ?

Rob Pike (นักอุดมการณ์หลักของภาษา) สร้างภาษา Go ให้เป็นภาษาอุตสาหกรรมที่เข้าใจง่ายและมีประสิทธิภาพในการใช้งาน ภาษานี้ได้รับการออกแบบมาเพื่อประสิทธิภาพการทำงานสูงสุดในทีมขนาดใหญ่ และไม่ต้องสงสัยเลย โปรแกรมเมอร์มือใหม่หลายคนบ่นว่ามีคุณสมบัติมากมายที่ขาดหายไป ความปรารถนาในความเรียบง่ายนี้เป็นการตัดสินใจอย่างมีสติของนักออกแบบภาษา และเพื่อที่จะเข้าใจอย่างถ่องแท้ว่าเหตุใดจึงจำเป็น เราต้องเข้าใจแรงจูงใจของนักพัฒนาและสิ่งที่พวกเขาพยายามทำให้สำเร็จใน Go

แล้วทำไมมันถึงทำง่ายขนาดนี้ล่ะ? นี่เป็นคำพูดสองสามข้อจาก Rob Pike:

ประเด็นสำคัญที่นี่คือโปรแกรมเมอร์ของเราไม่ใช่นักวิจัย ตามกฎแล้วพวกเขายังอายุน้อยจึงมาหาเราหลังจากเรียนจบ บางทีพวกเขาอาจจะเรียน Java หรือ C/C++ หรือ Python พวกเขาไม่เข้าใจภาษาที่ยอดเยี่ยม แต่ในขณะเดียวกัน เราก็ต้องการให้พวกเขาสร้างซอฟต์แวร์ที่ดี นั่นคือเหตุผลที่ภาษาควรจะเข้าใจและเรียนรู้ได้ง่าย

เขาน่าจะคุ้นเคยประมาณพูดคล้ายกับซี โปรแกรมเมอร์ที่ทำงานที่ Google เริ่มต้นอาชีพตั้งแต่เนิ่นๆ และส่วนใหญ่คุ้นเคยกับภาษาขั้นตอน โดยเฉพาะตระกูล C ข้อกำหนดสำหรับประสิทธิภาพการทำงานที่รวดเร็วในภาษาการเขียนโปรแกรมใหม่หมายความว่าภาษาไม่ควรรุนแรงเกินไป

คำพูดที่ชาญฉลาดใช่ไหม?

สิ่งประดิษฐ์แห่งความเรียบง่าย

ความเรียบง่ายเป็นเงื่อนไขที่จำเป็นสำหรับความงาม เลฟ ตอลสตอย.

การรักษาความเรียบง่ายเป็นหนึ่งในเป้าหมายที่สำคัญที่สุดในการออกแบบ ดังที่คุณทราบ โครงการที่สมบูรณ์แบบไม่ใช่โครงการที่ไม่มีอะไรจะเพิ่ม แต่เป็นโครงการที่ไม่มีอะไรจะลบออก หลายๆ คนเชื่อว่าเพื่อที่จะแก้ปัญหา (หรือแสดง) ปัญหาที่ซับซ้อนได้ จำเป็นต้องมีเครื่องมือที่ซับซ้อน อย่างไรก็ตามมันไม่ใช่ ลองใช้ภาษา PERL เป็นตัวอย่าง นักอุดมการณ์ทางภาษาเชื่อว่าโปรแกรมเมอร์ควรมีอย่างน้อยสามวิธีในการแก้ปัญหาหนึ่งปัญหา นักอุดมการณ์ของภาษาโกใช้เส้นทางที่แตกต่างออกไป พวกเขาตัดสินใจว่าวิธีเดียว แต่เป็นทางที่ดีจริงๆ ก็เพียงพอที่จะบรรลุเป้าหมาย แนวทางนี้มีรากฐานที่สำคัญ: วิธีเดียวที่จะเรียนรู้ได้ง่ายกว่าและลืมได้ยากกว่า

ผู้อพยพจำนวนมากบ่นว่าภาษานี้ไม่มีนามธรรมที่สวยงาม ใช่ นี่เป็นเรื่องจริง แต่นี่เป็นหนึ่งในข้อดีหลักของภาษา ภาษามีเวทย์มนตร์ขั้นต่ำ - ดังนั้นจึงไม่จำเป็นต้องมีความรู้เชิงลึกในการอ่านโปรแกรม สำหรับความฟุ่มเฟือยของโค้ด นี่ไม่ใช่ปัญหาเลย โปรแกรม Golang ที่เขียนอย่างดีจะอ่านในแนวตั้ง โดยมีโครงสร้างเพียงเล็กน้อยหรือไม่มีเลย นอกจากนี้ ความเร็วในการอ่านโปรแกรมอย่างน้อยก็มีลำดับความสำคัญมากกว่าความเร็วในการเขียนโปรแกรม หากคุณพิจารณาว่าโค้ดทั้งหมดมีการจัดรูปแบบที่เหมือนกัน (ทำโดยใช้คำสั่ง gofmt ในตัว) การอ่านบรรทัดเพิ่มเติมสองสามบรรทัดก็ไม่ใช่ปัญหาแต่อย่างใด

ไม่ค่อยแสดงออก

ศิลปะไม่ยอมให้เสรีภาพถูกจำกัด ความแม่นยำไม่ใช่ความรับผิดชอบของเขา

เนื่องจากความปรารถนาในความเรียบง่าย Go จึงขาดโครงสร้างที่ผู้คนคุ้นเคยในภาษาอื่นมองว่าเป็นสิ่งที่เป็นธรรมชาติ ในตอนแรกมันอาจจะไม่สะดวกบ้าง แต่แล้วคุณจะสังเกตเห็นว่าโปรแกรมนั้นอ่านง่ายกว่าและไม่คลุมเครือมากกว่ามาก

ตัวอย่างเช่น ยูทิลิตี้คอนโซลที่อ่าน stdin หรือไฟล์จากอาร์กิวเมนต์บรรทัดคำสั่งจะมีลักษณะดังนี้:

package main

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

func main() {

    flag.Parse()

    scanner := newScanner(flag.Args())

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

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

    fmt.Println(text)
}

func newScanner(flags []string) *bufio.Scanner {
    if len(flags) == 0 {
        return bufio.NewScanner(os.Stdin)
    }

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

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

    return bufio.NewScanner(file)
}

วิธีแก้ปัญหาเดียวกันใน 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);
    }
}

นรกแห่งการคัดลอก

มนุษย์มีนรกอยู่ในตัวเขาเอง มาร์ติน ลูเธอร์.

ผู้เริ่มต้นมักจะบ่นเกี่ยวกับ 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 main() {

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

    fmt.Println(int32Sum(list32))
    fmt.Println(int64Sum(list64))
}

ภาษามีวิธีการเพียงพอที่จะดำเนินการก่อสร้างดังกล่าว เช่น เขียนโปรแกรมทั่วไปก็ได้

package main

import "fmt"

func Eval32(list []int32, fn func(a, b int32)int32) int32 {
    var res int32
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int32Add(a, b int32) int32 {
    return a + b
}

func int32Sub(a, b int32) int32 {
    return a + b
}

func Eval64(list []int64, fn func(a, b int64)int64) int64 {
    var res int64
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int64Add(a, b int64) int64 {
    return a + b
}

func int64Sub(a, b int64) int64 {
    return a - b
}

func main() {

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

    fmt.Println(Eval32(list32, int32Add))
    fmt.Println(Eval64(list64, int64Add))
    fmt.Println(Eval64(list64, int64Sub))
}

และถึงแม้ว่าโค้ดของเราจะกลายเป็นเรื่องยาวกว่ากรณีก่อนหน้านี้เล็กน้อย แต่มันก็กลายเป็นเรื่องทั่วไปไปแล้ว ดังนั้นจึงไม่ใช่เรื่องยากสำหรับเราที่จะใช้การดำเนินการทางคณิตศาสตร์ทั้งหมด

หลายๆ คนจะบอกว่าโปรแกรมใน D ดูสั้นกว่ามาก และพวกเขาก็พูดถูกด้วย

import std.stdio;
import std.algorithm;

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

อย่างไรก็ตาม มันสั้นกว่าเท่านั้น แต่ไม่ถูกต้องมากกว่า เนื่องจากการใช้งาน D ละเว้นปัญหาการจัดการข้อผิดพลาดโดยสิ้นเชิง

ในชีวิตจริง เมื่อความซับซ้อนของตรรกะเพิ่มขึ้น ช่องว่างก็แคบลงอย่างรวดเร็ว ช่องว่างจะปิดเร็วขึ้นอีกเมื่อคุณต้องการดำเนินการที่ไม่สามารถทำได้โดยใช้ตัวดำเนินการภาษามาตรฐาน

ในแง่ของการบำรุงรักษา ความสามารถในการขยาย และความสามารถในการอ่าน ในความคิดของฉัน ภาษา Go ชนะ แม้ว่าจะสูญเสียการใช้คำฟุ่มเฟือยก็ตาม

การเขียนโปรแกรมทั่วไปในบางกรณีทำให้เราได้รับประโยชน์อย่างปฏิเสธไม่ได้ สิ่งนี้แสดงให้เห็นอย่างชัดเจนโดยแพ็คเกจการเรียงลำดับ ดังนั้นในการเรียงลำดับรายการใดๆ เราเพียงแค่ต้องใช้อินเทอร์เฟซ sort.Interface

import "sort"

type Names []string

func (ns Names) Len() int {
    return len(ns)
}

func (ns Names) Less(i, j int) bool {
    return ns[i] < ns[j]
}

func (ns Names) Swap(i, j int) {
    ns[i], ns[j] = ns[j], ns[i]
}

func main() {
    names := Names{"London", "Berlin", "Rim"}
    sort.Sort(names)
}

หากคุณใช้โปรเจ็กต์โอเพ่นซอร์สและรันคำสั่ง grep “interface{}” -R คุณจะเห็นว่ามีการใช้อินเทอร์เฟซที่สับสนบ่อยเพียงใด สหายที่มีใจปิดจะพูดทันทีว่าทั้งหมดนี้เกิดจากการขาดยาชื่อสามัญ อย่างไรก็ตาม นี่ไม่ใช่กรณีเสมอไป ลองใช้ DELPHI เป็นตัวอย่าง แม้ว่าจะมีข้อมูลทั่วไปเหมือนกัน แต่ก็มีประเภท VARIANT พิเศษสำหรับการดำเนินการกับประเภทข้อมูลที่กำหนดเอง ภาษา Go ก็ทำเช่นเดียวกัน

จากปืนใหญ่สู่นกกระจอก

และเสื้อรัดเข็มขัดจะต้องพอดีกับขนาดของความบ้าคลั่ง สตานิสลาฟ เลก

แฟนตัวยงหลายคนอาจอ้างว่า Go มีกลไกอื่นในการสร้างยาสามัญ - การสะท้อนกลับ และพวกเขาจะถูกต้อง...แต่เฉพาะในบางกรณีเท่านั้น

Rob Pike เตือนเรา:

นี่เป็นเครื่องมืออันทรงพลังที่ควรใช้ด้วยความระมัดระวัง ควรหลีกเลี่ยงเว้นแต่มีความจำเป็นอย่างยิ่ง

Wikipedia บอกเราดังต่อไปนี้:

การสะท้อนกลับหมายถึงกระบวนการที่โปรแกรมสามารถตรวจสอบและแก้ไขโครงสร้างและพฤติกรรมของตนเองระหว่างการดำเนินการ กระบวนทัศน์การเขียนโปรแกรมที่อยู่ภายใต้การสะท้อนเรียกว่าการเขียนโปรแกรมแบบสะท้อน นี่คือประเภทของการเขียนโปรแกรมเมตา

อย่างไรก็ตามอย่างที่คุณทราบคุณจะต้องจ่ายทุกอย่าง ในกรณีนี้คือ:

• ความยากในการเขียนโปรแกรม
• ความเร็วในการรันโปรแกรม

ดังนั้นจึงต้องใช้การสะท้อนด้วยความระมัดระวังเช่นเดียวกับอาวุธลำกล้องใหญ่ การใช้การไตร่ตรองอย่างไม่รอบคอบนำไปสู่โปรแกรมที่อ่านไม่ได้ ข้อผิดพลาดคงที่ และความเร็วต่ำ สิ่งเดียวที่โปรแกรมเมอร์จอมเห่อสามารถแสดงโค้ดของเขาต่อหน้าเพื่อนร่วมงานคนอื่นๆ ที่จริงจังและถ่อมตัวมากขึ้น

สัมภาระทางวัฒนธรรมจาก Xi? ไม่ จากหลายภาษา!

นอกจากโชคลาภแล้วหนี้ยังตกเป็นของทายาทอีกด้วย

แม้ว่าหลายคนจะเชื่อว่าภาษานั้นมีพื้นฐานมาจากมรดก C ทั้งหมด แต่ก็ไม่เป็นเช่นนั้น ภาษานี้ได้รวมเอาภาษาโปรแกรมที่ดีที่สุดไว้หลายด้าน

วากยสัมพันธ์

ประการแรก ไวยากรณ์ของโครงสร้างไวยากรณ์จะขึ้นอยู่กับไวยากรณ์ของภาษา C อย่างไรก็ตาม ภาษา DELPHI ก็มีอิทธิพลอย่างมากเช่นกัน ดังนั้นเราจะเห็นว่าวงเล็บที่ซ้ำซ้อนซึ่งลดความสามารถในการอ่านของโปรแกรมลงอย่างมากได้ถูกลบออกทั้งหมดแล้ว ภาษานี้ยังมีตัวดำเนินการ “:=” ที่มีอยู่ในภาษา DELPHI อีกด้วย แนวคิดของแพ็คเกจยืมมาจากภาษาเช่น ADA การประกาศเอนทิตีที่ไม่ได้ใช้นั้นยืมมาจากภาษา PROLOG

ความหมาย

แพ็คเกจจะขึ้นอยู่กับความหมายของภาษา DELPHI แต่ละแพ็คเกจจะห่อหุ้มข้อมูลและรหัสและมีหน่วยงานภาครัฐและเอกชน สิ่งนี้ช่วยให้คุณลดส่วนต่อประสานแพ็คเกจให้เหลือน้อยที่สุด

การดำเนินการนำไปใช้งานโดยวิธีการมอบหมายยืมมาจากภาษา DELPHI

รวบรวม

ไม่ใช่เรื่องตลกโดยไม่มีเหตุผล: Go ได้รับการพัฒนาในขณะที่กำลังคอมไพล์โปรแกรม C จุดแข็งประการหนึ่งของภาษาคือการรวบรวมที่รวดเร็วเป็นพิเศษ แนวคิดนี้ยืมมาจากภาษา DELPHI แต่ละแพ็คเกจ Go สอดคล้องกับโมดูล DELPHI แพ็คเกจเหล่านี้จะถูกคอมไพล์ใหม่เมื่อมีความจำเป็นจริงๆ เท่านั้น ดังนั้น หลังจากการแก้ไขครั้งถัดไป คุณไม่จำเป็นต้องคอมไพล์โปรแกรมทั้งหมด แต่คอมไพล์ใหม่เฉพาะแพ็คเกจที่เปลี่ยนแปลงและแพ็คเกจที่ขึ้นอยู่กับแพ็คเกจที่เปลี่ยนแปลงเหล่านี้ (และถึงแม้จะเป็นเช่นนั้น เฉพาะในกรณีที่อินเทอร์เฟซแพ็คเกจมีการเปลี่ยนแปลงเท่านั้น)

โครงสร้างระดับสูง

ภาษาประกอบด้วยโครงสร้างระดับสูงที่แตกต่างกันมากมายซึ่งไม่เกี่ยวข้องกับภาษาระดับต่ำเช่น C

• สตริง
• ตารางแฮช
• ชิ้น
• การพิมพ์แบบเป็ดนั้นยืมมาจากภาษาอย่าง RUBY (ซึ่งน่าเสียดายที่หลายคนไม่เข้าใจหรือใช้อย่างเต็มศักยภาพ)

การจัดการหน่วยความจำ

โดยทั่วไปการจัดการหน่วยความจำควรได้รับบทความแยกต่างหาก หากในภาษาเช่น C++ นักพัฒนาปล่อยให้การควบคุมอย่างสมบูรณ์ จากนั้นในภาษารุ่นหลังเช่น DELPHI จะใช้แบบจำลองการนับอ้างอิง ด้วยแนวทางนี้ ไม่อนุญาตให้ใช้การอ้างอิงแบบวนรอบ เนื่องจากคลัสเตอร์เด็กกำพร้าถูกสร้างขึ้น ดังนั้น Go จึงมีการตรวจจับคลัสเตอร์ดังกล่าวในตัว (เช่น C#) นอกจากนี้ ตัวรวบรวมขยะยังมีประสิทธิภาพมากกว่าการใช้งานส่วนใหญ่ที่เป็นที่รู้จักในปัจจุบัน และสามารถใช้กับงานแบบเรียลไทม์ได้หลายอย่างอยู่แล้ว ภาษาเองก็รับรู้สถานการณ์เมื่อค่าสำหรับจัดเก็บตัวแปรสามารถจัดสรรบนสแต็กได้ ซึ่งจะช่วยลดภาระในตัวจัดการหน่วยความจำและเพิ่มความเร็วของโปรแกรม

เห็นพ้องและเห็นพ้องกัน

ความเท่าเทียมและความสามารถในการแข่งขันของภาษานั้นเกินกว่าจะยกย่อง ไม่มีภาษาระดับต่ำใดที่สามารถแข่งขันกับ Go จากระยะไกลได้ พูดตามตรง เป็นที่น่าสังเกตว่าแบบจำลองนี้ไม่ได้คิดค้นโดยผู้เขียนภาษา แต่เป็นเพียงการยืมมาจากภาษา ADA เก่าที่ดี ภาษานี้สามารถประมวลผลการเชื่อมต่อแบบขนานนับล้านโดยใช้ CPU ทั้งหมด ขณะเดียวกันก็มีลำดับความสำคัญของปัญหาที่ซับซ้อนน้อยกว่าเกี่ยวกับการหยุดชะงักและสภาวะการแข่งขันซึ่งเป็นเรื่องปกติสำหรับโค้ดแบบมัลติเธรด

สิทธิประโยชน์เพิ่มเติม

หากทำกำไรได้ทุกคนก็จะเสียสละ

ภาษายังให้ประโยชน์มากมายแก่เราอย่างไม่ต้องสงสัย:

• ไฟล์ปฏิบัติการเพียงไฟล์เดียวหลังจากสร้างโปรเจ็กต์ช่วยลดความยุ่งยากในการปรับใช้แอปพลิเคชันอย่างมาก
• การพิมพ์แบบคงที่และการอนุมานประเภทสามารถลดจำนวนข้อผิดพลาดในโค้ดของคุณได้อย่างมาก แม้ว่าจะไม่ได้เขียนการทดสอบก็ตาม ฉันรู้ว่าโปรแกรมเมอร์บางคนทำโดยไม่ต้องเขียนการทดสอบเลยและคุณภาพของโค้ดก็ไม่ได้รับผลกระทบมากนัก
• การคอมไพล์ข้ามแพลตฟอร์มที่ง่ายดายและการพกพาที่ยอดเยี่ยมของไลบรารีมาตรฐาน ซึ่งช่วยลดความยุ่งยากในการพัฒนาแอปพลิเคชันข้ามแพลตฟอร์มอย่างมาก
• นิพจน์ทั่วไป RE2 นั้นปลอดภัยสำหรับเธรดและมีเวลาดำเนินการที่คาดการณ์ได้
• ไลบรารีมาตรฐานอันทรงพลังที่ช่วยให้โปรเจ็กต์ส่วนใหญ่ดำเนินการได้โดยไม่ต้องใช้เฟรมเวิร์กจากบุคคลที่สาม
• ภาษามีพลังมากพอที่จะมุ่งเน้นไปที่ปัญหามากกว่าวิธีแก้ปัญหา แต่ก็อยู่ในระดับต่ำพอที่จะแก้ไขปัญหาได้อย่างมีประสิทธิภาพ
• ระบบ Go eco มีเครื่องมือที่ได้รับการพัฒนาแล้วสำหรับทุกโอกาส: การทดสอบ เอกสาร การจัดการแพ็คเกจ ลินเตอร์อันทรงพลัง การสร้างโค้ด ตัวตรวจจับสภาพการแข่งขัน ฯลฯ
• Go เวอร์ชัน 1.11 นำเสนอการจัดการการพึ่งพาความหมายในตัว ซึ่งสร้างขึ้นจากโฮสติ้ง VCS ยอดนิยม เครื่องมือทั้งหมดที่ประกอบเป็นระบบนิเวศ Go ใช้บริการเหล่านี้เพื่อดาวน์โหลด สร้าง และติดตั้งโค้ดจากบริการเหล่านี้ได้ในคราวเดียว และนั่นก็เยี่ยมมาก ด้วยการมาถึงของเวอร์ชัน 1.11 ปัญหาเกี่ยวกับการกำหนดเวอร์ชันแพ็คเกจก็ได้รับการแก้ไขอย่างสมบูรณ์เช่นกัน
• เนื่องจากแนวคิดหลักของภาษาคือการลดเวทมนตร์ ภาษาจึงกระตุ้นให้นักพัฒนาจัดการข้อผิดพลาดอย่างชัดเจน และนี่ถูกต้อง เพราะไม่เช่นนั้นก็จะลืมการจัดการข้อผิดพลาดไปเลย อีกประการหนึ่งคือนักพัฒนาส่วนใหญ่จงใจเพิกเฉยต่อการจัดการข้อผิดพลาด โดยเลือกที่จะส่งต่อข้อผิดพลาดขึ้นไปข้างบนแทน
• ภาษาไม่ได้ใช้วิธี OOP แบบคลาสสิก เนื่องจาก Go ไม่มีระบบเสมือนจริงในรูปแบบที่บริสุทธิ์ อย่างไรก็ตาม นี่ไม่ใช่ปัญหาเมื่อใช้อินเทอร์เฟซ การไม่มี OOP จะช่วยลดอุปสรรคในการเข้าสู่ผู้เริ่มต้นได้อย่างมาก

ความเรียบง่ายเพื่อประโยชน์ของชุมชน

มันง่ายที่จะซับซ้อน และยากที่จะทำให้ง่ายขึ้น

Go ได้รับการออกแบบให้เรียบง่ายและประสบความสำเร็จตามเป้าหมายนั้น มันถูกเขียนขึ้นสำหรับโปรแกรมเมอร์อัจฉริยะที่เข้าใจถึงประโยชน์ของการทำงานเป็นทีม และเบื่อหน่ายกับความแปรปรวนอันไม่มีที่สิ้นสุดของภาษาระดับองค์กร ด้วยชุดโครงสร้างทางวากยสัมพันธ์ที่ค่อนข้างเล็กในคลังแสง ในทางปฏิบัติแล้วจึงไม่มีการเปลี่ยนแปลงตลอดเวลา ดังนั้นนักพัฒนาจึงมีเวลาเหลือมากสำหรับการพัฒนา และไม่ใช่สำหรับการศึกษานวัตกรรมทางภาษาอย่างไม่มีที่สิ้นสุด

นอกจากนี้ บริษัทยังได้รับข้อได้เปรียบหลายประการ เช่น อุปสรรคในการเข้าต่ำทำให้สามารถค้นหาผู้เชี่ยวชาญได้อย่างรวดเร็ว และความไม่เปลี่ยนแปลงของภาษาทำให้พวกเขาใช้รหัสเดียวกันได้แม้จะผ่านไป 10 ปีก็ตาม

ข้อสรุป

สมองขนาดใหญ่ไม่เคยทำให้ช้างตัวใดเป็นผู้ชนะรางวัลโนเบล

สำหรับโปรแกรมเมอร์ที่มีอัตตาส่วนตัวมีความสำคัญเหนือกว่าจิตวิญญาณของทีม เช่นเดียวกับนักทฤษฎีที่ชื่นชอบความท้าทายทางวิชาการและ "การพัฒนาตนเอง" อย่างไม่มีที่สิ้นสุด ภาษานั้นแย่มาก เนื่องจากเป็นภาษาช่างฝีมือทั่วไปที่ไม่อนุญาตให้คุณเข้าใจ ความพึงพอใจด้านสุนทรียะจากผลงานของคุณและแสดงตัวว่าเป็นมืออาชีพต่อหน้าเพื่อนร่วมงาน (โดยที่เราวัดความฉลาดตามเกณฑ์เหล่านี้ ไม่ใช่โดย IQ) เช่นเดียวกับทุกสิ่งทุกอย่างในชีวิต มันเป็นเรื่องของลำดับความสำคัญส่วนบุคคล เช่นเดียวกับนวัตกรรมที่คุ้มค่าอื่นๆ ภาษาได้พัฒนาไปไกลจากการปฏิเสธของสากลไปจนถึงการยอมรับของมวลชน ภาษามีความชาญฉลาดในความเรียบง่าย และอย่างที่คุณทราบ ทุกอย่างที่ชาญฉลาดนั้นเรียบง่าย!

ที่มา: will.com