Дмитpий Hecтepук

Блог о программировании — C#, F#, C++, архитектура, и многое другое

Язык программирования D

70 комментариев

У любого вменяемого программиста который сталкивается с языком программирования С++ должно рано или поздно возникать чувство отвращения и полной богозабытости. И если в случае с Java кто-то еще может поспорить что “светлое будущее впереди” (фиаско с Java 7 как бы намекает), то с С++ мне кажется определились все: и те кто недавно перешли или решили просто попробовать, и те кто с ним работают десятилетиями.

С++ устарел. Программы на С++, как бы красиво они не выглядели, не соответствуют современным реалиям. Попытки пропатчить C++ под 0x/2011 выглядят трезвыми только на фоне того, что в “плюсах” появились лямбда-выражения, а в Java 7 у Oracle нехватило силенок их сделать.

Вообще, мне по большому счету все равно. Все равно насчет Java-стека т.к. на Java я не пишу, на Scala меня не тянет (синтаксис F# на порядок лучше, имхо). С другой стороны, у меня есть небольшие “вкрапления” С++ в проекты, поэтому о них наверное стоит рассказать.

Зачем нужен С++?

Конкретно мне С++ нужен для параллелизации. Нет, поймите меня правильно, я ни в коей случае не против TPL и всяких прелестей вроде Parallel.For или AsParallel(). Более того, все что я сейчас делаю с коллекциями обычно содержит использование TPL т.к. это достаточно безопасный способ ускорить программу.

Но есть ряд областей где .Net-а мало. Возьмем например обработку изображений – даже если вы напишете обработку Bitmap’а в unsafe режиме на C#, это все равно будет существенно медленнее чем использование C++. Особенно если учесть, что в плюсах есть доступ к SSE (__mm_mul_ps и все такое). И самое главное, что манипуляций-то никаких особо не нужно, т.к. класс System.Drawing.Bitmap может выдать указатель на фиксированный блок памяти, который в последствии можно через P/Invoke передать в тело метода на C++. А дальше можно использовать все прелести OpenMP, Threading Building Blocks, а также мощный инструментарий.

Кстати о… думаю стоит пояснить, что я религиозно использую стек Intel, т.е. Intel Parallel Studio со всеми прелестями. Это важно потому что инструментарий этот достаточно хороший и много чего умеет, компилятор С++ от Microsoft в былые годы (до Intel) был ооочень слабоват – в те времена, чтобы заработали примеры из Generative Programming, нужно было использовать KAI C++, Metrowerks или еще какой-то сторонний компилятор. Мне правда повезло – на шаблонное метапрограммирование я так и не подсел, хотя идея конечно заманчива.

Итак, если прорезюмировать то, зачем мне С++ нужен, должен сказать, что нужен он для производительности в параллелизуемых алгоритмах. Для нативных библиотек С++ не критичен, т.к. всегда можно написать P/Invoke обертку или скачать уже готовую, а вот для новых, свежих алгоритмов – при условии что они не требуют качественного библиотечного окружения – С++ очень даже подходит.

А причем тут D?

Я уже давно хотел попробовать D, но все нехаватало времени. Теперь же у меня получилось истратить день на изучение особенностей языка и выборочное читание частей The D Programming Language Александреску. Книга, кстати, классная – объем информации большой, написано с долей весьма своеобразного юмора.

Собственно использование D под Windows требует от вас две вещи.

Во-первых, нужно скачать компилятор. Инсталлятор (MSI) все делает сам, напрягаться толком не нужно.

Во-вторых, хоть это и опционально, можно скачать IDE или пакет поддержки уже существующей IDE. Я конечно же скачал Visual D – пакет для Visual Studio. Особенности пакета:

  • Позволяет создавать проекты на языке D и конфигурировать их

  • Весьма слабо поддерживает IntelliSense – можно сказать что поддержки практически нет

  • Есть отладка (YMMV, конечно же)

  • Все это, увы, 32-bit

Одна из фееричных особенностей использования D – это то, что компиляция практически моментальна. Всем кто привык работать со студией это должно выносить мозг. Вы нажали F6, и программа скомпилировалась – вот так, просто.

D vs. C++

В чем же приемущества D? Попробую перечислить то, что бросилось в глаза:

  • Нет этого бреда с заголовочными файлами, #pragma once и т.п. Порядок файлов в проекте тоже не важен (F#, я смотрю на тебя). Пишешь module foo в одном файле и import foo в другом.

  • Строки… строки вменяемы, почти как в C#. Почти потому что остались извраты с UTF-16 и UTF-32 для тех кто знает в этом толк. Да, естественно что до .Net в плане глобализации не дотянуть – но цель не в этом.

  • Сборка мусора. При этом можно выделять память собственноручно если вдруг у вас приступ мазахизма.

  • Свойства! Java и С++ могут убить себя об стену, __declspec(property) идет лесом. Свойства, имхо, должны быть в любом современном языке программирования. И тут они есть, и ими приятно пользоваться.

  • Piece de resistance: ключевое слово mixin. Самый вменяемый подход к метапрограммированию, который просто ставит в угол Boo, Nemerle и иже с ними.

Язык D отличается очень продуманным, вменяемым дизайном и при этом не несет с собой кучу устаревшей/спорной идеологии на тему того что, например, публичные поля это плохо, надо делать свойства.

Mixin

Как работает метапрограммирование в языках вроде Boo? Там с помощью цитирования создается объектная модель кода – например [| x + y |] превращается в BinaryExpression. Вставки из реального мира делаются с помощью splice-оператора $. Тем самым, чтобы хоть что-то сгенерировать, нужно уметь создавать объектную модель нужного кода.

В большинстве случаев это вообще не нужно. Гораздо проще взять и сгенерировать строку (на подобии T4), которая создает текстовое представление и добавляет его в исходный код на этапе компиляции. Это в 100 раз проще чем мучаться с объектной моделью компилятора.

В языке D, инструкция mixin просто принимает строку. Напишите mixin("string Name;") и вы добавили в класс поле Name. Тривиально. Естественно что строки можно не только передавать напрямую, но и создавать отдельные функции, которые исполняются на этапе компиляции. Это решает проблему метапрограммирования в большинстве случаев.

Недостатки

Куда же без них. Вот то, что я успел заметить:

  • Дебаггер порой идет совсем не туда куда нужно. Вложенные функции и делегаты дебажатся “с грехом пополам”.

  • Конкретно под Windows, D компилируется только в 32-bit.

  • Стандартные библиотеки конечно не дотягивают до какой-нть STL но они намного более вменяемы. Так что это палка о двух концах.

  • Стандартных библиотек на самом деле две – Phobos и Tango. Какую использовать – непонятно. В Phobos я уже столкнулся с недопиленностью – например std.xml сейчас переписывается.

  • Никто пока не воспринимает D серьезно. Даже у F# больше exposure чем у D, что собственно понятно – ведь F# продвигает Microsoft и этот язык активно используется в quant finance.

  • IntelliSense не работает в Visual D. Надо будет еще глянуть на D-IDE которая, кстати, написана под .Net 4 :)

