ಸ್ಮಾರ್ಟ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗೆ ಗೋ ವಿನ್ಯಾಸ ಏಕೆ ಕೆಟ್ಟದಾಗಿದೆ

ಕಳೆದ ತಿಂಗಳುಗಳಿಂದ ನಾನು ಅಳವಡಿಕೆಗಳಿಗಾಗಿ Go ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ. ಪರಿಕಲ್ಪನೆಯ ಪುರಾವೆ (ಅಂದಾಜು: ಕಲ್ಪನೆಯ ಕಾರ್ಯವನ್ನು ಪರೀಕ್ಷಿಸಲು ಕೋಡ್) ತನ್ನ ಬಿಡುವಿನ ವೇಳೆಯಲ್ಲಿ, ಭಾಗಶಃ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯನ್ನು ಅಧ್ಯಯನ ಮಾಡಲು. ಕಾರ್ಯಕ್ರಮಗಳು ತುಂಬಾ ಸರಳವಾಗಿದೆ ಮತ್ತು ಈ ಲೇಖನದ ಉದ್ದೇಶವಲ್ಲ, ಆದರೆ ಗೋ ಬಳಸುವ ಅನುಭವವು ಅದರ ಬಗ್ಗೆ ಕೆಲವು ಪದಗಳಿಗೆ ಅರ್ಹವಾಗಿದೆ. ಹೋಗುವುದಾಗಿ ಭರವಸೆ ನೀಡುತ್ತಾನೆ (ಅಂದಾಜು: 2015 ರಲ್ಲಿ ಬರೆದ ಲೇಖನ) ಗಂಭೀರ ಸ್ಕೇಲೆಬಲ್ ಕೋಡ್‌ಗಾಗಿ ಜನಪ್ರಿಯ ಭಾಷೆ. ಭಾಷೆಯನ್ನು Google ನಿಂದ ರಚಿಸಲಾಗಿದೆ, ಅಲ್ಲಿ ಅದನ್ನು ಸಕ್ರಿಯವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಬಾಟಮ್ ಲೈನ್, ಗೋ ಭಾಷೆಯ ವಿನ್ಯಾಸವು ಸ್ಮಾರ್ಟ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗೆ ಕೆಟ್ಟದ್ದಾಗಿದೆ ಎಂದು ನಾನು ಪ್ರಾಮಾಣಿಕವಾಗಿ ಭಾವಿಸುತ್ತೇನೆ.

ದುರ್ಬಲ ಪ್ರೋಗ್ರಾಮರ್ಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆಯೇ?

ಗೋ ಕಲಿಯಲು ತುಂಬಾ ಸುಲಭ, ಆದ್ದರಿಂದ ಪರಿಚಯವು ನನಗೆ ಒಂದು ಸಂಜೆ ತೆಗೆದುಕೊಂಡಿತು, ಅದರ ನಂತರ ನಾನು ಈಗಾಗಲೇ ಉತ್ಪಾದಕವಾಗಿ ಕೋಡ್ ಮಾಡಬಹುದು. ನಾನು ಗೋ ಕಲಿಯಲು ಬಳಸುತ್ತಿದ್ದ ಪುಸ್ತಕವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ Go ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಒಂದು ಪರಿಚಯ (ಅನುವಾದ), ಇದು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಲಭ್ಯವಿದೆ. ಗೋ ಸೋರ್ಸ್ ಕೋಡ್‌ನಂತೆಯೇ ಪುಸ್ತಕವು ಓದಲು ಸುಲಭವಾಗಿದೆ, ಉತ್ತಮ ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಸುಮಾರು 150 ಪುಟಗಳನ್ನು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಓದಬಹುದು. ಈ ಸರಳತೆಯು ಮೊದಲಿಗೆ ರಿಫ್ರೆಶ್ ಆಗಿದೆ, ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ತಂತ್ರಜ್ಞಾನದಿಂದ ತುಂಬಿದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಜಗತ್ತಿನಲ್ಲಿ. ಆದರೆ ಕೊನೆಯಲ್ಲಿ, ಬೇಗ ಅಥವಾ ನಂತರ ಆಲೋಚನೆ ಉದ್ಭವಿಸುತ್ತದೆ: "ಇದು ನಿಜವಾಗಿಯೂ ಹಾಗೆ?"

