Если язык быстро меняется, считается ли это хорошей вещью?

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

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

если язык быстро меняется, это хорошо или плохо для программиста?

Хорошо

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

Плохо

• Язык имеет дополнительную сложность - новые функции могут не всегда хорошо сочетаться с унаследованными функциями (например, отношение C ++ к C)
• Устаревший код может устареть и больше не работать в новой версии языка без обновлений (Python 2.x -> 3.x)
• Компиляторы и другие инструменты для языка должны быть обновлены. В настоящее время существует несколько версий.
• Сторонние библиотеки могут не поддерживать более новую версию языка
• Несмотря на существование стандарта, может потребоваться время, чтобы найти стандартный / нормальный способ реализации новых функций и определить некоторые из более неясных случаев их поведения

Любят ли программисты изучать новые вещи на языке или предпочитают придерживаться того, что они уже знают?

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

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

Улучшения велики ... если они обратно совместимы .

C # делает это красиво. Они добавляют вещи, выражения lamdba, улучшенную поддержку многопоточности, linq, ... Но ваша пятилетняя программа на C # 2.0 будет по-прежнему работать без каких-либо изменений и может быть легко обновлена ​​до C # 4.0 без каких-либо изменений.

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

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

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

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

Изменения также связаны со стоимостью обучения и временем. Не все работодатели готовы обучать разработчиков новым функциям. Это добавляет значительную нагрузку на разработчиков, чтобы они обучались сами или иначе - это не тривиально, специализированные курсы могут стоить от 1500 до 3500 долларов каждый!

Непрерывные изменения могут заблокировать разработчиков в «устаревшем» программном обеспечении. Возьмем пример разработчика ASP, который не догнал MVVM через 2 года, или пример разработчика Windows Forms, который не изучал WPF. Эта блокировка может значительно повредить карьере разработчика.

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

Я не думаю, что есть один правильный ответ.

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

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

Только для примера, давайте предположим, что было примерно одинаковое количество людей, пишущих на Ruby и Fortran. Кроме того, давайте предположим, что в обоих было примерно одинаковое количество кода. Я бы сказал, что шансы довольно хороши, что изменение, которое нарушает точно такой же процент каждого (и таким образом, что для исправления потребовалась одна и та же работа), будет гораздо более приемлемым для пользователей Ruby, чем для пользователей Fortran, как правило. (по крайней мере, предполагая, что они видели это как улучшение).

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

Другим фактором является размер и продолжительность жизни проектов, для которых предназначен язык. Язык, который обслуживает относительно небольшие проекты или те, которые мы знаем заранее, имеет короткую продолжительность жизни (например, веб-интерфейс), может сойти с рук относительно часто, потому что вряд ли многие продолжат использовать одну и ту же кодовую базу скажем, 10 лет в любом случае. Язык (например, C ++ или Java), который больше подходит для более крупных и долгоживущих проектов, которым может потребоваться, скажем, 5 лет для первоначального выпуска, может постоянно использоваться (и постоянно развиваться) в течение трех или четырех десятилетий, что, очевидно, требует большой гораздо больше стабильности.

У меня был парень, который сказал мне, что ему нравится его C ++, и он останется таким. Он не заботится о D и не интересуется им, он не хочет знать и использовать C #. Он выучил java, потому что ему пришлось заниматься многими проектами, в которых он нуждался, и он, очевидно, хорошо работает на тех языках, которые он знает

Другой любит C # и не знает каждое ключевое слово или знает библиотеки .NET 4 (async и все) и не использовал абстрактные ключевые слова или используемые атрибуты.

Я просто говорю, что большинство людей не заботятся

Теперь о последствиях обновления бьется (для библиотек или скомпилированного кода), люди БУДУТ заботиться.

Я отвечу за C # (но этот анализ может быть применен и к Scala):

Это изменение функции вызывает некоторые проблемы, когда вы приближаетесь к «стилю» языка:

В 2011 году C # может делать много разных вещей, и это хорошо. К сожалению, у него есть две разные парадигмы (если не больше):

• OOP
• Функциональный (подумайте о лямбда-функциях и LINQ)

Различные стили проверки типов

• Динамический набор текста
• Статическая печать

Не всегда понятно, когда вы хотите использовать тот или иной.

Я думаю, что это действительно зависит от языка и от того, что язык имеет. Например, я думаю, что если бы C # и Java начали выскакивать изменения в более быстром темпе, это было бы принято (до тех пор, пока они обратно совместимы, как сказал Карра ). Однако, если язык еще не набрал обороты и все еще быстро меняется, я знаю, что не буду беспокоиться об этом, так как есть шанс, что я пытаюсь выучить сегодня, будет совершенно иначе, чем через 6 месяцев и поскольку язык новый / непопулярный, для меня не будет вреда (читай: моя карьера), чтобы я просто передал его.