У меня (уже год наверно) варится в голове одна мысль.
Коротко звучать примерно так будет: Почему большинство ЯП сделаны не для программистов?

Я серьезно. Если взять Оберон, то он создан явно для роботов. А если взять Lua, то на ней писать без ошибок сможет только сверхчеловек.
Мне реально сложно назвать язык, который был бы создан с учетом целевой аудитории. Некоторые хипстерские языки на это претендуют (питон, к примеру), но там масса ошибок уже другого плана (поощрение бряков в циклах, например)
Лично мне нужна середина. Что-то между Oberon и Lua. И размышляя о своем языке я стараюсь думать именно в этом направлении.

Related пример из жизни:
Недавно с коллегой разговаривали и статическом анализе кода 1С. Что нужно проверять, а что нет.
Говорили конкретно о двух вещах (все про язык 1С):
1. Авто-переменные без объявления.
2. Передача параметров по ссылке.

Пример по первому пункту:
В 1С не нужно объявлять локальные переменные. Они создаются автоматически при первом присваивании.
## Код:
```
Var y;
Function Foo()
    x = 1 // тут будет создана новая локальная переменная
    y = 1 // тут будет выполнено присваивание переменной уровня модуля
EndFunction
```

В среде 1С-никовниктоне объявляет локальные переменные (хотя Var в функциях тоже есть).
Из-за этого периодически бывают проблемы, т.к. в глобальном контексте постоянно что-то меняется в процессе развития прикладного решения. Эти присваивания без объявления начинают внезапно присваивать новым глобальным переменным и свойствам (в 1с свойства объектов дополняют глобальный контекст модуля, который связан с объектом). Более того новые глобальные свойства еще и в платформе появляются от версии к версии.
И хорошо если такое присваивание в новом окружении вызывает исключение, а ведь бывает что и исключения нет как и присваивания! Ну в общем я думаю понятно. Погружаться во все тонкости не буду.

Пример по второму пункту:
В 1С по дефолту все параметры передаются по ссылке:
## Код:
```
x = 1
y = 1
Function Foo(x, Val y)
    x = 2 // изменили внешнюю переменную
    y = 2 // это локальная переменная
EndFunction
// x == 2; y == 1
```


Ну так вот. Эти два примера довольно занятны. Авто-переменные - это сейчас во всех скриптовых языках. И это ведь очевидное дерьмо. Но все упорно продолжают так делать. Сделано типа для человека, но сделать неправильно гораздо легче чем правильно. При добавлении нового свойства коллега не будет шерстить твой код на предмет совпадений. Это очевидно. Люди в 99% случаев идут по менее затратному пути к ближайшему банану.
И по той же причине никто не будет использовать Var в функциях. Ведь авто-переменные - это легче!
И самое смешное, что реально гораздо легче. Ведь в 1С нельзя при объявлении сразу присвоить значение. Вам придется не только написать эти три буквы "Var", но еще и продублировать название переменной (а они в 1С длиннючие). Это все довольно действительно существенные затраты, если вы пишете много кода. И программеров можно понять. На мой взгляд эта ошибка дизайна языка примечательна тем, что авторы не учли целевую аудиторию. Т.е. (как бы это странно не звучало), что языком будет пользоваться человек.
Странный вывод, да? Как такая хрень могла произойти вообще? Автор явно думал о чем-то другом, когда проектировал язык. Но блин почему???

По второму примеру еще эпичнее. Наверно многие знают, что в хорошем языке параметры по дефолту должны быть по значению. Это даже и не обсуждается особо. Умолчательная передача по ссылке - это зло. И в 1С конечно же допустили эту ошибку дизайна и сделали передачу по ссылке более легкой для программиста, чем передачу по значению. Никто не хочет к каждому параметру Val приписывать! Ведь так?! Или нет?
А истина заключается в том, что это не создает проблем в 1С. Я за всю практику (8 лет) ни разу не столкнулся с проблемами из-за передачи по ссылке. И этому есть объяснение. Программист - существо разумное. И в части логики наверно разумнее представителей большинства других профессий. Другими словами, просто нет идиотов, которые будут портить без надобности пришедшие параметры. Не роботы же за клавиатурой. Вы ведь даете своему ребенку вилку в полной уверенности, что он не станет ею выколупывать себе глаз. Но вот программистов почему-то негласно принято считать полными идиотами. Почему это так?
И тут в 1С как это не странно нет ошибки дизайна. Практически никто не пишет Val. И это работает. Просто тут (возможно случайно) учтена целевая аудитория.

А вот еще пример: В 1С и присваивание и равенство - это один и тот же символ "=". И никаких проблем из-за этого нет! Вот ну ни капельки. Мы (человеки) так легко распознаем контекст, в котором стоит этот символ, что даже не замечаем этого. Так нахрена в языках делают разные символы??? Это для кого? Для роботов? Так ведь даже компилятор прекрасно знает контекст и технической трудности в распознавании нет совершенно (за исключением присваиваний в выражении как в C).
Не иначе это для инопланетян. Потому как разумное объяснение этому придумать сложно.

Ну и вдогонку: Нафига точки с запятыми? Это ж бред. Lua - пример синтаксиса, где они тупо не нужны. Там нет ни костылей, ни хитрых схем вставки точек с запятыми во время компиляции как в Go. Просто синтаксис спроектирован таким образом, что необходимости в них просто нет. Их там оставили только для оформительных вещей (т.е. для человека). Вот это пример дизайна, ориентированного на человека.

Я в голове держу такую мантру:
1. Язык программирования это для человека в первую очередь (т.е. допускаю даже чисто оформительные синтаксические элементы)
2. Работать должны роботы (например, порядок объявления процедур должен быть удобным для человека, а не для компилятора)
3. Очень важную (никем видимо не понятую) роль при проектировании языка играет целевая аудитория.