Go ನ ಸರಳತೆಯು ಅದರ ಮಾರಾಟದ ಬಿಂದುವಾಗಿದೆ ಮತ್ತು ದೊಡ್ಡ ತಂಡಗಳಲ್ಲಿ ಗರಿಷ್ಠ ಉತ್ಪಾದಕತೆಗಾಗಿ ಭಾಷೆಯನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಎಂದು Google ಹೇಳಿಕೊಂಡಿದೆ, ಆದರೆ ನನಗೆ ಅನುಮಾನವಿದೆ. ಕಾಣೆಯಾಗಿರುವ ಅಥವಾ ಹೆಚ್ಚು ವಿವರವಾದ ವೈಶಿಷ್ಟ್ಯಗಳಿವೆ. ಮತ್ತು ಡೆವಲಪರ್‌ಗಳಲ್ಲಿ ನಂಬಿಕೆಯ ಕೊರತೆಯಿಂದಾಗಿ, ಅವರು ಏನನ್ನೂ ಸರಿಯಾಗಿ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ಎಂಬ ಊಹೆಯೊಂದಿಗೆ. ಸರಳತೆಯ ಈ ಬಯಕೆಯು ಭಾಷೆಯ ವಿನ್ಯಾಸಕಾರರ ಪ್ರಜ್ಞಾಪೂರ್ವಕ ನಿರ್ಧಾರವಾಗಿತ್ತು ಮತ್ತು ಅದು ಏಕೆ ಬೇಕು ಎಂಬುದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಡೆವಲಪರ್‌ಗಳ ಪ್ರೇರಣೆ ಮತ್ತು ಅವರು ಗೋದಲ್ಲಿ ಏನನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ನಾವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.

ಹಾಗಾದರೆ ಅದನ್ನು ಏಕೆ ಸರಳಗೊಳಿಸಲಾಯಿತು? ಇಲ್ಲಿ ಒಂದೆರಡು ಉಲ್ಲೇಖಗಳಿವೆ ರಾಬ್ ಪೈಕ್ (ಅಂದಾಜು: ಗೋ ಭಾಷೆಯ ಸಹ-ಸೃಷ್ಟಿಕರ್ತರಲ್ಲಿ ಒಬ್ಬರು):

ಇಲ್ಲಿ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ನಮ್ಮ ಪ್ರೋಗ್ರಾಮರ್ಗಳು (ಅಂದಾಜು: ಗೂಗ್ಲರ್ಸ್) ಸಂಶೋಧಕರಲ್ಲ. ಅವರು ನಿಯಮದಂತೆ, ಸಾಕಷ್ಟು ಚಿಕ್ಕವರು, ಅಧ್ಯಯನ ಮಾಡಿದ ನಂತರ ನಮ್ಮ ಬಳಿಗೆ ಬರುತ್ತಾರೆ, ಬಹುಶಃ ಅವರು ಜಾವಾ, ಅಥವಾ C/C++, ಅಥವಾ ಪೈಥಾನ್ ಅನ್ನು ಅಧ್ಯಯನ ಮಾಡಿದ್ದಾರೆ. ಅವರು ಉತ್ತಮ ಭಾಷೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಅವರು ಉತ್ತಮ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ರಚಿಸಬೇಕೆಂದು ನಾವು ಬಯಸುತ್ತೇವೆ. ಆದ್ದರಿಂದಲೇ ಅವರ ಭಾಷೆ ಅವರಿಗೆ ಅರ್ಥವಾಗಲು ಮತ್ತು ಕಲಿಯಲು ಸುಲಭವಾಗಬೇಕು.
 
