История изменений

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать будет не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

А дурак будет «хватать о камни». И появляются лозунги, что наследование не нужно, достаточно интерфейсов; и появляются языки, в которых ни ООП, ни исключений. Все знают, о каких языках речь. ;)

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны чрезвычайно упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать будет не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

А дурак будет «хватать о камни». И появляются лозунги, что наследование не нужно, достаточно интерфейсов; и появляются языки, в которых ни ООП, ни исключений. Все знают, о каких языках речь. ;)

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны чрезвычайно упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). Недавно вообще смешно было: т.н. «архитектор» признал, что сервисов слишком много, и тут же создал новый сервис с несчастным десятком классов. При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать будет не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

А дурак будет «хватать о камни». И появляются лозунги, что наследование не нужно, достаточно интерфейсов; и появляются языки, в которых ни ООП, ни исключений. Все знают, о каких языках речь. ;)

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны чрезвычайно упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо будет.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

А дурак будет «хватать о камни». И появляются лозунги, что наследование не нужно, достаточно интерфейсов; и появляются языки, в которых ни ООП, ни исключений. Все знают, о каких языках речь. ;)

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны чрезвычайно упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

А дурак будет «хватать о камни». И появляются лозунги, что наследование не нужно, достаточно интерфейсов; и появляются языки, в которых ни ООП, ни исключений. Все знают, о каких языках речь. ;)

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны чрезвычайно упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны чрезвычайно упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом (каждый сервис в отдельном контейнере, ага, с хорошо если всего парой десятков env-ов). При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и являются нормой ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядок менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и многие сценарии на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, и выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими (spring же ж) стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

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

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись в него не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: в 90х все ломанулись не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: все ломанулись не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: все ломанулись не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом. При этом вся система сильно связана, и нередки ситуации с длинными, в т.ч. даже рекурсивными цепочками вызовов между сервисами; и множество сценариев на порядки менее эффективны, чем могли бы быть.

Меня последнее время одолевает одна мысль:

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

Индустрия периодически подкидывает дурачкам серебряные пули.

Взять тот же ООП: все ломанулись не разбирая дороги, пихали наследование где надо и где не надо, фигачили «16 паттернов в 32 строках кода» – а в результате закономерно получался типичный кошмар.

Потому что сама идея серебряной пули в принципе порочна, т.к. подразумевает, что думать не надо.

Продолжая тему ООП-шных языков, такой же (если не хуже) кошмар с исключениями. Ни на одной работе не видел, чтобы исключениями умели пользоваться. В пределе – тупо создают по новому подклассу Exception на каждый throw, пилят килотонны бессмысленных и беспощадных catch-rethrow в каждом методе, причём работает всё это в удивительную раскоряку, ошибки сыпятся как попало какие попало, в результате логи засраны длиннющими стек-трейсами с многократными повторениями (т.к. в каждый catch-rethrow обязательно впиливают логирование), а морда либо глотает ошибки, либо показывает их так, что лучше бы не показывала.

Умный человек, набив некоторое критическое количество шишек, остановится, подумает, решит, что всё хорошо в меру, выработает и формализует для себя какие-то сбалансированные подходы.

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

Сюда же NoSQL (этот хайп уже вроде давно утих), чистое ФП (судя по hh, на подъёме), и на моё ИМХО самая мерзотная серебряная пуля из ныне здравствующих – микросервисы.

При том, что, если подумать, то в каждой конкретной системе и для NoSQL можно место найти; и ФП-шные паттерны очень упрощают жизнь – безо всякого чисто-ФП-шного фанатизма; и без сервисов (не «микро», мать вашу) ни одна серьёзная система не обойдётся.

А вот, например, на моей нынешней работе сервисы создаются не по принципу «когда нужно», а по принципу «когда можно». Каждую новую мелочь в новый сервис заворачивают. Видимо уже не способны думать о декомпозиции в других терминах – в maven-модулях, packages, да хотя бы банальных классах. И в результате непрерывно трахаются с непрерывно отваливающимся деплойментом.