Блеск и нищета GWT (или почему я не верю в Dart часть 2)

    Одной из самых обсуждаемых тем на Хабре стало объявление Гугла о создании нового языка Dart, претендующего на то, чтобы полностью заменить Javascript.
    Для Гугла это не первый проект подобного рода. С 2006 года существует Google Web Toolkit, позволяющий создавать веб-приложения полностью на Java. На нём, например, работают Adwords и Google Wave.
    Но, не смотря на красивые обещания и очень серьезные, особенно по меркам 2006 года, возможности, GWT так и «не взлетел». Да, проект поддерживается и развивается, но сообщество разработчиков так и не сложилось. Сторонних компонентов мало, они не поддерживаются, знакомых с системой программистов найти сложно.
    Практически все «плюшки» языка Dart, которые сейчас рекламирует Google, уже были реализованы в Webtoolkit-е. В этой статье я хочу проанализировать достоинства и недостатки GWT в попытке рассмотреть мутные очертания будущего Dart.

    Цели и задачи


    С точки зрения программиста, для создания современных веб-приложений приходится использовать целый зоопарк технологий: HTML, CSS и Javascript для клиентской части; SQL, PHP и часто какой-нибудь шаблонизатор типа Smarty для серверной; данные перемещаются по сети при помощи XML, JSON или какого-нибудь велосипеда.

    Это классический Unix-way: для каждого участка работ применяется свой инструмент. Такой подход обеспечивает огромную гибкость. Если какой-то конкретный инструмент вам не нравится, вы можете заменить его на другой: PHP на питон, SQL на NoSQL, HTML на Flash.

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

    Вторая проблема в неизбежном дублировании кода. Например, если где-то вам нужно запросить у пользователя дату (скажем, отлёта), вы должны использовать обычное текстовое поле ввода, а затем проверять введенное значение. Во-первых, нужно убедиться, что это вообще дата, а не ;DROP TABLE, а во-вторых — что она лежит в каком-то ближайшем будущем. Эти проверки приходится делать трижды: в клиентской части (юзабилити), серверной (безопасность) и в базе данных (целостность). И если база данных в большинстве случаев проверяет всё автоматически, то проверки в серверной и клиентской части придется писать самостоятельно, а с учетом локалей это не самая тривиальная задача. В итоге вы получите две функции, делающие одно и то же, но ни использовать одну из другой, ни хотя бы просто скопировать их нельзя.

    GWT, как и Dart, призван решить эти проблемы. В случае GWT из всего зоопарка остаётся только Java и небольшой кусок CSS, отвечающий только за шрифты и цвета (но не за расположение элементов). Всё остальное либо сокрыто в глубине библиотек, либо используется на уровне стандартной заглушки (HTML с единственным div-ом, в который потом программно будет вставлен весь интерфейс).

    Кроме зоопарка технологий есть еще зоопарк браузеров во главе с IE. Даже сейчас, обрабатывая банальное событие нажатия клавиши (onkeypress), в javascript приходится проверять версию браузера, потому как разные браузеры вызывают эту функцию по-разному. Тогда же, в 2006-ом, приходилось использовать огромное количество костылей просто для того, чтобы страница выглядела более-менее одинаково. GWT красиво решал и эту проблему.

    Как это работало


    Весь GWT-проект писался в одной среде и на одном языке — теплом ламповом Java с MVC и паттернами. Это был почти полноценный Java в том плане, что эмулировалась почти вся стандартная библиотека, но конечно просто перенести весь код из десктопного приложения было нельзя. Google даже выпускал специальную сборку редактора Eclipse, в котором всё, включая отладку, работало из коробки.

    На серверной стороне всё было похоже на обычные Java Server Pages с подключенными библиотеками GWT. Но так как JSP-хостинг ещё нужно было найти, в настройках всего этого хозяйства так или иначе приходилось разбираться. Впрочем, серверную часть можно было создать на чем угодно, но все преимущества единого языка при этом, разумеется, терялись.

    Клиентская же часть компилировалась из Java в Javascript, причем под каждый браузер компилировался и динамически подгружался свой файл. Это позволяло избежать вороха проверок версии браузера и в целом работало очень хорошо.

    HTML как таковой не использовался. Теоретически можно было сверстать свою HTML страницу и затем программно вставить в нужные места элементы управления, но всё же мейнстримом было создание полностью динамического интерфейса целиком на Java. Были даже полу-рабочие графические редакторы, позволяющие рисовать интерфейс мышкой почти как в редакторе форм .Net или там Delphi. Расположение и размеры элементов задавались программно, на долю CSS оставались только шрифты, цвета и мелкие рюшки типа скругленных уголков.

    В-общем, в теории всё выглядело очень здорово.

    Практика


    На практике всё было не так радужно.

    В автоматически создаваемых элементах интерфейса использовалась махровая табличная верстка. Любой прямоугольный блок генерировал таблицу с одной ячейкой. Панель (объединение нескольких блоков) представлялось таблицей с одной строкой или столбцом. Диалоговое окно представляло собой нагромождение вложенных панелей. На выходе получалась каша из таблиц довольно большой степени вложенности, разобраться в которой было практически невозможно. Браузеры тоже без особой радости пережевывали получившийся гигантский DOM.

    Я совершенно не приверженец семантической верстки, я понимаю, что реализовать программную генерацию HTML с позиций классического ООП, да ещё так, чтобы это работало одинаково во всех версиях IE, да еще в 2006-ом году, можно было только на таблицах. Однако то, что получилось в GWT — оно просто тормозило. Оно до сих пор тормозит, даже в Хроме, даже на современных процессорах, даже на страницах с всего-лишь сотнями виджетов.

    Сверстать свой HTML и скормить его GWT на практике оказалось также не очень-то просто. Это вам не jQuery, где вы можете легко манипулировать DOM и генерировать свой HTML так, как считаете нужным. Вы могли, в теории, сэкономить пару верхних уровней таблиц, но совсем от них отказаться — никак. Хуже всего дела обстояли с взаимодействием GWT и нативного Javascript.

    В теории GWT поддерживает JSNI — что-то а-ля ассемблерных вставок в Си, только с Javascript в роли ассемблера. Но работает это только в одну сторону. То есть вызвать какую-то внешнюю js-библиотеку из GWT вы можете без проблем. А вот наоборот… Да что там javascript, банально повесить свой onclick на html-элемент, чтобы перехватить его в GWT — такое шаманство не было описано в мануале и, похоже, вообще не было предусмотрено разработчиками. Сделать-то это можно было, но с помощью трюков Javascript, а не GWT.

    Гугловцы старались полностью перекрыть все различия браузеров, но всё же до конца этого сделать не смогли. Оставались (по крайней мере в версии 2.2, дальше я уже не работал) кое-какие тонкие моменты, которые даже в javascript-е относятся к «шаманствам», таким как запрет выделения текста при смазанном клике мышкой. Но это уже придирки.

    Концептуальные проблемы


    Надо признать, что в целом GWT работал. Может местами медленно, может кое-где коряво и не до конца, но работал. Главная его беда в том, что пресловутая скорость разработки больших приложений на GWT оказалась намного ниже, чем на стандартном зоопарке технологий. И если проблемы предыдущего раздела Dart решит, то проблемы со скоростью разработки — нет.

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

    Java, и с ним весь классический ООП, зиждется на идее разделения классов и собственно объектов — экземпляров класса. Это подходит всяким бизнес-приложениям, которым нужно обрабатывать миллионы строк накладных, платежей, остатков на складах и так далее. Классов там относительно мало, а вот объектов — много.

    В вебе всё не так. На одной странице у вас есть всего одна форма входа, одна корзина, один текущий пользователь и одна кнопка «заплатить бабло». Городить для каждого из этих элементов отдельный класс и потом создавать по одному экземпляру каждого класса… а зачем? Практика показывает, что чаще всего разделять классы и объекты в вебе просто не требуется.

    Ок, скажет последователь Банды Четырёх, а что же будет, когда потребуется вторая кнопка «бабло», но с перламутровыми пуговицами? В Javascript-е всё вот именно так и будет: вторая кнопка, созданная по прототипу первой, но с пуговицами. В классическом же ООП будет отдельный класс, но это полбеды; главное — будет рефакторинг с выделением интерфейса и написанием кучи кода, который вообще ничего не делает, а просто поддерживает структуру классов. А всё из-за статической типизации, которая не позволяет просто так использовать вместо «просто кнопки» «кнопку с перламутром».

    Я четыре года писал на GWT, и я могу уверенно сказать, что для веба утиная типизация лучше статической. И влияет оно только на скорость компиляции, а не на скорость исполнения кода.

    GWT делали истинные фанаты классического ООП, не позволявшие никаких отклонений от Святых Паттернов. Если кто-то решил, что нельзя использовать инлайн-стили элементов, значит нельзя и точка. Нет такой функции — изменить стиль, и не будет, делайте всё CSS-классами. Вообще, конечно, в большинстве случаев инлайн-стили действительно не стоит использовать, но как, например, реализовать анимацию? Создавать 20 классов вида .opacity03 { opacity: 0.3 }?

    Блин, в GWT есть компонент типа Grid (элемент управления типа таблица, в которой можно править ячейки), в котором полностью реализован свой MVC. В визуальном элементе управления… Если вам нужно сделать табличку 2х3, вам нужно описать модель, контейнер и далее по списку. Строк так на 200 кода:)

    Если эта же команда делала Dart… ну, не знаю. Сейчас не 2006-ой год, Javascript окреп, устаканился и оброс библиотеками уровня jQuery. Я не вижу ни одной причины, по которой Dart «выстрелит». Не смотря на всю мощь Гугла.

    Комментарии 227

      +24
      На 100% согласен с автором.
        0
        Был на конференции в Москве, там был докладчик, один из разработчиков новых стандартов Js, по его словам в новых версиях будет просто МАССА многих фич, таких как появление полноценных классов и перегрузка методов…
        JavaScript будет еще долго, это факт.
          +3
          То что JS развивается это конечно хорошо.
          Но тот же V8 от Google использует уже устаревший JavaScript 1.6, при том что с 2009 года стабильным считается 1.8.5.
          И поддерживает его только Mozilla Fundation, которая в общем-то его и разрабатывает…
          Так что если Google Chrome вытеснит Firefox, то маловероятно что JS продолжит развиваться, потому как судя по появлению Dart он не выгоден Googl-у, и он его развивать скорее всего не будет.
            +10
            Уточнение: V8 реализует ECMAScript (международный стандарт ECMA-262 5th edition). То, что называется JavaScript 1.x это исключительно Mozilla'вкий диалект. Браузеры поддерживают именно ECMAScript, а не JavaScript (это связанно с тем, что JavaScript это торговая марка на самом деле). Развитие ECMAScript происходит в рамках комитета TC-39. Следующая редакция ES известна как Harmony. V8 поддерживает часть фич из Harmony (скрыты под флагами, как нестандартные): weak maps, block scope bindings (let), proxies.
              0
              Вы немного заблуждаетесь. ECMA-262, edition 5 (то, что вы назвали 1.8.5 в случае Mozilla) поддерживают Firefox, Chrome и IE. en.wikipedia.org/wiki/ECMAScript. В комитет по разработке этого стандарта входит еще больше компаний, не только Mozilla. Пропорцию их усилий по развитию стандарта и доведению до ума сложно оценить, но если покопаться на сайте Ecma, некоторые выводы можно сделать, наверное тоже очень неожиданные, судя по тому как вы хороните JS.
                0
                Если я не ошибаюсь, официальный ответ Google по поводу «1.8» был что-то вроде такой — как только будет утверждена соотвествующая версия ECMAScript с фичами (т.е. генераторы и т.д.), в V8 оно реализованно будет почти сразу.

                Отмечу что в последних сборках V8 уже есть флаг "--harmony":
                code.google.com/p/v8/source/browse/trunk/ChangeLog
                2011-10-13: Version 3.7.0
                Added flag --harmony to activate all experimental Harmony features.

                Кроме того, Dart все-таки слишном… объектно-ориентированный. Для large-scale проектов это возможно и хорошо, но он уже не «универсальный», что делает его более нишевым.

                Не вижу причины не развивать V8 как отдельным универсальным движком.
                +2
                Слишком это всё долго. В хроме даже давно пресловутый let не работает. Что уж говорить о классах и других кофескриптах.
                +8
                Мне нравится JavaScript. Мне нравится его подход к решению задач в браузере. Есть замечательный фреймворк(или библиотека — кто как называет) jQuery. Она при всей своей мощи — не такая огромная. И при этом не запрещает мне использовать нативный JS.
                На платформе пишу под C++ + QT + QScript и меня всем этот набор устраивает, причем уже долгое время.
                Сейчас вообще тенденция пошла, все в браузер засовывать. А как браузер это будет исполнять — мало кого волнует. С V8 — гугловцы молодцы, респект. Да и вообще пнули в скорость работы всех остальных производителей браузеров. Но вот свалку городить — это уже не есть гуд.
                Многие разработчики, помимо классического ООП, нехотят знать ничего. У них устаканилось, что такое объект, что у него есть класс-описание и т.д. И другие вариации они не примут никак. И в силу преимущественного количества языков такого типа — не трудно было догадаться о том, что будут бурные холивары. Еще никто не смог доказать тот факт, что прототипное ООП идеологически правильней классического. Я не собираюсь создавать холивар — я просто прошу трезво оценить ситуацию, и заняться чем-то более серьезным.

                Извините что большие посты пишу.
                  +7
                  Лично я в браузере приму что угодно, что даст возможность просто объяснить коммиятору или чекеру, что вот здесь ожидается строка, вот здесь — произвольный объект, вот здесь — массив, а здесь — нечто (объект или запись, буде таковые введут), имеющее числовое поле id (число), поле даты date и строковое name.

                  И чтобы нетипизированных переменных либо не было вообще, либо они запрещались по всему файлу чем-то вроде «use strict»;

                  Вот после этого на JS было бы куда как менее противно писать. А классы — это всё шелуха.
                    0
                    Чем же вам так они сильно мешают эти «нетипизированных переменных либо не было вообще»
                      0
                      Все проще. Статическая типизация будет только мешать, на самом деле.
                      Достаточно просто строгой динамической(скажем, как в Python|Ruby), чтобы в 90% случаев, где сейчас возвращается undefined, кидался эксепшн в рантайме. Чтобы не было неявных приведений типов.

                      Вообще, по-моему, слабую динамическую типизацию нужно запретить.
                        +3
                        Как по мне так типизация должна быть на стороне «программы» она ее код и ее «модели» должны ее формировать, пока пользователь не задаст обратного, не вижу ничего в этом плохого куда больше для вижу минусов в null/nil/0/""/" " & etc чем в том что вдруг откуда не возьмись в строку вместо значения «нет данных» придет 0… Вот автоматическое преобразование второго в первое, пошло бы действительно на пользу.
                          0
                          Может, мы о разной статической типизации говорим? Мне ближе всего модель из D — где можно сказать int i = myFunc(); — и если myFunc возвращает что-то, что в int преобразовываться не умеет, получим ошибку на этапе компиляции. С другой стороны, там же довольно просто организовывается проверка вроде duck tuping — когда просто декларируется: «auto x = y, и должно компилироваться int t = y.foo(1)». То есть можно наложить произвольное условие на принимаемый тип.

                          Но на худой конец классическая плюсовая или джавовская модель (без укзанаия исключений, конечно) тоже сгодится (с некоторыми поправками). Суть — в том, чтобы нельзя было просуммировать яблоки и велосипеды, грубо говоря, и чтобы не оказалось, что на восьмом уровне в стеке где-то пытаемся вызвать сто лет назад переданную строка как коллбек — и при этом чтобы проверки не занимали половину кода.
                            +2
                            Да я понял идею. Тут сложно сказать, какие будут плюсы и минусы. Честно говоря, я никогда не задумывался о статической типизации в замене JS.

                            Насчет коллбэков, кстати — тогда уж их проще заменить на акторы. Замена почти равноценная, а стройность кода и устойчивость к ошибкам — гораздо выше.
                              +2
                              Да я понял идею. Тут сложно сказать, какие будут плюсы и минусы. Честно говоря, я никогда не задумывался о статической типизации в замене JS.

                              Насчет коллбэков, кстати — тогда уж их проще заменить на акторы. Замена почти равноценная, а стройность кода и устойчивость к ошибкам — гораздо выше.
                                +2
                                Да я понял идею. Тут сложно сказать, какие будут плюсы и минусы. Честно говоря, я никогда не задумывался о статической типизации в замене JS.

                                Насчет коллбэков, кстати — тогда уж их проще заменить на акторы. Замена почти равноценная, а стройность кода и устойчивость к ошибкам — гораздо выше.
                            +2
                            А кто вам мешает всё типизировать?
                            Сделайте себе типы Integer, Boolean, Float, засуньте в них примитивы, валидацию типа в сеттерах и вперёд.
                              +2
                              А кто вам мешает всё типизировать?
                              Сделайте себе типы Integer, Boolean, Float, засуньте в них примитивы, валидацию типа в сеттерах и вперёд.
                                –1
                                тим, что это динамическая типизация. хочется проверку в «компил тайм». Для JS — проверка типов должна делаться сразу в момент загрузки файла браузером.
                                  +3
                                  Тем, что это надо организовывать сеттеры, руками (или тулзой какой) проверять типы… уже есть опыт — если такие вещи делаются не в рамках языка, то они перестают работать в самый неудобный момент — в каких-нибудь нетривиальных/сложных случаях, где проверка типов больше всего и нужна.
                                    +1
                                    Возможно, создатели Dart с этого и начали — прикрутили типизацию, потом проверку типизации, потом автоматическую генерацию всей этой байды, чтобы не писать руками… а когда опомнились, то у них уже была тонна кода, которую они и назвали новым языком прораммирования :)
                                      +1
                                      Возможно, создатели Dart с этого и начали — прикрутили типизацию, потом проверку типизации, потом автоматическую генерацию всей этой байды, чтобы не писать руками… а когда опомнились, то у них уже была тонна кода, которую они и назвали новым языком прораммирования :)
                                        +3
                                        Какая-то фигня с комментариями уже не первый раз: нажимаю «Написать» — никакой реакции, через некоторое время снова нажимаю «Написать» — появляются два комментария.
                                +3
                                Интересно, что вы сейчас используете в замену вебтулкита, ну или вообще, для веб разработки в целом. Другими словами, что в данный момент, по вашему, решает задачу веб-разработки наиболее простым и практичным способом?
                                  0
                                  jQuery + PHP + MySQL, как ни странно. Да, местами коряво, да, приходится переписывать одни и те же функции N раз, но по скорости разработки ничего лучше я пока не видел.
                                    0
                                    По скорости разработки, python + bigtable/postgre очень рекомендую хотя бы попробовать.
                                      +1
                                      postgre по скорости разработки не выигрывает, скорее позже.
                                      bigtable вообще не в тему, к разработке не относится.

                                      Я ведь тоже могу кричать — 0MQ, RabitMQ, Rubinius, Memcached.

                                      :)
                                        0
                                        Выше приводили связку образующею «платформу» (jQuery + PHP + MySQL), соответственно: python + bigtable это отсылка к платформе google appengine использования которой дает не малый прирост к скорости разработки, ИМХО. python + postgre предложена как альтернатива php + mysql распространенной модели для шаред и впс, например; Postgre для меня показался куда более «стройным» решением и в ряде случаев более быстрым. Соответственно были предложены на «попробовать» две разные платформы, что именно вас не устраивает?
                                  +61
                                  GWT очень даже взлетел. Когда его только-только показали, все грезили тем, что я бы назвал AJAX Promise — что можно написать приложение десктопного уровня с помощью веб-технологий, и он будет работать, при этом не требуя никаких телодвижений от администраторов сети — нужно просто разослать по email сотрудникам URL приложения — никаких развертываний, никаких танцев с бубном вокруг каждой клиентской машины. Мы поэтому сейчас и пишем в большинстве своем внутренние приложения на HTML-CSS-JavaScript, что админы — люди ленивые, и продать систему, не требующую установки на каждый компьютер клиента существенно легче.

                                  Но писать на HTML всегда казалось слишком сложно. Вот и начались все эти идеи с компиляцией в JS. GWT был одним из самых первых и самых успешных таких проектов. Когда он появился, все закричали:
                                  — Да вы что — это ж именно то, на чем написали GMail и Google Docs! Значит и мы сможем написать наше энтерпрайз-приложение!
                                  Сам Гугл при этом тактично молчал, пропагандировал GWT на всех конференциях, рассказывал о том, как это все здорово.

                                  Так GWT завоевал свое место в Энтерпрайзах. А потом случился казус: Google открыл свою библиотеку на JS — Google Closure — со словами
                                  — Вообще-то Gmail и Доксы написаны на ДжаваСкрипте.
                                  Все такие:
                                  — Эээ… пардон, а… на GWT тогда что написано???
                                  — Ну, вообще-то, мы на нем Google Wave написали, но он страшно тормозит, поэтому мы его закрываем.

                                  И звук такого разочарования: — Уап-вап-уаааап…

                                  А на самом деле JavaScript — язык весьма толковый. Если на нем написать строк 700 нормального кода, не изобретая особенных велосипедов, а используя современные практики — Underscore JS, JSLint, ES5-Strict, jQuery DOM-Events-Ajax и MVC/MVP-подход, — то писать на нем получается быстрее, проще и удобнее. Потому что пока мой товарищ напишет на Java свой UI на GWT, ему придется насоздавать несколько десятков классов, тысячу раз протанцевать вокруг всех типов, писать длинные методы-простыни из-за того, что в Java тяжело с колбэками; я успею все то же самое набросать в виде читаемой верстки, небольшого CSS и аккуратного скрипта, который я смогу нормально, без танцев с бубном и без постоянного редеплоймента протестировать и отдебажить во всех браузерах. И оно будет работать быстрее — всегда. Я никогда не видел, чтобы GWT-компилятор выдал на выходе код оптимальнее того, что, например, используется в jQuery. Основной тормоз производительности в вэбе — DOM-манипуляции. В jQuery они отточены до блеска, в GWT — отнюдь нет.

                                  Во многом проблемы GWT в Java, а не в самом подходе. Пример того же CoffeeScript показывает, что сам подход «компилируем в JS» вполне имеет право на существование. Даже с учетом того, что строки в результирующем JS отличаются от исходников на CS, соответствие прослеживается очень хорошо. Так что все возможно.

                                  Крики о том, что, мол, JavaScript ни черта не модульный, — полная чушь. Модульность не определяется типами, модульность — это интерфейсы и энкапсуляция. Ни то, ни другое в JavaScript не представляет какой-то сложности — Google Closure или Yahoo UI — яркие примеры успешной модульной архитектуры на JS. В случае с последней можно иметь несколько версий библиотеки и плагинов на одной странице — они не будут наступать друг другу на пятки никоим образом. Это jQuery.noConflict() на стероидах. И это именно тот подход, который Gilad Bracha — один из Дартистов — использует в своем языке Newspeak — там он как раз и разбирался с модульностью в программировании.

                                  Tool support? Откройте Chrome Developer Tools, IE9 Dev Tools, Opera Dragonfly, Firebug — там есть столько всего — пользуйся, не хочу! И откройте JetBrains WebStorm или любую другую их среду, где есть поддержка JavaScript. GWT нервно курит в сторонке.
                                    +28
                                    Аргументы по существу к вашим замечаниям
                                    a) На GWT написан Adwords — основной продукт на котором держится весь бизнес Google, преувеличивать используя историю с закрытием Wave явно не стоит
                                    b) Дебажить в яваскрипте всегда было адски непросто, если вы тут упоминаете IE9 Dev Tools как средство для дебага в IE — это гкхм… мягко говоря, вы им мало пользовались на огромных проектах. Firebug, Chrome dev tools — тут претензий нет, IE dev tools — откровенно унылое говно, может на hello world оно и работает адекватно, но явно не на чем-то большом.

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

                                    Но вот незадача, представьте себе проект жирного клиента в браузере с командой в 10+ человек, Enterprise уровня, что-то вроде Adwords интерфейса, работающего с разными кастомными API и имеющий очень нехилое Desktop-alike GUI, и нетривиальной бизнес логикой.

                                    И вот перед вами задача, как у ответственного за выбор технологии — на чем это все писать? Да, при этом вы понимаете, что вам и самому-то далеко до уровня хотя бы того же Крокфорда, не то что будущим 10+ членам вашей команды.

                                    По-ходу дела, вы также перелопатили кучу JS библиотек, которые как бы вроде и решают задачу, но каждая — какую-то свою отдельную, и ведь мечтается взять сразу что-то готовое и цельное, чтобы и архитектура правильная (MVP), и коммунити было, и документация вменяемая, и т.п. и т.д.

                                    Вот если взглянуть на GWT немного со сдвигом в бизнес, а не в быстроту манипуляции домом и прочие технические нюансы — какое бы вы решение приняли?

                                      +9
                                      С удовольствием отвечу.

                                      а) На GWT написан AdWords — да, и это история успеха. Однако, AdWords — далеко не самый популярный ресурс Google по посещаемости по сравнению с теми же Docs. Согласитесь, гораздо меньше людей размещают в Гугле рекламу, чем редактируют документы. У меня есть строгое подозрение, что если бы GWT действительно давал бы преимущества перед чистым JavaScript, Google за 5 лет его существования провел бы несколько миграций продуктов на него. Пять лет — срок немалый. Даже если мы возьмем 2-3 года на обкатку технологии, все равно уже прошло достаточно времени, чтобы «поверить» в него и выпустить на нем еще что-то. Тот же Buzz или Google+ — почему они не на GWT?

                                      Кроме того, мне неизвестен ни один другой крупный проект, написанный на Гвите. Я верю, что они есть, просто не знаю. Очень бы хотелось услышать о каком-то таком проекте, о том, на какие грабли пришлось наступить, о том, как преодолевались те или иные ограничения.

                                      б) Дебажить в Джаваскрипте действительно не всегда легко, но у меня в связи с этим вопрос — а вообще легко ли дебажить GUI? Вся эта событийная модель, где в секунду действия летит куча эвентов, и выделить среди них тот, который тебе нужен, не всегда возможно. Что касается IE9 — на сегодня это второй удобный для меня тул после Chrome Dev Tools. Обычно мы отлаживаем все до блеска в Хроме, а затем переключаемся на Эксплорер, и там работаем с IE-specific вещами. Да, не всегда достаточно, особенно, если работаешь с VML — тут вообще дело дрянь:( Но в целом, я очень доволен, в сравнении с тем же дебаггером в IE8. Нужно учитывать, что Микрософт в данном случае в роле догоняющего. Хорошо, хоть браузер сделали человеческий.

                                      В случае с 10+ человек вынужден сознаться, что опыта нет. Сейчас у меня в команде 4 человека, считая меня. До этого момента JavaScript знал только я. Ничего, научил — сделал серию заданий, которые нужно было выполнить, все с упором на выбранный стек технологий. Сегодня каждый из них спокойно работает с языком и со всеми его «странностями». Я заметил, что прототипизированное наследование у многих начинающих девелоперов вызывает кучу вопросов, но затем они обнаруживают, что динамическая типизация в сочетании с _.extend() дают желаемый эффект, и успокаиваются. Дальше в основном только восторги: нравятся object literals и callbacks, не нравится три равно в ряд.

                                      Цельного предложения на JS аля GWT на сегодняшний день нет — тут вы правы. Есть большие виджет-библиотеки: YUI, jQuery UI и Google Closure — но они не предоставляют организацию приложения. Так что я решил отталкиваться от MVP. Долго колебался между Backbone и Knockout и остановился на последнем. Не прогадал — Нокаут позволяет описывать взаимодействие UI-компонентов между собой и с сервером через механизм подписки. В демо к нему в основном показываются байндинги, но со временем мы все больше и больше отдачи получаем от механизма подписок. Сейчас data-bind воспринимается как что-то, что приятно иметь, но не самое главное.

                                      Организация кода вырастает из ViewModel и обработчиков — отдельные части мы раскидываем по файлам в соответсвии с задачей. Например, загрузка-сохранение данных — один модуль, взаимодействие с виджетами — другие модули. В результате даже в случае, когда кто-то работает с одними и теми же частями проекта, на ноги друг другу наступают редко — в большинстве случаев важен сам факт того, что вызван эвент, а порядок обработчиков значения иметь не должен. Сложности возникают, если это не так — тут мы внимательнее перерабатвыаем сценарий.

                                      Второй кирпич в основе современного JavaScript — Underscore. Если вы хоть чуть-чуть знаете, что такое LINQ в .NET, то в данном случае это нечто подобное — я имею в виду, что цель проекта — сделать код декларативным, спрятав все, что не имеет отношение к постановке задачи. Сейчас в нашем проекте практически не осталось циклов — все операции по работе с коллекциями мы производим через функции Underscore. Частично его функциональность пересекается с jQuery, в таких случаях мы отдаем предпочтение Underscore — в нем гораздо меньше магии и отлаживать соответствующие места удобнее. Вообще после выбора Knockout JS и Underscore мы заметили, что применение jQuery фактически свелось к аяксу и т.н. live-эвентам.

                                      Что было бы, сли бы наш проект велся на GWT? Я уверен, что мы бы потратили уйму времени на организацию кода, гораздо больше, чем в случае с JavaScript. Хотя тут играет роль среда разработки. В моем случае голоса в пользу GWT подавались — у кого-то даже был опыт работы с ним. Я просто предложил пройти курс JavaScript и самое сложное задание из него (с редактируемой гридой, автокомпитом, аяксом и т.д.) сделать на нашем стеке и на GWT. Ребята попробовали и сказали GWT нет.

                                      Два года назад я бы сказал: выбирайте YUI, а модули пусть потом вырастают сами, используйте custom events для их связи. Сегодня я говорю: выбирайте некоторый MVP фреймворк и Underscore, а библиотеку виджетов по вкусу — если у вас на странице jQuery и можно обойтись jQuery UI — пользуйтесь на здоровье, иначе — YUI — они не подведут. На GWT я всегда смотрел с опасением, хотя Java я оченнь люблю и пишу на ней много лет.
                                        +9
                                        Насчет

                                        Согласитесь, гораздо меньше людей размещают в Гугле рекламу, чем редактируют документы.
                                        я все-таки позволю себе не согласиться =)

                                        По-поводу вашего опыта использования — очень интересно было бы еще в деталях почитать, особенно про связку Knockout + Underscore, возможно у вас где-то завалялись записи в личном блоге. У меня такого опыта к сожалению не было, и кстати, выбор в пользу GWT делался почти 2.5 года тому назад, когда про такие либы ничего не было слышно. Тогда мы рассматривали вещи типа jQuery UI, YUI Library, SproutCore, Javascript MVC, Cappuccino.

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

                                        В чем прокол у явасрипта как у набора тулзов и как языка — так это в сложности поддержания дисциплины. А вот как раз java для этого подходит более чем, так как тут тебе весь набор средств — начиная от строгой типизации в самом языке, заканчивая тоннами готовых утилит для контроля за качеством кода.

                                        Спорить хорошо это или плохо — предмет другого разговора, до старта проекта на GWT у меня был за плечами опыт PHP / Javascript(prototype, jquery), Delphi, Pascal(x86) и всякое еще разное по мелочам. Но вот на чем мне уж точно не хотелось писать после PHP (CakePHP) — так это на Яве, страшилки про мегабайты XML файлов конфигураций, сотни иерархий классов с интерфейсами — все это меня откровенно пугало.

                                        Я сторонник концепции convention over configuration, которая кстати сказать, отлично работает в маленьких командах и на динамических языках типа Python/Ruby/JS. То есть при прочих равных, проще договориться между собой и использовать гибкий динамический язык, чем клепать тонны конфигураций и делать средства для контроля кода — но на сложных проектах с кучей людей, увы, другие законы — договориться становится просто физически нереально.

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

                                        Касательно тест-задания про редактируемый grid — точно могу сказать, что скорость создания своих компонентов(виджетов) в GWT таки будет казаться черепашьей по сравнению с обычным яваскриптом. Но как только этот компонент написан — тут уж re-use идет капитальный. Мы по этой причине вначале очень сильно тормозили, так как нужно было много чего сделать с нуля (из стандартных GWT виджетов мы использовали только несколько, все остальное пришлось делать самим)

                                        В общем, резюмировать могу вот этой замечательной картинкой :)



                                        Да, по ходу дела, наши стейкхолдеры иногда задалбывают неудобными вопросами — зачем нам GWT, которое не очень-то популярно(стоимость программиста сильно выше), разработку точно уж agile не назовешь (dev-mode тормозит, java overhead и все сопутствующие) ну и т.п. в том же духе. В какой-то момент, я решил более ясно изложить нашу позицию и родил опус Why GWT? — там более развернуто расписано почему и когда нужно выбирать GWT.

                                          0
                                          В точку. Мы в свое время взяли ExtJS. Гораздо более легковесный, чем GWT, но и с ним было СТОЛЬКО геморроя на UI, что просто финиш. В этом году написали свой фреймворк на Underscore и jQuery. Гораздо лучше все стало. Гораздо проще модифицировать UI. Дизайнер уже не рвет на голове волосы, выискивая класс в дебрях сгенеренного дума.
                                        +4
                                        > Во многом проблемы GWT в Java, а не в самом подходе. Пример того же CoffeeScript показывает, что сам подход «компилируем в JS» вполне имеет право на существование. Даже с учетом того, что строки в результирующем JS отличаются от исходников на CS, соответствие прослеживается очень хорошо. Так что все возможно.

                                        Преимущество GWT — это возможность отладки клиентской логики именно на уровне Java. Та же идея и с Dart. Никакой CoffeeScript этого не позволит, пока не будет создан свой CoffeeScript-runtime, т.е., вероятнее всего — никогда.
                                          +1
                                          Забавно, в про всякие JUnit в треде вообще никто не в курсе?
                                          В плюс написания всего насквозь на Джаве необходимо дописать в возможности сквозного применения TDD на всех уровнях разработки при помощи одних удобных и мощнецких инструментов (у нас — Mockito+JUnit и автотестирование в Тимсити).
                                          Ну плюс с divной DOM-моделью в ходе развития ветки 2.x надо сказать стало гораздо лучше, чем живописует автор статьи.

                                          Да, если есть ещё в Москве GWTшники непристроенные — идите к нам работать. Печеньки, все дела…
                                            0
                                            JUnit — да, рулит. Но в вебе на селениум всё же куда больше нагрузки приходится.
                                          –1
                                          Что на Java быстро писать не выходит — кто бы спорил. Но это недостатки конкретно Явы (не особо связанные, кстати, с собственно классами). К дарту всё это отношения не имеет.
                                            +3
                                            > Что на Java быстро писать не выходит — кто бы спорил.

                                            Я могу поспорить. При наличии хорошей IDE — очень даже выходит.
                                              0
                                              Она (или библиотеки её?) способствует слишком уж большому разбиению на классы, куче (не всегда нужных, в общем-то) уровней абстракции, чрезмерной детализации и т.п. Как-то громоздко оно. Мне пару раз синтаксис обращения ко всяким HashMap в кошмарах снился, кроме шуток. Хорошо что не особо много на ней писать пришлось.
                                                +2
                                                Что кошмарного в map.get(key) и mao.put(key,value)?
                                                  0
                                                  То, что это читается, мягко говоря, неудобно, а использовать это в более сложных выражениях, чем простое присваивание — ещё более неудобно. А вот [] мгновенно выхватываются взглядом, и в выражениях хорошо «сидят». В этом плане синтаксис STL гораздо приятнее.

                                                  Впрочем, я вообще сторонник специального синтаксиса — он (в разумных пределах, конечно) позволяет гораздо быстрее читать код.
                                                  0
                                                  Может быть Вы еще считаете ассоциативные массивы (котрые и списки и словари в одном) из PHP верхом изящества?
                                                  В Java коллекции на все случаи жизни, просто. В разных местах оптимальнее применять свою реализацию коллекции. А в PHP из-за его «универсальных» array эффективность просто зашкаливает.
                                                    0
                                                    Нет уж, спасибо. Хотя будь это просто одной из возможностей — ничего бы против не имел. А вот разные put/get/assign/equals читать крайне неудобно, и выгоды в этом никакой — специальный синтаксис был бы удобнее намного.

                                                    Но это скорее пример, хорошо демострирующий «дух» джавы — очень много неудобочитаемого и объемного кода. Начиная с XML-конфигов тех же.
                                                  +1
                                                  Согласен отчасти — все-таки типизация требует времени, причем чем сложнее система типов, тем тяжелее с ней иметь дело. Однако, в клиент-серверных приложениях основной проблемой становится маршаллинг объектов, но тут дело в хорошем сериализаторе. Например, в нашем случае мы взялись за Gson — это JSON-сериализатор и парсер от Google. Умеет, например, такие вещи делать:

                                                  Type collectionType = new TypeToken<Collection>(){}.getType();
                                                  Collection customers = gson.fromJson(json, collectionType);


                                                  Заметьте там anonymous class для типа - очень эффектный способ специализации, но выглядит как черная магия. Это как раз тот случай, когда приходится "воевать" с типами.

                                                  Но в случае с UI Java, к сожалению, даже среда разработки выручить не может.
                                                    0
                                                    > Но в случае с UI Java, к сожалению, даже среда разработки выручить не может.


                                                    Почему? Почти в любой IDE для Java есть свой UI-Designer же.
                                                      +1
                                                      Типизация в разумных пределах особого времени не требует — int написать не сложнее, чем var, а написать декларацию структуры — не сложнее, чем проверить, что пришел ассоциативный массив (используемый как структура) со всеми нужными элементами. Просто заигрываться в здоровые иерархии классов не надо. В джаве в этом плане уже довлеет традиция и накопленная кодовая база, но для веба можно делать гораздо проще и при этом отлавливать массу ошибок.
                                                  0
                                                  Хочу лишь заметить, что GWT на своей стезе был далеко не первым, отстав от Echo1 и Vaadin на 4 года, от OpenLaszlo на 3 года, от ZK на год.
                                                  И, учитывая ваш комментарий и пост автора, не понимаю, чем GWT лучше.
                                                    +2
                                                    Ваадин, кстати, сейчас переехал на гвит
                                                      0
                                                      Я даже не знал, что он был не на )))
                                                    +1
                                                    Насчет tools не могу согласиться.
                                                    Отладка в GWT это одна из существенных причин его использовать. Фактически отладка GWT приложения
                                                    ничем не отличается от отладки обычного Java. А тут доступен весь набор встроенных средств Eclipse или IntelliJ Idea. Никакая среда для JavaScript даже близко ничего подобного не дает.
                                                      0
                                                      Отличный коммент. Подписываюсь и плюсую. GWT вводит совершенно ненужный в данном случае уровень абстракции, который решая одну проблему, порождает другие, отнимающие время. Java не самый лучший язык. ООП не самый лучший способ разработки для веб.
                                                      +11
                                                      Сдается мне, автор статьи весьма поверхностно знаком с GWT.
                                                        +6
                                                        Я ж указал в статье — я четыре долбаных года на этом GWT делал один достаточно сложный проект и реализовал десяток мелких. Не фуллтайм, но пару человеко-лет в сумме я на GWT потратил. Так что насчет «поверхностно» вы малость погорячились.
                                                        Да, в статье есть некоторые технические неточности, но они допущены сознательно, чтобы не перегружать текст ненужными деталями, которые не влияют на общий смысл.
                                                          +9
                                                          Немного цитат, что сразу бросилось в глаза:

                                                          > В автоматически создаваемых элементах интерфейса использовалась махровая табличная верстка. Любой прямоугольный блок генерировал таблицу с одной ячейкой.

                                                          Кроме HorizontalPanel / VerticalPanel есть еще 100500 компонентов, а если этого мало — можно написать свои, на любой вкус.

                                                          > Сверстать свой HTML и скормить его GWT на практике оказалось также не очень-то просто.

                                                          Про UiBinder вы, наверное, тоже не слышали.

                                                          > В теории GWT поддерживает JSNI — что-то а-ля ассемблерных вставок в Си, только с Javascript в роли ассемблера. Но работает это только в одну сторону. То есть вызвать какую-то внешнюю js-библиотеку из GWT вы можете без проблем. А вот наоборот…

                                                          Вы про это — code.google.com/webtoolkit/doc/latest/DevGuideCodingBasicsJSNI.html#methods-fields?
                                                            +2
                                                            Да-да, про JNI это оно самое. Вы на практике пытались это заставить работать? Ну вот хотя бы, как я уже говорил, повесить онклик на картинку, которую перехватит GWT? Я пытался (и делал). В документации, прямо скажем, далеко не всё указано.
                                                            Про панели — мне что, надо было перечислить всю библиотеку? Основные (HorizontalPanel, VerticalPanel, FlexTable, Grid) — верстают таблично. То что с них выходит в итоге это жесткая жесть. UI Binder при этом ну совсем никак не помогает. «Можете написать свои» это бугога.
                                                              +2
                                                              Использовал на практике как раз похожую ситуацию. Работало как часы. Возможно вы просто не сделали DOM.sinkEvents.
                                                                +1
                                                                Я не работал с GWT, но, мне кажется, ваш комментарий намекает на то, почему разработка может быть медленной: нужно не забыть использовать dom.sinkEvents (и откуда-то узнать об этом). И будет еще миллион мест, где нужно вызвать/настроить/объявить/изменить какую-нибудь мелочь.

                                                                Связка js/html/css, помимо single responsibility и modularity подкупает своей прозрачностью.
                                                                  0
                                                                  Обычно подключать слушатели напрямую в DOM элементу — это как раз нестандартное использование GWT, для этого есть соответствующие события в самом GWT. В целом технология достаточно объемная и прежде чем ее использовать, лучше читать мануалы, иначе можно сталкиваться с проблемами, которые кажутся неразрешимыми. Сама возможность писать код на Java никак не отменяет необходимость знания JS и CSS. Также необходимо понимание, как это все работает на связке, и только когда будет выигрыш от GWT.
                                                                    0
                                                                    По моему это дело опыта, а не прозрачности чего бы то ни было.
                                                                      +1
                                                                      Я не спорю, но идея в том, что при прочих равных для создания сайта на хорошей технологии надо полгода опыта, а на плохой--3 года.

                                                                      Например, ASP.NET и ASP.NET MVC. ASP.NET--полный отстой, и, к примеру, даже с тремя годами опыта вам понадобится 2 месяца, чтоб сделать сайтик. А с ASP.NET MVC человеку с месяцем опыта понадобится 1 месяц, чтоб сделать тот же сайтик.

                                                                      Потому что в ASP.NET MVC лучшая архитектура (более прозрачная, меньше скрытых зависимостей, меньшая связность компонент и тп), и он лучше соответствует парадигме веба. Фраза «Возможно вы просто не сделали DOM.sinkEvents» намекает на те же проблемы, что есть в ASP.NET; но не на 100%))
                                                                  +4
                                                                  > Вы на практике пытались это заставить работать?

                                                                  Ну того что мне смогло потребоваться JSNI вполне смогло сделать.

                                                                  > повесить онклик на картинку, которую перехватит GWT

                                                                  Т.е. у вас есть где-то картинка, на onClick на которую вам нужно перехватить? И хандлер в JSNI-методе не срабатывал? Или в чем была проблема?

                                                                  > Основные (HorizontalPanel, VerticalPanel, FlexTable, Grid) — верстают таблично

                                                                  Почему вы думаете что это основные? Основные — это SimplePanel например, состоящая из 1-го div'а.
                                                                  Другое дело, что проще и быстрее использовать Grid/etc.

                                                                  > UI Binder при этом ну совсем никак не помогает.

                                                                  Поверьте мне, это вполне удобная и полезная штука. На личном опыте ощутил.

                                                                  > «Можете написать свои» это бугога.

                                                                  Да какие «бугога», это не так уж и сложно.
                                                                    +2
                                                                    Проблема с JNI в том, что имена ваших переменных, функций и классов в обфуксированном коде меняются при каждой компиляции. Внешний Javascript, который не прошел через компилятор, не может использовать выражения вида this.@com.google.gwt.examples.JSNIExample::myInstanceField — они, естественно, никуда не ведут. Вам приходится выполнять линковку вручную, то есть сначала вызывать javascript-функцию с callback-ом на себя, а потом этот callback eval-ить с нужными параметрами. И в документации (опять же, не знаю как сейчас) на этот счет тишина.
                                                                      +1
                                                                      А, вот теперь понятно. А если попробовать внутри JSNI метода определить JS функцию (которую и вызывать извне) и в ней сделать вызов this.@com.google.gwt.examples.JSNIExample::myInstanceField?
                                                                        0
                                                                        Вот кстати не знаю, разрешит ли компилятор сделать такой финт ушами. Не пробовал.
                                                                        • НЛО прилетело и опубликовало эту надпись здесь
                                                                          +1
                                                                          Такая простота — уже провал.
                                                                          +2
                                                                          А просто в GWT коде сделать что нибудь типа:
                                                                          public static native void defineBridgeMethod()/*-{
                                                                          $wnd.functionName = function() {
                                                                          return @com.corp.gwt.module.AppClass::myFunction()();
                                                                          }
                                                                          }-*/
                                                                          а потом просто в скрипте вызвать functionName()
                                                                          Или я чегото не понял и вы именно это имели ввиду говоря про вызовы callback-ов, тогда не очень понятно в чем тут сложность.
                                                                            +2
                                                                            Пока писал успели добавить кучу комментов :(
                                                                              0
                                                                              Ну примерно к этому и сводится, только не все такие методы могут быть static
                                                                              • НЛО прилетело и опубликовало эту надпись здесь
                                                                    –25
                                                                    Да и ник автора соответствует.
                                                                      +38
                                                                      Ну не всем же называться мастерами:)
                                                                      +3
                                                                      Возникла такая же мысль.
                                                                      >>В классическом же ООП будет отдельный класс, но это полбеды; главное — будет рефакторинг с выделением интерфейса
                                                                      >>и написанием кучи кода, который вообще ничего не делает, а просто поддерживает структуру классов. А всё из-за
                                                                      >>статической типизации, которая не позволяет просто так использовать вместо «просто кнопки» «кнопку с перламутром».
                                                                      Когда начинаешь учить Java может случиться enterprise головного мозга. Важно понять что никто не заставляет использовать интерфейсы и наследование везде и всюду. На java тоже можно все делать просто и быстро.
                                                                        +2
                                                                        Всегда удивляли люди которые лепили интерфейс на каждый класс, утверждая что это истинный java-стайл…
                                                                      +11
                                                                      GWT превосходен! Мало какой фреймворк или технология поразили меня сильнее.
                                                                      Убежден, что не существует более красивых изящных и продуктивных способов создания веб-приложений.

                                                                      >> HTML как таковой не использовался.

                                                                      Про UI-Binding почитайте плз…

                                                                      >> Нет такой функции — изменить стиль, и не будет, делайте всё CSS-классами.

                                                                      widget.getElement().getStyle().setProperty("fontSize", "1.2em");


                                                                      >> Если вам нужно сделать табличку 2х3, вам нужно описать модель, контейнер...

                                                                      Видимо речь шла о CellTable. Используйте обычный Grid или FlexTable

                                                                        +2
                                                                        Да-да, я знаю про getStyle(). Её тихо и без помпы добавили в 2.0, где она не работала в ИЕ, а нормально работать она начала где-то к 2.2 — как раз когда мы переписывали проект на jQuery. Спасибо, Великий Гугл!
                                                                        Вы, кстати, не находите, что такой подход — типа вашего getStyle или моего любимого
                                                                        grid.getCellFormatter().setWidth(0, 0, "45%");

                                                                        выглядит как-то немного длинновато по сравнению с реализацией того же на js или css? Не многовато-ли синтаксического мусора для таких простых действий? Подобных строк ведь в коде больше половины… Вот про это я и говорю — вроде всё работает, но без GWT получается в разы быстрее.
                                                                        Я знаю про Grid и FlexTable. Про UI-Binding не слышал, если вы про UI Bind, то это бред. Давайте добавим еще и XML, из которого будет генерироваться java-код, который скомпилируется в javascript, который породит html. Гениальное решение, ящитаю.
                                                                          0
                                                                          Парсер лох, следует читать «если вы про UI Binder»
                                                                            +3
                                                                            > Подобных строк ведь в коде больше половины

                                                                            Четкое следование паттерну MVC/MVP, выделение view в отдельный класс + UiBinder творят чудеса.
                                                                              0
                                                                              Да-да, а ещё люди придумали CSS и HTML, как раз для описания UI и внешнего вида, которые для этого намного лучше подходят и которые кушаются прямо браузером, без промежуточных компиляторов.
                                                                                +3
                                                                                И что же мешает использовать HTML/CSS практически в чистом виде в шаблонах UiBinder?
                                                                                  –1
                                                                                  И css не сразу появилось, и концентрироваться на html моложе 5-ой версии все уже чурачатся.

                                                                                  Консерватизм — не самая лучшая черта. А уже для профессии — губительна.
                                                                              0
                                                                              widget.getElement().getStyle().setProperty(«fontSize», «1.2em»);

                                                                              постыдились бы людям такой код показывать…
                                                                              +3
                                                                              Скажу пару слов в защиту GWT. Сам по себе GWT отличный инструмент, но его нужно использовать по назначению. У него достаточно узкая ниша – тяжелые веб-приложения. Именно тогда код, скомпилированный GWT, будет производительнее написанного вручную. Также остаются все плюшки Java разработки: привычные инструменты для статического анализа, покрытия кода, юнит-тестирования, документирования. Но, как и любой инструмент, GWT нужно правильно применять – приложение с хорошей архитектурой будет работать совсем не медленнее аналогичного, написанного на чистом JavaScript. А решение проблем, описанных автором, давно уже есть в мануалах, например, интерфейс можно описывать в виде xml разметки – UiBinder, использовать Cell Widgets, или использовать готовые библиотеки, например GXT.
                                                                                +4
                                                                                А почему автор берёт в пример приложения вроде интернет магазинов. Я вот сижу, пишу учётную систему в вебе (да-да, та что с малым кол-вом классов и большим кол-вом объектов) и думаю, как бы мне впихнуть представления автора в собственные реалии? Нынешний подход из сборной солянки всяких технологий или использования фреймворков вроде RoR хорошо работает для разработки сайтов, интернет магазинов и подобных приложений. Однако становится дурно когда ты фигачишь какую-нибудь финансовую систему с кучей форм, все на одно лицо, в которой везде должны быть одинаковые виджеты. В таких системах о вёрстке вообще речи не должно идти, иначе проект никогда не закончится. Функционал здесь как правило важнее рюшечек и супер удобства.
                                                                                  –3
                                                                                  Думаю фанаты Apple с вами не согласятся на счет рюшечек.
                                                                                  Почему, кстати, только интернет-магазины? Ну вот есть у вас столь любимый бюрократами отчет. Пару десятков колонок, тысченка строк, подытоги, пара сводных графиков. Кнопки сохранить и распечатать. Юзер кликает по ячейкам, в них на лету встраиваются input-ы, он там чего-то правит.
                                                                                  В каком месте тут нужны классы? Ячейки и строки? Бросьте, это примитивные типы для хранения данных, бизнес-логики в них почти нет. Ну конечно можно создать под них классы, но не обязательно. Основная логика принадлежит объекту «таблица», которая должна пересчитывать подытоги, сообщать графикам что пора перерисоваться и т.п. Таблица здесь в единственном экземпляре, все остальные объекты тоже.
                                                                                    +2
                                                                                    Потому что у наших бюрократов семь пятниц на неделе и отчёты меняются каждую неделю. А чтобы быстро и дёшево нафигачить очередной отчёт, нужно чтобы виджеты для редактирования и отображения по дефолту генерились из типа данных в колонке. Я не желаю каждый раз свёрстывать страницу для нового тупого отчёта. Я хочу просто прописать, что вот запрос должен отображаться в таком-то гриде. И тем более я не желаю прописывать валидацию на серверной стороне для бесконечных форм, если все поля можно просто разнести по типам.

                                                                                    Согласно статье автоматизация таких вещей в GWT реализована не лучшим образом. Но я имею массу положительного опыта в использовании такого подхода для учётных систем в вебе.
                                                                                      –1
                                                                                      Вот вы знаете, ваши слова звучат разумно (ну кроме валидации на сервере, она обязана быть), но по факту подкрутить javascript оказывается быстрее, чем «прописать что запрос должен отображаться в таком-то виде». Ну как-то вот так вот оно получается.
                                                                                    –2
                                                                                    «В таких системах о вёрстке вообще речи не должно идти, иначе проект никогда не закончится. Функционал здесь как правило важнее рюшечек и супер удобства.»
                                                                                    Пусть пользуются консолью баш наше все…
                                                                                    </сарказм>
                                                                                    Пробовали предложить подобный им интерфейс в поддержку вашей логике?
                                                                                    +3
                                                                                    Про Grid, точнее Cell Widgets, чистая правда. Очень Ориентированное Программирование. Попробовал один раз на свою голову, потом забивал костыль за костылем, чтобы элементарно повесить обработчик на ячейку. Касательно поста могу сказать, что GWT очень хорошо подходит для портирования десктоп приложений в веб, как вариант. Другой случай: есть толковые спецы, которые пишут на Java N лет и вдаваться в кросбраузерную верстку и остальные нюансы им не хочется, да и время не позволяет, а хочется написать полноценное веб-приложение здесь и сейчас.
                                                                                      +2
                                                                                      >Весь вопрос в том, какая парадигма позволяет быстрее решить конкретную задачу.
                                                                                      Соглашусь

                                                                                      >Java, и с ним весь классический ООП
                                                                                      >Это подходит всяким бизнес-приложениям
                                                                                      Подохит, а еще это подходит множеству других задач, или вы думаете enterprise это и есть вся java?

                                                                                      >В вебе всё не так.
                                                                                      Ого, а как?

                                                                                      >На одной странице у вас есть всего одна форма входа, одна корзина, один текущий пользователь
                                                                                      Ого, значит веб это у нас только интернет магазины? Фигасе…

                                                                                      Ну и дальше в таком же духе. «Специалисты» на хабре негодуют :)
                                                                                        +3
                                                                                        Это одна из лучших статей на Хабре за последнее время. Большое спасибо!

                                                                                        Полностью разделяю вашу позицию по этому вопросу.

                                                                                        Еще я был бы очень рад услышать вашу точку зрения о том, как можно было бы решить проблему с зоопарком из JS/CSS/PHP/etc более изящно, чем это пытается сделать Google.
                                                                                          +1
                                                                                          JS на сервере. Не обязательно node.js, но что-то в духе. Потом возможно хранилище, которое будет быстро перелопачивать JSON и давать интерфейс на подобие jQuery.
                                                                                            0
                                                                                            1) А чем JS на сервере принципиально лучше любого другого языка?
                                                                                            2) Один из плюсов того же GWT как раз в том, чтобы не хранить дерево объектов View на сервере (как в JSF) и соответственно не дергать его (сервер) на каждый чих.
                                                                                            3) Могу ошибаться, но пока парадигма NodeJS выглядит так, что сервер должен быть тупой (минимум бизнес-логики), но надежный. Далеко не все веб-сервисы и приложения укладываются в эти рамки.
                                                                                              0
                                                                                              1) дублирование кода
                                                                                              0
                                                                                              А как быть с эстетическим протестом против JS? Не в смысле, что дарт лучше, но всё же что-то неправильное есть в языке, если без гирлянды библиотек типа jQuery и underscore писать почти невозможно?
                                                                                                +2
                                                                                                На чистом Java, С++ или C# вообще без библиотек вы даже hello world не скомпилируете. И что, это плохие языки?
                                                                                                То, что новые фишки сначала обкатываются в сторонних библиотеках — это нормально. Тот же boost в С++. Уж лучше так, чем лепить в стандартную либу непонятно что, а потом половину этой либы объявлять deprecated как в Java.
                                                                                                  –6
                                                                                                  Во-первых, да, Ява это плохой язык, а С++ не очень хороший. Во-вторых, всё же stdio это стандартная библиотека, часть системы. Стандартная библиотека JS это браузер. В-третьих, я не согласен с такой аналогией. Речь не идёт о новых фишках. Речь идёт о непосредственном поле применения языка — работе с ДОМом. Очень тяжело, практически невозможно понять, почему мне надо писать
                                                                                                  document.getelementById('#bubuka')
                                                                                                  для столь фундаментальной и базовой операции. Библиотечные костыли
                                                                                                  $('#bubuka')
                                                                                                  костылями и остаются из-за позавчерашнего синтаксиса. Должно быть просто #bubuka, или как-то столь же просто, ДОМ должен быть одним из базовых типов данных. В версии jQuery мы имеем шесть мусорных символов, что, конечно, прогресс по сравнению с тремя десятками без неё, но в идеале должно быть не больше двух. ИМО.
                                                                                                    +1
                                                                                                    Ну если вам нужен именно getElementById, определите себе $=function(e){return document.getElementById(e)} и радуйтесь. Вариант с #e действительно был бы удобнее, но увы, увы.
                                                                                                    Но всё же объект jQuery устроен немного:) сложнее, и вот такие трюки как $(".myclass td span") определить #-подобной семантикой довольно сложно.
                                                                                                      +2
                                                                                                      Стандартная библиотека JS это браузер.

                                                                                                      Сомнительное утверждение. Контр-примеры: mongo dbshell, node.js, views в CouchDB, скриптинг в OpenOffice, Adobe Creative Suite, PDF, кишки Mozillы — тут HTML DOM, как правило, вообще не нужен.

                                                                                                      Что не отменяет изрядную громоздкость самого DOMа — ну так на то он и отдельная спецификация, его можно развивать отдельно, а можно и полностью заменить другим интерфейсом. Тут уж все карты у разработчиков броузеров на руках.
                                                                                                +11
                                                                                                Достаточно перестать относиться к стеку веб-технологий как к проблеме. В этом и заключается unix way: для каждой задачи свой инструмент. Для копирования файлов — программа cp, для удаления — rm. Для стилей в веб-странице — CSS, для поведения — JS.
                                                                                                  +1
                                                                                                  С некоторого времени веб перестал быть просто страницами, и пользователи ждут десктопо-подобного поведения, реализовать которое можно разными путями, но с использованием текущего стека веб-технологий достаточно неадекватно. И получается, что либо SQL БД у нас теперь на клиенте, либо каждый чих, включая onmouseover отправляется на сервер. GWT, как и остальные, пытается скрыть всё внутреннее уродство, но мы то о нём знаем.
                                                                                                  Делал красиво десктопо-подобные приложения на HTML+JS+CSS+whatever на серверной стороне, и довольно сильно запарился без отсутствующего на тот момент .live в jQuery как минимум, а как максимум нежеланием некоторых браузеров делать eval тэгу script, который добавлялся в какой-то новый элемент AJAX запросом. Да, это было красиво, но повторять такой опыт я бы вряд ли захотел.
                                                                                              • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                  +3
                                                                                                  Для ситуации «есть десктопное приложение на Java, есть толпа кодеров, которые ничего кроме Java не знают, и нужно сделать веб-версию» — да, безусловно, GWT рулит без вариантов.
                                                                                                  Но статья не о трудностях больших компаний, нанявших толпу Java-кодеров.
                                                                                                  • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                    • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                    +3
                                                                                                    Всё это вещи, на мой взгляд, спорные. Особенно, применение глаголов прошедшего времени.
                                                                                                    Бесспорная проблема у GWT одна: он безумно, катастрофически, убийственно, до слёз долго компилируется. И так же медленно работает в hosted mode.
                                                                                                    Что делать то? Делать то что? Какой супер-компьютер брать?
                                                                                                      +3
                                                                                                      а вам часто его надо компилировать? В хостед моде (который теперь девелопер моде) он на лету ваши изменения транслирует в виртуальную машину в которой крутится JS при отладке и отдается браузеру через плагин. Что-то более быстрое для разработки придумать сложно. Ну а когда время деплоить на сервер, да, придется потратить пару минут.
                                                                                                      • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                          0
                                                                                                          Один браузер + одна локаль + ещё драфт компилэйшн + ssd винчестер — всё равно не спасают. Может, i3 на ноутбуке уже убогим стал и надо i7 брать. Но как-то я н десктопах c i5 особого счастья тоже не видел.
                                                                                                          • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                          +2
                                                                                                          Вы собеседника читаете? И так же медленно работает в hosted mode — я сказал. А графики вообще в хостед моуд не работают. Но ООП обертка для ofc2 так убого написана, что json я стал ручками собирать и тестировать под apache httpd. Вот там да, что-то более быстрое, чем httpd придумать сложно :-) В конечном итоге не совсем ручками, с помощью GWT-ных классов JSONValue и моих расширений над ними, а флэшку запихнул в свое расширение FlashComponent, а charts из инхеритов выкинул, но всё равно под хостед моуд это не работает.
                                                                                                          0
                                                                                                          Насчет прошедшего времени — всё-таки я сильно сомневаюсь в светлом будущем GWT после выхода Dart. Всё же держать несколько принципиально разных решений для одного и того же достаточно дорого. Вряд ли GWT быстро закроют, но он и раньше развивался очень неспешно, а уж сейчас-то…
                                                                                                            +3
                                                                                                            А может GWT будет компилиться в дарт?
                                                                                                            +1
                                                                                                            Кстати, верно подмечено — у нас сейчас 3 приложения, суммарно время компиляции составляет в районе получаса. При этом мы поддерживаем только Gecko/IE8/Webkit (то есть еще и не все пермутации компилируем)

                                                                                                            Для регулярных билдов решаем супер-компьютером High-Memory Quadruple Extra Large Instance, удается сократить время до 20минут.

                                                                                                            Ну а на машинах рядовых девелоперов получается существенное ускорение если пересесть на SSD, докинуть памяти хотя бы до 8гб, и сидеть на чем-то вроде core i5
                                                                                                              +2
                                                                                                              SSD поставил, на первое время отлегло. Всё, кроме GWT, залетало :-) Памяти ему, вроде, не особо требуется. И компилируется оно в один поток. Одна пермутация, по крайней мере. Т.е., супер-пупер многоядерность сама по себе не поможет.
                                                                                                                0
                                                                                                                Увеличивать количество localWorkers пробовали?
                                                                                                                  0
                                                                                                                  Да. Одна пермутация — один поток. По вашей ссылке картинка есть, которая показывает, что при одной пермутации увелечиние LocalWorkers никакого эффекта не оказывает.
                                                                                                                    0
                                                                                                                    Все равно стоит поиграться, нам помогло
                                                                                                            +3
                                                                                                            GWT — это не средство для написания веб-приложений. Это фреймворк для написания RIA. Но не всё есть RIA. И сводить веб к ним — это кощунство. Так вот, GWT только для RIA и предназначен. Он не способен описыват серверную логику, генерацию HTML и т.п. JavaScript в общем случае — это не средство написания RIA. JavaScript позволяет сделать более интерактивным и удобным то, что обычным HTML+CSS сделать таковыми не получается. Скажем, в том же вики-движке можно с помощью JS сделать валидацию форм, кнопки для редактора вики-разметки, более удобный загрузчик картинок. Но это никак не отменяет базового функционала сайта — валидация всё равно делается и на сервере, вики-разметку так же парсит сервер, пусть она даже и набита в обычном text area, а файлы загрузить можно через простой input type=«file». При этом сохраняется главное, на мой взгляд, преимущество веба — за каждой страницей остаётся её адрес. GWT на такое не способен, т.к. в принципе для этого не предназначался. Как я понимаю, Dart выступает заменой JS в его различных сферах применения, а не только как алтернатива GWT.

                                                                                                            C другой стороны, проблема дублирования остаётся. Лично у меня появилась идея, как можно её избежать. Ряд действий (валидация, отправка и обновление форм, парсинг вики-разметки при предпросмотре) всё равно делаются сервером. Но на стороне браузера такие вещи обычно оказываются более удобными. Не хотелось бы дублировать код, написанный на Java, ещё и на JS. Идея состоит в том, чтобы автоматически получать JS-версию кода, уже написанного на Java. Для этого можно написать декомпилятор байткода Java в Javascript. Вот каковы варианты использования такой штуки:

                                                                                                            1. Валидация форм. Валидацию выполняет контроллер. Если вынести валидацию в отдельный метод контроллера, то этот метод можно преобразовать в JS, который то же самое делал бы на стороне браузера и выдавал бы alert'ы. Это вместо генерирования той же самой страницы, но с сообщениями об ошибках ввода.
                                                                                                            2. Частичная перерисовка страниц при отправке формы. Логику генерации разметки так же можно перенести на сторону браузера. Когда пользователь нажимает кнопку отправки формы, очень часто пользователю в ответ выдаётся та же страница по тому же шаблону. Вместо этого браузер мог бы передавать веб-серверу только новые параметры шаблона в ajax-запросе и автоматом перерисовывать часть страницы.

                                                                                                            При этом тот же самый функционал остаётся и с выключенным JS. Если же нужно написать что-то более динамическое, работающее именно на клиенте, разработчик может взять в руки JS или GWT — что ему нравится.

                                                                                                            Я уже сделал кое-какие наработки в этом направлении. У меня есть свой фреймворк, и в репозитории я выделил ветку, в которой работаю над декомпилятором байт-кода — уже есть первые успехи (почти правильно переписанный на JS метод java.util.ArrayList.indexOf в качестве примера). В перспективе хочется добиться генерации качественного читабельного JS, чтобы не столкнуться с проблемой текучих абстракций, которая присуща GWT.
                                                                                                              0
                                                                                                              Посмотрите в торону Fantom.
                                                                                                              +6
                                                                                                              Блин, чувак, я хотел быть в лучшем за 24 часа (.
                                                                                                                +6
                                                                                                                Извини, друг, не хотел обидеть:)
                                                                                                                +6
                                                                                                                Во-первых, кроме GWT емть не менее интересный Vaadin, который красив и не генерит бешеного HTML. Он просто тратит ваш трафик.

                                                                                                                Во-вторых, для подвешивания событий есть GWT-обертка вокруг jQuery (GQuery, ЕМНИП).

                                                                                                                В-третьих, GWT для RIA и приложений, которые иначе были бы написаны на swing/swt/jambi.

                                                                                                                Я закончил, спасибо.
                                                                                                                  +3
                                                                                                                  GWT справляется со своей задачей вполне. Использую Vaadin, в корне которого крутится GWT для RIA приложений идеальный вариант. А по поводу Dart… да пусть он будет. Выстрелит или нет покажет время. Я недавно читал статью в одном журнале, там сравнивали Go, Vala, D. Дак вот D превосходит Go и Vala по многим параметрам, но о нем не говорят. А все почему? Потому что нет рекламы, маркетинга, грамотной подачи технологии. Так же и Dart. Утихнет рекламная шумиха, и настанет жесткая проверка временем.
                                                                                                                    +2
                                                                                                                    Еще 2 копейки по поводу того что GWT не взлетел. Как минимум в одной ооочень крупной соцсети рунета взлетел, и довольно успешно
                                                                                                                      +2
                                                                                                                      2 Cher: так и скажем — Одноклассники ;-)
                                                                                                                        +1
                                                                                                                        не секрет видимо )
                                                                                                                        0
                                                                                                                        если кому мало мощности JS/Jquery рекомендую www.knockoutjs.com. Я с сентября с ним работаю, мне очень понравилось и я использую и буду использовать это в реальных проектах.
                                                                                                                        Плюсы:
                                                                                                                        — принципиально лучше user experience
                                                                                                                        — более структурированный js код в результате, который легче поддерживать
                                                                                                                        — переход общения клиент сервер на обмен данными(json) а не полями

                                                                                                                        К сожалению, в изучении не самая простая штука. Но если в что-то упретесь — всегда есть форум.
                                                                                                                        PS: МОжет написать статью о нем на хаббре? Хотя в принципе есть замечательное вводное видео

                                                                                                                          0
                                                                                                                          Напишите, очень интересно почитать будет.
                                                                                                                            +1
                                                                                                                            Вообще-то уже неоднократно фреймворк описывался на Хабре, в том числе мной.
                                                                                                                              0
                                                                                                                              :) посмотрю
                                                                                                                              «Чукча — не читатель, Чукча — писатель.»
                                                                                                                              0
                                                                                                                              Почему не backbone.js? Рассматриваю оба фреймворка, не знаю в каком направлении пойти, но пока backbone перевешивает. А на оба не хочется терять время.
                                                                                                                                +1
                                                                                                                                Я не использовал backbone, так что аргументировано ответить не могу. Могу посоветовать посмотреть примеры и сравнить код, который пишется на knockout и backbone и для себя решить, что понятнее и больше соответствует складу ума.

                                                                                                                                Вот похожие примеры:
                                                                                                                                http://documentcloud.github.com/backbone/examples/todos/index.html
                                                                                                                                js код к нему — http://documentcloud.github.com/backbone/examples/todos/todos.js

                                                                                                                                и knockoutjs:
                                                                                                                                knockoutjs.com/examples/betterList.html
                                                                                                                                  +1
                                                                                                                                  Я выбрал Нокаут, но вам могу сказать, что что бы вы не выбрали, в любом случае останетесь в выигрыше.

                                                                                                                                  Если кратко, то Knockout за счет data-bind-атрибутов даст вам упрощенную работу с UI-элементами. Большинство обработчиков событий, которые связанны с UI, в Бэкбоне придется писать ручками, а в Нокауте — нет. Зато Backbone делает больше работы на бэкэенде, в плане связи с сервером.

                                                                                                                                  Так что выбирайте — что для вас важнее — помощь с интерфейсом или с аяксом. В нашем проекте число различных запросов в коде совсем небольшое, а UI — очень сложный. И мы используем KO, так как он позволяет нам сократить объемы кода в большей степени, чем Backbone.
                                                                                                                                –1
                                                                                                                                Автор, я твой фанат! Вот за это тебе особенное спасибо: "… весь классический ООП, зиждется на идее разделения классов и собственно объектов — экземпляров класса. Это подходит всяким бизнес-приложениям, которым нужно обрабатывать миллионы строк накладных, платежей, остатков на складах и так далее. Классов там относительно мало, а вот объектов — много. В вебе всё не так." и так далее. Читал и горючими слезами обливался, т.к. ты кратко и емко формализовал то, что мучает меня в последнее время. Плюсик тебе в карму и остальные части тела! И запрос на дружбу тебе сейчас отправлю. :-)
                                                                                                                                  +10
                                                                                                                                  Прочитав статью и комментарии я не увидел ничего про поддержку написанного приложения.

                                                                                                                                  Главное отличие enterprise решений от не-enterprise в том, что в первом случае приложения задумываются не просто как "написал, показал колиенту, срубил денег, отвалил".
                                                                                                                                  Здесь необходимо рассматривать вопрос не о том как быстро написать приложение, а о том, как удобнее его потом будет поддерживать.
                                                                                                                                  Да ещё и с постоянно меняющейся командой разработчиков.

                                                                                                                                  У Java (и GWT как её части) тут большой положительный «опыт».
                                                                                                                                  Это — enterprise технология по самой задумке.
                                                                                                                                  И как бы там ни ругали Jav-у и java програмеров за их чрезвычайную приверженность к паттернам, — всё равно — когда я смотрю на java-код (паттерн), то я понимаю, что именно тут программист хотел сказать.

                                                                                                                                  И когда попадается на глаза (да даже и своё! чё греха таить?!) какой-то разброс PHP-шных зарезервированных слов, гордо именуемый Скриптом, то обычно хватаешься за голову — такое поддерживать через полгода будет просто нереально.
                                                                                                                                  Но просто написать — конечно! В разы быстрее. (на том же PHP)

                                                                                                                                  Короче, хотел сказать — Лучше день потерять (много «лишнего» java-кода на GWT), а потом за 5 минут долететь (лёгкая поддержка кода, написанного «как пишут большие дяди»).
                                                                                                                                    +2
                                                                                                                                    Понимаете, Javascript не то чтобы прям развился, просто широкие массы его наконец-то поняли. Да, 99% того, что на нём пишут — это быдлокод, но это в любом языке так. Ну может на PHP процент чуть выше, в С++ чуть ниже, но сути это не меняет.
                                                                                                                                    На Javascript можно и нужно писать хорошо поддерживаемый код. Ну да, в Javascript определение полей и функций класса перенесено в конструктор, поэтому на первый взгляд классов как таковых как бы и нет. И что? Это как-то мешает писать хороший поддерживаемый код? Исключительно дело привычки.
                                                                                                                                      +1
                                                                                                                                      > Это как-то мешает писать хороший поддерживаемый код?

                                                                                                                                      Имхо, мешает сама природа JS. Динамическая типизация вкупе с прототипным наследованием приводит к тому, что, смотря на функцию типа такой

                                                                                                                                      funсtion my_cool_function(obj1, obj2) {
                                                                                                                                       if (do_smth(obj1)) {
                                                                                                                                         return obj2;
                                                                                                                                       } else {
                                                                                                                                         return smth_else(obj2);
                                                                                                                                       }
                                                                                                                                      } 
                                                                                                                                      


                                                                                                                                      я мало того что не могу сказать, что за объекты obj1 и obj2, так даже если начну отлаживать, то увижу объекты obj1 и obj2 просто как набор полей и значений, без малейшего намека на то, что за сущности стоят за объектами. В этом смысле даже PHP удобнее. Ситуация осложняется тем, что в разные времена obj1 и obj2 могут принимать совершенно разные типы а так-же против нас работает слабая типизация (это когда можно невозбранно складываешь яблоки с апельсинами числа со строками или чего похуже).
                                                                                                                                        +1
                                                                                                                                        Да, про числа со строками это пожалуй главный косяк javascript-а номер 2. Номер 1 — автоматическая расстановка; в конце текстовых строк.
                                                                                                                                        Вообще в js косяков хватает, но их хватает в любом языке. В тех же плюсах есть очень заковыристые способы прострелить себе ногу, не смотря на всю типизацию.
                                                                                                                                          –3
                                                                                                                                          > Вообще в js косяков хватает, но их хватает в любом языке.

                                                                                                                                          Именно. Весь вопрос в их количественном измерении.

                                                                                                                                          wtfjs.com/
                                                                                                                                            +6
                                                                                                                                            wtfjs — это пример дибилизма разработчиков, которые не хотят даже посмотреть в сторону документации:
                                                                                                                                            — Оу я сегодня красила ногти в розовый цвет и программировал на JavaScript и хотел разбить строку из 6 символов на строки по два символа. Я нашла метод split, который переводится как «делить», я написала '123456'.split('2'), а оно мне выводит глупость какую-то! Этот JavaScript такооой слоооожный и тупооооой


                                                                                                                                            Там есть откровенный бред:
                                                                                                                                            Math.min() < Math.max(); // false
                                                                                                                                            

                                                                                                                                            А чего оно вообще должно иметь другое значение? Вообще-то оно ведят себя строго согласно документации.

                                                                                                                                            ",,," == new Array(4); // true
                                                                                                                                            
                                                                                                                                            0 == "0" // true, wtf!
                                                                                                                                            
                                                                                                                                            var foo = [0];
                                                                                                                                            console.log(foo == !foo);
                                                                                                                                            console.log(foo == foo);
                                                                                                                                            

                                                                                                                                            Эта фигня и фразы типа «Is it time to have a „maybe“ operator? :-P» меня вообще убивают. Оператор нестрогого сравнения — очень гибкая штука и он старается подстроится под программиста. Это просто инструмент, имеющий свои правила и люди, которые его критикуют — просто мудаки. Если вам нужно строгое сравнение — есть оператор "===". В чём проблема его использовать всегда и никогда не использовать "=="? В том, что нельзя будет сказать "Этот JavaScript такооой слоооожный и тупооооой"?

                                                                                                                                            Its still hilarious. Now, check this out:
                                                                                                                                            
                                                                                                                                                3..toString();
                                                                                                                                                // "3"
                                                                                                                                            

                                                                                                                                            Это что за хрень? Чего тут вообще неочевидного? Во что ещё должна приводится (3.0).toString()?

                                                                                                                                            Я уж молчу про остальной бред типа:

                                                                                                                                             3 > 2 > 1 // false
                                                                                                                                            
                                                                                                                                            parseInt('06'); // 6
                                                                                                                                            parseInt('08'); // 0
                                                                                                                                            
                                                                                                                                            NaN === NaN // false
                                                                                                                                            


                                                                                                                                            Не позорьтесь — не давайте больше ссылку на этот сайт с высерами бреда и непрофессионализма.
                                                                                                                                              +1
                                                                                                                                              Вопрос восприятия. Вы это воспринимаете как тупость разработчиков-неосиляторов, а многие, включая меня — как противоречивость, неоправданная переуложненность и WTF-нутость спецификации.

                                                                                                                                              Вы кстати выбрали оттуда самые очевидные приколы, но там достаточно и настоящего WTF-a. Чего только стоит нетранзитивность и несимметричность ==. Вот в языке есть вредное в программировании больших систем (к ним можно отнести все современные JS-фреймворки) автоматическое приведение типов. И именно из-за него в языке есть и == и ===. Что стоит программисту по ошибке написать == вместо === и в одном случае из 100 будет баг. Кстати, это один из тех «врожденных пороков», которые, по мнению Google не исправимы эволюционным путем, для чего и городят с нуля новый язык Dart.

                                                                                                                                              Почему-то Java, Python прекрасно обходятся без этих возможностей, а WTF-нутости в них заметно меньше.

                                                                                                                                              > Не позорьтесь — не давайте больше ссылку на этот сайт с высерами бреда и непрофессионализма.

                                                                                                                                              Не вижу ничего позорного. С моей точки зрения — отличный, познавательный, местами смешной сайт, вполне оправдывающий своё название, и иллюстрирующий, что JS в WTF-нутости (т.е. именно в WTF-нутости своей спецификации, к которой Вы аппелируете) местами даст фору тому-же Perl'у.
                                                                                                                                              Заглянув в профиль, понимаю, что задел за живое, откуда и такая эмоциональная Ваша реакция. Но, поверьте, я тоже знаком с JS не по наслышке.
                                                                                                                                                0
                                                                                                                                                На самом деле просто нужно понять, что "==" — это не тот же "==", что и в Java, вот и всё. Ситуация точно та же, что и с «3 > 2 > 1». Почему то считают, что JS должен себя вести как другие языки. А я вот долго программировал на Делфи и хочу, скажем, чтобы значение переменной присваивалось при помощи :=

                                                                                                                                                var a := 123; // SyntaxError
                                                                                                                                                


                                                                                                                                                Ой, какой плохой язык, у него оператор := работает неправильно, надо срочно запостить на wtfjs. Что стоит программисту по ошибке написать == вместо = и в одном случае из 100 будет баг.

                                                                                                                                                Это глупо, не находите? Оператор критикуют не за его недостатки, а за то, что он не такой, как в Java, всё.

                                                                                                                                                Пожалуйста, покажите настоящий wtf код с того сайта и обсудим его, потому что я ничего стоящего так и не нашёл. Там половина приколов — одинаковые приколы про "==", треть от оставшихся — приколы из-за стандарта «IEEE 754».
                                                                                                                                                  +1
                                                                                                                                                  > Что стоит программисту по ошибке написать == вместо = и в одном случае из 100 будет баг.
                                                                                                                                                  Нифига, в этом случае баг будет воспроизводиться гораздо чаще. И хорошему компилятору в таком случае не мешало бы выдать warning.

                                                                                                                                                  > Там половина приколов — одинаковые приколы про "=="
                                                                                                                                                  Угу, они явно показывают, что неявное приведение типов — зло.

                                                                                                                                                  > Пожалуйста, покажите настоящий wtf код с того сайта и обсудим его
                                                                                                                                                  И Вы меня убедите, что JS все-таки хорош и удобен? Вряд ли получится…
                                                                                                                                                    +2
                                                                                                                                                    Неявное приведение типов, как и любой инструмент — зло в неумелых руках.
                                                                                                                                                    Нет, не буду убеждать. Мне просто интересно там увидеть реальный wtf код, а не фигню.
                                                                                                                                                      –1
                                                                                                                                                      > Мне просто интересно там увидеть реальный wtf код, а не фигню.

                                                                                                                                                      Все примеры сайта wtfjs являются реальным wtf-ом, если под wtf-ом понимать несоотвествие принципу наименьшего удивления.
                                                                                                                                                        0
                                                                                                                                                        «Принцип наименьшего удивления» не имеет единицы измерений и способа определения их значения, потому не больше, чем философские рассуждения. Меня вот в Java, например, может удивить, почему new Integer(500) != new Integer(500), а в языке с перезагрузкой операторов — наоборот. Всё зависит от того, то взять за точку отсчёта. И для JS почему-то берут Java.
                                                                                                                                                          0
                                                                                                                                                          В Java'е как раз очень просто, достаточно запомнить одно правило:

                                                                                                                                                          "==" сравнивает объекты по ссылке, .equals() — по содержанию.
                                                                                                                                                          Примитивные типы также сравниваются по "==".


                                                                                                                                                          Применяя эту логику для JS пытаемся написать правило

                                                                                                                                                          "===" сравнивает объекты по ссылке, "==" — по содержанию".

                                                                                                                                                          И получаем вагон приколов на wtfjs, когда нам надо в каждом конкретном случае напрягать мозг и думать что именно нам применить — == или === и не пролезет ли что то лишнее если оставим ==.
                                                                                                                                                            +2
                                                                                                                                                            В JS тоже все просто, хочешь строгое сравнение используй ===, хочешь нестрогое (с приведением типов по правилам, описанным в спецификации) используй ==. Где wtf? На приведенном сайте есть совсем запредельные по своей тупости примеры, типа:
                                                                                                                                                            var a = {};
                                                                                                                                                            a == {} // false
                                                                                                                                                            
                                                                                                                                                            var a = [];
                                                                                                                                                            a == [] // false
                                                                                                                                                            

                                                                                                                                                            А что, простите, автор хотел получить сравнивая два разных объекта?
                                                                                                                                                              0
                                                                                                                                                              Применяя эту логику для JS пытаемся написать правило

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

                                                                                                                                                                «Принцип наименьшего удивления» таки имеет единицы измерений и способы определения их значения.


                                                                                                                                                                Там где в Яве достаточно запомнить одно кондовое правило, в JS надо в голове иметь всю спецификацию описывающую == и ===.
                                                                                                                                                                  0
                                                                                                                                                                  А почему я не могу в джаве передать метод в качестве параметра? Как-то так:
                                                                                                                                                                  uiWidget.onclick( element.run );
                                                                                                                                                                  


                                                                                                                                                                  Или, хотя-бы, так:
                                                                                                                                                                  uiWidget.onclick( element.run.bind( element ) );
                                                                                                                                                                  

                                                                                                                                                                  В javascript это сделать достаточно просто (необходимо лишь помнить про корректный this), а в Java надо в голове иметь всю спецификацию описывающую событийную модель

                                                                                                                                                                  final element // bla-bla
                                                                                                                                                                  button.addEventListener(
                                                                                                                                                                    new MouseAdapter() { 
                                                                                                                                                                      public void onClick() {
                                                                                                                                                                         element.run();
                                                                                                                                                                      }
                                                                                                                                                                    }
                                                                                                                                                                  )
                                                                                                                                                                  


                                                                                                                                                                  Тут надо и про final помнить и кучу кода писать. Так кто более wtf?

                                                                                                                                                                  Ещё раз говорю — "==" ничего не имеет общего с "==" из Java.
                                                                                                                                                                  "==" это "===" в Java.
                                                                                                                                                                  ".equals()" это ".equals()" в Java.

                                                                                                                                                                  Например, LibCanvas:
                                                                                                                                                                  var p1 = new Point( 5, 8 );
                                                                                                                                                                  var p2 = new Point( 5, 8 );
                                                                                                                                                                  
                                                                                                                                                                  p1 ==  p2; // false
                                                                                                                                                                  p1 === p2; // false
                                                                                                                                                                  p1.equals( p2 ); // true
                                                                                                                                                                  


                                                                                                                                                                  "==" — это синтаксический сахар JS, которого в Java просто нету. Отсюда и все ваши WTF
                                                                                                                                                                    0
                                                                                                                                                                    > а в Java надо в голове иметь всю спецификацию описывающую событийную модель

                                                                                                                                                                    Никакой спецификации событийной модели в языке нету, это Вам не C# с его делегатами. В Java — обычные старые классы и их композиция.

                                                                                                                                                                    > про final помнить

                                                                                                                                                                    Не надо помнить совершенно. Если забудете — компилятор всяко не скомпилит и укажет на ошибку.

                                                                                                                                                                    > и кучу кода писать

                                                                                                                                                                    Не проблема, при хорошей IDE, которая пишет за вас 80% кода. Более того, для JS умная IDE (в той же степени как для явы) как раз не возможна из-за природы языка.

                                                                                                                                                                    > "==" — это синтаксический сахар JS, которого в Java просто нету. Отсюда и все ваши WTF

                                                                                                                                                                    Ну я примерно то же и пытался сказать. Только вижу в этом не плюс (дополнительный синтаксический сахар) а минус (вредная возможность неявного приведения типов и все неочевидности, с этим связанные).
                                                                                                                                                                      +1
                                                                                                                                                                      Не умеете пользоваться сахаром — не пользуйтесь. Мне (и не только мне) он — очень удобен. Дополнительный сахар — это хорошо. Даже не смотря на то, что её нету в Java.
                                                                                                                                                                        +1
                                                                                                                                                                        > Не умеете пользоваться сахаром — ...

                                                                                                                                                                        Скорее не «не умею» а «не хочу».

                                                                                                                                                                        >… — не пользуйтесь.

                                                                                                                                                                        С радостью бы, да, к сожалению, не выходит, именно из-за:

                                                                                                                                                                        > Мне (и не только мне) он — очень удобен. Дополнительный сахар — это хорошо.

                                                                                                                                                                        Миллионы людей им уже пользуются и от этого не уйти. Многим нравится синтаксический сахар Perl. Он им просто нравится. Им нравится проявлять творчество и рождать шедевры типа таких

                                                                                                                                                                        www.cpan.org/misc/japh
                                                                                                                                                                        ru.wikipedia.org/wiki/JAPH.

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

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

                                                                                                                                                                        Потому Google и хочет выкинуть JS и начать с чистого листа.
                                                                                                                                            +2
                                                                                                                                            Именно. система типов — это, кроме всего прочего, ещё и документация.
                                                                                                                                        –1
                                                                                                                                        Дарт имеет большие шансы заменить GWT
                                                                                                                                          0
                                                                                                                                          Истину вам говорю: в день великомученника Стефана, Земля налетит на небесную ось!
                                                                                                                                          +6
                                                                                                                                          Данная статья — классический пример непонимания автором используемой технологии. И то как ее заплюсовали лишь говорит о том, насколько народ не в теме.

                                                                                                                                          На GWT можно писать простенькие «скрипты». Правда вопрос — зачем? Но там на сложность генерируемого DOM наплевать. Объемы не те.

                                                                                                                                          В остальном же GWT — для сложных RIA приложений. И требуется хорошее понимание соответствующих паттернов иначе набыдлокодить очень-очень легко. Вам надо вешать onclick через JSNI? — Это не GWT-way. Вам надо генерить кучу своего HTML? — Возможно, и тут вы просто неправильно используете эту библиотеку.

                                                                                                                                          Минусов в GWT хватает. И сложность разработки на нем очень высока (не надо заниматься самообманом). Но ничего из приведенного в статье, фактически, не является минусами GWT. Ну или, как минимум, в данных версиях *уже* не является. Более подробно расписали выше. И хотя мне есть что добавить, смысла в этом не вижу.
                                                                                                                                            0
                                                                                                                                            Да что ж вы все к onclick-у привязались то. Это простейший пример, чтобы объяснить суть проблемы связи с внешним js. Ну пусть этот клик будет брошен не статическим HTML-элементом, а скажем Google Maps-ами или еще каким-нибудь сторонним js API, аналогов которому в GWT нет. Что, писать свои карты, потому как гугловские по плохим паттернам сделаны? Бред же.

                                                                                                                                            И оставьте уже эту ерунду про RIA. Если для helloworld нужно написать 100 строк кода, то в большом приложении будет полный завал. Ну не бывает по-другому. Как выше заметили, в Java есть плюшки, действительно помогающие в больших проектах, тот же JUnit и внешние тулзы для контроля качества кода, но к GWT они никаким боком не относятся.
                                                                                                                                              +4
                                                                                                                                              Есть официальные (в смысле сделанные ребятами из Гугла) google maps api для GWT (правда карты там версии 2). Все прекрасно работает. И код там вполне себе нормальный без диких извратов.

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

                                                                                                                                              Hello world можно написать быстро и просто. Не надо тут. 1 xml + 1 класс. Причем все это при желании генерится соответствующими визардами в IDE.

                                                                                                                                              А по поводу RIA — это далеко не ерунда. Не просто так в GWT применяется не MVC, а MVP. Поднять каркас сложного приложения на GWT без опыта долго. Надо курить кучу мануалов, всяких best practice'ов, смотреть видео с конференций и т.п. Именно поэтому я и написал, что использование GWT не является простым и не надо его воспринимать как простой фреймворк. Но подняв этот самый грамотно настроенный каркас, приложение пишется сравнительно быстро и просто. При этом все хорошо отлаживается и тестируется.

                                                                                                                                              И да, если попытаться построить приложение на основе hello world'a, получится хрень. Сам я с такой проблемой сталкивался и приходилось долго и нужно все рефакторить, а то и переписывать с нуля.

                                                                                                                                              GWT построено вокруг определенных шаблонов. Как с точки зрения кода, так и мышления. Если вы «в теме», то все будет норм. Хотя, понятное дело, GWT серебренной пулей не является. Если вы пытаетесь писать «по-своему», то, возможно, столкнетесь с кучей неудобств. Но это совершенно нормальная ситуация для любого сложного фреймворка.

                                                                                                                                              Исходя из тех аргументов, что вы приводите, лично мне видится, что вы, не изучив толком технологию, попытались сразу написать серьезный проект. И столкнулись с трудностями изучения. Хотя, насколько я понимаю, дело было 5 и более лет назад и тогда GWT мог быть куда хуже. Но мне с трудом верится, например, что тогда были проблемы с тем же вызовом Java из JS через JSNI. Или что так геморно повесить обработчик события.

                                                                                                                                              ЗЫ: И, да, JUnit вполне относится к GWT. Может, вы просто не умеете его готовить?

                                                                                                                                               

                                                                                                                                              Сейчас лично мне *сейчас* совершенно пофиг на Dart. Влетит, не влетит — я, что, — Ванга? Пусть в Гугле доделают его до внятного состояния, пусть потом он пройдет испытание несколькими серьезными проектами вне Гугла. А только потом можно говорить имеет этот язык какие-либо перспективы или нет.

                                                                                                                                              У Гугла есть ресурсы, чтобы написать свой язык и продвигать его. Отлично. Даже если их попытки провалятся, из этого можно будет сделать полезные выводы. Как в плане стратегии, так и в плане языка — почерпнуть что-то интересное для реализации во фреймворках, к примеру.

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

                                                                                                                                              Это по поводу языка. По поводу же ваших статей. Что этой, что «части 1». В обоих аргументация нулевая. В первой части человек явно какой-то фанатик, который не способен воспринимать чужую точку зрения, а в этой — незнание технологии и, следовательно, ошибочный вывод.
                                                                                                                                                –1
                                                                                                                                                Да, мне действительно пришлось пять лет назад писать сразу серьезный проект на GWT, и да тогда действительно под GWT не было очень многих плюшек (и кстати сейчас тоже очень и очень многого нет). Проект в итоге трижды серьезно рефакторился, практически переписывался с нуля под свежие версии GWT, с добавлением новых фишек и технологий. Да, GWT развивался, но слишком медленно, многие серьезные баги висят годами, очень и очень многого там нет.
                                                                                                                                                Понимаете, я ведь не с улицы пришел, до GWT я участвовал в больших и очень больших проектах в том числе на Java и методологией, паттернами и прочим в целом очень даже владел. Ну знаете, если библиотека нормально принимает только свою родную реализацию MVP, которую допилили-то буквально совсем недавно, а со всеми остальными получается очень медленная скорость разработки — ну извините, это плохая, негодная технология.
                                                                                                                                                В итоге я пришел к выводу, что дело тут не в MVP/MVC и даже не в GWT, а в классической ООП парадигме как таковой. Она не очень применима в веб-приложениях, особенно в больших. Вот и всё.
                                                                                                                                                Я очень хотел бы услышать тут разработчиков ну пусть не AdWords-а, но хотя бы Одноклассников или там Evernote, вот к их словам я бы прислушался.
                                                                                                                                                А так ваши комментарии это зашкаливающее ЧСВ и слепая вера в Святые Паттерны, не более.
                                                                                                                                                • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                  –2
                                                                                                                                                  Хороший камент, подписываюсь под каждым абзацем.

                                                                                                                                                  Вдогонку оппонентам — gwt/java/OOP/паттерны — эти фреймворки/технологии/платформы/парадигмы/идеологии требуют больший уровень для входа в тему.

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

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

                                                                                                                                                    –1
                                                                                                                                                    походу у кого-то баттхёрт от моих каментов.
                                                                                                                                                  –1
                                                                                                                                                  И оставьте уже эту ерунду про RIA. Если для helloworld нужно написать 100 строк кода, то в большом приложении будет полный завал. Ну не бывает по-другому.

                                                                                                                                                  Вы заблуждаетесь настолько глубоко, что даже заблуждаетесь насчет глубины своего заблуждения.

                                                                                                                                                  Ну нельзя измерять возможности и область применения инструментов по одному синтетическому примеру «хеловорлда».

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

                                                                                                                                                  Это как крики, что лучшая IDE — это блокнот/vim.
                                                                                                                                                  Сразу видно об уровнях «проектов» таких блокнотеров/vim-еров.

                                                                                                                                                  Так и в случае с хеловорлодом.

                                                                                                                                                  Вы пойдите еще к разработчикам системы безопасности АЭС и скажите, что ваша разработка на [язык+технологии] говно, потому как хеловорлд занимает неприлично много строк, по сравнению с вашим любимым [быдло-языке].
                                                                                                                                                    0
                                                                                                                                                    что-то цитирование не сработало…
                                                                                                                                                    первый абзац — цитата.
                                                                                                                                                      +2
                                                                                                                                                      На моём любимом «быдло-языке» Си (никто правда до вас не называл его «быдло») хелловорлд занимает одну строку.
                                                                                                                                                      И я абсолютно уверен, что именно на нём (ну максимум на плюсах) написаны системы безопасности АЭС и прочие важные штуки. Просто потому, что Java и прочие managed-языки не годятся для систем реального времени. Точка.
                                                                                                                                                        0
                                                                                                                                                        согласен, насчет реального времени, хотя споры не утихают и есть движения насчет этого.

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

                                                                                                                                                        но возьмем более реальный пример — банкинг или трейдинг.

                                                                                                                                                          0
                                                                                                                                                          и я не приравнивал Си к быдло языкам :)
                                                                                                                                                          из контекста вших каментов нельзя было сделать вывод, какой ваш любимый язык.
                                                                                                                                                  +3
                                                                                                                                                  Не могу понять, почему все так любят обливать грязью новые непонятные им технологии. Мне, например, очень хотелось бы порядка в Javascript'е. И Dart на мой взгляд неплохая замена тому же Coffeescript'у. Но как бы я не ненавидел Javascript с его спагетти обратного вызова, я не пойду и не буду писать статьи с тоннами ненависти. Вопрос: зачем?
                                                                                                                                                    0
                                                                                                                                                    Люди хотят грязи (с) :)
                                                                                                                                                    +2
                                                                                                                                                    Слишком много далеко идущих обобщений, все равно что утверждать: 'затея Ferrari выпустить машину красного цвета кажется безумной — АвтоВАЗ тоже выпускал машины красного цвета и мы все знаем что из этого получилось.'.

                                                                                                                                                    Во-первых, странным выглядит сравнение нового языка и старого фреймворка, только на том основании что этот фреймворк тоже использовал один (но, sic! Промежуточный) язык.
                                                                                                                                                    Цель дарта, в первую очередь, создать быстрый и удобный в коллективной разработке язык для браузера. Задача оправдана, потому что js a) медленный (и не может быть не медленным) б) не удобен в коллективной разработке (потому что нет никакой возможности указать другим программистам как использовать твой код).Поддерживка северной версии это бонус который удешевляет разработку (с меньшей вероятностью придется искать программиста знающего язык X). Обращаю внимание — это бонус, а не стремление пересадить всех на один язык — если вы понимаете что для вашей задачи на сервере лучше использовать ruby никто не запретит его использовать.

                                                                                                                                                    Еще одно замечание насчет скорости: выше более или менее справедливо замечали что самое тормозное это все равно работа с Dom-деревом. Это так потому что никто не осмеливается писать вещи которые будут тормозить и без дом'а. Например модный сейчас canvas ограничен только своим API, т.е. Вы можете менять его содержимое попиксельно, но никто в зравом уме делать этого не будет — медленно.
                                                                                                                                                      –2
                                                                                                                                                      Я не думаю, что какой-либо мифический язык, будь он хоть трижды типизирован, способен радикально улучшить обход DOM дерева, а как вы сами сказали, в вебе это основное.
                                                                                                                                                      Поэтому все рассуждения про «быструю замену JS», которая бы быстро выполнялась, это ерунда.

                                                                                                                                                      Вопрос в скорости разработки больших веб-приложений. Но вот тут, раз уж скорость исполнения некритична, утиная типизация имеет преимущество. Статическая типизация требует написания большого количества технического кода — объявлений классов, интерфейсов, абстракций и прочего, прочего, но позволяет отловить не так уж много ошибок. Если вы попытаетесь передать в функцию аргумент не того типа, что в Dart, что в Javascript вы скорее всего получите ошибку и всё сразу обнаружите. А вот если у вас есть две переменных одного типа, a и b, и вы вместо a случайно передали b, то никакая типизация отловить эту ошибку вам не поможет. А вот кода для статической типизации придется понаписать намного больше.
                                                                                                                                                        +3
                                                                                                                                                        Утиная и статическая типизации это не антонимы. Язык может поддерживать и статическую и утиную типизации (например go). Я говорил о статической типизации в противовес динамической. Безусловно в языке для веба должен быть тип 'variant' который может хранить что угодно, но в большинстве случаев удобнее понимать с каким типом мы оперируем, чтобы фрукты на слово 'х@у' не умножать.

                                                                                                                                                        По поводу скорости я писал выше. Помниться здесь прискакивала статья про порфирование эмулятора x86 на js, там как раз использовалось расширение js — typed array, без которого не то чтобы невозможно было такое написать, но это просто не работало бы с приемлемой скоростью.
                                                                                                                                                          +2
                                                                                                                                                          Обход DOM-дерева — это основное в «эффектах на страничке», но никак не в полноценных приложениях, которые бы заменили десктопные. А как раз там javascript и неудобен — когда нужно держать и обрабатывать (кодом, который писали разные люди!) какие-то сложные модели данных, выполнять «тяжелую» алгоритмику. Мои любимые примеры — шифрование и обработка графики, которую запросто можно выводить на canvas, но вот сделать фотошопообразные обработки на JS — нет уж, спасибо.
                                                                                                                                                            –4
                                                                                                                                                            Фотошоп на js в браузере? Нет, спасибо.
                                                                                                                                                            А вот во всяких социальных и «офисных» приложениях основное как раз DOM. Тяжелые алгоритмы там если и есть, то они всё равно крутятся на сервере.
                                                                                                                                                              +3
                                                                                                                                                              Спасибо или не спасибо — а тренд именно таков, и гугл совершенно закономерно к этому готовится.
                                                                                                                                                              –2
                                                                                                                                                              Фотошоп на js в браузере? Нет, спасибо.
                                                                                                                                                              А вот во всяких социальных и «офисных» приложениях основное как раз DOM. Тяжелые алгоритмы там если и есть, то они всё равно крутятся на сервере.
                                                                                                                                                                –2
                                                                                                                                                                Фотошоп на js в браузере? Нет, спасибо.
                                                                                                                                                                А вот во всяких социальных и «офисных» приложениях основное как раз DOM. Тяжелые алгоритмы там если и есть, то они всё равно крутятся на сервере.
                                                                                                                                                            +5
                                                                                                                                                            JS очень дешев в быстрой разработке, но неимоверно дорог в дальнейшей поддержке и маштабировании.
                                                                                                                                                              +1
                                                                                                                                                              Я был на конференции от гугла про оптимизацию javascript Google Chrome. Там говорили, что в процессе оптимизации они делают фейковые классы, в которые преобразовывают javascript-код. Я забыл как именно это помогает ускорению, но это есть по факту.
                                                                                                                                                              Что касается преимуществ объектной модели javascript перед другими: я в целом согласен, но есть одно но. Простому программисту трудно писать код в таком стиле, с классами тупо ПРОЩЕ разобраться. А как показывает практика более простые для понимания языки вытесняют более сложные. Например, php вытеснил perl из веба.
                                                                                                                                                                  +2
                                                                                                                                                                  Кстати, в Windows 8 Javascript станет одним из официально-поддерживаемых языков разработки приложений в новом стиле Metro. Очевидно, что Microsoft видит будущее за JS и уж точно не будет способствовать продвижению альтернативных языков, вроде Dart.
                                                                                                                                                                    0
                                                                                                                                                                    Хозяйке на заметку: типизация в Дарт — это всего лишь фишка в помощь разработчику. Даже если вместо ожидаемого Integer в переменной будет что угодно другое — все продолжит работать (правда временами, очевидно, неизвестно, к чему эта работа приведет).
                                                                                                                                                                      0
                                                                                                                                                                      Вот за это автору отдельное спасибо:

                                                                                                                                                                      Я четыре года писал на GWT, и я могу уверенно сказать, что для веба утиная типизация лучше статической. И влияет оно только на скорость компиляции, а не на скорость исполнения кода.


                                                                                                                                                                      Изучая различные web подделки я раньше не мог понять одну вещь — зачем люди делают, обертки, кучу классов внутри которых куча методов вида:

                                                                                                                                                                       function add_element( $e )
                                                                                                                                                                              {
                                                                                                                                                                                      $this->elements[] = $e;
                                                                                                                                                                              }
                                                                                                                                                                      
                                                                                                                                                                              function set_x_legend( $x )
                                                                                                                                                                              {
                                                                                                                                                                                      $this->x_legend = $x;
                                                                                                                                                                              }
                                                                                                                                                                      
                                                                                                                                                                              function set_y_legend( $y )
                                                                                                                                                                              {
                                                                                                                                                                                      $this->y_legend = $y;
                                                                                                                                                                              }
                                                                                                                                                                      
                                                                                                                                                                              function set_bg_colour( $colour )
                                                                                                                                                                              {
                                                                                                                                                                                      $this->bg_colour = $colour;
                                                                                                                                                                              }
                                                                                                                                                                      


                                                                                                                                                                      Потом эти методы мучительно инициализируются конструкциями вида:
                                                                                                                                                                      $chart->add_element( $line_out );
                                                                                                                                                                      $chart->add_element( $line_in );
                                                                                                                                                                      $chart->set_x_axis( $x );
                                                                                                                                                                      $chart->set_y_axis( $y );
                                                                                                                                                                      


                                                                                                                                                                      Почему нельзя тупо сделать?
                                                                                                                                                                      $chart_settings = array(array("$line_out","$line_in"), $x,$y,… bla bla");

                                                                                                                                                                      Или еще тупей просто подключить библиотеку и вызывать просто функцию с просто аргументами?

                                                                                                                                                                      Думал я об этом и чувствовал себя недалеким быдлокодером, который просто еще не понимает великой идеи мировой революции :)

                                                                                                                                                                      И тут впервые сказано — оказывается ИНОГДА можно употреблять процедурный подход! За эту смелую, яркую и сверкающую удивительной новизной идею готов аплодировать стоя как настоящий быдлокодер!
                                                                                                                                                                        +1
                                                                                                                                                                        Не просто так есть термин «ООП головного мозга». Если вы пишите API, которым будут пользоваться другие разработчики, соизвольте писать наиболее качественный код. Если вам надо написать маленький скриптик, то нафиг не н