ಅವರು ಪರಿಚಿತರಾಗಿರಬೇಕು, ಸ್ಥೂಲವಾಗಿ ಹೇಳುವುದಾದರೆ ಸಿ. Google ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ತಮ್ಮ ವೃತ್ತಿಜೀವನವನ್ನು ಮೊದಲೇ ಪ್ರಾರಂಭಿಸುತ್ತಾರೆ ಮತ್ತು ಹೆಚ್ಚಾಗಿ ಕಾರ್ಯವಿಧಾನದ ಭಾಷೆಗಳೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದಾರೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ C ಕುಟುಂಬ. ಹೊಸ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ತ್ವರಿತ ಉತ್ಪಾದಕತೆಯ ಅವಶ್ಯಕತೆ ಎಂದರೆ ಭಾಷೆ ತುಂಬಾ ಆಮೂಲಾಗ್ರವಾಗಿರಬಾರದು.

ಏನು? ಆದ್ದರಿಂದ ರಾಬ್ ಪೈಕ್ ಮೂಲತಃ ಗೂಗಲ್‌ನಲ್ಲಿನ ಡೆವಲಪರ್‌ಗಳು ಉತ್ತಮವಾಗಿಲ್ಲ ಎಂದು ಹೇಳುತ್ತಿದ್ದಾರೆ, ಅದಕ್ಕಾಗಿಯೇ ಅವರು ಈಡಿಯಟ್ಸ್‌ಗಾಗಿ ಭಾಷೆಯನ್ನು ರಚಿಸಿದ್ದಾರೆ (ಅಂದಾಜು: ಮೂಕ) ಇದರಿಂದ ಅವರು ಏನನ್ನಾದರೂ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ನಿಮ್ಮ ಸ್ವಂತ ಸಹೋದ್ಯೋಗಿಗಳನ್ನು ಯಾವ ರೀತಿಯ ಸೊಕ್ಕಿನ ನೋಟ? 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);
    }
}

ಮತ್ತು ಈಗ ಯಾರು ಹೆಚ್ಚು ಓದಬಲ್ಲರು? ನಾನು ನನ್ನ ಮತವನ್ನು ಡಿ ಅವರಿಗೆ ನೀಡುತ್ತೇನೆ. ಅವರು ಕ್ರಿಯೆಗಳನ್ನು ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿ ವಿವರಿಸುವುದರಿಂದ ಅವರ ಕೋಡ್ ಹೆಚ್ಚು ಓದಬಲ್ಲದು. ಡಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಬಳಸುತ್ತದೆ (ಅಂದಾಜು: ಪರ್ಯಾಯ ಕಾರ್ಯ ಕರೆ и ಟೆಂಪ್ಲೇಟ್ಗಳು) ಗೋ ಉದಾಹರಣೆಗಿಂತ, ಆದರೆ ಅವುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಏನೂ ಸಂಕೀರ್ಣವಾಗಿಲ್ಲ.

ನಕಲು ಮಾಡುವುದು ನರಕ

ಗೋವನ್ನು ಸುಧಾರಿಸಲು ಜನಪ್ರಿಯ ಸಲಹೆಯೆಂದರೆ ಸಾಮಾನ್ಯತೆ. ಎಲ್ಲಾ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಬೆಂಬಲಿಸಲು ಕೋಡ್‌ನ ಅನಗತ್ಯ ನಕಲು ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಲು ಇದು ಕನಿಷ್ಠ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯವನ್ನು ಪ್ರತಿ ಪೂರ್ಣಾಂಕ ಪ್ರಕಾರಕ್ಕೆ ಅದರ ಮೂಲ ಕಾರ್ಯವನ್ನು ನಕಲು-ಅಂಟಿಸುವ ಮೂಲಕ ಬೇರೆ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ; ಬೇರೆ ಯಾವುದೇ ಮಾರ್ಗವಿಲ್ಲ:

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 ಟೆಂಪ್ಲೇಟ್ ಪ್ರಕಾರ ಮತ್ತು ಭವಿಷ್ಯಕ್ಕಾಗಿ. ಹೌದು, ಇದು ಮತ್ತೆ ಗೋ ಆವೃತ್ತಿಗಿಂತ ಹೆಚ್ಚು ಜಟಿಲವಾಗಿದೆ, ಆದರೆ ಸ್ಮಾರ್ಟ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅಷ್ಟು ಕಷ್ಟವಲ್ಲ. ಯಾವ ಉದಾಹರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಸುಲಭ ಮತ್ತು ಓದಲು ಸುಲಭವಾಗಿದೆ?