Впечатления

Мне D очень понравился. Это язык с максимальным уровнем вменяемости и достаточно низким уровнем шума. Если вам не нужно завязок на 100 библиотек, D позволит вам быстро разрабатывать и компилировать ваш код. При этом вы не теряете в выразительности – тут и делегаты, и события, и вложенные функции, функциональные литералы (= лямбда-выражения), не говоря уже о совсем продвинутых вещах вроде вариадичных шаблонов.

Резюмируя, должен сказать что D меня очаровал, и в ближайшее время я планирую его использовать к некритичных, non-production проектах дабы прочувствовать все его возможности. А они, судя по первичным наблюдениям, весьма обширны.

Реклама

Written by Dmitri

28 августа 2011 в 21:14

Опубликовано в D

комментариев 70

Subscribe to comments with RSS.

  1. А засчет чего достигается моментальная компиляция?

    Alexander

    28 августа 2011 at 21:47

    • За счет грамотного дизайна языка (автор D — компиляторостроитель) и выкидывания всего ненужного.

      Dmitri

      28 августа 2011 at 22:30

    • 1. Нет «заголовочных файлов»
      2. Нет partial classes
      3. Это просто в принципе должно быть «моментально» (как в Delphi) — ничего сверхсложного компилятор не делает.
      4. Компилятор пишется профессионалами.

      Vincent

      29 августа 2011 at 18:10

  2. Язык заинтересовал, хотя тоже давно за него хотел, да всё никак. Есть к Вам пару вопросов:
    1. Как у него с параллелизацией?
    2. Какова скорость работ программ если сравнить с С, С++, C#?
    3. Что за фиаско у Java7?

    P.S. Не мало мелких опечаток, из-за некоторых не всегда понятно что имелось ввиду.

    ZeroOne

    29 августа 2011 at 0:36

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

      Что касается проблем с Java 7, написал об этом чуть ниже.

      Опечатки фишку по мере нахождения :)

      Dmitri

      29 августа 2011 at 16:17

  3. ZeroOne

    29 августа 2011 at 0:38

    • Да. Иногда делаю кросспост на все ресурсы которые знаю :) Кстати, на Хабре у меня тоже такой ник.

      Dmitri

      29 августа 2011 at 8:52

      • К сожалению, меня на Хабре нет, но буду иметь ввиду)

        ZeroOne

        29 августа 2011 at 9:31

  4. Тоже интересует инфа о фиаско Java7.

    Kurt

    29 августа 2011 at 1:01

    • Фиаско на самом деле два.

      Первое — это явный недобор фич. Я искренне надеялся что наконец будут лямбды. А так мотивации использовать язык очень мало (после C#-a).

      Второе — уже настоящее фиаско — это сломанный код (действительно сломанный), который генерировался в одной из оптимизаций. В Java 6 он был опциональным, но в Java 7 стал дефолтным. Подробнее про эти проблемы можно почитать тут.

      Dmitri

      29 августа 2011 at 9:09

  5. Очень хорошая информация!

    kotev1000

    29 августа 2011 at 7:53

  6. Согласен с оценкой Ди — это хороший, практичный, перспективный язык. Но он с трудом пробирается в массы из-за невразумительных ГУИ библиотек и сомнительной перспективности библиотеке доступа к СУБД.
    Из неотмеченных приятностей:
    Помимо mixin, есть вполне вразумительное generic программирование. Поддержка (в языке и либах) ranges — более современный подход, чем iterators. Работа с массивами — на порядок нагляднее и удобнее C#. Unit-tests — встроены прямо в язык. Со строками никаких проблем не нашёл, всё работает и не напрягает.
    Вобщем, язык более чем достойный внимания.

    Vincent

    29 августа 2011 at 12:23

    • Ну что касается UI то это извечная проблема, хотя например под Windows 8 парадигма поменяется, и интерфейсы наверняка можно будет делать на HTML5. Что касается интерфейсов к базам данных — да, это проблема, хотя если база вывешивает REST-интерфейс наружу, то всего чего нехватает в D — это механизмов потребления RESTful сервисов.

      Dmitri

      29 августа 2011 at 16:20

      • UI сейчас, слава MS, перестало быть проблемой — WPF (да и ВинФормс) спокойно решают все задачи (на HTML5 не ставил бы ни в коем случае). Но для Ди нет сравнимой по мощности библиотеки для UI — даже биндинги — и те устарели (посмотрите DGUI, но его только пишут). Так что дигиталмарсу надо бы поднапрячься, без UI даже самый мощный язык никому не нужен.
        REST — это всё забавно, но не интересно — нужна единая библиотека, типа того же ADO.NET(или даже BLToolkit); Она вроде бы как есть, но уже давно не развивается и авторы даже планировали её переписать — это удручающие новости, т.к. СУБД — это неслабый кусок всех приложений вообще, а Ди и тут отстаёт.

        Vincent

        29 августа 2011 at 16:56

    • Перспективный?! Я о нём слышу сколько себя помню, а у меня хорошая память. И ни разу не слыхал ни об одном реальном его использовании. Хотя, специально не искал.

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

      moiseev

      29 августа 2011 at 16:29

      • Александреску пишет различные библиотеки для него, а «больше» никто с этим языком не работает. Но мне кажется что это не так критично. Вот для меня язык, например, работает. Ведь что нужно — чтобы основные фичи языка вели себя как надо.

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

        Dmitri

        29 августа 2011 at 16:44

      • Языку Ди 2.0 (обсуждаемому) — 4 года. Вы очень маленький для него :)
        Реально его не используют, но это не отменяет его перспективности. БАЗА языка — великолепна, а это уже намного лучший старт, чем у недожаб и перешарпов. Языку нужны библиотеки, это пока его слабое место.

        Vincent

        29 августа 2011 at 17:00

        • Откуда бы я догадался, что мы про D2 говорим =) Чесслово, я про D услышал чёрти когда и всегда все говорят что язык хорош. Отсюда и непонятка: почему у хорошего языка нет комьюнити. Вон Clojure — его один Хики выносил и вот он где. Александреску вроде не последний человек в индустрии, мог бы, наверное, и порекламировать. Библиотеки они ведь появятся вместе с коммьюнити, не всем же быть дотнетами с большой корпорацией на подхвате.
          А в чём заключается БАЗА языка? Структура компилятора и непротиворечивость синтаксиса?

          moiseev

          29 августа 2011 at 17:12

        • Если вы слышите о языке «сколько себя помните», про узнаваемые фичи 2.0 просто стыдно не знать. Вам уже стыдно? :)
          > почему у хорошего языка нет комьюнити.
          Элементарно из-за отсутствия важных, ключевых библиотек. Профи не будет тратить время на «примитивщину», а юзер это просто не потянет. Такую рутину должна проделать компания-производитель.
          Где сейчас Clojure я не скажу даже с анальным микроскопом — его в мэйнстриме просто нет.
          Александреску, кстати, и проделал гигантскую работу — выпустил книгу по Ди, да ещё пишет либы. Но опять же, это не совсем те либы, которые хотели бы видеть хомячки.
          >А в чём заключается БАЗА языка?
          В принципах, в реализованных идеях. Сейчас Ди содержит столько, что только успевай писать. И всё это обкатано до практического удобства. В отличии от C#, который только и сумел, что с грехом пополам воплотить ООП.

          Vincent

          29 августа 2011 at 18:04

        • Не стоит наезжать на C# — он на сегодня намного более интересен чем Java и C++ вместе взятые. В нем много хороших идей. И он не только ООП воплотил, но и хорошую дельту функциональщины — например я использую монаду Maybe и даже (в отдельных местах) каррирование :)

          Что я заметил в D так это то что «я просто пишу код», в то время как в C# я постоянно прыгаю навигацией между классами, что-то рефаторю, и т.п. Совершенно другой подход, другие ощущения.

          Dmitri

          29 августа 2011 at 18:48

        • Беда Цэшарпа в том, что это коммерческий продукт. Т.е. деньги(трудозатраты/бенефит) — это первое, что рассматривается при улучшении языка — ну не мудаизм? Поэтому всякие «плюшки» можно ждать годами — пока разрабов не затыркают требованиями и те, с лёгкой ленцой, начнут умно чертить квадратики на борде.

          Vincent

          30 августа 2011 at 10:43

        • А Java — не коммерческий продукт а общественный процесс (community process), и что — результат лучше?

          Dmitri

          30 августа 2011 at 11:43

  7. Думаю поковырять этот D на выходных) Спасибо за статью, меня заинтересовало

    lazorg

    29 августа 2011 at 15:37

  8. Я бы не торопился вписывать 32 бита в недостатки — у нас пока о 64 битах больше шума, чем реальных приложений и _потребностей_.
    Стандартная либа у Ди одна — Phobos. Под неё и нужно ориентироваться.

    Vincent

    29 августа 2011 at 18:15

    • Phobos недопилен и очень Си-образен. А еще я вот только что заметил что мне не хватает LINQ :)

      Dmitri

      29 августа 2011 at 18:39

      • Недопилен — не более, чем .NET — у каждой библиотеки найдётся «потенциал для роста». Хотя по богатству функционала — да, бедновато, но это проблема времени — всё можно написать.

        А что такое «Си-образен» и как это выливается в недостаток?

        LINQ? хех… Невелика панацея — выборки можно делать средствами std.algorithm;

        Vincent

        30 августа 2011 at 10:29

        • Ну, есть разные грани. Например мне понадобился std.xml, так он оказался раз в 50 слабее чем System.Xml.Linq. И если баги в .Net объяснимы, то тут мне порой даже точку остановки было не поставить :)

          Си-образность в основном выявляется когда у вас есть много глобально-доступных функций которые не ограничены в рамках тех классов к которым они применимы. Еще пример — то, что некоторые строковые манипуляции обобщены с массивами. С одной стороны понятно, что строки — это массивы, но это как-то неопрятно.

          А вот std.algorithm буду изучать… надеюсь там лучше чем в STL :)

          Dmitri

          30 августа 2011 at 16:11

        • Ну, DM тоже не всесилен — что актуально, то и допиливают. К слову, XML — это epic fail, я бы советовал с ним завязывать.

          Phobos — обычная либа в процедурном стиле. Зачем функции обязательно принадлежать какому-то классу? Что find(str, «abc»), что str.find(«abc») — никакой разницы. После цэшарпа — да, непривычно :) но не неудобно.
          Функции прекрасно ограничены типами параметров, какие тут могут быть непонятки?

          > некоторые строковые манипуляции обобщены с массивами. …это как-то неопрятно.

          Взгляните на это так: есть куча функций над массивами (куда можно передить и строку в том числе, т.е. выигрываем в универсальности) плюс специфичные только для строк функции. Тогда всё выглядит вполне логично.

          Vincent

          30 августа 2011 at 16:45

  9. Немного юмора от коллеги Суворова:

    Dmitri

    29 августа 2011 at 23:03

  10. Почему не Go, например?

    alex xenofontov (@ALxen)

    30 августа 2011 at 9:53

    • Хороший вопрос на который у меня нет ответа. С Гуглом есть правда такая проблема — они не любят Windows и соответственно их ничто не мотивирует поддерживать свои решения в этой ОСи. А еще у D более понятное позиционирование (замена С++).

      Dmitri

      30 августа 2011 at 11:39

    • Потому, что это Гугл — поисковый гигант, не опозорившийся только в единственной области — поиск. А у ДМ за плечами два компилятора, причём с современными фишками и нативные для винды.

      Vincent

      30 августа 2011 at 16:50

      • Кстати да, думаю никто не ожидал такого фиаско от G+. Хотя много людей пользуется, хотя я лично в упор не понимаю зачем :)

        Dmitri

        30 августа 2011 at 20:48

        • Вам показалось что он потерпел фиаско. Очень даже пользуются, кто-то с других сервисов переходит, кто уже перешёл, кого-то просто достала убогость и реклама в facebook, кому-то просто оказалось по душе то, как он устроен, кому-то наличие всех сервисов рядом на одной вкладке очень понравилось. В общем, очень разные люди пошли или ушли. Да и очень много там людей из Open-Source мира, в частности, Linux.
          Поэтому тут Вы ошиблись :)

          ZeroOne

          30 августа 2011 at 20:57

        • Я знаю что им много кто сейчас пользуется. У меня в друзьях человек 100 гиков которые зарегились чтобы посмотреть. Лично мое наблюдение такое: G+ не дает пользователю чего-то необычного, ради чего стоило бы переходить. И еще парадигма очень странная: что если я хочу чтобы человек был у меня в кругах, но читать его сообщения категорически не намерен?

          Кстати, у меня в G+ такой паттерно поведения появился: как только я вижу что человек — пусть даже известный и компетентный технарь — постит какую-то муть, офтоп, фотку «я с детьми» или что-то в подобном роде — он сразу, моментально удаляется. Просто блоги это одно, но в G+ люди начинают постить невесть что, включая персональные вещи до которых мне и дела нет. Это я к тому, что парадигма «кругов» очевидно не сработала, раз много людей откровенно ленятся чтобы посылать личные вещи только для близких.

          Dmitri

          30 августа 2011 at 21:04

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

          ZeroOne

          30 августа 2011 at 21:11

        • Да, но не-гиков я вообще там не видел. А инвайты я рассылал.

          Dmitri

          30 августа 2011 at 21:13

        • К сожалению, негиков там полно)

          ZeroOne

          30 августа 2011 at 21:22

  11. По поводу математических расчетов на D у меня есть некоторые печальные наблюдения.
    Правда, похоже, это не проблема D.
    Как-то для большего понимания возможностей быстродействия языков одной задачи я написал мини бенчмарк.
    Языки были Lua/LuaJit, D, С++ (Visual и Intel), C#, Nemerle и Java.
    Хотел оценить D и посмотреть тормоза LuaJit при куче property like обращений к таблицам.
    Числа в Lua это double, поэтому в остальных языках тоже использовал double.
    Тест, как обычно, содержал кучу циклов, вызовов функций, вычислений и т.п.
    Потом выводилось число -результат.
    Все языки у меня выдавали одинаковый результат, кроме D (число было совсем другое).
    Я не считаю себя большим специалистом в D (как и в других языках). Начал разбираться.
    Часть теста представляла генератор чисел по рекурентной формуле A(n+1) = k*A(n)^2 -1
    Я знаю, что формула чувствительна к точности вычислений и начальному Seed.
    Ее поведение описано в книге Стюарта “Математика хаоса” и там показано, что при некоторых K небольшие отклонения в начальном значении приводят к совсем другому ряду.
    У меня не было цели проверять точность вычислений у типов и языков, мне нужен был простой генератор случайных значений.
    На С это выглядело примерно так:

    #include 
    int main()
    {
    	int i;
    	double Seed = 0.321456789L;
    	for(i=0; i < 1000; i++) {
    		printf("%.14f\n", Seed);
    		Seed = 1.69193L * Seed * Seed - 1.0L;
    	};
    	return 0;
    }
    

    В результате числа от -1 до 1
    97й член ряда для D отличается на 0.76 от других языков. Это уже другой ряд.
    Смотрел DMD 1,2 GDC типы float, double, real. D всегда считал одинаково, но по-своему.
    Посчитал в Excel, посмотрел другие компиляторы, разные ключи компиляции С++ и D(у D их не много).
    Это проблема не D.
    Одинаково считает Microsoft линейка (без Excel) С++ (Visual, Intel), .Net, Java, Lua (компилятор VC++)
    Lua (компилятор MinGW?) считала как Excel (или меня уже переклинило)
    !!! MinGW C++ дает результат, как и D.
    По моим результатам, одинаковые алгоритмы откомпилированные VC++ и GCC, DMD могут давать разные результаты.
    Я понимаю накопление ошибки округления, но хотел бы что-бы она накапливалась более одинаково для компиляторов ( ну и языков).
    В переходе на D меня смутила возможность/вероятность получения результатов отличных от предыдущих на С++.
    Есть желание понять и разобраться.
    Для заинтересовавшихся, исходники анализа ситуации на http://ifolder.ru/25481081.
    По быстродействию. Ориентировочно:
    DMD все уныло, медленнее С# и java -client,
    GDC дает очень приличное быстродействие, как MinGW C++.
    Для ориентира С# работал ~23 sec.
    Самый быстрый Intel C++ ~13s.
    Visual C++ ~16s. GDC в этих же пределах.
    LuaJit + ffi на секунду обошел С#.
    scimark2 индекс на Core2 Quad 2500

    +------------+---+
    |Intel C++   |981|
    +------------+---+
    |Visual C++  |881|
    +------------+---+
    |Java -server|801|
    +------------+---+
    |GDC         |777|
    +------------+---+
    |LuaJit ffi  |644|
    +------------+---+
    |Java -client|517|
    +------------+---+
    |LuaJit      |501|
    +------------+---+
    |C# (3.51)   |500|
    +------------+---+
    |DMD         |374|
    +------------+---+
    

    Динамический LuaJit часто не хуже C#, абидна.
    Форум на dprogramming.ru у меня не доступен, где есть тусовка русских D-шников?

    Andrey3f

    31 августа 2011 at 10:31

    • Интересные находки! Боюсь такие ньюансы могут существенно затормозить адаптацию этого языка. Что касается перформанса, то это не удивительно — ведь язык относительно свежий, а С++ уже лет «цать» полируют, причем такая мегамашина как Intel оптимизирует его для своих процессоров, следовательно понятно почему Intel C++ выиграл. Собствено, я поэтому Intel-евский компилятор и использую.

      Dmitri

      31 августа 2011 at 10:47

      • Digital mars C++ тоже «медленный», как и DMD, похоже у них один бэкэнд.
        GDC сейчас развивается очень активно, слышал, что LDC адаптировали для версии 2.0
        GDC и LDC вполне быстрые.
        Вторая версия D очень интересная.
        Скоро книгу Александреску издадут на русском языке, может это поможет развитию популярности языка в России.

        Andrey3f

        31 августа 2011 at 12:33

    • Я бы не стал делать никаких особых выводов из этого теста — он слишком чувствителен к точности и говорит только то, что все считают по-своему. Возьмите тесты с общеизвестными числами — e, pi, какие-нть ряды фурье — там и проверьте, на какой итерации у кого быстрее достигается точность.

      По поводу быстродействия тоже неахти какой тест — тут мильён причин отставания от идеального АСМа.
      Кроме того, учитывая гигагерцы под капотом, уже как-то не смешно мерять 10 микросекунд с 9 — большинство приложений даже не спотыкнётся.

      Vincent

      31 августа 2011 at 11:18

      • Я ничего не хотел сказать плохого по поводу D, язык мне очень нравится, наоборот указал, что схема расчета в популярном MinGW C++ аналогична принятой в D.
        Похоже есть минимум 2 общепринятых подхода к вычислениям и округлениям при работе с плавающей точкой (stdlib), условно один Windows like (vc), а другой Unix like (gcc) и на вопрос что из них «правильнее» я думаю нет однозначного ответа.
        Возможно результаты С# на windows и mono тоже будут иногда отличаться по этой же причине.
        А по поводу теста быстродействия, то в коде это не весь тест, а только та часть, которая, как я понял давала расхождения в результатах.
        Полный тест крутился несколько минут и состоял из кучи косвенных вызовов функций на которых, как я думал, должен очень тормозить Luajit, но он справился. Меня интересовали результаты по Luajit, ну и по D для замены С++ части.

        А D для меня интересен как современный, быстрый, высокоуровневый язык.

        Похоже Вы знакомы с темой D, подскажите где есть форум русских D-шников?

        Andrey3f

        31 августа 2011 at 12:56

        • > и на вопрос что из них «правильнее» я думаю нет однозначного ответа.

          Вот поэтому ваш изначальный комментарий с цифрами только сбивает с толку. Как появится однозначный тест, показывающий «промашки» — тогда велкам.

          > подскажите где есть форум русских D-шников?

          Я с таким не сталкивался. Иногда на RSDN промелькнёт пара тем, не более. Проще найти ответ на дигиталмарсовых ньюсах, да на форумах проектов dsource.org;

          А вы можете опубликовать сорсы для ваших многоминутных тестов? (для VC, C# и D) Уж очень странно выглядит отставание Ди по ср. с C#

          Vincent

          31 августа 2011 at 13:21

        • Загрузил на http://ifolder.ru/25486775
          Перестроил .exe последними версиями
          Теперь GDC и DMD дали разный результат :-(
          Интел даже медленнее VC, лень крутить ключи.

          Строка компиляции для DMD
          dmd.exe -O -inline -release micro1_d.d

          Строка компиляции для GDC
          gdc -frelease -inline -O3 -s -fomit-frame-pointer -msse3 micro1_d.d -o micro1_d_gdc

          Еще раз. Я хотел написать тест с циклами и случайными ветвлениями для запутывания предсказателя переходов и кеша процессора, для мне был нужен простейший генератор случайных чисел одинаковый для всех языков, я взял простейшую формулу из книги, которую недавно читал. По книге эта формула давала хаотические блуждания. Я не хотел тестировал ошибки операций с плавающей точкой, но для одного из языков получились другие результаты, а я его планировал попробовать в деле. Это меня расстроило. Подскажите где исправить.

          Меняя параметры
          Cfg.ArrSize = 20000;
          Cfg.Loops = 200000;
          можно увеличить время выполнения до минут и часов, но это ничего нового не покажет.

          Не знаю как делать форматирование

          Core2 Quad 2500

          +------------------+-----+---------------------+
          |Компилятор        |Время| Результат на экране |
          +------------------+-----+---------------------+
          |Intel C++ 11.1    |  67s|    1155132229.291116|
          +------------------+-----+---------------------+
          |Visual C++ 2008   |  63s|    1155132229.291116|
          +------------------+-----+---------------------+
          |GDC-r575-20110723 |  81s|    1930882290.264692|
          +------------------+-----+---------------------+
          |LuaJit+ffi        |  86s|      1155132229.2911|
          +------------------+-----+---------------------+
          |LuaJit            | 196s|      1155132229.2911|
          +------------------+-----+---------------------+
          |C# (3.51)         |  88s|     1155132229.29112|
          +------------------+-----+---------------------+
          |DMD 2.054         |  97s|    1157342517.583529|
          +------------------+-----+---------------------+
          

          Мои интересы C#, Nemerle, Lua, D, Haskell и немного Scala.

          Andrey3f

          31 августа 2011 at 15:17

        • Andrey, спасибо, вечером посмотрю!
          Я думаю, если чьи-то результаты отличаются, но сами по себе — валидные, чего зря моск парить? :) А если важна идентичность чисел, то извините, возможно ваша формула вообще не подходит для «межязыковой совместимости» — нужно что-то более устойчивое к погрешностям. Почему-бы вам не взять простое число и сдвигать его с прибавлением переноса? (есть такие генераторы)

          C# 3.51 — это, извините, кто? :) У меня есть VS2010(C# + C++), попробую на них.

          Vincent

          31 августа 2011 at 15:57

        • Вообще лично мне кажется, что ограничивать перформанс численными вычислениями — это не очень корректно. Ибо сразу понятно что в «плюсах» оптимизирующий компилятор настроен на любую оптимизацию (в т.ч. с использованием SSE и невесть какого еще зла) цикла for, а соответственно конкретно для вычислений разница в 1.5 раза это еще цветочки.

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

          Dmitri

          31 августа 2011 at 16:01

        • C# 3.51 это я так назвал С# от .Net 3.5 sp1 (VS2008)
          С VS2010 .Net 4.0, говорят, что его компилятор С# дает более шустрый код.

          В Lua все вызовы вида Cfg.Seed и Cfg.B идут через hash таблицы, а в остальных языках нет.
          Целью было оценить потери быстродействия Lua на таких обращениях.
          Согласен, что генераторы случайных чисел строят на базе целых, но в Lua нет целых, только double.
          Поэтому и наступил на эти грабли.

          А с математической точки зрения это неустойчивый, «кривой» генератор.

          Ассемблер смотреть сил пока нет.

          Andrey3f

          31 августа 2011 at 16:18

        • Еще про Scimark http://leonardo-m.livejournal.com/82803.html сравнивал DMD c GCC.
          Я взял его исходники, нашел еще для С++, С#, Java, Lua
          Из этого я и получил оценку потенциального быстродействия для компиляторов, которую я привел выше
          Быстродействие GDC вполне достойно внимания.

          +------------+---+
          |Intel C++   |981|
          +------------+---+
          |Visual C++  |881|
          +------------+---+
          |Java -server|801|
          +------------+---+
          |GDC         |777|
          +------------+---+
          |LuaJit ffi  |644|
          +------------+---+
          |Java -client|517|
          +------------+---+
          |LuaJit      |501|
          +------------+---+
          |C# (3.51)   |500|
          +------------+---+
          |DMD         |374|
          +------------+---+
          

          Andrey3f

          31 августа 2011 at 16:05

        • А тогда вопрос, какие фичи из DMD не поддерживает GDC?

          Dmitri

          31 августа 2011 at 16:16

        • Как я понимаю, у DMD и GDC один открытый фронтэнд, а бэкэнд у GDC от gcc 4.5.2, а у DMD свой, закрытый скорее всего аналогичен digitalmars C++.
          т.е. фичи должны быть одинаковые.
          Быстродействие GDC должно быть как у gnu c++.
          У D есть бэкэнд в .Net, его не смотрел.
          Быстродействие не всегда определяющий фактор, фичи важнее.
          Надеюсь, что в моих тестах ошибка. D классная штука.

          Andrey3f

          31 августа 2011 at 16:25

  12. В основном разобрался со своими проблемами с плавающей точкой.
    Компилятор D (во всяком случае GDC) работает нормально.
    Заглянул в ассемблер Visual C++ и gcc (gdc).
    Столкнулись мои глюки и «особенности» компиляторов.
    Моя ошибка — был ошибочно добавлен суффикс L к double константам (в С и D программах),
    Cfg.Seed = 0.321456789**L**;
    т.е. фактически сказал, что у них тип long double, а не double.
    Visual C++ на это отреагировал спокойно, а для gnu С++ и D начались «особенности», они начали генерить код не SSE/SIMD командами, а FPU, с другим результатом.
    Если чуть отвлечься, то Visual C++ может генерировать код для плавающей точки с разной точностью (fast, strict, precise), т.е. с fast — программа будет считать чуть быстрее, но менее точно, а с precise наоборот. Результаты вычислений будут отличаться. Это нормально.
    Код для fast и precise можно генерировать с SSE/SIMD или FPU командами процессора.
    В Visual C++ результаты вычислений совпадают независимо от выбранной системы команд.
    т.е. fast+SSE == fast+FPU, а precise+SSE == precise+FPU. Это ожидаемо и нормально.
    !!! Но для gnu С++ мне не удалось получить одинаковых результатов с -mfpmath=387 и -mfpmath=sse,
    т.е. precise+SSE != precise+FPU. Это мне непонятно.
    Таким образом, когда из-за моей ошибки с суффиксом L, gnu начал генерировать часть кода с FPU командами, я получил другой результат в gnu C++ и D.

    Теперь о хорошем.

    Если убрать суффиксы L и поставить эквивалентные ключи компиляторов, то GDC позволят получить программу с быстродействием и результатом как у Visual C++

    Core2 Quad 2500
    +----------------------------------+-----+---------------------+
    |Компилятор                        |Время| Результат на экране |
    +----------------------------------+-----+---------------------+
    |Visual C++ 2008 precise, sse      |  63s|    1155132229.291116|
    +----------------------------------+-----+---------------------+
    |Visual C++ 2008 precise,nosse     |  61s|    1155132229.291116|
    +----------------------------------+-----+---------------------+
    |MinGW C++ 4.5.2 nofast,sse        |  65s|    1155132229.291116|
    +----------------------------------+-----+---------------------+
    |GDC-r575-20110723 nofast, sse     |  64s|    1155132229.291116|
    +----------------------------------+-----+---------------------+
    |C# (3.51)                         |  88s|     1155132229.29112|
    +----------------------------------+-----+---------------------+
    |Visual C++ 2008 fast,sse          |  61s|    1159718769.573946|
    +----------------------------------+-----+---------------------+
    |Visual C++ 2008 fast,nosse        |  55s|    1159718769.573946|
    +----------------------------------+-----+---------------------+
    |MinGW C++ 4.5.2 fast,sse          |  65s|    1159718769.573946|
    +----------------------------------+-----+---------------------+
    |GDC-r575-20110723 fast, sse       |  55s|    1159718769.573946|
    +----------------------------------+-----+---------------------+
    |DMD 2.054                         |  94s|    1228324550.713549|
    +----------------------------------+-----+---------------------+
    |DMD 1.069                         |  84s|    1228324550.713549|
    +----------------------------------+-----+---------------------+
    

    Ключи для GDC
    «precise» gdc -frelease -inline -O3 -fomit-frame-pointer -msse3 -mfpmath=sse
    «fast» gdc -frelease -inline -O3 -fomit-frame-pointer -msse3 -mfpmath=sse -ffast-math

    Замечания и выводы:
    У меня на машине в этом тесте Visual C++ без sse работает быстрее чем с модным sse.
    fast и precise не очень различаются по скорости.
    D (GDC) почти в полтора раза быстрее С# и равен по скорости С++.
    DMD работает медленнее и дает свой результат, ну и ладно.
    Пока не понятно различие результатов вычислений от системы команд в gnu C++, наверно что-то сделал не так.

    Для себя —
    Сравнивать и тестировать языки лучше на «устойчивых» задачах, надо понимать, что делаешь, не связываться с особенностями компиляторов и не делать поспешных выводов.

    Andrey3f

    1 сентября 2011 at 15:23

    • Мне кажется что чего-то ждать от SSE на не-Inteleвском компиляторе не имеет особого смысла. Вся суть SSE в том чтобы самому его использовать.

      Dmitri

      1 сентября 2011 at 19:57

  13. Все кому интересен D, присоединяйтесь к группе http://www.ddevel.org/groups/profile/79/d-programming-language. Сайт еще разрабатывается и расчитан для програмистов.

    Алексей

    16 октября 2011 at 12:23

    • Регистрация: «Отобр_о_жаемое имя». Ребят, ну ё-моё! Ржач, да и только…
      А что, это сайт одного девелопера? http://dprogramming.ru/ не достаточно?

      Vincent

      17 октября 2011 at 10:51

      • Оба сайта какие-то странные, если честно.

        Dmitri

        17 октября 2011 at 11:41

      • Vincent — спс за за то что указал на ошибку. Двиг сайта я перевожу сам и в основом все что есть еще черновой вариант.
        А по поводу того что он пустой так это потому что я его еще до ума не довел.
        http://dprogramming.ru/ — к сожалению умер.

        Алексей

        3 декабря 2011 at 16:07

        • Ладно, чем больше сайтов по Ди, тем лучше. А _цель_ вашего сайта какая? Если это какая-то «помощь», какая конкретно?

          Vincent

          4 декабря 2011 at 23:12

        • В планах с помощью пользователей перевести документацию по D1 и D2 и держать ее в актуальном состоянии, с помощью вики в группе. А вообще сайт для програмистов в сфере геймдева расчитан.

          Алексей

          5 декабря 2011 at 14:35

  14. Ну не… меньше всего это похоже на сайт программинга! Скорее, фэйсбук :) А соц.сетями мы уже по уши сыты. Может, сделать сайт более традиционно? Я вот меньше всего думаю о переводах Д2 и программинге вообще, глядя на вашу хомепагу. Вы можете набросать примерный дизайн? (хоть в Paint’е)

    Vincent

    5 декабря 2011 at 14:56

    • Я сейчас просто в свободное время занимаюсь переводом самого движка сайта. Конечно перевод еще кривой и не до конца но я это исправлю. Как с русификацией полностью закончу займусь за дизайн. А по поводу того что сайт на соц сеть смахивает — так это потому что двиг от соц сети взят.
      Мне его архитектура и простота нравится — планируется полная переделка как дизайна так и возможностей. Что я хочу использовать от соц сетей так это возвожность выбирать тип получаемой информации. то есть если тебя интересует с++ то ты сможешь выбрать эту категории и больше никакой лишней информации не только не получать но и на сайте не видеть — только то что надо именно тебе. Лично меня огромные порталы бесят именно тем что там куча не нужно информации для меня — я хотел бы сам выбирать.

      Алексей

      5 декабря 2011 at 15:19

      • Могу сразу предсказать судьбу такого «сайта» — сдохнет, так и не набрав даже десятка регистраций. Почему? Да потому что вы занимаетесь абсолютно ортогональной ерундой, а самое главное, что людям нужно — у вас отсутствует. Зачем вы тогда тратите свои усилия? С точки зрения ваших целей, сайт — полный бред. Напишите тупо пару страниц, прикрутите вики — это ВСЁ, что требуется для нормальной, координированной работы.

        Vincent

        5 декабря 2011 at 15:49

        • Нда, не ожидал такой бурной дискуссии в блоге. Что касается русскоязычных сайтов — они все обречены — разработчикам легче кучковаться на английском, да это и фильтр хороший, ведь мало кто хочет общаться с разработчиками которые по английски не понимают.

          Dmitri

          5 декабря 2011 at 16:01

        • Ну RSDN-то жив! :) sql.ru тоже вертится. И русские сайты по D тоже нужны — даже с моим fluent english я предпочитаю русский сжатый текст. Буржуи в этом плане те ещё пи-оболы. :)
          Сейчас нужен простой сайт, где можно 1) читать новости о D и библиотеках, статьи, обучалки и хинты 2) Расшаривать личные проекты (никаких VCS, просто файлы) 3) Вики со всеми мыслимыми доками с постепенным переводом на русский.
          dprogramming.ru в этом плане практически идеален, но я не знаю кто его хозяин и насколько он серьёзно уделяет время проекту.

          Vincent

          5 декабря 2011 at 16:16

        • RSDN жив для определенного сегмента людей. Я например стараюсь там не появляться.

          Dmitri

          15 декабря 2011 at 17:14

  15. Официальный русский сайт языка программирования D http://dlang.ru/

    Петр

    14 марта 2013 at 19:35

    • Официальный это как? Кто-то из команды D мейнтейнит?

      Dmitri

      14 марта 2013 at 21:11

      • Нет, просто слово «официальный» красивше «неформальной подпольной группы любителей Ди» :))
        Шучу, не обижайтесь. Я люблю Ди даже больше, чем C#!

        Jaja

        14 марта 2013 at 21:42

        • Кстати, тут не упомянули официальный русский сайт языка D http://dlang.ru/

          Петр

          3 августа 2013 at 20:45


Оставить комментарий

Заполните поля или щелкните по значку, чтобы оставить свой комментарий:

Логотип WordPress.com

Для комментария используется ваша учётная запись WordPress.com. Выход / Изменить )

Фотография Twitter

Для комментария используется ваша учётная запись Twitter. Выход / Изменить )

Фотография Facebook

Для комментария используется ваша учётная запись Facebook. Выход / Изменить )

Google+ photo

Для комментария используется ваша учётная запись Google+. Выход / Изменить )

Connecting to %s

%d такие блоггеры, как: