Обновить
-28
Beduin@beduin01read⁠-⁠only

Пользователь

Отправить сообщение

Как я понимаю блокчейн не панацея и есть другие технологии. Процитирую то что нашел про ту же IOTA:
"The IOTA Tangle is a quantum-secure Directed Acyclic Graph (DAG), with a fixed token supply with zero inflationary cost ...IOTA has no separation between users and validators; rather, validation is an intrinsic property of using the ledger, thus avoiding centralization"
Кто в теме пожалуйста объясните что это за штука и чем от блокчейна отличается.

На сколько удобно в GraphQL с реляционными БД работать?

Очень советую всем попробовать http://pijul.com/
Куда проще и логичнее чем GIT который у меня ничего кроме неприязни не вызывает.

Очень интересно будущее FireFox в контексте движка Servo на Rust. Падание FireFox будет серьезным ударом по Rust и куче сил вложенных в Servo.

Так же авторы языка делали Go для мелких утилит в 100-150 строк кода, поэтому Go в больших проектах это в первую очередь геморрой т.к. он не позволяет делать элементарные абстракции и обобщения.


Даже Python на фоне Go смотрится куда более продуманным и совершенным языком.

Я еще раз сделаю акцент на том, что Go подходит для создание кучи легковесных потоков, но совершенно не подходит для обработки данных (хотя если упороться можно хоть числодробилку на PHP написать).


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))
}

Тоже самое на D. В которому впрочем поддержка этих же легковесных потоков тоже есть.


import std.stdio;
import std.algorithm;

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

Судя по тому что рассказывают докладчики у Go есть только одно преимущество, можно легко и быстро создавать кучу легковесных потоков. В остальном не язык, а один сплошной архаизм поощряющий костылестроение в попытках обойти его конструктивные недостатки.

Процесс концентрации научного капитала необратим. Все разговоры про "отечественное" это чистой воды профанация. Говорю как человек работавшей в одной крупной гос-конторе и участвовавший в распилах десятков миллионов рублей.


Просто никому не нужно менять текущую систему. Любая борьба с коррупцией и бюрократией — это подрыв текущего государственного строя.


Недавно звали на работу в одну контору по разработке еще одного отечественного Linux. Там просто стыд. За три года работ не было сделано ничего кроме заключения контракта с минобороны.


На 100% уверен в то, что тут будет тоже самое.


Пока у власти сапоги и (почти) военная диктатура никакой науки в России не будет. Но в условиях современных тенденций не исключаю вариант и того, что самой России лет через 5 уже не будет.

Попробуйте D. Он объективно получше Go будет.

На старые браузеры можно и нужно класть болт. Доля IE около 5% вместе с Edge. А вот процент людей с плохим зрением или ограниченными возможностями куда выше. Позаботьтесь лучше о них, а не о тех кто не может нормальный браузер себе поставить.

Шикарно! Планируете ли вы коммерческое применение получившихся результатов? Если да, то какое? Будете ли предлагать результаты работы компаниям которые занимаются ДЗЗ?

D мне кажется все таки по духу ближе к c++
D проще C#. C# сложным языком не считается.

Микросервисы они на то и микросервисы, что там кодовая база сотни строк т.е. их легко можно будет переписать на другой язык.


Да и ближайшей замены go не видно в его нише простого языка для сетевых сервисов.
Как минимум D и Nim

Go типичный хайп, растет так же быстро как и будет падать.
Хорошо. Назовите мне три любых преимуществ Go перед D.

Такие примеры часто встречаются в академической среде, но не в практической разработке
Если писать только Hello World'ы то да, а если выполнять минимальную работу с данными, то возможность делать обобщения это это не просто здорово, а неимоверно круто. Код — не самоцель. Чем меньше кода, тем лучше. Куча народу пишет на Python потому что он позволяет коротко и компактно выражать мысли и вопрощать идеи, а не тратить время на борьбу с языком.

У Go нет ни единого реального преимущества перед D, кроме поддержки Google. Если вы планируете писать проекты в 100-150 строк кода, то возможно Go и будет хорошим вариантом, но вот когда проект начнет расти вы от простыней кода будете сходить с ума. Тем более синтаксис D куда привычнее для программистов на Си-подобных языках чем Go-шный.

Почему выбор остановился на Go, а не на 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))
}

D:


import std.stdio;
import std.algorithm;

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

На удивление D в два раза короче, а код на Go чистой воды лапша.


Или вот парсинг аргументов командной строки:


Go:


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)
}

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 улучшать бесполезно, его проще закопать.

Хотите что-то среднее между Rust и Go берите D. Он куда приятнее и проще чем Go и Rust.
Зачем что-то транслировать в Си если можно транслировать или в WASM или в какой нить IR/IL?

Информация

В рейтинге
Не участвует
Откуда
Москва, Москва и Московская обл., Россия
Дата рождения
Зарегистрирован
Активность