ಸರಳ ರೀತಿಯ ಸಿಸ್ಟಮ್ ಬೈಪಾಸ್

ಇದನ್ನು ಓದುತ್ತಿರುವ ಗೋ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಬಾಯಿಯಲ್ಲಿ ನೊರೆ ಬರುವುದು ಮತ್ತು “ನೀವು ತಪ್ಪು ಮಾಡುತ್ತಿದ್ದೀರಿ!” ಎಂದು ಕಿರುಚುತ್ತಾರೆ ಎಂದು ನಾನು ಊಹಿಸುತ್ತೇನೆ. ಸರಿ, ಸಾಮಾನ್ಯ ಕಾರ್ಯ ಮತ್ತು ಪ್ರಕಾರಗಳನ್ನು ಮಾಡಲು ಇನ್ನೊಂದು ಮಾರ್ಗವಿದೆ, ಆದರೆ ಇದು ಟೈಪ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಮುರಿಯುತ್ತದೆ!

ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಮೂರ್ಖ ಭಾಷೆಯ ಪರಿಹಾರದ ಈ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:

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 ಲೇಖನದಿಂದ ಎರವಲು ಪಡೆಯಲಾಗಿದೆ Go ನಲ್ಲಿ ಭಾಷಾವೈಶಿಷ್ಟ್ಯಗಳು (ಅಂದಾಜು: ನನಗೆ ಅನುವಾದವನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗಲಿಲ್ಲ, ನೀವು ಇದಕ್ಕೆ ಸಹಾಯ ಮಾಡಿದರೆ ನನಗೆ ಸಂತೋಷವಾಗುತ್ತದೆ). ಸರಿ, ಇದು ಭಾಷಾವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದರೆ, ಭಾಷಾವೈಶಿಷ್ಟ್ಯವಿಲ್ಲದ ಉದಾಹರಣೆಯನ್ನು ನೋಡಲು ನಾನು ದ್ವೇಷಿಸುತ್ತೇನೆ. ಬಳಕೆ interface{} - ಒಂದು ಪ್ರಹಸನ, ಮತ್ತು ಭಾಷೆಯಲ್ಲಿ ಇದು ಟೈಪಿಂಗ್ ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡಲು ಮಾತ್ರ ಅಗತ್ಯವಿದೆ. ಇದು ಖಾಲಿ ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ ಮತ್ತು ಎಲ್ಲಾ ಪ್ರಕಾರಗಳು ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತವೆ, ಎಲ್ಲರಿಗೂ ಸಂಪೂರ್ಣ ಸ್ವಾತಂತ್ರ್ಯವನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಶೈಲಿಯು ಭಯಾನಕ ಕೊಳಕು, ಮತ್ತು ಅಷ್ಟೆ ಅಲ್ಲ. ಈ ರೀತಿಯ ಚಮತ್ಕಾರಿಕ ಸಾಹಸಗಳಿಗೆ ರನ್‌ಟೈಮ್ ಪ್ರತಿಫಲನದ ಬಳಕೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ. ರಾಬ್ ಪೈಕ್ ಕೂಡ ಇದನ್ನು ದುರುಪಯೋಗಪಡಿಸಿಕೊಳ್ಳುವ ವ್ಯಕ್ತಿಗಳನ್ನು ಇಷ್ಟಪಡುವುದಿಲ್ಲ ಎಂದು ಅವರು ತಮ್ಮ ವರದಿಯೊಂದರಲ್ಲಿ ಉಲ್ಲೇಖಿಸಿದ್ದಾರೆ.

ಇದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದ್ದು ಅದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಬೇಕು. ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ ಅದನ್ನು ತಪ್ಪಿಸಬೇಕು.

