Язык Bosque — новый язык программирования от Microsoft

    Буквально несколько дней назад компания Microsoft представила публике новый язык программирования. Языку дали название Bosque. Главная миссия дизайна языка — лучше быть богатым и здоровым, чем бедным и больным чтобы он был прост и понятен как для человека, так и для компьютера.



    Информации пока что очень мало, язык еще очень свежий и нестабильный. Есть лишь paper от Марка Марона и дока в начальной стадии написания.


    Давайте попробуем рассмотреть некоторые особенности языка.


    1) Все значения в Bosque являются неизменяемыми (immutable), чтобы каждый блок кода не содержал никаких сайд-эффектов. По мнению авторов языка это полезно как для человека, так и для компьютера.


    При этом, как ни странно, чуть далее по тексту рассказывается, что можно объявить изменяемую переменную ключевым словом var!. И это не просто сахар для более удобной инициализации иммутабельной переменной, это действительно настоящая переменная.


    Ладно, допустим, это некий компромисс, и в локальном скоупе так сделали. Но дальше идет упоминание о еще не реализованной фиче языка — передаче аргументов функции по ссылке


    function internString(ref env: Map<String, Int>, str: String): Int {
        if(env.has(str)) {              //use the ref parameter
            return env.get(str);
        }
    
        env = env.add(str, env.size()); //update the ref parameter
        return env.size();
    }

    Может я чего-то не понимаю, но странная какая-то иммутабельность в языке, если мы можем передать Map по ссылке, и фунция ее намутирует.


    2) В языке нет циклов for, while и т.д. Вообще никаких нет. Вместо этого есть коллекции и пайплайны. Другими словами, вместо циклов нужно использовать более высокоуровневые штуки типа map, filter и т.д.


    3) Строки можно делать разных типов. Т.е., например, можно сделать строку-имя или строку-zipcode, и для type-чекера это будут две разные строки. Если вы в аргументе функции ожидаете zipcode, а вам по ошибке туда пихают имя, то компилятор это не проглотит. Синтаксис такой: String[Zipcode].


    Тоже сомнительная штука, почему не просто ZipCode. Один раз объявить, что ZipCode — это строка и везде в сигнатурах это писать. И почему именно для строк эта типизация сделана, а не для интов, например.


    4) Вызов функций можно делать с указанием названия аргументов из сигнатуры функции, например: myfunc(x=1, y=2)


    5) В стандартной библиотеке есть различные коллекции, и с коллекциями можно работать по разному. Можно просто по цепочке вызывать map, потом filter и т.д., а можно работать через пайплайны.


    var v: List[Int?] = List@{1, 2, none, 4};
    
    //Chained - List@{1, 4, 16}
    v->filter(fn(x) => x != none)->map[Int](fn(x) => x*x)
    
    //Piped none filter - List@{1, 4, 16}
    v |> filter(fn(x) => x != none) |> map[Int](fn(x) => x*x)
    
    //Piped with noneable filter - List@{1, 4, 16}
    v |??> map[Int](fn(x) => x*x)
    
    //Piped with none to result - List@{1, 4, none, 16}
    v |?> map[Int](fn(x) => x*x)

    6) рекурсия считается злом, которое может усложнить программу, поэтому рекурсивные фунции надо помечать словом rec


    7) программы на Bosque являются детерминированными. Другими словами в языке нет неопределенного поведения. Например, нельзя использовать переменные, пока они не были определены; алгоритмы сортировки только стабильные и т.д. Если программа выдала какой-то результат, то такой же результат будет и потом, никаких сюрпризов


    8) Вместо классов и интерфейсов в языке есть понятия entity и concept.


    concept Bar {
        field f: Int;
    }
    
    entity Baz provides Bar {
        field g: Int;
        field h: Bool = true;
    }
    
    var y = Baz@{f=1, g=2, h=false}; //Create a Baz entity with the given field values
    var x = Baz@{f=1, g=2};          //Create a Baz entity with default value for h

    Пример кода


    Вот крестики-нолики на Boscque
    //-------------------------------------------------------------------------------------------------------
    // Copyright (C) Microsoft. All rights reserved.
    // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
    //-------------------------------------------------------------------------------------------------------
    
    //
    //This is a bosque test/benchmark for a tic-tac-toe program.
    //
    
    namespace NSMain;
    
    entity Board {
        const playerX: String[PlayerMark] = 'x'#PlayerMark;
        const playerO: String[PlayerMark] = 'o'#PlayerMark;
    
        const allCellPositions: List[[Int, Int]] = List[[Int, Int]]@{
            @[ 0, 0 ], @[ 1, 0 ], @[ 2, 0 ],
            @[ 0, 1 ], @[ 1, 1 ], @[ 2, 1 ],
            @[ 0, 2 ], @[ 1, 2 ], @[ 2, 2 ]
        };
    
        const winPositionOptions: List[List[[Int, Int]]] = List[List[[Int, Int]]]@{
            List[[Int, Int]]@{ @[ 0, 0 ], @[ 0, 1 ], @[ 0, 2 ] },
            List[[Int, Int]]@{ @[ 0, 1 ], @[ 1, 1 ], @[ 2, 1 ] },
            List[[Int, Int]]@{ @[ 0, 2 ], @[ 1, 2 ], @[ 2, 2 ] },
    
            List[[Int, Int]]@{ @[ 0, 0 ], @[ 1, 0 ], @[ 2, 0 ] },
            List[[Int, Int]]@{ @[ 1, 0 ], @[ 1, 1 ], @[ 1, 2 ] },
            List[[Int, Int]]@{ @[ 2, 0 ], @[ 2, 1 ], @[ 2, 2 ] },
    
            List[[Int, Int]]@{ @[ 0, 0 ], @[ 1, 1 ], @[ 2, 2 ] },
            List[[Int, Int]]@{ @[ 0, 2 ], @[ 1, 1 ], @[ 2, 0 ] }
        };
    
        //Board is a list of marks, indexed by x,y coords from upper left 0 based
        field cells: List[String[PlayerMark]?];
    
        factory static createInitialBoard(): { cells: List[String[PlayerMark]?] } {
            return @{ cells=List[String[PlayerMark]?]::createOfSize(9, none) };
        }
    
        method getOpenCells(): List[[Int, Int]] {
            return Board::allCellPositions->filter(fn(pos: [Int, Int]): Bool => {
                return !this->isCellOccupied(pos[0], pos[1]);
            });
        }
    
        method getCellContents(x: Int, y: Int): String[PlayerMark]? 
            requires 0 <= x && x < 3 && 0 <= y && y < 3;
        {
            return this.cells->at(x + y * 3);
        }
    
        method isCellOccupied(x: Int, y: Int): Bool {
            return this->getCellContents(x, y) != none;
        }
    
        method isCellOccupiedWith(x: Int, y: Int, mark: String[PlayerMark]): Bool 
            requires mark == Board::playerX || mark == Board::playerO; 
        {
            return this->getCellContents(x, y) == mark;
        }
    
        method markCellWith(x: Int, y: Int, mark: String[PlayerMark]): Board 
            requires mark == Board::playerX || mark == Board::playerO;
            requires 0 <= x && x < 3 && 0 <= y && y < 3;
            requires !this->isCellOccupied(x, y);
        {
            return this<~(cells=this.cells->set(x + y * 3, mark));
        }
    
        hidden method checkSingleWinOption(opt: List[[Int, Int]], mark: String[PlayerMark]): Bool {
            return opt->all(fn(entry: [Int, Int]): Bool => this->isCellOccupiedWith(entry[0], entry[1], mark));
        }
    
        hidden method checkSingleWinner(mark: String[PlayerMark]): Bool {
            return Board::winPositionOptions->any(fn(opt: List[[Int, Int]]): Bool => this->checkSingleWinOption(opt, mark));
        }
    
        method checkForWinner(): String[PlayerMark]? {
            if(this->checkSingleWinner(Board::playerX)) {
                return Board::playerX;
            }
            elif(this->checkSingleWinner(Board::playerO)) {
                return Board::playerO;
            }
            else {
                return none;
            }
        }
    }
    
    entity Game {
        field winner: String[PlayerMark]? = none;
        field board: Board = Board@createInitialBoard();
    
        method hasWinner(): Bool {
            return this.winner != none;
        }
    
        method getWinner(): String[PlayerMark] 
            requires this->hasWinner();
        {
            return this.winner->as[String[PlayerMark]]();
        }
    
        method makeAutoMove(mark: String[PlayerMark], rnd: Int): Game
            requires !this->hasWinner();
        {
            var! nboard: Board;
            if(!this.board->isCellOccupied(1, 1)) {
                nboard = this.board->markCellWith(1, 1, mark);
            }
            else {
                var opts = this.board->getOpenCells();
                var tup = opts->uniform(rnd);
                nboard = this.board->markCellWith(...tup, mark);
            }
    
            return this<~( board=nboard, winner=nboard->checkForWinner() );
        }
    
        method makeExplicitMove(x: Int, y: Int, mark: String[PlayerMark]): Game 
            requires !this.board->isCellOccupied(x, y);
        {
            var nboard = this.board->markCellWith(x, y, mark);
            return this<~( board=nboard, winner=nboard->checkForWinner() );
        }
    }
    
    entity PlayerMark provides Parsable {
        field mark: String;
    
        override static tryParse(str: String): PlayerMark | None {
            return (str == "x" || str == "o") ? PlayerMark@{ mark=str } : none;
        }
    }
    
    entrypoint function main(): Game {
        var! game = Game@{};
    
        game = game->makeAutoMove(Board::playerX, 0);
        game = game->makeAutoMove(Board::playerO, 1);
        game = game->makeAutoMove(Board::playerX, 2);
    
        game = game->makeExplicitMove(2, 0, Board::playerO);
        game = game->makeExplicitMove(2, 1, Board::playerX);
    
        return game;
    }

    Итого


    В общем, желаю языку удачи, конечно, но пока что Bosque выглядит странновато и сыровато. Скорее proof of concept. Причем, не совсем ясно, что именно является киллер-фичей. Документация порождает больше вопросов, чем ответов.


    Компилятор для Bosque написан на Typescript, а не на самом языке, как это принято (например, компилятор Typescript написан на Typescript). Т.е. язык, скорее всего, еще недостаточно развит для написания более менее сложных программ.


    В ближайшем выпуске подкаста "Цинковый прод" мы обязательно обсудим новый язык Bosque, возможно удастся собрать побольше информации. Так что не забудьте подписаться.

    Support the author
    Share post

    Similar posts

    Comments 297

      +4
      Может мне кто нибудь объяснить, почему компилятор для яп пишется на том же яп? На сколько я знаю, первый компилятор для TS был написан не на TS, и был написан только с одной целью — скомпилировать компилятор на TS. Так вот — это делается по идеологическим причинам или по каким то другим?
        +12
        Во-первых, это традиция. Во-вторых, на новом языке нужно что-то написать, какую-то реальную программу, чтобы отладить все нюансы. Можно выдумывать абстрактную программу в вакууме, а можно начать с реальной — с компилятора.
        Но вообще, конечно, это необязательно для языка. Просто хорошая традиция
          0
          Если это традиция, то где же компиляторы (или хотя бы интерпретаторы) Perl на Perl, PHP на PHP, Ruby на Ruby или Python на Python?

          Чтобы отладить все нюансы есть достаточно реальных задач кроме собственно компилятора, в то время как написание компилятора не обязательно затронет все нюансы которые нужно отлаживать, но вот времени займёт просто уйму (особенно если язык сильно отличается от того на котором пишут первый компилятор).

          Задачи, к тому же, необязательно должны быть такими сложными во время разработки языка — к примеру, для отладки рекурсии хватит чисел Фибоначчи, для отладки многопоточности или асинхронной обработки — web-client/server.

          Но разумеется, если у разработчиков свободного времени вайлом — тогда да, почему бы и нет, собственно, пишут же эмулятор Z80 на bash
            +7
            Ну, есть PyPy, есть PHPPHP.

            Для интерпретируемых языков больше характерна реализация на более низкоуровневом языке (C или C++, как правило). Или наличие трансляторов в C/Javascript.
              +1
              Так вы перечислили не компилируемые ЯП, если что. Они не самые быстрые, потому интерпретатор, как по мне, на том же языке писать — профита мало Да, за остальных не скажу, но есть у Питона — PyPy, можете почитать, ради интереса
                +3
                Компилятор Perl6 написан на нем же.
                  +4
                  Компилятор Python на Python, это уже упомянутый PyPy, который помимо того что следует традиции, ещё и предоставляет jit-оптимизации, и ускоряет программу в несколько раз.
                    +3

                    Формально, PyPy — это не компилятор Python на Python.


                    PyPy — это реализация интерпретатора Python на подмножестве языка RPython (валидный код на Python не обязательно является валидным для RPython).


                    Сам PyPy написан на RPython, который уже является компилируемым языком. Но при этом компилятор RPython уже по большей части написан на Python.

                      +10
                      Картинка просто напрашивается:

                        0
                        Про «курицу или яйцо» как-то попроще было :\
                    +1
                    <шутка>а вы не задумывались над тем что эти люди просто научились писать в совершенстве компиляторы и больше не с чем заморачиваться не хотят <\шутка>
                      –1
                      PHP поэтому и остался ограниченным языком для интернета. Компилируемые программы на нём никто не пишет. Питон тоже крайне медленный язык(правда есть быстрые реализации, но всё же). Так что ваше примеры только подтверждают правило, что нет полноценных языков, которые себя компилировать не могут.
                      0
                      Компилятор — программа переводящая нечто написанное на неком языке в форму пригодную для исполнения на неком устройстве.

                      — Машина работает с маш. кодами операций и аргументами в виде ячеек памяти и регистров.
                      — Асемблер даёт имена маш. кодам и регистрам, делая их человекочитаемыми и наворачивает немного синтаксического сахара по оформлению операций. Но всё это приводимо к маш. кодам практически 1:1
                      — С и иные системные языки — реализуют некоторые базовые конструкции алгоритмизации в своём синтаксисе, а также организуют среду программирования, состоящую из процедур и методов их написания. Что-то из данных процедур можно написать на асемблере и, используя соглашение о вызове процедур, внести её в среду программирования.
                      И так далее. То есть язык более высокого уровня добавляет некоторое количество абстракций над языком более низкого, которые в основном представляют из себя просто часто повторяемые конструкции нижележащего языка приятно оформленные в некоторый синтаксис. Когда компилятор языка пишется на самом компилируемом языке возникает ощущение, что языка в этом месте быть и не должно. Возможно нужно спуститься ниже и переписать язык более низкого уровня. Компилятор может частично быть написан на своём языке, но ядро компилятора должно быть написано на языке, в который данный компилятор программу и перегоняет… По другому смысла в компиляторе не видно.

                      И вообще это языковое безумие заставляет всё чаще вспоминать историю о Вавилонской башне если честно…
                        +1
                        Компилятор — программа переводящая...
                        Если говорить только о самом переводе в исполнимую форму, без уточнения момента перевода, то есть более обобщающий термин — транслятор.
                        А уже в зависимости от того, выполняется ли трансляция целиком всей программы до выполнения, или по кусочку во время исполнения — получаем деление на компиляторы и интерпретаторы.
                          0

                          Грань становится тоньше, когда вспоминаем про JIT-компиляторы, которые могут также по кусочкам в рантайме программу компилировать

                            0
                            скорее, не тоньше, а размытее.
                          –1
                          И вообще это языковое безумие заставляет всё чаще вспоминать историю о Вавилонской башне если честно

                          Вот дозахватят нас роботы, тогда и bip bop bop bop bop bip bip bip bip bip bip bip bop bop bop bop bip bip bip bip bip bop bip bop bop bop bop bip bip bop bop bip bip bip bop bop bop bop bip bip bip bip bip bop bip bop bop bop bop bip bip bop bop bip bop bip bop bop bop bop bip bip bip bip bip bop bip bop bop bop bip bop bop bop bop bop bop bip bop bop bop bop bip bip bip bop bop bop bip bop bop bop bop bip bip bip bip bop bop

                            +3

                            А если будет восстание обезьян, тогда что? Ook! Ook.?

                              0
                              Если и есть к этому предпосылки, то не в нашей вселенной.
                                0
                                Я бы не был так уверен

                                  0
                                  Ну да. Если посадить миллион обезьян за пишущие машинки, то рано или поздно одна из них выиграет президентские выборы?
                                    +1
                                    рано или поздно одна из них выиграет президентские выборы?
                                    Пишущие машинки для этого совершенно излишни.
                          +1

                          "Традиция" — это довольно сырой аргумент. Нужно понимать, что такие вещи делаются чтобы деньги зарабатывать напрямую, либо использовать наработки в других местах. Это ведь не Вася из 9 класса, который написал свой первый парсер и "потому что так принято" делать никто не будет.


                          Раскрутка компилятора позволяет разработчикам на языке, для которого создается компилятор, этот язык и развивать. Достаточно прагматичная цель, интуитивно выглядит разумным, что разработчики, которым что-то нужно от языка, будут охотнее в него вносить изменения и им не нужно будет вникать в особенности низкоуровневой разработки на втором языке (на котором написан компилятор).
                          Окружение уже развёрнуто, знай себе только патчи отправляй.


                          Правда, если язык незрелый — для него нет никаких инструментов. Для TS куча линтеров-чекеров, поддержка в редакторах, миллиарды статей и много разработчиков, поэтому в данном случае от этого нет никаких преимуществ.


                          Вполне возможно, что через год-полтора сам язык торжественно передадут в сообщество (читай: забьют на разработку), а наиболее интересные решения войдут в TypeScript.

                          +2
                          Еще два плюса:
                          • Разработчики языка сами пишут на нём — хорошо для понимания проблем и развития языка.
                          • Пользователям проще участвовать в разработке и в крайнем случае смотреть на детали реализации.


                          Пример когда другой язык реализации мешает — Java. Отчасти поэтому сейчас есть проект VM на самой Java — GraalVM.
                            +3
                            Это называется «dogfooding».
                            В том смысле, что разработчики должны сами есть ту «собачью еду» что производят, чтоб лучше понимать какова она на вкус.
                              +1

                              Наверное все же "dogfooding"

                                0
                                Да, конечно! Спасибо, исправил.
                              • UFO just landed and posted this here
                                +5
                                Смотрите, вот файл из недр компилятора TypeScript github.com/Microsoft/TypeScript/blob/master/src/compiler/checker.ts 1.8 Мегабайта (!) одним куском. И его нельзя отрефакторить, потому что был использован module pattern который применяется в JS но абсолютно не имеет никакого смысла в TypeScript. И этот паттерн не расширяем. В итоге мы имеем 32К строк в одном файле? И 2624 вхождения слово function (из них большинство это действительно функции, а не комменты) И 462 стрелочных функции. И он растёт, и будет расти. Ещё в 2017 году я предпринимал попытки автоматизированными средствами это отрефакторить github.com/Microsoft/TypeScript/issues/17861 Ввиду нехватки времени на разработку предложенное решение имеет недостатки и проваливает производительность (я там бинжу все функции, а это не требуется в общем случае, но правильный детектор этого писать лень).

                                Так вот, новые ЯП как правило нужны для введения и демонстрации новых техник программирования, ЯП никто не релизит ради синтаксиса. И есть концепция en.wikipedia.org/wiki/Eating_your_own_dog_food которая говорит что нужно использовать свой продукт. И вот вы как разработчик языка начинаете на нём писать его — же. Понимать как на самом деле работает то что вы придумали. В случае в TS изначальная архитектура пришла из старых JS подходов, и она откровенная слаба в TS мире. Вот поэтому я считаю что нужно писать ЯП на нём самом, не если это не DSL какой-нибудь.
                                  0
                                  А почему этот модуль нельзя разбить на несколько модулей поменьше + ещё один модуль который импортирует все функции из этих «чанков» и реэкспортирует их всех в виде неймспейса ts.
                                    0
                                    Потому что в данном случае у этих функций огромный общий шареный стейт, что должно бы было быть свойствами объекта. Вот его часть
                                    Вот его кусок, но это не всё
                                     const compilerOptions = host.getCompilerOptions();
                                            const languageVersion = getEmitScriptTarget(compilerOptions);
                                            const moduleKind = getEmitModuleKind(compilerOptions);
                                            const allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions);
                                            const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
                                            const strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
                                            const strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
                                            const strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
                                            const noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
                                            const noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
                                            const keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
                                            const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : ObjectFlags.FreshLiteral;
                                    
                                            const emitResolver = createResolver();
                                            const nodeBuilder = createNodeBuilder();
                                    
                                            const globals = createSymbolTable();
                                            const undefinedSymbol = createSymbol(SymbolFlags.Property, "undefined" as __String);


                                    И эти константы замыкаются и юзаются из кучи функций, отдаются колбеки и тп. Чтобы разделить стейт, грамотно его пробросить и всё такое нужно огромное количество усилий. И я вижу только два пути, автоматом конвертнуть типа как я предлагал и потом начать разводить по наследованию, и второе, сказать что у нас теперь есть новый компилятор tsc 2.0 и в нём написать всё это заново с новой архитектурой. Пока же эта штука продолжает расти.
                                      0
                                      Что если все эти зависимости перенести в один объект. Вроде:

                                      const context = {
                                          compilerOptions: host.getCompilerOptions(),
                                          languageVersion: getEmitScriptTarget(compilerOptions),
                                          moduleKind: getEmitModuleKind(compilerOptions),
                                          // ...


                                      Во всем коде использовать этот объект как Service Locator, а потом начать передавать всем, кто его хочет как зависимость?
                                        0
                                        Так я и делал в своём рефакторинге, я в том случае все свойства на this навесил и все методы пробиндил. И это даже тесты прошло полностью. Проблема в том что код стал ещё хуже и просел перформанс. А руками это сделать можно, ничего кроме объёма работы не мешает. Но сейчас никто не готов столько работы пожертвовать.
                                  0
                                  Основная причина, имхо, в том, что невозможно оценить пригодность и эффективность языка, не написав на нем хотя бы одну сложную программу. Сделать минимальный bootstrapping на другом языке, чтобы сразу писать основной код компилятора языка на нем же самом — это одновременно красивый ход для инженеров и эффективный для бизнеса.

                                  Кроме того, усовершенствование компилятора (добавление новых оптимизаций и проверок) помогает улучшать его собственную работу.
                                    0
                                    Это делается в том числе и для доказательства того, что язык тьюринг-полный.
                                      0
                                      Не сказал бы. Тьюринг полноты не достаточно для удобного программирования, и в то же время есть много не тьюринг полных DSL которые удобны. Как пример тьюринг полнота системы типов typescript github.com/Microsoft/TypeScript/issues/14833 вот ещё посмотрите ru.wikipedia.org/wiki/Тьюринговская_трясина
                                        0

                                        Вроде был язык, в котором только 3 функции, первая печатает "Hello world", вторая выводит текст программы, а третья генерирует компилятор этого языка. Так что возможность написать компилятор языка на самом языке не является доказательством полноты по Тьюрингу.

                                          0
                                            0
                                            только без генерации компилятора.
                                        +1
                                        Вот пишете вы на каком-то языке, растёте и в какой-то момент хотите в нем что-то улучшить/пофиксить и опа — оказывается что ваш 20 летний опыт разработки на этом языке тут не поможет, надо пойти ботанить какой-то другой язык на котором написан компилятор.
                                          +1
                                          Ну справедливости ради стоит сказать что ооочень часто средний разработчик решает задачи кратно проще чем разработка компилятора, и идея просто зайти, почитать и поправить компилятор для внесения своих фич обычно идеей и остаётся, не зависимо от того, на каком языке это написано.
                                            0
                                            Очевидно, что это не для средних, но кто-то должен развивать язык и понятно что это должны делать те, кто им пользуются, а раз пользуются, то скилы других языков теряются в связи с ненадобностью.
                                          0
                                          Это называется Bootstrapping.
                                          +9
                                          Как можно создавать язык программирования, не написав к нему документацию? Это уже не первый случай. Сначала накодят что-то, а потом задним числом сочиняют спецификацию.
                                            +2
                                            А почему нет? Вполне может быть что авторы ещё не представляют себе что там должно быть, как оно должно работать или вообще ещё не определились чего хотят, вот и эксперементируют, заодно собирая мнения и идеи.

                                            Разница только в том что кто-то это делает публично, а кто-то «тайно» — в первом случае об отсутствии спецификации в начале разработки известно всем, а во втором об этом может никто и не узнать (поскольку её выложат вместе с языком) — хотя принципиальной разницы нет.

                                            В конце концов, это ж не мостостроение, где опасно начинать строить пока нет проекта и расчётов, особенно с учётом того что нигде в продакшн это не используется.
                                              +1
                                              Встречный вопрос: какой смысл писать документацию к проекту в экспериментальной стадии, когда основные фичи еще обкатываются?
                                                0
                                                Сначала накодят что-то, а потом задним числом сочиняют спецификацию

                                                Называется Agile. И внезапно это удобно и эффективно, хотя и не везде.
                                                0

                                                Не в том ли идея чтобы он сразу мог бы параллелится?

                                                  0
                                                  Для упрощения этой задачи тут только иммутабельность, что само по себе не гарантирует хорошего паралеллизма.
                                                    0
                                                    Ну если нет циклов и идет работа со множествами то это напоминает SQL, который как раз располагает к паралеллизму…
                                                      0
                                                      Всё-таки давайте не будем смешивать в кучу язык общего назначения и SQL.

                                                      Кстати, fun fact: Я был так много наслышан о том, как Хаскелл хорошо параллелится, ещё когда начал учить первый язык, что когда я схватился за Хаскелл, был поражён, что параллелить надо через монаду, что накладывает не одно ограничение на мой код, т.к. я ещё не понял их и трансформеры. Итог: не один десяток малых параллельных проектов на С++ и ни одного на Хаскелле.

                                                      Вот тебе и «easy parallelism by design».
                                                      • UFO just landed and posted this here
                                                          0
                                                          А оператор `par` уже устарел?
                                                            0
                                                            Это и есть монада

                                                            Ничего не устарело, просто я открыл для себя с изучением Хаскеля, что недостаточно просто «сказать» программе, что я хочу её раскидать на десять кластеров, а надо-таки раскидывать этот лёгкий-для-параллелизма из коробки по парам и секам.

                                                            Написать-то можно, если задаться, но к многопоточности приходишь, как набираешься чуть опыта и видишь, где от неё профит словить.
                                                              0
                                                              Нет, это не монада.
                                                                0
                                                                Благодарю, загуглил сигнатуру, был сбит с толку другим результатом гугла.
                                                                0

                                                                Точно также в сиквеле, надо сразу думать множествами, а не мыслить "так, берем один элемент, проверяем..."

                                                              0

                                                              Зачем там монады, если можно практически любой map заменить не думая на parMap rdeepseq?


                                                              Есть, конечно, и монада Par, но она для чуть более сложных задач.

                                                        +2
                                                        если мы можем передать Map по ссылке, и фунция ее намутирует.

                                                        Не зная как устроена Map, это сложно понять. Не исключено, что в Map метод добавления элемента генерит новый Map просто (как в Scala).
                                                          +35
                                                          Делаем простой и понятный язык для человека, поэтому добавляем побольше разномастных скобочек, стрелочек, знаков, двоеточий, точку с запятой в конце! *картинка с изображенеим genius*
                                                            +17
                                                            Да-да. На первый взгляд новый язык по читаемости может поспорить с Perl, J и триграфами C++.

                                                            Мне кажется, я даже мгновенно перестал ненавидеть JavaScript после того как увидел это. Серьёзно, ещё пол-часа назад я хотел любыми силами избежать JavaScript в моей жизни, а сейчас JavaScript уже не кажется чем-то сильно плохим.
                                                              0
                                                              Наверно, для этого и создан новый язык, чтобы программеры понимали, что все не так плохо))) Это, конечно, шутка.)
                                                              +1
                                                              Как вам удобнее читать формулировки теорем — в кванторах или в словах?
                                                                +11
                                                                Слабая и неуместная аналогия. Мне удобен код с синтаксисом, который вызывает минимальную когнитивную нагрузку — моя голова и так будет загружена при чтении/написании кода. Здесь синтаксис, похоже, впитал всё самое жуткое из мира c/c++, так ещё и сверху присыпал от себя.
                                                                  +1
                                                                  Если я правильно понял ваш первый комментарий, вы затронули сразу две темы — и визуальный шум, как точки с запятой, и специальные конструкции, как стрелочки. Насчёт шума я вас полностью поддерживаю. Но я хотел узнать именно про второе. Меня удивляет, что есть люди, предпочитающие писать «function», а не "=>". Пытаюсь понять причину.
                                                                    +2
                                                                    Не, стрелочка в определении лямбд у меня нареканий не вызывает — это уже устоявшийся вариант.
                                                                    Я про другое. Если взглянуть на этот код, то можно увидеть следующие «интересности»:
                                                                    1) в классе (который назвали entity) есть const поля, а есть field. Казалось бы и то, и другое — поля класса, но к первым в коде обращаются через явное указание типа и двоеточия (Board::playerX), а ко второму через точку и this (this.cells). Нужно ли было делать такую разницу для данных в одной области видения?
                                                                    2) стрелочка используется и для вызова методов класса, и для пайпинга. Нет, конечно, можно подвести эти вещи под один знаменатель, если представить что каждый метод неявно принимает параметр this (вроде того, как это сделано в Питоне). Но нужно ли?
                                                                    3) потом мы видим, что через двоеточия мы по сути можем обращаемся к статическим const полям (game = game->makeAutoMove(Board::playerX, 0);). При этом само поле не помечено как static, хотя спецификатор этот есть (factory static createInitialBoard()). Кстати к этому статичному фабричному методу мы обращаемся уже через указание класса и собаку (field board: Board = Board@createInitialBoard();). Зачем надо было делать такое различие — не ясно.

                                                                    Да, может всему этому есть объяснение и сложно судить по куску кода о языке. Но серьёзно, как отметили выше, ощущение такое, что ребята просто на ходу сочиняют разрозненные куски, а потом под это подведут кривую спецификацию. В то время как лучше было бы начать с другого конца.
                                                                      0
                                                                      Мне удобнее. Потому что function сразу бросается в глаза (особенно с подсветкой современных редакторов), заставляя заострить на этом куске кода внимание. "=>" же беглым взглядом вообще мало отличимо от оператора присваивания.
                                                                      Ну и вот, например, тут достаточно о разнице между function и "=>". Помимо того факта, что для этих стрелочек обычно надо ещё какой-нибудь Babel городить.
                                                                        +1
                                                                        Там ровно два различия: свой this и свой arguments. Но если функции нужен свой this — то это никакая не функция, а метод; а для методов в свежем стандарте есть свой синтаксис. С arguments же всё ещё проще: надо перестать их использовать.
                                                                          0
                                                                          (особенно с подсветкой современных редакторов),

                                                                          Скорее в древних блокнотах. Современный редактор умеет в семантическую подсветку. А подсветка уровня кейвордов — это про древний блокнот.

                                                                          Соответственно — function является лишним синтаксическим шумом, т.е. редактор умеет красить функции в уникальный цвет. И современно без разницы какие они.
                                                                            0
                                                                            sublime — это древний блокнот?
                                                                              0
                                                                              А почему нет?
                                                                                0
                                                                                Я ведь дал критерии. Может отличать функции от не-функций в каком-нибудь С++ — не блокнот и не древний. Не может? Блокнот. Да и судя по википедии оно и позиционируется как блокнот.
                                                                          0
                                                                          >> впитал всё самое жуткое из мира c/c++
                                                                          Что конкретно?
                                                                          0
                                                                          На словах или в коде (в добавку к формулам). Очень часто тривиальные для понимания вещи прячут за вырвиглазными формулами с кучей нечитаемых переменных (речь про статьи по cs если что).
                                                                            +1
                                                                            Вероятно, люди деляться на тех, кому проще в кванторы, и тех, кому проще в слова. И это очень странно. Потому что смысл абсолютно одинаковый, но короткие специализированные знаки должны считываться и обрабатываться мозгом быстрее. Возможно, что вы недостаточно выработали навык их чтения. Но я встречал других людей, кто предпочитает естественный язык специализированному.
                                                                        +4

                                                                        Зачем?

                                                                          +1
                                                                          Это управленческий паттерн «незаменимая команда». Когда команда, разрабатывающая один из ключевых продуктов компании, переводит его на специально ими выдуманную технологию — новый язык программирования, принципиально новую СУБД с ни с чем не совместимым языком запросов, пишет с нуля новую ОС, на которой будет крутиться сервер продукта, ну и т.д.
                                                                          В итоге команда, которой удалось реализовать этот паттерн, надолго становится незаменимой — их становится очень сложно уволить, не завалив разрабатываемый продукт, потому что спецов по новой технологии в ближайшее десятилетие будет исчезающе мало.
                                                                          Именно поэтому программистам очень выгодно реализовывать этот паттерн. А вот для менеджера, допустившего такое, например переписывание половины браузера на принципиально новый язык — признак профнепригодности, особенно когда компания испытывает финансовые трудности.
                                                                            +1
                                                                            Это да, но самые упоротые — это «независимые консультанты». Во времена оны приходилось сталкиваться с персонажем, предлагавшим оптимизацию программ для (внимание!) «полного соответствия Ruby-way». Что самое удивительное — его даже кто-то нанимал…
                                                                            0
                                                                            У всех остальных языков есть Фатальный© Недостаток™.
                                                                            +22
                                                                            Теперь мало того, что вместо вставления кода текстом — он вставлен картинками. Так мы теперь ещё и второй раз обливаем читателя дерьмом, используя для этого вместо моноширинного шрифта совершенно нечитабельный serif и блюрим картинку:



                                                                            Давайте вы её еще под углом сделаете и мигающей, вдруг ещё остались люди, которым удобно читать это уг?

                                                                            EDIT: Оказалось, что блурилось из-за масштабирования в браузере, но это всё-равно камень в огород автору статьи
                                                                              0
                                                                              По идее если подсветить код как JavaScript — должно быть неплохо
                                                                              function internString(ref env: Map<String, Int>, str: String): Int {
                                                                                  if(env.has(str)) {              //use the ref parameter
                                                                                      return env.get(str);
                                                                                  }
                                                                              
                                                                                  env = env.add(str, env.size()); //update the ref parameter
                                                                                  return env.size();
                                                                              }
                                                                                –5
                                                                                единственное место, где я нашел подсвеченный код — это pdf файл. Какой там шрифт есть, такой и есть.

                                                                                Можно разве что побольше сделать картинку, чтобы читалось получше
                                                                                  –5
                                                                                  в общем, я сделал шрифт побольше, но хабр зачем-то искажает размер картинки, поэтому замыленность всё равно есть
                                                                                    +1
                                                                                    А если просто переписать код его вроде немного? Ду ну бред какой-то.
                                                                                      +1
                                                                                      И вручную раскрасить? Или оставить равномерно чёрным, чтобы плевались теперь на это?
                                                                                        +1
                                                                                        Как выше уже продемонстрировали можно включить подсветку js, а так да, текст всегда лучше чем картинка с текстом, ну если только ты не капитан джек воробей.
                                                                                +8
                                                                                Это явно не язык, который ставит задачу завоевать рынок или даже быть примененным в продакшене. Это исследовательский проект, чтобы найти новое направление развития языков программирования. Тут, похоже, под ясностью и для человека, и для машины понимается создание практичного для обычного человека языка, который может формальную верификацию. Мое беглое чтение примеров формального доказательства алгоритмов на специализированных языках повергло меня в ужас как-то давно, так что смысл в этом видится вполне.
                                                                                  +2
                                                                                  Вот вот. Среднему индусу в MS такое не осилисть.
                                                                                    +4
                                                                                    Не осилить такое почти никому, почему формальную верификацию на практике практически нигде не видно. А то, что видно, лишь небольшие кусочки и алгоритмы. В основном максимум это статические анализаторы кода и здоровенные сборники правил как писать на каком-нить С. Даже там, где от корректности кода зависят жизни людей.
                                                                                    +3
                                                                                    Так себе язык для формальной верификации, имхо. Ну, такое сугубо любительское имхо любителя поидрисировать на выходных.
                                                                                      +1
                                                                                      И чего в нем такого нового? Исследовательского?
                                                                                      +12
                                                                                      Языки все больше становятся похожи на какие то клиновидные записи или древнеегипетские иероглифы ('x'#PlayerMark, =>, <~, Board::playerO, @, |>, |< и т.д. и т.п. в самых неожиданных местах) и не понятно зачем вместо превычного слова «class» и «struct» или «record», которые уже не одно десятилетие в других языках применяются, выдумывать что то новое. Вместо function вставили method, тогда вместо if нужно было еще что нибудь придумать, а еще лучше вообще язык поменять на русский, была бы еще одна 1С, только в функциональном стиле.
                                                                                        +2
                                                                                        Вместо function вставили method

                                                                                        Я так понял, что это означает, что функция виртуальная. Или нет?
                                                                                          0
                                                                                          Ну в каком-то языке программирования (JS?) это может и так, но концептуально-то разница меду функцией и методом не такая. Лучше уж сделали бы как в С++ (virtual/override) или как в джаве — где всё виртуальное (зачем нужны невиртулаьные методы? — хороший вопрос для собеседования!)
                                                                                            –1
                                                                                            Ответ: для того, чтобы всех запутать и после cast вызывался другой метод.
                                                                                            Адепты С++ ответят, что тем самым экономят место в виртуальной таблице вызовов.
                                                                                              0

                                                                                              Адепты C++ ответят, что тем самым, во-первых, легко получить классы без виртуальных методов вообще (что экономит место в лейауте класса и приводит к прочим приятным результатам на тему тривиальности типов), а, во-вторых, они облегчают работу девиртуализатору и инлайнеру (нечего девиртуализировать, если методы не виртуальные).

                                                                                          0
                                                                                          Языки все больше становятся похожи на какие то клиновидные записи или древнеегипетские иероглифы

                                                                                          Ну почти все языки полны всяких «иероглифов», в заблуждение они вводят разве что новичков, со временем они запоминаются и проблем с их пониманием нет, конечно если не городить всяких заумных конструкций. Есть другая крайность — когда язык очень похож на естественный, как например SQL или COBOL, читать вербозный код не очень-то легко, а писать на таком языке вообще мрак и уныние.

                                                                                          вместо if нужно было еще что нибудь придумать

                                                                                          Ага, как в Red, if с одной ветвью, either — с двумя.
                                                                                            0
                                                                                            if с одной ветвью, either — с двумя.

                                                                                            Хм, на первый взгляд крутая идея
                                                                                            +1
                                                                                            > тогда вместо if нужно было еще что нибудь придумать
                                                                                            whatever(false condition)
                                                                                              +1
                                                                                              а еще лучше вообще язык поменять на русский

                                                                                              Тсс, тихо! А то ещё призовёте дьявола в 1С 8.4 в виде:

                                                                                              #РасходнаяНакладная↑Conclude(СуммаСовсемБез НДС).Подобно()
                                                                                                0
                                                                                                «Подобно» или все же «Подробно»?
                                                                                                  0

                                                                                                  А мне интересно что такое Conclude и почему не на русском? Внешняя команда или…?

                                                                                                    +1
                                                                                                    Именно Подобно, этакий LIKE от отечественного производителя.
                                                                                                  0
                                                                                                  Нужен язык на кане. Код как искусство.

                                                                                                  Ну или прямо иероглифами. Ёмкость потрясающая получится.
                                                                                                  +6
                                                                                                  программы на Bosque являются детерминированными… Если программа выдала какой-то результат, то такой же результат будет и потом, никаких сюрпризов


                                                                                                  Вот эта формулировка меня очень и очень смущает. То есть… скажем, если программа использует БПСЧ… или обращается к жесткому диску / сетевому адресу… результатом будет синий экран?

                                                                                                  Или вот это:
                                                                                                  алгоритмы сортировки только стабильные


                                                                                                  под стабильными, наверное, понимаются устойчивые алгоритмы? А если я напишу на Bosque алгоритм Шелла (неустойчивый) — будет исключение рантайм? Ошибка компиляции?

                                                                                                  Поясните, пожалуйста. Взрывает мозг…

                                                                                                    +1
                                                                                                    Дословно в документации так:

                                                                                                    Thus, Bosque does not have any undefined behavior such as allowing uninitialized variable reads and eliminates all under defined behavior as well including sorting stability and all associative collections (sets and maps) have a fixed and stable enumeration order.

                                                                                                    As a result of these design choices there is always a single unique and canonical result for any Bosque program. This means that developers will never see intermittent production failures or flaky unit-tests!

                                                                                                    Больше информации нет никакой.

                                                                                                    Возможно, я что-то не так понял. Готов исправить статью
                                                                                                      +4
                                                                                                      Почитайте про «неопределённое поведение». Например в Си, порядок некоторых операций не определён в стандарте и разные компиляторы выдают разный результат в таких случаях.
                                                                                                        –7
                                                                                                        Авторам языка придется определить все возможные сочетания операций и выражений при всех возможных условиях. Флаг им в руки, так сказать…
                                                                                                          0
                                                                                                          Но это же в любом случае приходится делать авторам компиляторов.
                                                                                                          Хотя бы простые и общие правила не помешали бы, почему-то есть языки, где это сделано.
                                                                                                            +2
                                                                                                            Нет. Отсутствие UB можно доказывать индуктивно и, как следствие, линейно или квадратично по числу правил вывода типов (см. Featherweight Java, например).
                                                                                                            +1
                                                                                                            Вот если появится вторая реализация, появятся и UB.
                                                                                                              +1
                                                                                                              UB может появляться и без второй реализации.
                                                                                                          0
                                                                                                          Непонятно, какие преимущество у этого ЯП по сравнению с другими? Тем же С++.
                                                                                                          Вот мне нужен ЯП, смесь из ассемблера(доступ к флагам и регистрам процессора), С и С++(классы, виртуальные функции) и при этом достаточно простой. Думаю развивать идею ассемблера MASM'а(UASM), кодогенерирующие макросы .if, .while, .for, и т.п.
                                                                                                          А по этому ЯП(назовём его Боська), в упор не вижу каких либо достоинств. Да, у меня память не очень хорошая, и очень не хочется её перегружать лишней инфой, изучая кучу очень сложных ЯП. Надо проще делать, чтобы простой как Lua и достаточно функциональный как С++.
                                                                                                            +1
                                                                                                            КО подсказывает, что в С/С++-программы можно делать ассемблерные вставки, использовать intrinsics или линковать к ним модули на ассемблере.
                                                                                                              0
                                                                                                              назовём его Боська

                                                                                                              Назовём его Босх.

                                                                                                                0
                                                                                                                Уже есть такой язык — Паскаль. И прост(не зря школьникам преподают) и функционален.
                                                                                                                –1
                                                                                                                del
                                                                                                                  +2
                                                                                                                  В статье почему-то не упомянуто, что это от команды MS Research. Т.е. пока просто какой-то эксперимент. Что-то попробовать и посмотреть, что из этого может получиться.
                                                                                                                  Поэтому, обсуждать можно какие-то моменты, с учетом того, что все может поменяться раз и на 180. А может и вообще сгинуть. Или какие-то фичи где-то прикрутят.
                                                                                                                  А так-то чего бы не написать в заголовке «MS представил общественности убйцу C#»
                                                                                                                    –4
                                                                                                                    И что, что от MS Research? Понятно, что не от MS Office. И в заголовке, кстати, нет ровно никакой желтизны.

                                                                                                                    Поясните свою мысль.
                                                                                                                      +1
                                                                                                                      Ну от MS Research или от MS Developer Division — огромная разница.
                                                                                                                      Желтизна сегодня — она именно такая. Написать абсолютную правду, но так, чтобы сформировать ложное впечатление. «Новый язык от Microsoft» — это явно про какой-то продукт, который распространяет компания Microsoft. Не эксперимент в Research, а конкретный продукт с поддержкой в Visual Studio.
                                                                                                                        –3
                                                                                                                        Я не в курсе про MS Developer Division и т.д. Поэтому и попросил пояснить мысль.
                                                                                                                          +1

                                                                                                                          Так может быть вам как автору новости стоило бы всё выяснить, прежде чем торопиться писать?)

                                                                                                                            –3
                                                                                                                            Выяснить всю структуру Microsoft?
                                                                                                                            Если бы я знал о таких нюансах, я бы конечно выяснил.
                                                                                                                              0
                                                                                                                              Хотя бы выяснить, что такое Microsoft Research, и какими проектами они занимаются? Тяп-ляп и в продакшен, да?
                                                                                                                                –3

                                                                                                                                Самоутверждаетесь в комментариях, да?

                                                                                                                                0
                                                                                                                                В readme репозитория, на который вы даёте ссылку в начале «статьи», как раз и говорится, что язык Bosque это проект Microsoft Research и приводится ссылка на него. «Выяснить структуру Microsoft» не обязательно — вся информация не дальше первых ссылок поисковой выдачи. Это не так уж и сложно, если решили выложить некий обзор. Абзац с подведением итогов говорит о том, что вы действительно не разобрались что этот проект ни что иное как PoC.
                                                                                                                      +6

                                                                                                                      Выглядит как первоапрельская шутка.

                                                                                                                        +1
                                                                                                                        «Весь апрель — никому не верь!»
                                                                                                                          +2
                                                                                                                          А я думал я один трижды проверил дату пока дочитал пост
                                                                                                                          +2
                                                                                                                          Главная миссия дизайна языка — чтобы он был прост и понятен как для человека, так и для компьютера.

                                                                                                                          Взаимоисключающие параграфы? Языки программирования созданы так, чтобы быть понятными человеку. Для компьютера лучше всего понятен ассемблер.


                                                                                                                          рекурсия считается злом, которое может усложнить программу, поэтому рекурсивные фунции надо помечать словом rec

                                                                                                                          Почему? Многие алгоритмы наоборот в рекурсивном виде выглядят просто и естественно. А нерекурсивный вариант выглядит куда более громоздко.


                                                                                                                          А как нужно помечать потенциально рекурсивные функции, т.е. такие, которые могут вызывать сами себя, но опосредованно?


                                                                                                                          программы на Bosque являются детерминированными. Другими словами в языке нет неопределенного поведения. Например, нельзя использовать переменные, пока они не были определены; алгоритмы сортировки только стабильные и т.д.

                                                                                                                          Какие-нибудь современные языки являются недетерминированными? Вспоминается только C++. Записывать это в плюсы — все равно что писать, что в языке можно использовать не латинские идентификаторы.


                                                                                                                          Если программа выдала какой-то результат, то такой же результат будет и потом, никаких сюрпризов

                                                                                                                          Что это за чушь вообще. А что если используется функция генерации случайных чисел?


                                                                                                                          Также хочется задать авторам вопрос: чем их не устроил собственный же язык F#?

                                                                                                                            0
                                                                                                                            Также хочется задать авторам вопрос: чем их не устроил собственный же язык F#?
                                                                                                                            NIH в масштабе локальной команды?
                                                                                                                              0
                                                                                                                              Для компьютера лучше всего понятен ассемблер.

                                                                                                                              Программа на машинном языке тогда уже. Программа на мнемокодах (языки ассемблера) — тоже понятнее для человека.
                                                                                                                                0
                                                                                                                                чем их не устроил собственный же язык F#?

                                                                                                                                Тоже возник такой вопрос. А вообще лучше бы они Nemerle поддержали.

                                                                                                                                  0
                                                                                                                                  " чем их не устроил собственный же язык F#" Это теперь у всех такое поветрие — яростно пропихивать свою поделку, потом сами же забрасывать. Как ябочники вместо C++ зачем-то пропихивал objective-c, потом сами же его и забросили.
                                                                                                                                    0
                                                                                                                                    F# слишком сложен, он вдвое сложнее C#, а С# сам по себе непрост, у МС нет собственного простого языка (VB.NET не в счёт) а-ля Python/Go/PHP. Нужен простой, чтобы его можно было в школах преподавать.
                                                                                                                                      +1

                                                                                                                                      Извиняюсь за занудство, но как вы определили, что именно вдвое, а не в полтора раза и не в пять раз?

                                                                                                                                        0
                                                                                                                                        Видимо, .net имеет такую же сложность, как и функциональный стиль, соответственно, их сочетание сложность удваивает.
                                                                                                                                          –1
                                                                                                                                          Так же, как я определяю, что одна книга вдвое толще другой: по количеству нового материала. Книга F# for fun and profit имеет аж 1930 страниц! F# может почти всё, что может С# плюс вдвое больше. Учитывая, что помимо самого языка нужно еще изучить функциональную парадигму программирования, привыкнуть к новому синтаксису, получается не проще, чем еще раз прочесть книгу по С# + GoF. Понятное дело, что инженеры, научные работники, а так же школьники, студенты, хипстеры и стартаперы не являются целевой аудиторий F#.
                                                                                                                                          • UFO just landed and posted this here
                                                                                                                                              0
                                                                                                                                              F# гибридный язык, так что рискнувшему его изучить придется «запачкать ноги».
                                                                                                                                                0
                                                                                                                                                Я как-то случайно наблюдал, как человек (причём совершенно не технарь) первым языком учил JS… В общем, было видно, что equational reasoning человеку куда ближе и милее, чем вся ОО или вообще императивная парадигма.
                                                                                                                                                  0
                                                                                                                                                  а кто-то вообще с релейных диаграмм
                                                                                                                                          0
                                                                                                                                          Я не понял, сперва говорится об иммутабельных значениях, а потом о возможности объявления мутабельных переменных. Так что всё-таки иммутабельно, значения или переменные?

                                                                                                                                          Вместо классов и интерфейсов в языке есть понятия entity и concept.

                                                                                                                                          Но это те же интерфейсы и классы, просто названы по-другому.
                                                                                                                                            0
                                                                                                                                            В такой формулировке это звучит как утверждение, что присвоить переменной новое значение можно, а вот никакой внутренней мутабельности уже нет — если нужно заменить значение поля в объекте, изволь менять весь объект, как-то так…
                                                                                                                                            –2
                                                                                                                                            Главная миссия дизайна языка — лучше быть богатым и здоровым, чем бедным и больным чтобы он был прост и понятен как для человека, так и для компьютера

                                                                                                                                            Какая же инновационная идея появилась у Microsoft, никто до этого раньше даже и не додумывался.
                                                                                                                                              +1

                                                                                                                                              M$ изобрели Erlang только TypeScript

                                                                                                                                                0
                                                                                                                                                Пока это всего лишь эксперимент, и, возможно, этот проект ждёт та же печальная судьба, что и Code Contracts.
                                                                                                                                                  +1
                                                                                                                                                  Че-то я не осознал цели этого творения. Если крупная компания выводит на общее обозрение нечто, пусть и не в форме релиза, но под своим именем, она чего-то ждет. Языки имеют специализацию. А тут я че-то ничего внятного не нашел.
                                                                                                                                                  Хотя… возможно, это очередная попытка от MS создать Java.
                                                                                                                                                    0
                                                                                                                                                    А зачем MS создавать еще один Java?

                                                                                                                                                    Разве MS не создала свое виденье Java создав C#?
                                                                                                                                                      –10
                                                                                                                                                      Именно. И проект, в общем-то оказался провальным. Можно сколько угодно обсуждать спешность шарпа, но его удел оказался корпоративные решения. А прибитость его к .net вообще не ясна, потому, что никакой крос-платформенности он не дает. В общем, как по мне, так акая-то хрень вышла. Как и VB до этого. Который MS сует куда не попадя, даже в свои браузеры совала. Сравнивать его с Java язык не поворачивается.
                                                                                                                                                        +5
                                                                                                                                                        корпоративные решения… никакой крос-платформенности

                                                                                                                                                        Вы что-нибудь слышали про Unity?
                                                                                                                                                          0
                                                                                                                                                          А прибитость его к .net вообще не ясна, потому, что никакой крос-платформенности он не дает.


                                                                                                                                                          Я просто оставлю это здесь
                                                                                                                                                          image
                                                                                                                                                            0
                                                                                                                                                            Я тоже, просто оставлю это тут.
                                                                                                                                                            Несмотря на существование Mono, C# тесно привязывает разработчиков к платформе Microsoft (включая ОС, офисные решения). Таким образом, пользователь программного обеспечения, написанного на .NET, часто не имеет выбора в использовании различных компонент системы. Это приводит к так называемому vendor-locking, при котором производитель стороннего ПО может диктовать покупателю практически любые условия на поддержку внедрённого проекта. В то время, как пользователь приложения Java, как правило, может сам выбрать поставщика дополнительного ПО (такого, как БД, ОС, сервера приложений и т. д.).


                                                                                                                                                            Это указано на вики. И копипастю сюда не как пруф, а как текс с которым Я согласен. И имею то же мнение.

                                                                                                                                                            К кросплатформенности я отношу не просто исполнение кода на чем-то ином, а развитую экосистему продукта, адаптированную под платформу. MS же тянет все свое с собой. И… пфффф… Ну и повторюсь еще раз — это лишь мое мнение.
                                                                                                                                                              +3
                                                                                                                                                              С такой точки зрения java такой же vendor-lock, т.к. стандартное явление видеть программистов, которые живут энтерпразйным java стеком и всю жизнь за его пределы не вылазят, что их даже на работу не взять себе для чего-то другого.

                                                                                                                                                              А в общем, вы процитировали глупость, с которой согласны лишь потому, что не имеете представления о ситуации так же как ее не имеет автор этого опуса. Кроме этого вашего mono вообще-то есть .net core.
                                                                                                                                                                +1
                                                                                                                                                                это лишь мое мнение.

                                                                                                                                                                Оно какими-нибудь фактами подкреплено? На прошлых двух работах писал на дотнете совсем не под windows — мобильная разработка на Xamarin(Android, iOS) и тяжелый бэк на .NET Core(Linux) — есть вполне конкретные контрпримеры к утверждению, что оно прибито к MS-экосистеме / кроссплатформенность недостаточного качества для энтерпрайза.


                                                                                                                                                                К кросплатформенности я отношу не просто исполнение кода на чем-то ином, а развитую экосистему продукта, адаптированную под платформу. MS же тянет все свое с собой

                                                                                                                                                                nuget? Если взять топ-100 пакетов оттуда по популярности(не стал проверять дальше), все они работают на *nix без проблем.

                                                                                                                                                                  –2
                                                                                                                                                                  Мне́ние — понятие о чём-либо, убеждение, суждение, заключение, вывод, точка зрения или заявление на тему, в которой невозможно достичь полной объективности, основанное на интерпретации фактов и эмоционального отношения к ним.

                                                                                                                                                                  Подкреплено личным опытом, в период с момента его первого релиза до 2014г.
                                                                                                                                                                    0
                                                                                                                                                                    Подкреплено личным опытом, в период с момента его первого релиза до 2014г.


                                                                                                                                                                    Слушайте, ну вы вроде как тим лид, да еще и с таким большим опытом работы с .net. Кому как не вам понимать что за 5 лет в современной индустрии меняется вообще все и ваш опыт .net пятилетней давности имеет мало общего с тем что мы имеем в 2019 году.
                                                                                                                                                                      0

                                                                                                                                                                      Или… или как тимлид с некоторым опытом, который наблюдал многострадания MS подвинуть Java, а еще и Delphi (че к нему то привязались, вообще не ясно) одним махом. При этом, завезя все, что было в VB и прибив гвоздями к своему любимому OLE. Наблюдая конвульсии шарпа с первой презентации (с криками — долой самодержавие Java!) до отказа от всех внедрений на нем в крупных компаниях и переход на Oracle.
                                                                                                                                                                      Я таки (за 10 лет) сложил свое мнение и об языке и о его перспективах и сделал свой выбор, в свое время. И ни разу о нем не пожалел.


                                                                                                                                                                      Вот как завезут .net на хотя бы 30% устройств как предустановленную машину, так и поговорим. А то в свое время визгу было, что мир теперь изменится, про java забудут и везде будет .net. А я как отъехал от MS так за все время, даже случайно не встретил .net на чем-то отличном от винды.

                                                                                                                                                                        +1
                                                                                                                                                                        До наступления эпохи смартфонов .net как раз и был предустановлен более чем на 30% устройств.

                                                                                                                                                                        А на смартфонах предустановленный .net и не нужен: mono прекрасно распространяется вместе с приложением.
                                                                                                                                                                          –2
                                                                                                                                                                          До наступление эпохи смартфонов была эпоха динозавров, когда ничто кроме MS не было. Даже на IE 6.0 VB работал как скриптовый язык. И MS пыталась «подскочить» в уезжающий без нее поезд компактных устройств. Напомню, что MS запилила WinCE и WindowsMobile где .net устанавливалась. Ну и где оно? Это невмеру прогрессивное архитектурное и инженерное решение?

                                                                                                                                                                          Ровно также, как только появилась Java, тут же скукожилось и съехало в небытие. Причем скукоживаться начало уже тогда, когда простые мидлеты появились на простых телефонах. Заметьте не .net, а Java машина туда ставилась. Почему бы?

                                                                                                                                                                          С выходом первого андройда WindowsMobile был приговорен. Вялые попытки что-то там пропихнуть через покупку Nokia увенчались тоже полным крахом. Сейчас MS приторговывает… Nokia 3110 (или какого они там мамонта возродили) в оригинальном исполнении. Смешно? По мне так очень.

                                                                                                                                                                          А на смартфонах предустановленный .net и не нужен: mono прекрасно распространяется вместе с приложением.


                                                                                                                                                                          Возможно. Только приложения такие никому не нужны. В лес со своими дровами…
                                                                                                                                                                          +3
                                                                                                                                                                          Реальная ситуация здесь:
                                                                                                                                                                          Developer Survey Results 2019
                                                                                                                                                                            0
                                                                                                                                                                            Занимательная ссылка (y)
                                                                                                                                                                              0
                                                                                                                                                                              Вот такую еще динамику нашел. Собственно, наглядно описывает все, что я выше излагал — linkedin
                                                                                                                                                                        0
                                                                                                                                                                        и тяжелый бэк на .NET Core(Linux)

                                                                                                                                                                        Не вброса ради а любопытства для: в качестве ОС для разработчика на этом проекте вы использовали Windows или таки Linux?
                                                                                                                                                                          0

                                                                                                                                                                          Windows — до VS кроссплатформенным IDE не дотянуться ещё.


                                                                                                                                                                          IIRC, ни в Rider, ни в VSCode, ни даже в Monodevelop a.k.a Xamarin Studio a.k.a VS for Mac нет edit-and-continue до сих пор.

                                                                                                                                                                  +3
                                                                                                                                                                  В общем, как по мне, так акая-то хрень вышла.

                                                                                                                                                                  Какая-то аргументированная критика C# в сравнении с Java у вас есть?
                                                                                                                                                                  Именно. И проект, в общем-то оказался провальным.

                                                                                                                                                                  С вашей стороны весьма глупо называть провальным язык, который уже давно занял неплохую долю в своей нише и очень крупное сообщество.
                                                                                                                                                                    +2
                                                                                                                                                                    Какая-то аргументированная критика C# в сравнении с Java у вас есть?
                                                                                                                                                                    Лично я скажу, что в Шарпах в сравнении с Джавами просто прекрасные Дженерики
                                                                                                                                                                      0

                                                                                                                                                                      А в чем отличие, можете в двух словах рассказать?

                                                                                                                                                                        +1
                                                                                                                                                                        var text  = GetComponent<Text>();
                                                                                                                                                                        var image = GetComponent<Image>();
                                                                                                                                                                        

                                                                                                                                                                        В Java невозможно так сделать — информация о дженериках теряется на этапе компиляции и этот код скомпилируется во что-то такое:
                                                                                                                                                                        Text  text  = GetComponent();
                                                                                                                                                                        Image image = GetComponent();
                                                                                                                                                                        

                                                                                                                                                                        Естественно, работать не будет. В Шарпах информация о типах сохраняется и её можно использовать не только как подсказки, но и в коде.
                                                                                                                                                                          +1

                                                                                                                                                                          Вот это как раз без особых проблем работает, просто вместо угловых скобок надо использовать class:


                                                                                                                                                                          Text text = GetComponent(Text.class);
                                                                                                                                                                          Image image = GetComponent(Image.class);
                                                                                                                                                                            +1
                                                                                                                                                                            Да я понимаю, что можно без этого. В Go вон вообще без дженериков обходятся как-то. Просто это менее удобно.
                                                                                                                                                                              0
                                                                                                                                                                              Тут всего-то на 4 символа больше писать надо, это совсем не то же самое что и «без дженериков». Если сравнивать с тем как в Java «реализованы» свойства — то эти 4 символа и вовсе незаметны.
                                                                                                                                                                                +1
                                                                                                                                                                                Мне оно не шибко нравится не по количеству символов, а по сути.
                                                                                                                                                                                Да и это не единственный пример, где то, что дженерики пропадают на этапе компиляции — мешает
                                                                                                                                                                          +1
                                                                                                                                                                          В том, что они не пропадают во время исполнения. Отсюда два следствия:

                                                                                                                                                                          1. статические поля и методы также могут использовать типы-параметры;
                                                                                                                                                                          2. можно без хитрых извращений и без тонн автогенерированного кода взять и использовать контейнер, параметризованный примитивным типом.
                                                                                                                                                                            0
                                                                                                                                                                            2. Вы о том, что в Java список может принимать только Boxed Integer, но не примитивный int?
                                                                                                                                                                              +1
                                                                                                                                                                              Ага, именно об этом. Соответственно, или мириться с постоянными упаковками, которые никакой Escape analysis не уберёт по построению — или использовать отдельный интерфейс и отдельную реализацию для списка чисел.
                                                                                                                                                                        –4
                                                                                                                                                                        Вы мне еще мнение запретите высказывать :))) Смешно.
                                                                                                                                                                  +2
                                                                                                                                                                  Похоже на тестовый полигон, на котором будут обкатывать будущие фичи для других языков.
                                                                                                                                                                    +6
                                                                                                                                                                    String[ZipCode]

                                                                                                                                                                    Чего только люди ни придумают лишь бы не делать алгебраические типы…


                                                                                                                                                                    Вообще конечно выглядит пока сомнительно. Особенно комбинация заявленной иммутабельности с ref — то ли авторы сами толком не определились, чего они хотят от языка, то ли не очень понимают, что immutability это совсем не то, что делает const в javascript. Вообще изрядно отдаёт какой-то фиксацией на javascript-е. Как будто авторы даже с наработками "родного" майкрософтовского F# не вполне знакомы, хотя пайп |> явно оттуда потянули.

                                                                                                                                                                      +2
                                                                                                                                                                      Хм, а мне понравился отказ от циклов в пользу перебирающих методов. Ведь при работе с коллекциями обычно требуется их отфильтровать либо агрегировать. Школьные задачки типа «посчитать количество чётных чисел в массиве, стоящих на нечётных местах» в расчёт не берём — задача синтетическая и рассчитана как раз на понимание циклов.
                                                                                                                                                                        +1
                                                                                                                                                                        А у меня довольно часто встречаются задачи, в которых простейший цикл выглядит проще чем комбинация фильтров. Как правило, это задачи вида map + filter + map, где из первого map нужно «прокинуть» в последний исходный объект, который при этом совершенно не нужен в фильтре. Особенно плохо всё становится, когда в ходе изменения требований необходимость этого объекта в конце цепочки то появляется, то исчезает.
                                                                                                                                                                          +2
                                                                                                                                                                          К слову, один из таких случаев — когда последний map должен знать номера объектов в исходном (неотфильтрованном) списке.
                                                                                                                                                                            +1

                                                                                                                                                                            Ну вообще говоря можно сначала отобразить объект в пару (объект, индекс) и потом делать всё остальное. В идеале компилятор может всю цепочку вызовов превратить в обычный цикл, но на практике, кмк, такого ещё нет.

                                                                                                                                                                              0
                                                                                                                                                                              Так об этом и речь: object -> {map} -> (object, index) -> {filter} -> (object, index) -> {map} -> object_processed_with_index.
                                                                                                                                                                                0
                                                                                                                                                                                Тогда начать можно со списка индексов, хотя это выглядит не вполне красиво. Я так делал с GUAVA c использованием Lists.transform(new AbstractList(){...}, ...).
                                                                                                                                                                                0
                                                                                                                                                                                Ну я тоже так делаю, но мне это напоминает «строительство клозуры (=замыкания) вручную». Не особо элегантно.
                                                                                                                                                                            0

                                                                                                                                                                            Меня несколько смущает, что ничего не сказано про ленивость вычислений. Если уж отказываться от циклов, то это must have.

                                                                                                                                                                            –10
                                                                                                                                                                            Я тут написал статью, где были подвергнуты критике две любимые концепции нынешнего ИТ — очередь и стек.

                                                                                                                                                                            Так же была описана концепция OS BlockOut (разработанная в 1995), где все процессы организованы в сети процессов, обменивающихся сообщениями. Входами сетей являются внешние события, выходами — выходные устройства. Сети передают сообщения без буферизации, то есть размер очередит всегда == 1, соответственно, никогда нет рекурсий, то есть стек не нужен.

                                                                                                                                                                            Статья была перенесена в черновики, так как столкнулся с «хабраэффектом», а именно, травле по принципу «белая ворона» в стае чёрных. Попытки аргументированных споров были, но минимум. Большая часть аргументов была в стиле: «ты — дебил». Соответственно, всё это сопровождалось минусованием и невозможностью нормальной дискуссии по правилам размещения сообщений.

                                                                                                                                                                            Что мы видим в данном языке: та же попытка сетей процессов, обменивающихся сообщениями которые идут по каналам. То есть моя концепция 1995-го года.

                                                                                                                                                                            Далее, есть ещё одна тема, которая вызовет у любителей современного состояния ИТ страшное раздражение. На эту тему я ещё статей не писал. Это необходимость исключения высокоуровнего императивного программирования и тотальный переход на декларативное. Только эта парадигма позволит нормализовать ситуацию с качеством ПО, так как даст возможность создавать программы, которые позволяют проверку на корректность и смогут избегать дурацких ошибок императивного стиля. Так же, несомненно, это позволит как автоматизировать производство ПО, так и повысить продуктивность разработки.

                                                                                                                                                                            Дак вот, этот язык — попытка добавить декларативности в программирование. Эти самые пайплайны — это и есть декларативность низкого уровня, то есть с довольно простыми алгоритмами в виде замены циклов. Ты описываешь структуру обработки, а система программирования сама подбирает как выполнять обработку, то есть оптимизировать циклы. Не радикальное улучшение, но уже что-то.

                                                                                                                                                                            Таким образом, данный язык — несомненно шаг вперёд, но, скорее всего, он далее лабораторий МС не пойдёт, как многие хорошие вещи, которые там разрабатывались, к примеру Singularity.
                                                                                                                                                                              –10
                                                                                                                                                                              Два минуса и как обычно без объяснений )) Люблю хабр! Товарищи, обосновать не хотите? Так-то это хамство. И то, что вам это позволяют авторы сайта, не означает, что вы так себя можете вести!
                                                                                                                                                                                +4
                                                                                                                                                                                Не вижу в этом языке никаких процессов и каналов. Pipe operator только называется так, а дальше коллекций дело не уходит.

                                                                                                                                                                                За процессами и каналами — в go, в Erlang, или в Java и её библиотеку Akka, или в .NET и в библиотеку Akka.NET. Но там очереди, почему-то, есть. Как и стек. Не согласна почему-то реальность с вашими фантазиями…
                                                                                                                                                                                  –6
                                                                                                                                                                                  Коллекции + map reduce хочу заметить. А этими парадигмами закрывается львиная доля задач.

                                                                                                                                                                                  Ну и насчёт реальности, вопрос времени. Когда кончатся индусы с китайцами, придётся что-то делать, чтобы создавать софт. И это точно будет не императивная парадигма.
                                                                                                                                                                                    +2
                                                                                                                                                                                    Львиная-то львиная — вот только совсем не та, для которой обычно очереди используют.
                                                                                                                                                                                      –4
                                                                                                                                                                                      У меня один простой вопрос к любителям очередей: а зачем?

                                                                                                                                                                                      Опять же практически процитирую сам себя:

                                                                                                                                                                                      Очередь — это буфер. То есть мы пихаем в буфер некие элементы в надежде на что? Я так понимаю на то, что у нас сейчас заняты некие ресурсы и мы надеемся, что они в какой-то момент освободятся и мы сумеем обработать то, что набилось в очередь.

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

                                                                                                                                                                                      На первый вопрос ответ понятен: просто не умеем нормально проектировать. В результате, к примеру, лунные модули не садятся на Луну. Но это то, что видно, а бОльшая часть косяков, связанных с неправильной оценкой производительности, не видна, так как системы не настолько критические. Единственно, что я могу признать как вариант нормального использования очереди — это выравнивание пиков нагрузки. Но тогда очереди должны быть хотя бы ограничены по ёмкости. То есть мы должны осознавать какую нагрузку мы должны принять и выравнять.

                                                                                                                                                                                      Про второй вариант ответ так же прост: мы просто сбросим содержимое очереди. Дак зачем копить очередь, занимая ресурсы, если можно сбрасывать элементы сразу? Зачем ждать, пока клавиатура запищит от переполнения буфера, если можно просто до него не доводить, а блокировать приём новых элементов?

                                                                                                                                                                                      Я, конечно, не Эйнштейн, но метод Эйнштейна весьма полезен. Нужно иногда брать аксиому и превращать её в теорему. То есть пытаться понять, а аксиома ли то, что мы считаем аксиомой. Дак вот, рассуждения об очередях и стеке — это типичный пример того, как если порассуждать об аксиомах, окажется, что они вовсе и не аксиомы.
                                                                                                                                                                                        +2
                                                                                                                                                                                        Потому что пиковая нагрузка обычно выше чем средняя.
                                                                                                                                                                                          +1

                                                                                                                                                                                          Уважаемый, вы путаетесь в показаниях.


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

                                                                                                                                                                                          Вот за этим:


                                                                                                                                                                                          Единственно, что я могу признать как вариант нормального использования очереди — это выравнивание пиков нагрузки. Но тогда очереди должны быть хотя бы ограничены по ёмкости.

                                                                                                                                                                                          С одним дополнением — вы не всегда можете так просто ограничивать очередь по емкости. У вас может быть требование от бизнеса "обработать все входящие запросы".


                                                                                                                                                                                          Во-вторых, а если мы не дождемся освобождения ресурсов, либо их таки не хватит на разгрузку очереди, то что делать?

                                                                                                                                                                                          Вы опять отвечаете на свой вопрос самостоятельно:


                                                                                                                                                                                          То есть мы должны осознавать какую нагрузку мы должны принять и выравнять.

                                                                                                                                                                                          Такие ситуации нужно отслеживать и предотвращать. Ждать когда мощностей даже с очередями не хватит — глупо. Нужно с самого начала собирать статистику нагрузки, экстраполировать тренд и масштабироваться с учетом будущей нагрузки. Если ресурсов внезапно не хватит, то это ЧП и отказ в обслуживании части клиентов.


                                                                                                                                                                                          На первый вопрос ответ понятен: просто не умеем нормально проектировать.

                                                                                                                                                                                          Если вы где-то встретили решение, которое использовало очереди не по назначению, то это проблема не "очереди", а решения.


                                                                                                                                                                                          Про второй вариант ответ так же прост: мы просто сбросим содержимое очереди.

                                                                                                                                                                                          Что вы будете делать, если у вас требование от бизнеса "обработать абсолютно все входящие сообщения"? "Просто сбросить" далеко не всегда так просто, как хотелось бы. Это вы видите запросы в очереди, а другие видят в них деньги и время.


                                                                                                                                                                                          Озвучьте, пожалуйста, аксиому, которую вы пытаетесь превратить в теорему?
                                                                                                                                                                                          Не помню, чтобы кто-то всерьез заявлял "нужно везде использовать очереди".

                                                                                                                                                                                  +3

                                                                                                                                                                                  Зачем? Функциональный, типизированный, иммутабельный, но с возможностью обойти.
                                                                                                                                                                                  Есть же F#, Clojure и Haskell (первый и третий при поддержке Microsoft)

                                                                                                                                                                                    0
                                                                                                                                                                                    Согласен с вопросом. Язык похож на F#. Там так же можно сделать многое из статьи и mutable переменные есть.
                                                                                                                                                                                    0
                                                                                                                                                                                    Почему в новых мода описывать аргументы функций как имя: тип? Чем их не устраивает обычный стиль, тип имя?
                                                                                                                                                                                      +2
                                                                                                                                                                                      Как минимум одно из обоснований — чтобы спокойно прикрутить вывод типов и не заставлять писать везде `auto` или его аналог.
                                                                                                                                                                                        0
                                                                                                                                                                                        Ни от какого auto паскаль-стиль не уходит, а наоборот требует ввод кейворда для обозначения декларации переменной. Таким образом вы всегда будите писать синтаксический мусор вместо типа. Всякие там var, let и прочее.

                                                                                                                                                                                        С типом будет ещё больше мусора, а именно let/var name: type, а не type name;
                                                                                                                                                                                          0
                                                                                                                                                                                          Go опровергает ваши утверждения.
                                                                                                                                                                                            0
                                                                                                                                                                                            Что именно он опровергает? Поподробнее. Вводом := или подобной фигни? Ну дак это не опровержение — это подтверждение, т.к. это и есть кейворд для отделения декларации от использования. К тому же, он к делу отношения не имеет, т.к. почти во всех языках используется var/let. И говорим мы о таком языке.
                                                                                                                                                                                              0
                                                                                                                                                                                              Вот именно что опровергает. := позволяет опустить var и начать объявление с идентификатора переменной. Синтаксис полностью однозначен — либо сначала идет ключевое слово, либо идентификатор. Если мы ставим первым тип, то начинаются вечные проблемы с поиском этого типа и определением вообще, что это за хрень, чтобы потом уже определять, то ли это возвращаемое значение функции, то ли это переменная или еще какая хрень.
                                                                                                                                                                                                0
                                                                                                                                                                                                Я уже объяснял — это не работает. Причин тому масса. Основная из них заключается в том, что как звучал тезис? «имя: тип что-то там позволяет». := — опровергает этот тезис, т.к. в данном случае абсолютно неважно где и как написан тип — одного «имя: тип»/«имя» недостаточно для определения переменной.

                                                                                                                                                                                                К тому же, := — является таким же кейвордом, о котором я говорил. И абсолютно неважно в каком он будет виде. Т.е. мой тезис это никак не опровергает.

                                                                                                                                                                                                К тому же, это вообще находится за рамками контекста т.к. контекстом является а) синтаксис принятый в обсуждаемом языке, б) синтаксис принятый в си.

                                                                                                                                                                                                Так же, := — избыточен для ситуаций, где тип не выводится, а задаётся. Вам придётся либо использовать избыточность, либо вводить два типа операторов, что опять же — избыточность и синтаксический мусор.

                                                                                                                                                                                                К тому же, это локальные го-заморочки не присущи ни паскалю, ни всему тому, что используется его стиль.

                                                                                                                                                                                                А так же, самое важное — это вообще никак не зависит от стиля. Это работает в любом случае. Т.е. смысла приводить это в контексте разделения стилей нет — т.к. это не относится к одному из — это относится к обоим.
                                                                                                                                                                                                  0
                                                                                                                                                                                                  Основная из них заключается в том, что как звучал тезис? «имя: тип что-то там позволяет». := — опровергает этот тезис,

                                                                                                                                                                                                  Если по сути, а не формально, то тезис звучал как «имя сначала, тип потом Vs тип сначала, имя потом». Далее спор шел о ключевом слове auto для авто-вывода против якобы необходимого var для обычного объявления. Двоеточие это только пример реализации первого подхода. Пример го показывает, как можно иметь имя сначала, не имея «синтаксического мусора» перед именем.

                                                                                                                                                                                                  У вас простое взаимное недопонимание.

                                                                                                                                                                                                    0
                                                                                                                                                                                                    Пример го показывает, как можно иметь имя сначала, не имея «синтаксического мусора» перед именем.

                                                                                                                                                                                                    Нельзя. := — это синтаксический мусор, который, к тому же, писать сложнее нежели =, либо auto.

                                                                                                                                                                                                    К тому же, как я уже говорил — мы либо вводим :=/=, либо мы имеем не только := в качестве синтаксического мусора, но и аннотацию при которой := избыточно.

                                                                                                                                                                                                    Двоеточие это только пример реализации первого подхода.

                                                                                                                                                                                                    Это так же неверно, т.к. двоеточие не имеет никакого отношения к подходу.

                                                                                                                                                                                                    Я больше скажу — в си вообще аннотация типа ненужна. Она используется только для в одном случае — определение. Да и то нужен просто какой-то флаг для выражения намерения. Подойдёт вообще что угодно. const/auto/register. Всё это уже придумано и давно. Го просто взял эту логику из си.

                                                                                                                                                                                                      0
                                                                                                                                                                                                      Нельзя. := — это синтаксический мусор, который, к тому же, писать сложнее нежели =, либо auto.

                                                                                                                                                                                                      Во-первых, не мусор, а однозначность синтаксиса как для парсера, так и для человека. Во-вторых, писать это несравнимо проще auto. В-третьих, таки ничего лишнего перед именем переменной нет.

                                                                                                                                                                                                      Подойдёт вообще что угодно. const/auto/register

                                                                                                                                                                                                      Это ли не тот синтаксический мусор. Вместо типа мы пишем вещи, которые вообще не имеют никакого отношения к делу. Модификаторы доступа и устаревшие ключевые слова, которые нынче ничего не значат.

                                                                                                                                                                                                      Го просто взял эту логику из си.

                                                                                                                                                                                                      В этом нет логики, это синтаксические извращения. В Го однозначный синтаксис, которые имеет четкие правила — либо :=, либо var. Все. Пример тут не с кого брать было.
                                                                                                                                                                                                        0
                                                                                                                                                                                                        Во-первых, не мусор, а однозначность синтаксиса как для парсера, так и для человека.

                                                                                                                                                                                                        Мусор. Вы как бот повторяете один и тот же набор шаблонных фраз.

                                                                                                                                                                                                        Во-вторых, писать это несравнимо проще auto.

                                                                                                                                                                                                        Основания этим заявлениям.

                                                                                                                                                                                                        В-третьих, таки ничего лишнего перед именем переменной нет.

                                                                                                                                                                                                        Есть после имени. До оно, либо после — это ничего не значит.

                                                                                                                                                                                                        Это ли не тот синтаксический мусор.

                                                                                                                                                                                                        Нет, вы действительно бот. Какое отношение эти рассуждения имеют к теме? Никакого. Абсолютно неважно что они значит — они значат тоже самое, что и :=, только ещё больше.

                                                                                                                                                                                                        Вместо типа мы пишем вещи, которые вообще не имеют никакого отношения к делу.

                                                                                                                                                                                                        Чушь какая. Они имеют отношения к делу и никто их вместо не пишет. Вам лишь сообщили, что подобная логика объявления без типа существовала и существует в си.

                                                                                                                                                                                                        Модификаторы доступа и устаревшие ключевые слова, которые нынче ничего не значат.

                                                                                                                                                                                                        Вы опять где-то что-то услышали и начали повторять? Ну расскажите мне про то какой бесполезный статик, либо const, либо volatile. Или это, как обычно, пустой трёп?

                                                                                                                                                                                                        В этом нет логики, это синтаксические извращения.

                                                                                                                                                                                                        Опять же, когда нечего сказать — пиши херню.

                                                                                                                                                                                                        В Го однозначный синтаксис, которые имеет четкие правила — либо :=, либо var. Все. Пример тут не с кого брать было.

                                                                                                                                                                                                        Мне надоело с ботом разговаривать.

                                                                                                                                                                                                        Хотите поиграть — хорошо, я жду эквивалента кода:

                                                                                                                                                                                                        int a;

                                                                                                                                                                                                        На го.

                                                                                                                                                                                                          –1
                                                                                                                                                                                                          я жду эквивалента кода: int a;

                                                                                                                                                                                                          Это не код, это говно (неинициализированная переменная).


                                                                                                                                                                                                          А что касается того, что опровергает Go, то Go опровеграет два ваших утверждения: 1) необходимость мусора в виде двоеточия, отделяющего имя переменной от типа, 2) необходимость мусора в виде ключевого слова типа let, var или auto.


                                                                                                                                                                                                          Двоеточие в := не является отдельным элементом/ключевым словом. Два символа := являются одним, единым оператором, поэтому никакого мусора при его использовании уже нет. (Не будете же вы настаивать, чтобы присвоение значения переменной выполнялось вообще без единого оператора?)

                                                                                                                                                                                                            0
                                                                                                                                                                                                            Это не код, это говно (неинициализированная переменная).

                                                                                                                                                                                                            Т.е. ответа нет и адепт го порвался?

                                                                                                                                                                                                            А что касается того, что опровергает Go, то Go опровеграет два ваших утверждения:

                                                                                                                                                                                                            Фантазии брызжущих слюной адептов го.

                                                                                                                                                                                                            1) необходимость мусора в виде двоеточия, отделяющего имя переменной от типа

                                                                                                                                                                                                            Я уже отвечал на эту ахинею. Эта ахинея никак не связана с темой и с моим утверждением, т.к. она применима не только к паскаль-стилю.

                                                                                                                                                                                                            Т.е. я могу использовать := в любом из стилей. Это просто сахар, костыль. Определяются переменные го не так.

                                                                                                                                                                                                            2) необходимость мусора в виде ключевого слова типа let, var или auto.

                                                                                                                                                                                                            Что за нелепая попытка врать. Читаем мой коммент:

                                                                                                                                                                                                            Ни от какого auto паскаль-стиль не уходит, а наоборот требует ввод кейворда для обозначения декларации переменной. Таким образом вы всегда будите писать синтаксический мусор вместо типа. Всякие там var, let и прочее.

                                                                                                                                                                                                            Т.е. брызжущий слюной адепт го врёт, утверждая, что говорил «необходимость мусора в виде ключевого слова типа let, var или auto.», но я приводил это лишь как пример.

                                                                                                                                                                                                            Двоеточие в := не является отдельным элементом/ключевым словом.

                                                                                                                                                                                                            Является.

                                                                                                                                                                                                            Два символа := являются одним, единым оператором, поэтому никакого мусора при его использовании уже нет.

                                                                                                                                                                                                            Два символа в if «являются одним, единым оператором». Опять методичка потекла.

                                                                                                                                                                                                            Два символа := являются одним, единым оператором, поэтому никакого мусора при его использовании уже нет.

                                                                                                                                                                                                            Он и есть мусор, т.к. есть уже оператор =. А это другой оператор, который является костылём для решения избыточности паскаль-стиля.

                                                                                                                                                                                                            (Не будете же вы настаивать, чтобы присвоение значения переменной выполнялось вообще без единого оператора?)

                                                                                                                                                                                                            Опять чушь. Именно те, кто рассказывал про «проблему auto» утверждали, что переменную можно объявлять без избыточности.

                                                                                                                                                                                                            Я же сообщил, что это неверно и нужен механизм отделения. В ситуации же си-синтаксиса механизм ненужен — он уже есть.

                                                                                                                                                                                                            В ситуации же с паскаль-синтаксисом он нужен. Это var/let и прочая фигня. Именно с var сделан ваш го. А далее закостылено := — которая является таким же механизмом, лишней сущностью она повторяет уже существующие функционал.

                                                                                                                                                                                                            Вообщем, вы, насколько я погляжу, особо вменяемостью не блещете. Спорить о чём-то с ботами бесполезно, поэтому я вернуть к сити, а именно.

                                                                                                                                                                                                            Я отвечал изначально в контексте преимущества паскаль-стиля, т.е. я это опровергал. Теперь вам нужно сообщить — каким образом := относится к паскаль-стилю? Я заранее отвечу — никаким. Новы там можете попытаться что-то придумать.

                                                                                                                                                                                                              +1
                                                                                                                                                                                                              Т.е. ответа нет

                                                                                                                                                                                                              Вы требуете перевести незаконченный кусок кода с одного ЯП на другой. Это не всегда возможно: нужен контекст, более-менее осмысленный кусок кода. Если воспринимать приведённый код как цельный, то получается переменная, которой не присваивается значение. Это бессмысленный код, переводить нечего.


                                                                                                                                                                                                              Является.

                                                                                                                                                                                                              Враньё. Ни в описании языка, ни в восприятии текста программистом двоеточие не воспринимается как отдельный элемент. Ну и уж тем более оно не является ключевым словом.


                                                                                                                                                                                                              Он и есть мусор, т.к. есть уже оператор =.

                                                                                                                                                                                                              Это не мусор. Это важный элемент, позволяющий отличать объявление новой переменной от переприсваивания. Без него читаемость программы ухудшилась бы.


                                                                                                                                                                                                              каким образом := относится к паскаль-стилю

                                                                                                                                                                                                              Речь шла о том, что новые ЯП используют "паскалевский стиль". Го — один из этих новых ЯП, и именно такой, что является контрпримером к вашим тезисам.


                                                                                                                                                                                                              А что касается преимущества, то речь шла совсем о другом: о том что "let/var" нужен в обоих вариантах, но в паскалевском стиле он используется единообразно во всех ситуациях, а в C является в некотором роде костылём, подпирающим конструкцию, из которой убрали необходимый элемент — тип обявляемой переменной.

                                                                                                                                                                                                                0
                                                                                                                                                                                                                Как я уже говорил, я не будут отвечать на догматы фантиков уровня «это не мусор — это важный элемент», «мы не воспринимает это как отдельный элемент» и прочий бред.

                                                                                                                                                                                                                о том что «let/var» нужен в обоих вариантах

                                                                                                                                                                                                                Пруфы.

                                                                                                                                                                                                                но в паскалевском стиле он используется единообразно во всех ситуациях


                                                                                                                                                                                                                var v1 int = 100
                                                                                                                                                                                                                v1 := 100

                                                                                                                                                                                                                Единообразно, да. Объясняйтесь.

                                                                                                                                                                                                                а в C является в некотором роде костылём, подпирающим конструкцию, из которой убрали необходимый элемент — тип обявляемой переменной

                                                                                                                                                                                                                Обоснования этому набору слов. Что именно является костылём, что там и где и что подпирает.

                                                                                                                                                                                                                И ответа на самое главное нет — каким образом := относится к паскаль-стилю? Это просто костыль, который можно впилить в какой угодно стиль. Причём тут паскаль-стиль? Как это выступает за паскаль-стиль, но против си-стиля?
                                                                                                                                                                                                          0
                                                                                                                                                                                                          Я даже не поверить, что я отвечаю на настолько нелепые рассуждения.

                                                                                                                                                                                                          Есть синтаксис var name type =, базовый. Данный пациент утверждает, что никакой избыточности нет. Но авторы го с ним несогласны.

                                                                                                                                                                                                          Именно поэтому вводится var (), это есть ещё со времён паскаля. Потому что все очевидно, что объявление с аннотацией через var — это избыточно. Т.е. пациент спорит с объективной реальностью.

                                                                                                                                                                                                          Аналогично с := — это синтаксический сахар, который был добавлен специально для решения проблемы var name auto =.

                                                                                                                                                                                                          Т.е. мы имеем как минимум два варианта объявления переменных, но что же там нам сообщал пациент:

                                                                                                                                                                                                          В Go объявление функции, объявления типа указателя на функцию, передача функции как объекта первого порядка — все это идентичные синтаксически вещи

                                                                                                                                                                                                          Он заявлял, что проблема С++ в том, что синтаксис разный. В целом эти базовая методичка го «делаем что-то одним способом», но.

                                                                                                                                                                                                          Как мы видим, что тут эта методичка ломается. Потому что способов как минимум 2(3). А почему? Потому что общий случай избыточен и добавлен специальный сахар для решения проблемы.

                                                                                                                                                                                                            0
                                                                                                                                                                                                            Аналогично с := — это синтаксический сахар, который был добавлен специально для решения проблемы var name auto =.

                                                                                                                                                                                                            А это (существование какой-либо проблемы с var name =) опровергает Rust, где конструкции, аналогичной := нет. Если бы упоминаемая вами проблема реально существовала, её пришлось бы решать не только в Го, но также и в Расте.

                                                                                                                                                                                                              0
                                                                                                                                                                                                              А это (существование какой-либо проблемы с var name =) опровергает Rust,

                                                                                                                                                                                                              Опять поток шизофрении. Чего он там опровергает? Там есть let, который такая же подпорка для синтаксиса. И есть избыточность let name: type, когда как в си это type name.

                                                                                                                                                                                                              Если бы упоминаемая вами проблема реально существовала, её пришлось бы решать не только в Го, но также и в Расте.

                                                                                                                                                                                                              Как же быстро лозунги меняются. То := меня опровергает, то уже меня опровергает раст.

                                                                                                                                                                                                              Каким образом из отсутствия решения следует отсутствие проблемы? Вы вообще в логику можете?
                                                                                                                                                                                                          0
                                                                                                                                                                                                          Нельзя. := — это синтаксический мусор

                                                                                                                                                                                                          Можно. Я повторю еще раз тезис, на который вы категорично ответили «нельзя»:
                                                                                                                                                                                                          можно иметь имя сначала, не имея «синтаксического мусора» перед именем.
                                                                                                                                                                                                          Вы же отвечаете на другую реплику, которую я не писал и которая звучит как «можно обойтись без синтаксического мусора».

                                                                                                                                                                                                          Это так же неверно, т.к. двоеточие не имеет никакого отношения к подходу.

                                                                                                                                                                                                          Имеет; таким образом список идентификаторов синтаксически отделяется от типа, задавая однозначную грамматику. Это нужно именно при подходе «идентификаторы перед».
                                                                                                                                                                                                            0
                                                                                                                                                                                                            Я повторю еще раз тезис, на который вы категорично ответили «нельзя»:
                                                                                                                                                                                                            можно иметь имя сначала, не имея «синтаксического мусора» перед именем.

                                                                                                                                                                                                            Мне без разницы кто там и что говорил. Я говорил а) в рамках контекста определённым начальным комментом, б) я отвечаю только за свои тезисы.

                                                                                                                                                                                                            С чего вдруг вы решили, что вы можете в любой момент подменить начальный тезис и что-то мне предъявлять? Ваши манёвры меня волнуют мало.

                                                                                                                                                                                                            Имеет; таким образом список идентификаторов синтаксически отделяется от типа,

                                                                                                                                                                                                            В го? К тому же мы говорим про двоеточие в :=, а не о том что вы там себе напридумывали. Этот костыль можно впилить в какой угодно синтаксис — хоть в си. Он вообще никак не привязан ни к чему.

                                                                                                                                                                                            +4
                                                                                                                                                                                            Обычный это как в Algol 60?
                                                                                                                                                                                              +1

                                                                                                                                                                                              Ак