ООП будущего: Барух Садогурский и Егор Бугаенко о том, как мы будем программировать через 20 лет

    Концепция объектно-ориентированного программирования воспринимается разработчиками по-разному: кто-то говорит, что ей уже пора на свалку истории; кто-то кодит и не задумывается о том, что, как и почему он делает; а кто-то пытается работать в «pure OOP» парадигме, переворачивая классические паттерны с ног на голову.

    В преддверии Joker 2016 мы попросили Баруха Садогурского обсудить судьбу Java и ООП с Егором Бугаенко. Что из этого получилось, слушайте в аудиоформате или смотрите в видео:



    А под катом лежит полная расшифровка интервью со всеми ссылками.

    Барух jbaruch Садогурский: Всем привет. Меня зовут Бáрух, я developer advocate в компании JFrog, ведущий подкаста «Разбор Полётов», спикер на конференциях вроде Joker, JPoint, ну и всякой лабуде типа JavaOne, Devoxx и прочего. И сегодня в солнечном Маунтин-Вью мы сидим с известным в определённых кругах Егором Бугаенко, встретились поговорить за жизнь.

    Егор yegor256 Бугаенко: За жизнь? А я думал, про ООП, Java…

    Барух: Наша жизнь — это и есть ООП, Java. Для начала расскажи о себе для тех, кто не слышал.


    Егор: Java-программист, архитектор. Программировать начал лет 20 назад, ещё в школе — вначале это был PASCAL, потом ассемблер, потом C, потом C++, потом Java. Последние два с половиной года веду блог, благодаря которому появилась какая-то известность. Пишу книжки, сейчас пишу второй том. Пытаюсь немного поправить объектно-ориентированные подходы, которые используются в Java. Где-то получается, где-то меньше, но пытаюсь эту идею доносить в массы, благодаря чему эти массы…

    Барух: Бурлят!

    Егор: Бурлят и реагируют по-разному, да. Кому-то это нравится, кому-то нет, но эффект это производит, до кого-то какие-то мысли доходят. Кто-то против, и я не могу сказать, что сам уверен во всех своих мыслях на текущий момент, но процесс идёт. Да, чем я зарабатываю на жизнь: у меня небольшая распределённая команда в Пало-Альто, порядка 50 человек сейчас, так сказать, работающих, а суммарно человек 100. Мы пишем софт на заказ на Java. Заказчики у нас здесь, в Силиконовой долине, я управляю этими процессами с несколькими проджект-менеджерами. Программисты по разным странам, отовсюду. Вот этим зарабатываю, ну и книжка немножко денег даёт.

    Барух: У меня к тебе масса вопросов. Во-первых, задам острый вопрос: откуда ты такой взялся? Ты появился на поверхности русскоязычного Java-комьюнити год назад, вихрем прошёлся по конференциям на постсоветском пространстве, и я так понимаю, что завязал. Что это было, Бэрримор?



    Егор: Не завязал, у меня ещё 7 конференций впереди — меня приглашают, я не отказываюсь. Но теперь не так активно. Я выступил за последние полгода на 25 конференциях, немножко многовато.

    Барух: Так вот, как так получилось, зачем это тебе надо? Это достаточно тяжёлая работа, я по своему опыту знаю. Программист, архитектор, CTO внезапно решает: «А не провести ли мне полгода, разъезжая по конференциям».

    Егор: Хороший вопрос, у меня нет на него ответа. Но в какой-то момент я понял, что хочется расширить аудиторию. Блог меня на это подбил.

    Барух: Зачем тебе эта аудитория? На блоге много не заработаешь, на книжке много не заработаешь, я не вижу в этом коммерческого интереса. Может быть, ты таким образом хайришь людей?

    Егор: Ты понимаешь, я уже не контролирую этот процесс, я стал заложником процесса, который сам создал. Я завёл блог, появилось комьюнити, люди дают свой фидбэк и начинают меня вытаскивать, чтобы я с ними поговорил. Это двунаправленный процесс. С одной стороны, я хотел выступить на нескольких ключевых конференциях: JPoint в Москве, в Киеве JEEConf, в Белоруссии тот же JET. А другие места появились сами, потому что люди меня стали видеть и говорить «Давай и сюда тоже».

    Барух: У меня есть интересная аллегория, она весьма непроста, но попробую. То, что ты делаешь, у меня вызывает религиозные коннотации. У тебя «пророчество» как процесс: ты ходишь по миру, рассказываешь какие-то совершенно «еретические» вещи, люди тебя любят, ненавидят, ты это уже не контролируешь. Это совершенно библейская история. И они обычно плохо кончают, эти пророки!

    Но у меня по поводу твоей концепции объектно-ориентированного программирования очень много вопросов, сейчас мы попробуем их как-то последовательно выстроить. Основной вопрос такой: ты пытаешься придать термину «объектно-ориентированное программирование» какое-то значение, которого не только сейчас у него нет, как ты утверждаешь, но и которого, на мой взгляд, никогда не было.

    Есть то, что мы называем объектно-ориентированным программированием. Это, как мне кажется, отличается от того, что ты называешь объектно-ориентированным программированием. И возникает вопрос «зачем?» Есть тот путь, который ты считаешь правильным, и у него могут быть плюсы и минусы, как и у любой парадигмы — функциональной, объектно-ориентированной и так далее. Почему ты пытаешься всунуть свой путь именно в нашу знакомую, уютную, обжитую, нишу объектно-ориентированного программирования?

    Егор: Почему не создать какую-то новую парадигму, ты спрашиваешь?

    Барух: Ну она и есть новая парадигма же. У слов есть свои значения. ООП — это классы, объекты, посылка месседжей объектам с определёнными параметрами для получения обратно какого-то значения. Это полиморфизм, наследование, какие-то вещи, которые мы знаем, любим и так далее. Теперь ты приходишь и говоришь: «Нет, объекто-ориентированное программирование — это не это». Зачем?

    Егор: Ну, скорее не «зачем», а «почему». У меня нет ответа на вопрос «зачем?», потому что для этого должна быть какая-то цель, у меня такой чёткой цели нет. Ни денежной, ни какой-то другой. Это вопрос, скорее, «почему?», почему я так делаю. Потому что мне сильно не нравится то, с чем я работал на протяжении многих лет… Мне не нравится ни тот код, который я писал, ни та Java, которую я видел, ни библиотеки, с которыми я сталкивался, мне неприятно с ними работать. Не только мне, а людям, которые вокруг меня, программистам. Я вижу, какой код они пишут, как тяжело этот код потом понимать, поддерживать, как вообще неприятно программировать.


    Мне не нравится ни тот код, который я писал, ни та Java, которую я видел, ни библиотеки, с которыми я сталкивался, мне неприятно с ними работать.



    Я на конференциях задавал вопрос аудитории: «Вам нравится то, что вы делаете? Вы любите этот код, вы с утра просыпаетесь, смотрите на этот код и хотите его писать, или вы пишете потому, что вам нужно это делать?» Кто-то говорит «Да, нам нравится», но я думаю, многие лукавят. Я помню себя, когда первые три дня или три недели пишешь программу с нуля, и она тебе нравится, а последующие три года ты пишешь её потому, что должен.

    Барух: Ну это всё понятно, но это нормальное явление…

    Егор: Я думаю, что ненормальное.

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

    Егор: Но они и там нагадят. Если они не поняли ООП и просто от него отвернулись, сказали, что оно плохое в целом, всё ООП… Как вот недавно в блоге я собрал цитаты известных людей об объектно-ориентированном программировании. Они все говорят гадости. Начиная с Дейкстры, заканчивая сегодняшним днём. Люди говорят, что это противная концепция в принципе, давайте её не использовать, потому что она помогает создавать «spaghetti code».

    Барух: Ну да, они утверждают, что индустрия переросла объектно-ориентированное программирование — так же, как она переросла процедуральное программирование. И тут я опять возвращаюсь к тому же вопросу. Естественный ответ был бы: «ОК, вот новая парадигма, вот «ООП 2.0». А ты говоришь: «Нет, то, что вам не нравится, на самом деле называется по-другому». И вместо того, чтобы предствавить свою новую парадигму (что само по себе непростой путь), ты к этому добавляешь ещё сопротивление того, что люди не понимают, зачем ты пытаешься назвать это чем-то иным.


    Весь мейнстрим неправильный, 95% вы делаете неправильно



    Егор: Ну чтобы носом их ткнуть. Это такой элемент провокации, который необходим, чтобы люди задумались. Если я им предложу «ООП 2.0», как ты говоришь, ну почитают несколько человек, скажут: «Ну хорошо, ещё одна идея какая-то, отложим её, подумаем. У нас есть Java, она прекрасна, она идёт вперед, она мейнстрим, на ней все пишут, по ней проводятся огромные конференции, на ней огромные фреймворки, всё прекрасно». Есть какая-то другая, новая парадима? Ну хорошо, у него пол-фреймворка, восемь программистов, ну вот пусть они там сидят и копаются. Когда же я прихожу в этот центральный мейнстрим и говорю «Ребята, весь ваш мейнстрим неправильный, 95% вы делаете неправильно», народ начинает шевелиться, ёрзать на стуле и понимает, что ему не предлагают что-то третье (куда он может пойти, а может проигнорировать), а объясняют, что сегодня ты только вредишь всем. Конечно, это вызывает большие эмоции. У меня много мейлов есть, мне люди пишут: «Я понял, что десять лет подряд делал не то, твоя такая-то статья открыла мне глаза, я теперь всё понял, я буду делать так», а другой пишет: «Да заткнись ты, прекращай это рассказывать, мы знаем, что делать». Такая разнополярная реакция говорит о том, что людей это затрагивает, что им это небезразлично, а это хорошо. А если делать что-то стоящее в стороне, это мало кому покажется интересным.

    Барух: То есть ты специально выходишь на линию огня для того, чтобы заставить людей задуматься.

    Егор: Так получилось. Когда я начинал статьи писать, у меня была первая статья о том, что null reference — это плохо. Она не очень провокационная, потому что многие об этом знают и говорят. Я написал немного более резким тоном: большинство статей говорит о том, что старайтесь его избегать, а я написал, что это в принципе плохо, это evil, не трогайте его. Потом пошёл чуть дальше и написал про геттеры и сеттеры. То есть я не хотел никого провоцировать, я просто писал, исходя из своего опыта. Потом отследил реакцию и понял, что многих людей это цепляет за живое, и они согласны с этим, увидел много фолловеров, не хейтеров. А потом подключились хейтеры. Но я их игнорировал, потому что видел, что кому-то это в кассу, кто-то с этим согласен. Я пошёл немного дальше. Но я не специально, не было такой задачи: давай мы сейчас спровоцируем толпу, увидим, на что у них будет реакция и начнём собирать трафик. Такой цели не было. Я просто написал сначала несколько статей из своего нескольколетнего опыта.



    Барух: То есть ты опять же возвращаясь к религиозной тематике, которая меня не отпускает, это какое-то реформаторство. То есть ты делаешь какое-то новое прочтение. И, как в любом реформаторстве, есть люди, которые называют тебя еретиком и хотят сжечь на костре… Есть, наоборот, последователи. И, в общем-то, ты это осиное гнездо палкой расшевелил.

    Егор: Причем хейтеры — это в основном люди, которые мало читают, которые мало слышали, слышали звон — ну ты сам это видел на «Разборе полётов» в 109-м выпуске, когда Женя EvgenyBorisov Борисов пришёл и клеймил меня, особо не прочитав ничего. Я всё хочу послать ему книжку. Я бы очень хотел, чтобы он прочитал всё целиком и собрал всё в кучу, ты же читал книжку, ты понимаешь это. А он прочитал что-то, услышал: «А, он говорит, что вот это плохо и это плохо, да он дурак».

    И большинство негативных реакций именно такое. Люди узнали что-то по пол-слова и сформировали мнение. Это не сбивает меня, потому что есть люди, которые согласны. Если бы были все несогласны, я бы сильно задумался, не зря ли провоцирую толпу. А так сделали недавно на Gitter-чат, там набралось за полтора месяца 120 человек, и люди обсуждают, часто уже в стороне от меня. Часто бывает идея какая-то, один спрашивает: «Как бы вы это сделали?», а другие ему отвечают: «Мы бы сделали это так» и дают ссылки на мой блог. Это очень прикольно наблюдать, когда мысли уже не мои, они уже там живут, люди этим пользуются. Это приятно. Хотя есть в этом же чатике хейтеры, мы систематически стараемся тушить, а они поднимают флейм. И там часто задают этот твой вопрос: «Зачем ты меняешь ООП, у нас всё хорошо, у нас есть Java… Ну назови это по-своему и отстань от нас».

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


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



    Егор: Да, ты прав совершенно, это плохо отражается на бизнесе. Во-первых, с приёмом на работу проблема, во-вторых, с поиском клиентов. Когда клиент приходит и слышит, что мы делаем что-то сильно иначе, чем другие, то возникает вопрос «а не ошибаются ли они». Мы вам всё закажем, а через полгода будем искать новую команду, которая всё это выбросит, потому что понимает только эта. Это есть. С набором на работу тоже проблема — хотя есть люди, которые очень хотят именно к нам, пока таких немного. Но мне интереснее не быть ещё одной компанией в большом ряду других, а быть компанией, которая делает что-то иначе и лучше. Может, я ошибаюсь.

    Барух: Женя Борисов просил узнать, насколько часто бывает, что на интервью ты даёшь претенденту тестовое задание, показываешь кусок кода, а он переворачивает стол и говорит «что это за херня, я не буду это писать».

    Егор: Я слышал тоже, как Женя Борисов сказал в каком-то «Разборе полётов», что у него в Израиле была знакомая команда, где люди делали что-то по-своему, и все остальные компании банили людей из этой команды. То есть, если ты приходишь из той компании, то всё, никаких интервью, потому что у тебя мозг сломан и ты пишешь по-другому. Я понимаю, у нас тоже есть такая штука. Мы когда принимаем Java-программистов на работу, мы часто даём кусок кода на Java, который, на мой взгляд, написан с большим количеством ошибок. И просим показать ошибки. Что бы вы исправили? И многим этот кусок кода кажется правильным, а там сеттеры, геттеры, null… Всё, про что я выступаю, там представлено. И те, кто не обращает на это внимания, просто рефакторит и считает, что всё нормально. Мы таких людей отклоняем. Но есть люди, их не так много, но и немало, которые находят и говорят: «Да вот тут у вас эти сеттеры, геттеры — это что за фигня, это ерунда… надо переписать по-другому». Вот таких людей мы сразу: оп, заходи. И они находятся, в месяц одного-двух неплохих ребят имеем.

    Барух: Это хороший темп.

    Егор: Мы не спешим, мы же не строим сейчас команду из тысячи человек. У нас на данный момент такой задачи нет. Но ситуация, мне кажется, на рынке меняется. Меня слышат, не так много людей, но кто-то слышит. Я думаю, что изменения пойдут не через мою компанию, не через коммерческие. А люди на местах у себя начнут менять. Мне написал человек несколько недель назад, что прочитал мою книжку, она ему очень понравилась, потом он показал из нее куски своим коллегам, и теперь с ним не дружат. Но он же пошёл и показал, значит, какой-то эффект пошёл, не я это рассказал, а он пошёл. Это прикольно.

    Барух: Антропологический интерес в этом всём я понимаю. Раз уж всплывает книжка, давай немножко поговорим про книжку. Это началось, как блог, который ты решил подбить вместе в какую-то подборку…

    Егор: Не, сначала я писал в блог чуть больше года, а потом со мной связалось издательство Manning. И они предложили написать книжку: ты напиши, мы опубликуем. Сначала я сказал «нет», потому что был занят, потом через полгода решил всё-таки написать. Сел прошлым летом и за два месяца её написал. Это было несложно, потому что материал из блога. Сейчас я пишу второй том, и это тяжелее: про некоторые темы никогда раньше не писал, и нет реакции людей. Когда писал первый том, знал реакцию читателей, у меня была куча комментов. С Manning потом не сложилось, и я опубликовал книгу сам. Желания изначально писать книжку у меня не было, но когда издательство предложило, я задумался.

    Барух: Твоя концепция развивается, в ней есть противоречивые моменты, это какой-то ментальный work in progress, когда картинка ещё не полностью сложилась. Что требует какого-то переосмысления того, что было написано. Вот этот второй том является переосмыслением первого, или ты первый откладываешь и говоришь «что было, то было»?

    Егор: Нет, я первый не трогаю, я во втором делаю ссылки на него: «вот я говорил это, а теперь я говорю немножко другое…»

    Барух: Вот это я ищу: где будет написано, что ты был неправ?


    immutability сейчас очень активно обсуждается в нашем чате и не можем до конца понять, что такое immutable object...



    Егор: Ну у меня это бывает. Я пишу, что я был неправ, уточняю что-то. Допустим, immutability сейчас очень активно обсуждается в нашем чате и не можем до конца понять, что такое immutable object… И это обсуждение очень живое, у меня есть в блоге четыре штуки, и в книжке целая глава про … Если всё это сложить, то там есть вещи, которые друг другу противоречат. Но я открыт этому, нет проблем сказать, что я был неправ.

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

    Егор: Вопрос хороший. Но даже если там были какие-то ошибки, они не такие серьёзные. Там нет таких фундаментальных ошибок, которые нужно было бы переписать целиком. Есть какие-то моменты, которые чуть-чуть левее, чуть-чуть правее, но в целом нет. И концепция — я не сказал бы «стройная», но складывается одно с другим. Я не просто пишу об идеях, я еще и код пишу также. И есть некоторые продукты, которым три года, два года, один год. Можно их просмотреть и увидеть, что в продуктах, которым три года, два года, масса вещей, до которых я дошел вот недавно, не было. Сеттеров не было, но в некоторых местах есть и null pointer, и ORM используется где-то. То есть некоторые вещи можно открыть в опенсорсе и увидеть, что теоретическая мысль была там ещё в зачатке. А более свежие продукты более интересные, в них уже используется вся красота ООП.

    Барух: Ну вот это интересное раскрытие информации о том, что на самом деле концепция ООП от Егора — она work in progress. Я не уверен, что многие, кто с твоей концепцией познакомился, это понимают. В основном из-за книжки. Потому что обычно, когда человек пишет книжку, поскольку оно на бумаге и автор не может добавить апдейт «вот тут мне написали в комментах, что я был неправ», оно как-то воспринимается законченным. Immutable, так сказать. Мне кажется, многие люди не в курсе, что это всё живёт, развивается, течёт. И на самом деле ты готов не только слушать, но и принимать критику, и она действительно может как-то изменять концепцию.


    Класс — это вообще ошибка. Не должно быть классов.



    Егор: Приведу пример. Ну вот например в книжке у меня написано, что класс — это определенная концепция, которая нужна и важна. Я разговораривал с Дэвидом Уэстом. И он мне говорил, что класс — это вообще ошибка. Не должно быть классов. Я думаю, я пока не уверен, прав он или что он имеет в виду.

    Барух: Концепция, что класс — это ошибка, это из JavaScript. Объектно-ориентированное программирование через prototype. И есть очень серьёзный диспут на очень высоком уровне, который уже продолжается двадцать лет, о том, нужен класс или нет. И есть доводы за и против. Довод за: в объектно-ориентированном программировании класс — это действительно совершенно лишняя сущность. Она не добавляет ничего. Ты создаёшь объект, как его считаешь нужно создать, и потом создаёшь ещё сколько-то таких же. Но тут, с другой стороны, есть масса проблем типа immutability: объект может измениться, что происходит с теми, кто создан до этого? Должны ли они измениться, должны соответствовать новому или старому? И почему вроде одинаковые объекты, созданные с разницей в несколько строк кода ведут себя по разному? Потому что в каком-то другом месте изменился prototype. Ну, приехали, классно теперь. Вот эта концепция blueprint как класса, из которого ты клепаешь объекты, этот вопрос решает, потому что класс — это что-то неизменяемое, а объекты от него потом отпочкуются и живут своей жизнью. А с прототипами это не так понятно. Поэтому тут безусловно есть, о чем подумать.

    Егор: Есть, да. И что, если я поменяю свое мнение?

    Барух: Ну, если ты ещё и от классов откажешься, то это вообще будет армагеддон.

    Егор: Я пока не отказываюсь от них, но Дэвид сказал мне: «Кто это вообще придумал, зачем они нужны?»

    Барух: А вот теперь скажи мне, давай возьмём такую гипотетическую ситуацию, что ты действительно решил отказаться от классов и наследования. Ты — человек, который мёртвой хваткой вцепился в Java (надо понять, почему, сейчас мы об этом тоже поговорим), но гнуть Java под свой ООП можно только до определённой степени.

    Егор: Да.

    Барух: Что ты будешь делать, если ты решишь, что класс — враждебная ООП структура?

    Егор: Я надеюсь, что я так не решу, хотя… Понимаешь, у меня есть некоторые статьи, где сказано «как плохо делать вот это», но не предложено никакой альтернативы Java, я так их и заканчиваю: если Java улучшится, и это будет какой-то новый язык, тогда мы сможем делать то-то и то-то.


    я предлагаю управление памятью: говорю, что диски и память должны быть чем-то одним. Мы же даём программисту в Java управлять файлом на диске — открыли, закрыли. Почему то же самое нельзя делать с памятью?



    Например, я предлагаю управление памятью: говорю, что диски и память должны быть чем-то одним. Мы же даём программисту в Java управлять файлом на диске — открыли, закрыли. Почему то же самое нельзя делать с памятью? Вот такой концептуальный вопрос. Java этого не даёт, а мне кажется, что правильный язык должен давать возможность управлять памятью. Как в C/C++, но в каком-то удобном виде. Но Java я не поменяю.

    Барух: Это подводит меня к следующему вопросу: почему ты мёртвой хваткой вцепился в Java? Ты уже пришёл к выводу, что истинного ООП-языка не существует. У нас есть платформа JVM, позволяющая относительно малой кровью написать любой синтаксис языка, в котором будут все карточные игры и все девушки лёгкого поведения истинного ООП, которые ты только захочешь. Тебе не приходило в голову такое?

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

    Барух: Я, наверное, тебе отвечу, что это отличная библиотека, но не обязательно функция языка. Существует подход, что в принципе языки должны быть минимализированы, а всё остальное подключается с помощью необходимых библиотек. И тебе есть дело до истории твоих коммитов в Git’е, а мне нет, например. Тебе нужна эта фича — ты подключаешь библиотеку, и она у тебя есть.

    Егор: А её невозможно сделать как библиотеку, она должна быть в языке.

    Барух: Вот это интересный вопрос. Почему?


    Потому что эта библиотека будет выглядеть криво, как AOP в Java, приклеена сбоку, как AspectJ



    Егор: Потому что эта библиотека будет выглядеть криво, как AOP в Java, приклеена сбоку, как AspectJ. Прикольная идея, классная, но нет её поддержки в языке. Есть аннотации, которые появились позже. В четвёртой Java вообще не было никакой поддержки AOP, и всё это было налеплено через неродные технологии. Поскольку они неродные, всё неудобно, некрасиво. Java, или любой язык, должен давать AOP by definition, он должен быть by default, встроен в язык. И так же доступ к Git. Это история наша — кто коммитит, сколько коммитит — это уже часть языка.

    Барух: Но сегодня это Git, а завтра — Mercurial.

    Егор: Это проблема, да.

    Барух: И эта проблема решается библиотекой. Сегодня подключил библиотеку для того, завтра для другого.

    Егор: Я согласен, возможно, нужна какая-то комбинация «язык + библиотека». Нужна возможность, используя язык, получить доступ.

    Барух: С тем, что для языка может быть полезно бóльшее количество SPI я, возможно, соглашусь.

    Егор: Вот штук 40 таких фич, которые должны появиться. Допустим, Continuous Integration. Она совершенно никак не приклеена к языку. Или build automation. У нас есть все эти мавены и грейдлы, которые к Java никакого отношения нативно не имеют. Сам код на Java не знает, что его будут билдить. Я внутри кода не могу получить доступ к этой информации. Или, допустим, юнит-тесты. Они существуют на Java как просто класс, но какие это классы? Какие это объекты? У меня есть объект book, что такое объект bookTest? Это странно. И эти методы — это не методы, это процедуры в чистом виде, микроскрипты. Оно должно быть сделано как-то иначе. Сделано так, потому что тесты сделали после Java. Нужны вам юнит-тесты — ну вот так лепите. Это не нативно, не клеится одно к другому. Этим пользуются, но должны быть более удобные средства внутри языка. Я думаю, что мы к этому идём. Такие plain языки типа C, где просто можете скомпилировать бинарник — это двадцатилетней давности, а сейчас нужно что-то новое.

    Барух: Это Java двадцатилетней давности, а C уже сорокапятилетней.

    Егор: Тем более, должно быть что-то новое. Я думаю, появится. Может быть, я что-то создам, не знаю. Это требует времени и, главное, должно быть коммьюнити. Создавая под себя, получу чисто моё решение. Вот ты говоришь «не Git, а что-то другое», а мне такое и в голову не придёт, для меня Git стандарт фе-факто. Ты скажешь «у нас целая команда на Mercurial или Subversion», а у меня уже не лепится, целый кусок рынка моё решение не будет поддерживать. Тут должно быть гетерогенное коммьюнити, где разные люди.

    Барух: Скажи, а что ты думаешь о новых языках? Два примера — Kotlin и, может быть, Ceylon, если ты на него смотрел.

    Егор: Ceylon мало смотрел, Kotlin — был на презентациях на конференциях. Я тут не могу быть экспертом, но, к сожалению, мне кажется, что общее направление в индустрии не в сторону чистого ООП, а, наоборот, в сторону его коммодизации. Вам нужны геттеры и сеттеры — так вот они by definition. В Котлине вам не нужно их писать, они там есть! Язык придуман и развивается как design pattern — люди накодили, а потом другие приходили и говорили «это назовём синглтоном, а это вот так». А должно быть с обратной стороны, должны люди приходить и говорить «давайте использовать такой design pattern, такое решение». И потом все практики за ними должны идти. А мы идём от практики к теории.


    Java EE, практически покойный по сравнению с технологией, которая рождается из best practices, по сравнению со Spring.



    Барух: Ты предлагаешь башню из слоновой кости. У нас в Java коммьюнити такая есть. И она на наших глазах рассыпается. Я говорю про Java EE, практически покойный по сравнению с технологией, которая рождается из best practices, по сравнению со Spring. Смотри: Java EE развивался как раз так, как ты считаешь правильным. Сидели умные пацаны, которые думали, какие best practices должны быть, назвали их официальным стандартом. Более того, этот стандарт продвигался самым сильным на рынке Java-игроком — самим Sun, а потом Oracle, у тебя есть стандарт from the source, что может быть лучше. И вот.

    Егор: Я согласен. Значит, плохие теоретики, инженеры. И они должны работать в связке, теоретики должны смотреть на практиков. Но потом не описывать увиденное, как Kotlin. Не хочу сказать конкретно про Kotlin, но выглядит так: посмотрели на то, что люди делают, и увидели, что все делают геттеры и сеттеру, давайте людям упростим жизнь. Я предлагаю наоборот: давайте людям усложним жизнь там, где они делают что-то неправильно, чтобы они перестали делать геттеры и сеттеры. А большинство языков программирования создаётся в битве за популярность. Они понимают, что если дать людям не 4 инструмента, а 14, упрощающих то, что и так делают, то их станут использовать с большим интересом.


    У Kotlin и им подобных направление, по-моему, неправильное. Практика должна идти с теорией, и теория должна корректировать практику.



    Как Ruby. Язык вроде создавался правильно, но там такое огромное количество статики, такое огромное количество процедур, что весь язык… Язык хороший, но с библиотеками выглядит как какая-то каша. Им очень тяжело пользоваться, по крайней мере, мне. Я пишу на Ruby, но это какой-то кошмар, Java лучше. У Kotlin и им подобных направление, по-моему, неправильное. Практика должна идти с теорией, и теория должна корректировать практику.

    Барух: То есть ты считаешь, что за языком должны стоять какие-то визионеры.

    Егор: Конечно. Должны говорить «Ребята, вы идёте немножко не туда, теперь пойдём туда». А не «Все идут туда, побежим вперёд и встанем с флагом». К чему это приведёт? Это временные языки, они умрут через несколько лет.

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

    Егор: Они не пойдут по новой дорожке, даже если ты им предложишь. Безусловно, то, что ты говоришь, имеет смысл. Никто не пойдёт по новой, потому что никто платить за это не будет.



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

    Егор: Именно. Но я не пытаюсь изменить ситуацию с сегодняшнего дня, чтобы мы с завтра стали писать иначе. Я пытаюсь менять на шаг вперёд, через год, два. Если сейчас мы начнём в головы программистам вставлять идею о том, что геттеры и сеттеры — плохая идея, то через три-четыре года, когда эти люди, которые сейчас учатся, начнут создавать свои фреймворки и улучшать что-то, учтут эти мысли.


    Когда я читаю твою книжку, это геометрия Лобачевского. У меня начинают пересекаться параллельные линии.



    Барух: Вот тут у меня есть для тебя интересная рефлексия. Вот то, что ты пытаешься сделать, и эти твои блог-посты, каждый поодиночке, преследуют эту цель. Ты объяснил, почему null — это плохо, что должно быть N параметров в методе, почему в конструкторе нельзя писать бизнес-логику. Каждый из этих ходов, наверное, немножко улучшает сегодняшнего Java-программиста. А потом я беру твою книжку, и, как я написал в ревью, я вижу совершенно другую, новую концепцию, по сравнению с сегодняшней Джавой. По совокупности всего вместе взятого. Когда я читаю один пост, могу немножко улучшить свой код, оставив всё остальное так же. Когда я читаю твою книжку, это геометрия Лобачевского. У меня начинают пересекаться параллельные линии. Это невозможно сочетать с тем, что я делаю сейчас. Или делаешь так, или по-другому. И твой код — он тоже совершенно другой. Он не постепенное изменение существующего. Когда я смотрю на твой код и сравниваю с моим, решающим те же задачи, это не просто «у тебя нет null, а у меня есть». Твой код вообще ничем не похож на мой, кроме скобочек и точек с запятой. И тут у меня получается некоторый диссонанс с твоей идеей инкрементальных изменений.

    Егор: Понимаю, о чём ты говоришь. Но я не добьюсь результата мягкими действиями. В блоге я в рамках одной статьи вбрасываю, человек читает, немножко меняется. Книжка делает бросок далеко вперёд. Она говорит «Вы здесь, а правильно — вот там, через 20 километров. Как вы туда доберётесь, я не знаю». Как в анекдоте: «Моё дело — стратегия, а с тактикой вы сами решайте». А блог даёт какие-то шаги — тут немножко так, тут так. Книжка забрасывает далеко вперёд и писалась с такой задачей, не на один год — как вброс в будущее. Ну и она должна быть резкой. Тяжело человека сдвинуть. Масса была статей про null и про геттеры-сеттеры. Ты можешь погуглить, не один я это пишу. Почему мои вызывают такой флейм, у меня про геттеры-сеттеры триста комментов за полгода, а у уважаемого Аллена Холуба за десять лет пару комментов? Потому что он говорит мягче. Он говорит «Старайтесь держаться от них подальше, не использовать их». А я говорю «Если ты используешь их, то ты дурак». Естественно, это вызывает реакцию и побуждает к изменениям.

    Барух: Ты сейчас ставишь две противоречивых цели. С одной стороны, ты говоришь об инкрементальном изменении людей, а с другой, про бросок на 20 километров… Вот смотри — Мой личный фидбэк — я прочитал, насладился мысленным экспериментом и забыл, потому что так писать сейчас я точно не буду. Мне очень понравилось, было очень интересно, я размял мозги, но что я приду на работу и начну писать так, не возникло мысли ни разу — в отличие от того, как я прочитал твой пост про null’ы и подумал «надо мне вот этого постараться поменьше теперь делать». Потому что я работаю в команде, мой код должны читать, и если я сейчас закоммичу в Git код «Yegor Style», то после code review мне нечем будет кормить семью. А если я уберу null’ы, меня только похвалят. И тут у тебя, насколько я вижу, есть конфликт этих двух целей — что-то реальное, что можно сделать завтра, и концепция, из которой нельзя ничего сделать завтра, если только не занимаешься опенсорсом себе в удовольствие.

    Егор: Это твоя позиция, а вот, например, Антон antonarhipov Архипов написал в ревью, что задумался над тем, как его собственный код исправить.

    Барух: Ха, ну ты привел пример, «код Антона Архипова»! Антон на данный момент — ведущий продакт-менеджер в ZeroTurnaround, и он не пишет код в продукт. Он не штатный программист. Он пишет много кода в опенсорсе, он делает кодревью, но это не тот человек, который пришел, надел наушники, хряпнул кофе, и до вечера у него восемь часов портянки кода выходят, который потом нужно тестировать, интегрейтить, ревьюить, поддерживать…

    Егор: Ты вроде тоже не такой.

    Барух: Я тоже не такой, но я ставлю себя на место программистов в команде, и я понимаю, что нет, я это никогда этого не сделаю. То, что я прочитал в книжке, это не просто прикольно, это супер-круто, причём, как по мне, самое крутое — это настолько непохоже на всё, что мы делаем и, тем не менее, имеет смысл. Но я почитал, я закрыл и меня это конечно обогатило, но ничего такого, что завтра я могу пойти и написать там нет, потому что книжка намекает, что это одна концепция, что это всё должно работать вместе, в отличие от разрозненных блог-постов. В этом есть прелесть, потому что ты построил общую концепцию, и в этом есть недостаток, потому что я не чувствую себя вправе взять один кусок, и проигнорировать остальное, я таким образом нарушаю концепцию, это неправильно! В блоге у тебя всё это отдельно, я захотел — согласился с null’ами, захотел — не согласился с сеттером. Книжка — это концепция. С концепцией я или соглашаюсь целиком, или нет.



    Егор: Согласен, есть такая проблема. Но в блоге всё разрозненно, и были люди, которые говорили прямо противоположные вещи: ты вот нам рассказываешь про здесь какой-то кусок, здесь какой-то, а оно всё куда-то сведётся у тебя воедино? Что ты вообще думаешь про ООП, как должен вообще выглядеть объект, ты можешь хоть раз написать целый код? То есть люди искали какой-то целостности. Поэтому книжка суммирует.

    Барух: В целостности есть безусловный плюс — из книжки мы понимаем, что такое «ООП от Егора». Но возвращаясь к твоей цели изменить разработчиков one step at a time — оно не там. И может быть нужно и то, и другое. И кажется в процессе этой беседы у меня появилось некоторое понимание, что для установления твоей credibility нужно, чтобы с одной стороны, люди узнали, что у человека есть концепция, книжку, в конце-концов написал, не проходимец, а с другой стороны, вот практические шаги, которые можно предпринять сейчас, если конкретно эти шаги вам подходят и нравятся… Вот тебе совет: берёшь эту книжку, которая концепция, и в конце каждого параграфа у тебя будет что-то типа: «Ребята, я понимаю, что у вас сейчас взорвётся мозг, и я понимаю, что вы не сможете это использовать завтра, а вот это вот, то что будет написано дальше — вот это сможете применить в коде без опасности быть убитым стулом на код ревью». Не просто ссылка на блог, а сформулированый practical advice на основе прочитанной главы. И тогда получается некоторая комбинация и целостной картины, и каких-то маленьких шагов, которые можно предпринять сегодня.

    Егор: Это хорошая мысль, может быть, действительно так сделаю.

    Барух: И вот тогда это, наверное, сводит две противоположные концепции.

    Егор: Я согласен, я попробую это сделать. Может быть, не прямо в книжке, но мысль хорошая. У меня было много комментов к книжке, люди говорят «мало практических примеров про то, как нам жить». Ты вот взял и показал нам два класса, это интересно, но у нас класс на две тысячи строк, как шестнадцать строчек твоего класса перенести на наши огромные портянки кода. Есть такой concern.

    Барух: Мне было бы интересно видеть не только второй том, но и второй revision первого. Какие будут сделаны выводы из первого тома, как это будет представлено. Вот эти практические советы — это то, чего мне очень не хватало в книжке: для меня она была абстрактным конём в вакууме и абсолютно мысленным экспериментом. И увидеть, как revision этой книжки изменит именно это, было бы интересно.

    Егор: Буду работать.

    Барух: Что ещё мы не обсудили? Какие планы на будущее?

    Егор: Я буду на Java Day в Киеве, там будут два моих доклада, не касающиеся моей книжки, не касающиеся ООП, и discussion board как раз про ООП с вышеупомянутым Женей Борисовым. Я думаю, этой дискуссии многие ждут. На JPoint’е получилось что-то спонтанное, но была реакция достаточно агрессивная, и я был недостаточно подготовлен.

    Барух: Вот да, это правильно, доклады по «твоему ООП» и по книжке должны быть дискуссионными, круглыми столами. Я очень рад, что в Киеве как раз такой формат выбрали.

    Егор: Так в любом докладе они начинают со мной дискутировать на четвёртой минуте доклада!

    Барух: Вооот. А тут у тебя как раз и будет «пять слайдов, а теперь давайте рубиться». И всё будет культурно, модераторы микрофоны носят, а не зоопарк.


    Люди не понимают фундаментальных вещей, а без этого сложно что-то строить.



    Егор: Мне ещё сложно презентовать на конференциях, потому что, когда читаешь всю книжку, то всё складно, а когда начинаешь кусок какой-то выдавать, то у меня не всегда хорошо получается. Перед тем, как научить чему-то, нужно научить чему-то ещё. Я пытаюсь рассказать про ORM, но для этого нужно рассказать вот это и вот это, а времени нет. Люди не понимают фундаментальных вещей, а без этого сложно что-то строить. Поэтому я не точно знаю аудиторию, насколько они готовы. Неплохой у меня доклад был, единственный, которым я был доволен — это было на Java Day в Минске, где я рассказывал про ООП в целом и приводил примеры. В нём было всё гладко, и вопросы были в тему, но это был последний мой доклад того турне. Когда говорю про практические вещи, про ORM, это беда уже.

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

    Егор: Ещё у меня будет выступление на конференции Oredev в Швеции. Посмотрим, что Европа скажет, у меня ещё не было такого опыта. Я попытаюсь подготовиться, это будет та же тема, что и на JPoint’е, но я попытаюсь ёе сделать в формате дискуссии или короче. Но ты знаешь, европейская публика более пассивная, чем наша.

    Барух: Северная Европа — тем более. В Швеции у тебя будет всё очень спокойно.

    Егор: У нас прямо шквал вопросов, так и должно быть, да?

    Барух: Конечно.

    Егор: Для меня это было открытие. Ну и пишу второй том, не знаю, когда его закончу, но до нового года он точно выйдет. Там будет про ORM много, там будет про MVC — точнее, против них. Там будет про аннотации, про монады, про именование переменных и ещё про что-то. По главам пишу, сейчас ORM заканчиваю.

    Барух: Спасибо огромное, увидимся.
    Метки:
    JUG.ru Group 809,82
    Конференции для взрослых. Java, .NET, JS и др. 18+
    Поделиться публикацией
    Комментарии 331
    • –8
      Через 20 лет java и C++ будут восприниматься как сегодня Objective-C или Delphi — нагромождение нелепых пережитков.
      • +6
        Через 20 лет Java будет 40 лет (как С++ сейчас), так что может быть и будет она живее всех живых. Правда у Java есть целый выводок перспективных JVM «детей», которые теоретически могут сократить ее ЖЦ.
        • +2

          Я бы не был так категоричен в отношении Objective-C, это все-таки полноценный ООП язык, а C++ не совсем.

          • +1
            Да они и сейчас уже…
            • –1
              Я очень на это надеюсь
              • 0

                В том смысле, что всё будем писать на JS?

            • 0
              На амазоне у Егора нет электронной версии книги, как так?
              • 0
                Вопрос к yegor256
                • 0
                  «I'm not planning to turn this into an e-book, at least until the end of 2018. Mostly because I'm greedy. I realize that the moment I publish a Kindle version, it will be available for a free download somewhere» (со страницы книги)
                  • 0
                    ога, спасибо, печально конечно, я бы для kindle купил даже по цене бумажной копии
                  • 0
                    Электронной нет и, скорее всего, не будет. Бумажную можно купить либо на Амазоне, либо через мой блог с доставкой из Украины. Пишите не shop@yegor256.com
                  • +4
                    я прочел первую статью про null из 2014 года, и я слабо понимаю чего это народ так наиндуцировался. По сути расписаны весьма очевидные вещи. Я не знаю как там в Java мире, но у нас в .net вещи примерно так и обстоят.

                    BTW, оттуда же из статьи

                    Iterator found = Map.search("Jeffrey");
                    if (!found.hasNext()) {
                      throw new EmployeeNotFoundException();
                    }
                    return found.next();
                    


                    имхо под этим куском кода маскируется желание использовать некий Optional<>, просто автор еще сам этого не понял ))
                    • +3
                      Вообще, если говорить о Монадах, то List — это 0..n, а Optional — это 0..1, что хорошо объясняет попытку Егора использовать итератор.

                      в Java 8, правда, Optional не следует этому на 100% и не предоставляет тот же набор API, что мы имеем для Stream API, из-за чего композиция Optional-ов например не возможна (в Java 9 добавили метод, но осадок остался)
                      • +1
                        в догонку, это можно сделать и без null и всяких Optional/Nullable

                        TValue GetValue(TKey key, Action onNotFound);
                        


                        return this.map.GetValue("Jeffrey", () => throw new EmployeeNotFoundException());
                        
                        • 0
                          Либо в языках, где есть Tuple-ы (как, например, 7ой шарп):

                          (value: TValue, found: bool) GetValue(TKey key);
                          


                          (value, found) = this.map.GetValue("Jeffrey");
                          
                          return found ? value : throw new EmployeeNotFoundException();
                          
                          • –1

                            Или где функции могут возвращать множественное значение (https://play.golang.org/p/FcpXetR1SC):


                                fruits := map[string]int{"apple": 100, "peach": 200}
                            
                                if fruit, ok := fruits["apple"]; ok {
                                    fmt.Println("found", fruit)
                                } else {
                                    panic("can't found")
                                }
                            
                          • 0
                            В Java 8 можно сделать map.computeIfAbsent(«key», () -> throw new EmployeeNotFoundException());
                            • 0
                              Не скомпилится если EmployeeNotFoundException checked
                        • –5
                          Optional<> есть зло, ровно такое же, как и NULL. Он не решает проблемы, а лишь камуфлирует ее. В коментах к статье об этом есть.
                          • +2
                            Вот только вариант из статьи с Iterator это, по сути дела, и есть Optional. Противоречите-с.
                            • –1
                              «По сути дела» весь наш код это лишь буквы и символы) Это не «суть» дела, а ее полное игнорирование. Суть дела как раз в том, что мы должны иметь дело либо с объектом либо с ошибкой. Все остальные суррогаты только вредят, будь то NULL, Optional, Iterator, Collection, etc.
                              • +1

                                Использовать исключения для control flow кажется мне не лучшей идеей. Особенно если функция по своей семантике возвращает или значение, или "здесь такой не проживает". Для этого и служит Option.

                          • +1

                            В статье про null написано, что null — это плохо, и в качестве хорошей альтернативы приведены два способа сделать всё ещё хуже (null object и кидание эксепшена). Если это впечатляет, то не в ту сторону.

                            • 0

                              Точный аналог Optional в ООП — это контролируемые эксепшены.

                            • +5
                              Иисусе, Кремниевая долина, кремниевая!
                              • +1

                                мы в курсе, что кремний для процов, а не силикон для сисек, чесслово. К сожалению, устоявщееся название региона это "Силиконовая Долина".

                                • +5

                                  Так было лет 10 назад. Сейчас всё же грамотность побеждает. Это вы там в эмиграции отстаёте от российских трендов ;-)

                                  • +2
                                    По-русски правильными будут оба варианта. В зависимости от того, что ты хочешь сказать. Слово «силиконовая» несёт в себе важную смысловую коннотацию, связанную с сиськами. Что бы ты не назвал «силиконовым», сразу возникает ассоциация с раздутыми сиськами и одновременно подгружается некоторый контекст, в котором раздутые сиськи принято осуждать, а тех, кто придаёт размеру сисек такое большое значение, — презирать. Так что если ты просто хочешь обозначить географическое место, то лучше говорить «кремниевая». Если же ты хочешь добавить немного иронии, то надо говорить «силиконовая», подразумевая тем самым, что на уровне пиара значимость этого места сильно преувеличена… как и привлекательность силиконовых сисек для истинных ценителей.
                                    • +1

                                      Википедия всё еще перебрасывает "Кремниевую" на "Силиконовую".

                                  • +1
                                    И не Иисусе, а Иисус.
                                    • +2

                                      Звательный падеж же. Аналогично "О Боже!", а не "О Бог!"

                                      • +1
                                        Тогда «О, Егоре» стало быть?
                                        • +8

                                          Нет, не стало быть. Правильно было бы "О, Георгий!". Т.к. Егор это современное имя, и нельзя сказать как бы оно звучало на старославянском.


                                          В русском языке славянизмы (заимствования из старославянского), играют такую же роль как латинизмы в английском. Вы же не исправляете своих американских коллег, когда они говорят data, а не datums.


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


                                          Поэтому для выражения восклицания форма "Иисусе" обоснована, т.к. является славянизмом, а употребление "О Егоре" не обосновано, т.к. этот вариант имени не является славянизмом. Имя вполне себе современное.

                                • +3
                                  Вот он говорит:
                                  Мне не нравится ни тот код, который я писал, ни та Java, которую я видел, ни библиотеки, с которыми я сталкивался, мне неприятно с ними работать. Не только мне, а людям, которые вокруг меня, программистам. Я вижу, какой код они пишут, как тяжело этот код потом понимать, поддерживать, как вообще неприятно программировать.

                                  Но не ясно — нравится ли ему тот код, который он пишет «правильно»? Дальше он упоминает, что концепция in progress, что код, ушедший в продакшн, уже не такой «правильный». То есть я не вижу каких-то радикальных плюсов по сравнению с другими концепциями.

                                  Каков вообще средний возраст его проектов? Если они пишут под заказ, то, я предполагаю, нет долгоживущих проектов. Тогда да, можно нагородить «ООП от Егора» и забыть, а в следующей проекте уже будет «ООП 2.0 от Егора», и так далее.

                                  Есть ли у него код, которому, скажем, 5, 10 лет, и он ему все еще нравится? Есть ли реально большие и долгоживущие проекты, в котором «правильное ООП» показало себя на практике? Ну чтобы все было покрыто тестами, чтобы можно было спокойно менять устаревшие куски, чтобы глаза не болели? Как по мне, это недостижимый идеал.
                                  • +2
                                    Да, нравится. Тот код, который мы пишем сейчас, мне (и нам) нравится. Вот например наш web framework: https://github.com/yegor256/takes Он весь написан руководствуясь именно теми принципами, которые описаны и на блоге и в книжке. Средний возраст наших проектов на настоящий момент два года. Реально больших проектов (5-10 лет) у нас пока нет. Всем этим идеям, о которых и книга и блог, всего года четыре. И таки да, все покрыто тестами. Посмотрите Takes Framework.
                                    • 0
                                      Понравился малый размер классов. Некоторые вещи режут глаз.

                                      Однако же мне это сильно напоминает мир Scala (не код, но, скажем, отличие от традиционного мира Java).
                                      Свидетели Scala тоже говорят, что у них золотая таблетка, правильное ФП и вообще рай. Однако там точно такие же проблемы: высокий порог вхождения, сложность с поиском людей, сложность с чтением кода.
                                      • 0
                                        Проблемы есть, безусловно, но именно для их решения и нужны статьи, разговоры, обсуждения и прочее. Все эти проблемы несоизмеримо малы по сравнению с главной проблемой — современный код на Java это почти всегда нечитаемый мусор.
                                        • 0
                                          Для меня takes тоже не сильно читаем :) Дело привычки.

                                          UPD Для улучшения читаемости я всегда в пул реквестах рекомендую дробить методы на более мелкие, а во многих случаях дробить нужно классы.
                                          • 0

                                            Совершенно аналогичные впечатления. Причем что характерно — не только код не читаем, не читается самое основное — задачи и цели фреймворка.


                                            И таки да, все покрыто тестами

                                            И что? Вот у меня нет никакой проблемы в жизни от того, что какой-нибудь сервлетный контейнер, Jetty там скажем, или еще какой-то, не покрыт тестами. Да пусть их хоть совсем там нет и не будет. Нисколько не страдаю от того, что в них много багов. Или они скажем медленные. Нету такой проблемы в природе. Незачем ее решать.

                                            • 0
                                              +1
                                              Тесты не гарантируют, что багов нету.
                                              Разве показывают, что что-то сломалось при изменении. Но скорее всего это сломался сам тест, так как он не ложится на измененный код. :)
                                              • 0

                                                Так о том и речь. Тесты в общем случае не гарантируют. Поэтому стремление покрыть все тестами зачастую вызывает подозрение, что тут что-то не так. А если это цель фреймворка, то...

                                          • +3
                                            современный код на Java это почти всегда нечитаемый мусор.
                                            Ну это by design xD
                                            “If Java had true garbage collection, most programs would delete themselves upon execution.”
                                            — Robert Sewell
                                            • 0
                                              Что в Java является наиболее нечитаемым? Из академического интереса спрашиваю.
                                              • 0
                                                Не думаю, что можно выделить что-то одно. Весь язык заслоняет собой программу и чтобы увидеть смысл написанного приходится продираться через бесконечные нагромождения синтаксиса, неуместных абстракций и т.д.
                                                Конечно, к этому можно привыкнуть и даже начать считать удобным, если достаточно долго себя в этом убеждать… только какой в этом смысл?
                                                • 0
                                                  Весь язык заслоняет собой программу и чтобы увидеть смысл написанного приходится продираться через бесконечные нагромождения синтаксиса, неуместных абстракций и т.д.

                                                  А про какой язык так сказать нельзя?

                                                  • 0
                                                    Про машинный язык.
                                                    • +1
                                                      Да про многие так нельзя сказать… Дальше всех к дзен продвинулись Lisp и SQL.
                                                      Кроме них, на мой взгляд, хорошо сбалансированы Ruby, Elixir, Smalltalk, F#… Да даже C# тут Java явно обходит, начиная с 3-й версии.
                                                  • 0
                                                    Для меня, среди прочего, нагромождение логики обработки исключений.
                                                    • 0
                                                      Можно пример кода?
                                            • +8
                                              Посмотрел, ужаснулся именоваю классов, закрыл.
                                              public final class App {
                                                public static void main(final String... args) {
                                                  new FtBasic(
                                                    new TkFork(
                                                      new FkRegex("/robots.txt", ""),
                                                      new FkRegex("/", new TkIndex()),
                                                      new FkRegex(
                                                        "/xsl/.*",
                                                        new TkWithType(new TkClasspath(), "text/xsl")
                                                      ),
                                                      new FkRegex("/account", new TkAccount(users)),
                                                      new FkRegex("/balance/(?<user>[a-z]+)", new TkBalance())
                                                    )
                                                  ).start(Exit.NEVER);
                                                }
                                              }
                                              

                                              FtBasic — что это???
                                              TkFork — что это???
                                              Что такое Ft или Tk? Зачем эти префиксы из аббревиатур?
                                              Этот код читаем только потому что там есть пути к ресурсам. Количество WTF на момент прочтения readme зашкаливает. Я очень надеюсь что мы не будем писать код с таким именованием классов больше никогда.
                                              • +1
                                                TkFork это Takes Fork, вероятно какая-то штука из фреймворка Takes которая что-то обрабатывает.
                                                Fk это скорее всего Fake, по крайней мере так именовано в других проектах.

                                                Еще есть например Comment и DyComment – это коммент в DynamoDB (реализация).

                                                На самом деле названия очень нормальные, просто нужно иметь конвенцию. Вот меня раздражает стандартная многословность Java и необходимость все свои классы называть DynamoUser, PostgresUser и так далее. А тут DyUser, PgUser – все четко.

                                                Upd: ой, ниже уже все ответили…
                                                • +3
                                                  Я всетаки отвечу.
                                                  Вот пришел я к вам в команду и вижу что вы используете DyUser. Это DynamicUser ( ну какой-то может быть очень активный) или DynamoUser — структура записи пользователя в DynamoDB? Часто бывает что из контекста это не понятно. В лучшем случае — я час проведу изучая код и пытясь понять что такое Dy, в худшем — пойду пытать вас. А у вас релиз завтра и пара противных багов висит. Но это еще «хорошие обревиатуры». Предположим что у нас есть еще бизнес обьекты типа Route и класс DyRoute — и это как раз тот самы Dynamic Route — он вообще относится к инфраструктуре и определяет куда нужно сейчас оправлять ваш запрос в зависимости от загрузки нижележащих сервисов. И ваще жопа — тк какого художника одна и таже обревиатура в разных кусках одного проекта означает соовсем не связанные между собой вещи.
                                                  Когда я был маленький, деревья большие и code-competion был только в emacs и контекстный — тогда сокращения имели смысл. На текущем витке развития software development — это примерно такой-же атавизм как и Go-To. Лучше про него просто забыть.
                                                  PS: Я не считаю что имена классов, обьектов или методов должны быть длинными. Совсем наоборот — они должны быть максимально корткими — но при этом читаемые. Такая вот задача минимизации — как не выплеснуть ребенка читаемости вместе с водой.
                                                  • 0
                                                    Вам надо еще почитать как люди «приходят в команду» к Егору и как они «пытают». Там все схвачено :)
                                              • +3
                                                Вот я когда пишу код, думаю о тех кто это потом будет читать.

                                                Как там понять что такое Fk, Tk, Fb, Xe? A RsXembly, что такое xembly?
                                                Rs и Rq — догадался, но почему нельзя было написать Request, Response?
                                                • 0

                                                  У Егора есть целая заморока насчёт длины идентификаторов. Он в стопятом про это говорил. Мол, поля не длиннее восьми символов, хардлимит. Про классы, наверно, тоже такое есть.

                                                  • +2
                                                    Странно, он так много рассуждает о readability, а потом в его же коде использует странные и непонятные аббревиатуры.
                                                    • 0
                                                      Нет, ну возможен компромисс. У нас в коде тоже иногда приходится сокращать для повышения читаемости. Обычно эти сокращения расшифровываются в месте объявления в комментарии. Просто когда идентификатор такой длины, что невозможно написать в одну строку что-то вида a.push(b.pop), когда a и b длиной в пол-экрана — это тоже плохо.
                                                      Потому что альтернатива —
                                                      a.push(
                                                          b.pop)
                                                      


                                                      А это ужас.
                                                      • 0
                                                        У нас в коде тоже иногда приходится сокращать для повышения читаемости.

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

                                                        Посмотрев же на Тakes Framework, я увидел, что эти странные именования используются повсеместно.
                                                        • 0
                                                          Я не хочу тут говорить вам, что можно придумать более информативные имена для «a» и «b», тк не знаю контекста.

                                                          Это условные обозначения, мне было лень придумать примеры.
                                                          Допустим, это было бы что-то типа
                                                          TConList = class //TConnectionList
                                                          или 
                                                          lFIdx: integer; //lFirstElementIndex;
                                                          
                                                          • +1
                                                            С появление intellisense я перестал думать о длинне имен и стараюсь писать читаемый код. Т.к. даже я сам через месяц с трудом вспоминаю такие аббревиатуры. Но возможно это у меня просто память короткая.
                                                            • +1
                                                              С появление intellisense я перестал думать о длинне имен и стараюсь писать читаемый код

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

                                                              Условно говоря,
                                                              lItem := lItem + some_func() + other_func();
                                                              

                                                              лучше, чем
                                                              lSomeListItemWithNiceJavaStyleName := 
                                                              lSomeListItemWithNiceJavaStyleName +
                                                              SomeFunctionGivingResultWithNicejavaStyleName() +
                                                              OtherFunctionGivingResultWithNicejavaStyleName();
                                                              

                                                              • 0
                                                                OtherFunctionGivingResultWithNicejavaStyleName();

                                                                Вот отличный пример такого: FizzBuzzEnterpriseEdition

                                                                А вообще, именование — это на самом деле довольно не просто.

                                                                Вот например ваши ConnectionList и FirstElementIndex.
                                                                Если бы я использовал FirstElementIndex только внутри List, скорее я бы назвал его просто «first».
                                                                Если бы он был частью публичного интерфейса List, то назвал бы FirstElementIndex.

                                                                Я же изначально писал, все очень зависит от контекста и домена.
                                                                • 0
                                                                  Конечно, в каждом случае надо смотреть отдельно. Я просто высказываю мысли вслух.

                                                                  Если бы я использовал FirstElementIndex только внутри List, скорее я бы назвал его просто «first».

                                                                  Здесь есть некоторая порция неоднозначности, потому что непонятно, индекс ли это, итератор ли, или сам элемент. Более того, непонятно даже, переменная ли это или формальный параметр. А уж в Delphi, на котором мне выпало сейчас писать, и вовсе может быть property объекта.
                                                    • +3
                                                      За идеей о том, что надо писать код со всеми этими заморочками, строго их соблюдая, стоит на самом деле, подсознательное желание быть родоначальником нового движения. Для этого автор эксплуатирует уязвимость начинающих программистов: падкость на новомодные течения. Конечно, идеи вцелом ок — но только если не возводить их в степень маразма, как это сделал он.

                                                      Это относится ко всему, кроме сеттеров и геттеров. С сеттерами и геттерами — недостаток языка. На самом деле, во всем вот этом сан и оракл виноваты, потому что не придумало нормальных сеттеров и геттеров. Это вызвало вот такие брожения, подсознательную ненависть к java. Это настроило мозги программистов на то, чтобы было желание придумывать новые языки, новые стили написания кода, новые фреймворки — лишь бы только уйти от сеттеров и геттеров.
                                                      • 0
                                                        Там автор сеттеры и геттеры вообще в любом виде не любит. Встроены они в язык или нет.
                                                        P.S. Минус мой. Промахнулся. Простите.
                                                        • +1
                                                          Я думаю изначально этот товарищь имеет ввиду, что геттеры/сеттеры зло, когда они раскрывают детали реализации, т.е. нарушают инкапсуляцию например, но будучи радикалом, он возвел это в абсолют.
                                                        • 0
                                                          Лучше не 8, а 9. У швейцарского заказчика фирмы, где я работал 9 лет назад, было де-факто правило трёхбуквенности: все слова в идентификаторах и наименованиях сущности и поля сокращались до трёх, в редких случаях шести букв. Это было в общем удобно, хотя некоторые вещи надо было специально запомнить, но их было мало. Две бкувы — это, конечно, маловато.

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

                                                          К наименованиям полей и интерфейсных методов сокращение лучше, конечно, не применять.
                                                      • +1
                                                        Простите, что это:
                                                        https://github.com/yegor256/takes/blob/master/src/main/java/org/takes/Take.java
                                                        Response act(Request req) throws IOException;

                                                        Глагол в качестве имени класса? Я не сталкивался в литературе с take в форме существительного (хотя гугл-транслейт говорит, что таковое значение есть).
                                                        Действие «act»??? Что за хрень? Никак не получилось сделать нормальное имя действия?

                                                        https://github.com/yegor256/takes/blob/master/src/main/java/org/takes/misc/EnglishLowerCase.java
                                                        public String string()

                                                        Что за действие «string»?
                                                        Почему имя класса — какое-то действие/состояние, а не объект-субъект?
                                                        • 0
                                                          Зачем вам гуглтранслейт, когда вы ищете перевод слова?
                                                          http://www.multitran.ru/c/m.exe?CL=1&s=take&l1=1
                                                          • 0
                                                            Гуглтранслейт универсален и знаком, раньше использовал яндекс.словари, но они закрылись… спасибо за интересную ссылку… А есть такое же, но больше с пояснением смысла (меньше вариантов, но с попыткой определения) и с примерами использования для каждого варианта? Сгодится и на английском языке…
                                                            • 0
                                                              https://www.lingvolive.com/en-us/translate/en-ru/take
                                                              Это те же Яндекс.Словари
                                                    • 0
                                                      Едем дальше, в статье про геттеры/сеттеры вообщем то тоже ничего нового. Даем собаке мяч, а не устанавливаем его.

                                                      Чем это отличается от rich model? переименовали сеттеры? А что нам делать с DTO?
                                                      • 0
                                                        Почитал блог Егора. Он пишет, что DTO — гадость.
                                                        • 0
                                                          А можно ссылку?
                                                          • +1
                                                            видимо вот это — http://www.yegor256.com/2016/07/06/data-transfer-object.html
                                                            • +1
                                                              и как то там весьма, кхм, как бы это сказать. Вообщем-то все то же, что можно увидеть в книжках критикуемого фаулера ))
                                                              И очевидно предлагается научить обьект загружаться/сохраняться в базу/json/… минуя DTO
                                                              • +1
                                                                Получается, вот так плохо:
                                                                Book book = api.loadBookById(123);
                                                                database.saveNewBook(book);
                                                                

                                                                А так хорошо:
                                                                Book book = api.bookById(123);
                                                                book.save(database);
                                                                

                                                                Особой разницы нет. Разница лишь в том, кто выполняет действие. Либо база сохраняет книгу, либо книга сохраняется в базу.

                                                                Конечно, если бы это был реальный мир, то книгу на полку ставил бы человек. Или робот :)
                                                                Тогда следует писать
                                                                bookManager.saveToDb(book, db);
                                                                

                                                                Что логически приводит к ORM системам :)
                                                                • +2
                                                                  Что логически приводит к ORM системам :)


                                                                  ORM низя — http://www.yegor256.com/2014/12/01/orm-offensive-anti-pattern.html
                                                                  • +1
                                                                    Я в курсе, это я так типа пошутил :)
                                                                    • 0
                                                                      Спасибо за ссылку.
                                                                    • +2
                                                                      Разница в том, что вы не уважаете объект :)
                                                                      • +1
                                                                        но когда к нему слишком много уважения, он, очевидно, начинает нарушать SRP )
                                                                        • +1
                                                                          Я очень уважаю инстанс HibernateSession! Это ведь тоже объект! :)
                                                                        • 0
                                                                          основной посыл в этих двух примерах, как я понял, что в первом случае мы получаем DTO из api и чего-то там с ним делаем, а во втором у нас уже появляется entity, которая обладает поведением и всем таким, что присуще rich model. Нууу… как бы да, хорошо, а где ООП v2?
                                                                          • 0
                                                                            А почему книга должна обладать поведением «сохраниться в базу»? Single responsibility principle хоть Егор не отменил еще своим божественным указанием? :)
                                                                            • +1
                                                                              ну про SRP я выше написал
                                                                              • +1
                                                                                ActiveRecord криминален по SOLID
                                                                              • 0
                                                                                как бы ничего особо криминального в этом нет, это банальный active record
                                                                                • +1
                                                                                  Конечно, криминального нет. Я же не пророк нового ООП.
                                                                                  • 0
                                                                                    А также о формате сериализации.
                                                                                • +1
                                                                                  Логично было бы иметь универсальное data = book.serialize; и database.saveserialized(data, booktype); Или сразу наследовать объект от serializable и передавать его базе. Действительно, нафига козе баян объекту что-то вообще знать о базе данных?
                                                                                  • 0
                                                                                    Но тогда базе придется знать внутренний формат сериализованной data, что в принципе не сильно отличается от DTO.
                                                                                    • 0
                                                                                      Это почему еще? Blob как есть.
                                                                                      • 0
                                                                                        А как мапить на колонки в таблицах? Или просто blob хранить?
                                                                                        • –1
                                                                                          А зачем мапить на колонки в таблицах? Просто blob.
                                                                                          Это у товарищей АИС-программистов профдеформация — привычка раскидывать через ORM всякие таблицы вида «сотрудники», где все по колонкам разбито. А зачастую нужно просто хранить сериализованные объекты. У нас в системе, например, в виде сериализованных объектов хранятся всякие user-specific настройки для разных модулей.
                                                                                          • +1
                                                                                            А искать по блобам как?
                                                                                            • –1
                                                                                              Это настолько зависящие от задачи параметры, что обсуждать их вне конкретной задачи не имеет смысла. Допустим, вы не производите поиск по данным, находящимся в блобе.
                                                                                              • 0
                                                                                                Про «book» же говорили.
                                                                                                Вот есть у вас библиотека, допустим большая.
                                                                                                Как выбрать все книги по автору, или по названию, или еще по какому критерию.

                                                                                                Просто если хранить «user-specific настройки», то проблем нет по userId достать можно, тут все просто.
                                                                                                А вот например с users уже врятли прокатит.
                                                                                                • 0
                                                                                                  Извините, ветка большая. Я вне контекста писал — как раз сейчас с теми самыми настройками работаю.
                                                                                                  • 0
                                                                                                    Ничего страшного.

                                                                                                    Вот вы писали выше:
                                                                                                    Логично было бы иметь универсальное data = book.serialize; и database.saveserialized(data, booktype);


                                                                                                    Как я понял «data» — это бинарные данные (или может быть строка, не суть).
                                                                                                    Сохранить данные в таком виде, да, очень просто.
                                                                                                    Но как потом искать или обновить записи?
                                                                                                    Я просто не вижу хорошего решения.
                                                                                                    • 0
                                                                                                      Если для книги, то да, больше orm с маппирование объекта на таблицу подойдет, где мы можем выборку по индексу сделать. Иначе придется ряд параметров, которые попадают под сериализацию, дублировать в виде колонок, а это слишком жирно.
                                                                                                      Когда я писал о book.serialize я не думал о книге; ветка, в которой я писал, была об, условно, «сохранении объекта в базу данных» и я думал об этом в контексте своей текущей задачи, которая — о сериализации объекта и передаче по сети и/или сохранении в БД. Так что приношу извинения за не совсем корректный комментарий, написанный для иного контекста.
                                                                              • +1
                                                                                book.save() — это будет ActiveRecord, что, по крайней мере для языков со статической типизацией, давно признано антипаттерном.
                                                                                bookManager.saveToDb(book, db);
                                                                                Если db инкапсулировать в bookManager (например, через «фабрику»), то будет как раз тот подход, что применяется сегодня в использовании ORM.
                                                                                • 0
                                                                                  давно признано антипаттерном

                                                                                  Подскажите, где про это почитать?
                                                                                  • +1
                                                                                    Да, если я ничего не путаю, ещё в первоисточнике (PoEAA) было примечание, что Active Record нарушает SRP и не рекомендуется использовать его в случаях сложнее, чем тривиальные.
                                                                      • 0
                                                                        Про DTO нам придется забыть.
                                                                        • 0
                                                                          Но тут же DTO таки используется! https://github.com/yegor256/takes/blob/master/src/main/java/org/takes/Take.java
                                                                          И получается, Request это лишь контейнер для данных. Почему он наружу свои данные выставляет? Это же нарушение инкапсуляции! :)
                                                                          Вместо того, чтобы писать request.respond(outputStream), тут введен некий конвертер :)

                                                                          Граница инкапсуляции есть всегда. И DTO есть в реальном мире (например, всяческие анкеты, фотографии, записи).
                                                                          • +4
                                                                            Да, замечание верное, действительно этот дизайн не идеален. И таки да, это нарушение инкапсуляции. В новых версиях или в новых продуктах будем умнее)
                                                                      • +20
                                                                        Кто все эти люди? Почему их междусобойчик со стенограммой находится здесь?
                                                                        • +2
                                                                          какие то новые свидетели
                                                                          • –3
                                                                            Это лучший комент! Жаль не могу апвоут его, кармы не хватает)
                                                                            • +1
                                                                              Один из них точно — д'Артаньян
                                                                            • +2
                                                                              Почему-то сразу вспомнил тред про то, что язык Си — шутка (http://www.linux.org.ru/forum/talks/284934)

                                                                              По статье: неприятное впечатление производят высказывания. То у них гадость, это — плохо, то — неправильно, се — неправильно. Очередная песня в стиле «крах ООП, победа ФП». А как правильно?
                                                                              Software development — это инженерная наука, где практика — главный критерий. Что конкретно они сделали? Если своими эпатирующими провокационными заявлениями они выступают против ряда повсеместно используемых в современной разработке вещей — пусть покажут, как надо. Где их мега-крутой проект, супер-чистый код с джедайским подходом и космической производительностью? Если их подход — работает, почему они ездят по конференциям, а не создают стартап, который за несколько дней привлечет миллионы инвестиций? Заявлять можно много чего, пиар и коммерция это все…
                                                                              • 0
                                                                                Ну собственно yegor256 в своих проектах пишет код в соответствии с описанными в статье принципами. Он как-то даже давал ссылки на github.
                                                                                • +3
                                                                                  Хорошо, но каков результат? Задачи стали решаться в 2 раза быстрее? Код сократился на 50%? Количество багов уменьшилось в разы? Если нет, то это разговоры о стиле, ничем не отличающиеся от того где ставить открывающую скобку. Вопрос удобства и соглашения. А замах в статье, словно новую парадигму придумали. Более того: даже если бы и придумали, ее эффективность нужно доказать. Уже много лет я слышу от одного знакомого, что ФП позволяет решать те же задачи в разы быстрее и с минимумом кода. Годы идут — но все (кроме гиков и некоторых стартапов) пишут на ООП. Ругают сам ООП, его последователей (мол, вы просто неспособны иначе мыслить, ФП освободит ваш разум..). Годы идут. Но мы же все тут понимаем, что разработка во многом движется бизнесом? Если бы ФП, или подход из данной статьи давал бы хотя бы 1% прироста скорости/качества/производительности — он бы быстро вышел на мировой рынок разработки, потому что 1% от этого рынка — это миллиарды долларов экономии (а значит прибыли). Рассуждаю, как торгаш сейчас, но увы, таковы реалии. Делать что-то потому что «это просто круто» (например, использовать git вместо svn) — трата времени и сил. Не все себе могут это позволить. Должен быть реальный результат, хотя бы в перспективе. А ругатели ООП тратят на это время уже не одно десятилетие.
                                                                                  • +1
                                                                                    Да, задачи стали решаться быстрее, код сократился, количество багов уменьшилось в разы. А как бы Вы предложили доказать эффективность? Подскажите, я с удовольствием докажу. В каком формате это сделать?
                                                                                    • +2
                                                                                      В каком формате мир завоевали сделанные на коленке Python, PHP, MySQL? Это происходит естественным путем, так что время само покажет.
                                                                                      • +1
                                                                                        И Вам нравится тот мир, который они завоевали? Точнее, нравится то, во что они превратили мир?
                                                                                        • +1
                                                                                          Не очень. Многие тривиальные и интуитивно понятные вещи до сих пор в мире программирования делаются тяжело. Есть ощущение, что что-то не так. Но вот тот код в комментариях ниже, с функцией max — точно не улучшит ситуацию.
                                                                                          • +1
                                                                                            А что улучшит, как думаете?
                                                                                            • 0
                                                                                              Не думал над этим. У меня нет цели изменить мир программирования, для меня это лишь инструмент для решения совершенно иных задач.
                                                                                              • +2
                                                                                                Улучшат языки, которые перестанут тянуть идею «всё есть объект» куда не надо… Объектами останутся только те части программы, которые действительно обладают своим поведением и полностью изолированы от остальной программы. Между собой они будут общаться исключительно отправкой сообщений. А само поведение объекта будет реализовываться декларативно (в функциональном и/или логическом стиле).
                                                                                                • +1
                                                                                                  А что такое «части программы, которые действительно обладают своим поведением и полностью изолированы от остальной программы»? Это что-то новое, пока нами не открытое? Почему эти части сейчас не являются объектами и счастье еще до сих пор не наступило? Что мешает?
                                                                                                  • 0
                                                                                                    Это уже есть, посмотрите на Erlang или Elixir, там это процессами называется, но по сути это и есть настоящие объекты.
                                                                                                    Я уверен, что через 20 лет все актуальные ЯП (кроме самых low-level) будут придерживаться аналогичных подходов, потому что это позволит эффективно использовать все 1024 ядра (ну или сколько тысяч их там будет к тому времени) и управлять сотнями компонентов умного дома из одной программы.
                                                                                                  • +1
                                                                                                    которые перестанут тянуть идею «всё есть объект» куда не надо…

                                                                                                    Действительно. ООП — это лишь метод, способ работы с данными. Есть ситуации, где это оправдано, есть, где нет. Где нет внутреннего состояния, где слои абстракции только скрывают суть действия ничем не помогая.
                                                                                    • –1
                                                                                      Вот один из наших мега крутых проектов с джедайским подходом: https://github.com/yegor256/takes Про производительность говорить не буду, мы о ней речи не ведем и за нее не боремся. Но в области ООП этот проект сделан неплохо. Значительно лучше чем весь тот мусор, который сейчас доминирует на рынке: Spring, Hibernate, и прочие. На счет стартапа мысль правильная — мы создаем стартап. На счет миллиона инвестиций, мы в процессе, следите за новостями )
                                                                                      • 0
                                                                                        Web Framework и вы не боретесь за производительность?
                                                                                        Да и когда вы называете решения проверенные годами и тысячами проектов — мусором… Это не профессионально.
                                                                                        • –1
                                                                                          За производительность есть кому бороться, это не мой профиль. Я про ООП больше, про чистый и красивый дизайн. Если он сейчас не такой быстрый, как тот мусор, что работает годами, то это безусловно проблема. Но это другая проблема. Давайте их не смешивать. А это действительно мусор. Если не согласны, то покажите мне код какого-нибудь Java проекта, который проверен годами. И давайте вместе на него посмотрим и оценим — мусор это или нет.
                                                                                          • 0
                                                                                            Если мы говорим о Web Framework, то и архитектура и производительность являются нефункциональными требованиями.
                                                                                            А у многих задач производительность является ключевой характеристикой.
                                                                                            К сожалению я не могу не смешивать их.
                                                                                            • +3
                                                                                              Android SDK рекомендует использовать статические методы и не использовать объекты. Стоит ли эту рекомендацию принимать как правильный стиль в ООП? Не будет ли правильнее считать частный конкретный случай просто временным затруднением аппаратной части? То же самое и у нас. Да, Java не умеет работать быстро с большим числом объектов. Она куда быстрее работает со статическими методами. Это беда Java, а не ООП. Придет время и место Java займет другая платформа, где ООП сможет работать правильно и красиво. И там не будет статических методов. Я предлагаю подумать об этой платформе уже сейчас. А еще почитайте вот это.
                                                                                              • 0
                                                                                                Я бы посмотрел на прототип такой платформы.
                                                                                                • +1
                                                                                                  Я бы тоже. Вот так я ее описал три года назад.
                                                                                    • +10
                                                                                      Вообщем заголовок меня заинтриговал, а в этом увлекательном разговоре нет возможности ознакомиться с позицией
                                                                                      Егора, потому что тут больше про борьбу с оппонентами, чем про ООП. Возможности купить книгу в электронном варианте тоже нет,
                                                                                      поэтому пришлось собирать целостную картинку из записей в блоге, а не из книги.

                                                                                      Итак нам обещают ООП 2.0

                                                                                      1) Why NULL is Bad?
                                                                                      «null плохой». ок, но мы это уже давно знаем. эта тема обсосана со всех сторон.

                                                                                      2) Getters/Setters. Evil. Period.
                                                                                      «get/set плохо». суть статьи — вместо процедурного барахла, используйте ООП

                                                                                      3) Data Transfer Object Is a Shame
                                                                                      «DTO плохо» взамен предлагается переложить сериализацию/десериализацию на саму сущность, минуя DTO

                                                                                      4) ORM Is an Offensive Anti-Pattern
                                                                                      «ORM плохо» взамен предлагается active record и репозитарий для бедных

                                                                                      5) Objects Should Be Immutable
                                                                                      «all classes should be immutable in a perfect object-oriented world». эта тема обсосана со всех сторон.

                                                                                      6) OOP Alternative to Utility Classes
                                                                                      «Utility классы зло, каждому методу по обьекту». И такой код я тоже видел.
                                                                                      аргументы: SRP, удобнее писать тесты, «An object-oriented approach enables lazy execution». весьма слабо.

                                                                                      7) If-Then-Else Is a Code Smell
                                                                                      if — зло, vrtual dispatch — добро. где-то я это уже видел. может у Фаулера/Физерса/Кириевски?

                                                                                      8) Singletons Must Die
                                                                                      синглтоны зло.

                                                                                      9) Class Casting Is a Discriminating Anti-Pattern
                                                                                      cast зло

                                                                                      10) Composable Decorators vs. Imperative Utility Methods
                                                                                      Why Many Return Statements Are a Bad Idea in OOP
                                                                                      Разложим мир на микроскопические обьеты.

                                                                                      Итого: Либо банальные вещи, либо маргинальные экстремистские идеи. Так мы будем писать через 20 лет?
                                                                                      • +3
                                                                                        Так мы будем писать через 20 лет?

                                                                                        Тогда появится какой-то новый Егор, который будет ездить по конференциям и рассказывать, что «чистый ООП» — это ужасно, что все проекты плохие и что надо писать в процедурном стиле.
                                                                                        • +14
                                                                                          Мда.

                                                                                          This is a classical example:
                                                                                          
                                                                                          public int max(int a, int b) {
                                                                                            if (a > b) {
                                                                                              return a;
                                                                                            }
                                                                                            return b;
                                                                                          }
                                                                                          


                                                                                          И пример «хорошего подхода»:
                                                                                          This is the code in a pure object-oriented world:
                                                                                          
                                                                                          public int max(int a, int b) {
                                                                                            return new If(
                                                                                              new GreaterThan(a, b),
                                                                                              a, b
                                                                                            );
                                                                                          }
                                                                                          

                                                                                          What do you think now?

                                                                                          Ай финк нау, что это воняет за километр и двухметровой палкой это трогать нельзя. Нельзя гордиться тем, что ты навернул 4 абстракции вместо одной стандартной конструкции. Это технопорно вида «смотри, как я умею» — интересно, но непрактично и нечитаемо. Судя по всему, остальные предложения такие же гениальные.
                                                                                          • +2
                                                                                            Прошу прощения у автора за резкость тона, вспылил. Сильно удивило «предложение о рационализации».
                                                                                            • 0
                                                                                              Прощения просить не нужно, это вполне нормальна и типичная реакция. Прочитать стоит книгу целиком, станет понятно о чем это все и для чего.
                                                                                              • 0
                                                                                                Купить и потом сжечь?
                                                                                                А вы хитрец!
                                                                                                • 0
                                                                                                  А почём растопка продаётся?
                                                                                                  • 0
                                                                                                    https://www.amazon.com/gp/product/1519166915/ref=as_li_tl?ie=UTF8&camp=1789&creative=390957&creativeASIN=1519166915&linkCode=as2&tag=yegor256com-20&linkId=RMGEO4ESPM4CGD3O
                                                                                              • 0

                                                                                                Напрасно просите. Автор сознательно рассчитывает именно на такую реакцию. Даже русский подстрочник балансирует между грубостью и хамством.

                                                                                              • +3
                                                                                                This is the code in a pure object-oriented world:
                                                                                                public int max(int a, int b) {
                                                                                                  return new If(
                                                                                                    new GreaterThan(a, b),
                                                                                                    a, b
                                                                                                  );
                                                                                                }
                                                                                                
                                                                                                Такие примеры кода просто показывают полное непонимание сути ООП и для чего вообще нужна эта парадигма. Недавно обсуждали ООП вдоль и поперёк, начиная от самых истоков и заканчивая практической пользой в настоящем, не охота повторяться…
                                                                                                Вот тут дело было.
                                                                                                • 0
                                                                                                  new GreaterThan(a, b)
                                                                                                  

                                                                                                  Интересно, а yegor256 смотрел scala? Там как раз сделано гораздо более ООПшно:
                                                                                                  a.<(b)
                                                                                                  
                                                                                                • –2