ನಾನು ಈ ಅಸಂಬದ್ಧತೆಗೆ ಬದಲಾಗಿ D ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇನೆ. ಅದನ್ನು ಯಾರಾದರೂ ಹೇಗೆ ಹೇಳಬಹುದು interface{} ಹೆಚ್ಚು ಓದಬಲ್ಲ ಅಥವಾ ಸುರಕ್ಷಿತವಾಗಿ ಟೈಪ್ ಮಾಡಬಹುದೇ?

ಅವಲಂಬನೆ ನಿರ್ವಹಣೆಯ ತೊಂದರೆಗಳು

ಜನಪ್ರಿಯ ಹೋಸ್ಟಿಂಗ್ ಪೂರೈಕೆದಾರರ ಮೇಲೆ ನಿರ್ಮಿಸಲಾದ ಅಂತರ್ನಿರ್ಮಿತ ಅವಲಂಬನೆ ವ್ಯವಸ್ಥೆಯನ್ನು Go ಹೊಂದಿದೆ VCS. Go ನೊಂದಿಗೆ ಬರುವ ಪರಿಕರಗಳು ಈ ಸೇವೆಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುತ್ತವೆ ಮತ್ತು ಅವುಗಳಿಂದ ಒಂದೇ ಸ್ವಪ್‌ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು, ನಿರ್ಮಿಸಬಹುದು ಮತ್ತು ಸ್ಥಾಪಿಸಬಹುದು. ಇದು ಉತ್ತಮವಾಗಿದ್ದರೂ, ಆವೃತ್ತಿಯೊಂದಿಗೆ ಪ್ರಮುಖ ದೋಷವಿದೆ! ಹೌದು, ಗೋ ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಗಿಥಬ್ ಅಥವಾ ಬಿಟ್‌ಬಕೆಟ್‌ನಂತಹ ಸೇವೆಗಳಿಂದ ನೀವು ಮೂಲ ಕೋಡ್ ಅನ್ನು ಪಡೆಯಬಹುದು ಎಂಬುದು ನಿಜ, ಆದರೆ ನೀವು ಆವೃತ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಮತ್ತು ಉಪಯುಕ್ತತೆಯ ವೆಚ್ಚದಲ್ಲಿ ಮತ್ತೊಮ್ಮೆ ಸರಳತೆ. ಅಂತಹ ನಿರ್ಧಾರದ ತರ್ಕವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನನಗೆ ಸಾಧ್ಯವಾಗುತ್ತಿಲ್ಲ.

ಈ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರದ ಕುರಿತು ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿದ ನಂತರ, ಗೋ ಅಭಿವೃದ್ಧಿ ತಂಡ ರಚಿಸಲಾಗಿದೆ ವೇದಿಕೆ ಥ್ರೆಡ್, ಅವರು ಈ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಎದುರಿಸಲಿದ್ದಾರೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಒಂದು ದಿನ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಸಂಪೂರ್ಣ ರೆಪೊಸಿಟರಿಯನ್ನು ನಕಲಿಸುವುದು ಮತ್ತು ಅದನ್ನು "ಇರುವಂತೆ" ಬಿಡುವುದು ಅವರ ಶಿಫಾರಸು ಆಗಿತ್ತು. ಅವರು ಏನು ನರಕ ಯೋಚಿಸುತ್ತಿದ್ದಾರೆ? ನಾವು ಉತ್ತಮ ಟ್ಯಾಗಿಂಗ್ ಮತ್ತು ಆವೃತ್ತಿ ಬೆಂಬಲದೊಂದಿಗೆ ಅದ್ಭುತ ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಅದನ್ನು Go ರಚನೆಕಾರರು ನಿರ್ಲಕ್ಷಿಸುತ್ತಾರೆ ಮತ್ತು ಮೂಲ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸುತ್ತಾರೆ.

Xi ನಿಂದ ಸಾಂಸ್ಕೃತಿಕ ಸಾಮಾನುಗಳು

ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ, ಗೋ ಅನ್ನು ತಮ್ಮ ಜೀವನದುದ್ದಕ್ಕೂ ಸಿ ಬಳಸಿದ ಜನರು ಮತ್ತು ಹೊಸದನ್ನು ಪ್ರಯತ್ನಿಸಲು ಇಷ್ಟಪಡದವರಿಂದ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ. ಭಾಷೆಯನ್ನು ಹೆಚ್ಚುವರಿ ಚಕ್ರಗಳೊಂದಿಗೆ ಸಿ ಎಂದು ವಿವರಿಸಬಹುದು(ಮೂಲ: ತರಬೇತಿ ಚಕ್ರಗಳು) ಇದರಲ್ಲಿ ಯಾವುದೇ ಹೊಸ ಆಲೋಚನೆಗಳಿಲ್ಲ, ಸಮಾನಾಂತರತೆಯ ಬೆಂಬಲವನ್ನು ಹೊರತುಪಡಿಸಿ (ಇದು ಅದ್ಭುತವಾಗಿದೆ) ಮತ್ತು ಇದು ನಾಚಿಕೆಗೇಡಿನ ಸಂಗತಿಯಾಗಿದೆ. ನೀವು ಕೇವಲ ಬಳಸಬಹುದಾದ, ಕುಂಟ ಭಾಷೆಯಲ್ಲಿ ಅತ್ಯುತ್ತಮ ಸಮಾನಾಂತರತೆಯನ್ನು ಹೊಂದಿದ್ದೀರಿ.

ಮತ್ತೊಂದು creaking ಸಮಸ್ಯೆಯೆಂದರೆ ಗೋ ಒಂದು ಕಾರ್ಯವಿಧಾನದ ಭಾಷೆ (C ಯ ಮೂಕ ಭಯಾನಕತೆಯಂತೆ). ನೀವು ಪುರಾತನ ಮತ್ತು ಹಳೆಯದು ಎಂದು ಭಾವಿಸುವ ಕಾರ್ಯವಿಧಾನದ ಶೈಲಿಯಲ್ಲಿ ಕೋಡ್ ಬರೆಯುವುದನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತೀರಿ. ಆಬ್ಜೆಕ್ಟ್ ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಿಲ್ವರ್ ಬುಲೆಟ್ ಅಲ್ಲ ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ, ಆದರೆ ವಿವರಗಳನ್ನು ಪ್ರಕಾರಗಳಾಗಿ ಅಮೂರ್ತಗೊಳಿಸಲು ಮತ್ತು ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಒದಗಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ನಿಮ್ಮ ಸ್ವಂತ ಲಾಭಕ್ಕಾಗಿ ಸರಳತೆ

ಗೋವನ್ನು ಸರಳವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಅದು ಆ ಗುರಿಯಲ್ಲಿ ಯಶಸ್ವಿಯಾಗುತ್ತದೆ. ಹಳೆಯ ಭಾಷೆಯನ್ನು ಟೆಂಪ್ಲೇಟ್ ಆಗಿ ಬಳಸಿಕೊಂಡು ದುರ್ಬಲ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗಾಗಿ ಇದನ್ನು ಬರೆಯಲಾಗಿದೆ. ಸರಳವಾದ ಕೆಲಸಗಳನ್ನು ಮಾಡಲು ಇದು ಸರಳವಾದ ಸಾಧನಗಳೊಂದಿಗೆ ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ. ಇದು ಓದಲು ಸುಲಭ ಮತ್ತು ಬಳಸಲು ಸುಲಭವಾಗಿದೆ.

ಇದು ಅತ್ಯಂತ ಮೌಖಿಕ, ಪ್ರಭಾವಶಾಲಿಯಲ್ಲ ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗೆ ಕೆಟ್ಟದ್ದಾಗಿದೆ.

ಸಪಾಕ್ಸಿ ಮರ್ಸಿನ್ವಾಲ್ಡ್ ಸಂಪಾದನೆಗಳಿಗಾಗಿ

ಮೂಲ: www.habr.com