Действительно ли синтаксис имеет значение в языке программирования? [закрыто]

Один из моих профессоров говорит, что «синтаксис - это пользовательский интерфейс языка программирования», такие языки, как Ruby, обладают отличной читабельностью и растут, но мы видим, что многие программисты работают с C \ C ++, так что программистам действительно важно, что синтаксис должно быть приемлемым?

Я хотел бы узнать ваше мнение по этому поводу.

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

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

Да, это так. Если вы сомневаетесь, возьмите APL , или J , или Brainfuck , или даже простой и простой Lisp или Forth, и попытайтесь понять любую не совсем тривиальную программу на нем. Затем сравните, например, с Python.

Затем сравните тот же Python (или Ruby, или даже C #) с такими вещами, как Cobol или VB6.

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

На практике я думаю, что это имеет значение. Читаемость уже обсуждалась выше. Другая проблема может заключаться в том, сколько нажатий клавиш требуется для выражения идеи / алгоритма? Еще одна проблема заключается в том, насколько легко простым опечаткам быть трудно уловить человеческий глаз, и сколько вреда они могут причинить.

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

Я полагаю, ваш профессор имеет в виду синтаксический сахар .

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

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

Роберт Мартин, опираясь на теорему о структурированном программировании , в своем основном выступлении на RailsConf 2010 рассказал о том , что программисты в основном делают с языками программирования : Роберт Мартин (видео на youTube, смотрите через 14 минут, хотя я рекомендую все это):

• Последовательность (назначение)
• Выбор (если заявления)
• Итерация (do-loop)

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

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

Да и нет.

Есть несколько различных аспектов синтаксиса.

• читабельность
• экспрессивность
• parsability

Читаемость уже упоминалась.

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

Давайте возьмем C ++ для примера. Я могу создать функцию первого порядка после этого способа:

class funcClass
{
  int operator()(int);
}
funcClass fun;

void run_func(funcClass fun)
{
   fun();
}

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

С другой стороны, в Common Lisp я могу имитировать что-то вроде этого :

(defun myfunc() )

(defun run_func(fun)
  (fun))

Или в Perl -

   sub myfunc
   {
   }

   sub run_func
   {
      my $func = shift;
      $func->();          #syntax may be a little off.
   }

Или в Python -

def myfunc():
    pass

def run_func(f):
    f()

Все они, по сути, имеют одно и то же семантическое содержание, хотя пример C ++ содержит метаданные определенного типа. На каком языке лучше всего выражена идея передачи функции высшего порядка? Common Lisp едва ли делает синтаксическую вариацию. C ++ требует, чтобы класс был создан только для «переноса» функции. Perl довольно прост в достижении некоторого уровня дифференциации. Так же как и Python.

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

По моему мнению, разборчивость имеет большое значение. В частности, я имею в виду способность среды IDE анализировать и разбивать язык без ошибок. Переформатирование полезно. Языки с разделителями-токенами обычно хорошо разбираются - ruby ​​/ c / pascal и т. Д.

Однако подумайте - основные системы всех видов были созданы на каждом серьезном языке для решения реальных проблем. Хотя синтаксис является барьером для выражения некоторых вещей, он является обходным барьером. Эквивалентность Тьюринга и все такое.

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

if (AlertCode = RED)
   {LaunchNukes();}

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

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

В случае с Liskell считалось, что использование s-выражений упростит использование макросов. Оказалось, что в Haskell макросы действительно не нужны, поэтому эксперимент тоже не сработал.

Вот в чем дело: если бы синтаксис ни для кого не имел значения, ни один эксперимент не был бы опробован.

Ответ может заключаться в разделении того, что «имеет значение», на компьютерные факторы и человеческие факторы . В синтаксисе много человеческих факторов:

• читабельность
• краткость
• Ремонтопригодность
• Педагогика
• Предотвращение ошибок
• Соответствие цели - это язык REPL, язык сценариев или язык крупных систем?

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

Возможно, поэтому вы всегда получите ответ «да и нет» на этот вопрос - потому что в этом есть два аспекта.

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

Я думаю, что действительно важно доступ к API и доступность низкоуровневой функциональности (например, управление памятью и блокировка), когда это необходимо. Большинство других языков поставляются с этими функциями. Проблема в том, что когда вам нужна дополнительная функциональность, вам часто приходится использовать язык, такой как C, для его реализации. И это громоздкое взаимодействие C с языком, который вы используете.

Для всего, кроме веб-разработки (и математики), я обнаружил, что C / C ++ по-прежнему является языком операционной системы и приложения. Это то, что поддерживается большую часть времени для истинной многопоточной, предварительно формирующей, кросс-платформенной разработки приложений. И синтаксис C в порядке. Просто очень просто и относительно многословно. Удивительный синтаксис не имеет большого значения. Доступность мощности и API Нам всем нужно взаимодействовать с кодом других людей (который большую часть времени написан на C или его производных).

Синтаксис определенно имеет значение. Это чрезвычайно ценно, если синтаксис языка достаточно гибок, чтобы позволить вам создать удобный и читаемый предметно-ориентированный язык для вашего приложения. Если вы сомневаетесь в этом, просто представьте, что вы решаете задачи алгебры в прозаической латыни, как это было сделано до 18-го века, или представьте, что вы делаете исчисление без уже знакомой нотации Лейбница. Конечно, текст исчисления нечитаем новичку, но с практикой мы можем использовать исчисление и нотацию Лейбница, чтобы быстро решить класс задач, которые требовали страниц математики классическими методами. Программирование это просто еще один кусочек математики. Удобное обозначение, близкое к проблемной области, может иметь огромное значение для производительности.

Вот программа, которая вычисляет способность 6:

S(K(S(S(SI(KK))(K(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)
(S(KS)(S(K(SI))K))))(KK)KK))))))(S(K(S(S(K(SI))(SII)(S(K(SI))(SII))
(S(K(S(S(KS)(S(KK)(S(SI(KK))(K(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)KK)))))))
(S(K(S(S(KS)(S(K(SI(KK)))(SI(K(KI)))))))(S(K(S(K(S(S(K(SI))(SII)(S(K(SI))
(SII))(S(K(S(S(KS)(SI(KK)))))(S(S(KS)(S(K(S(KS)))(S(K(S(KK)))(S(S(KS)K)
(K(SI(K(KI))))))))(K(K(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)))))))))))
(S(S(KS)K)(K(SI(K(KI)))))))))))(S(S(KS)K)(K(SI(K(KI))))))(S(S(KS)(S(KK)(S(KS)
(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)
(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)
(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)(KI)
(S(S(KS)(S(KK)(S(KS)(S(K(SI))K))))(KK)KK)))))))

Синтаксис минимален:

expression: expression term | term
term: ‘(‘ expression ‘)‘ | combinator
combinator: 'S' | 'K' | 'I' 

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

Обратите внимание, что синтаксис LISP только для чтения (если вообще), потому что он имеет намного больше синтаксиса, чем выше. Итак, если поклонники LISP скажут вам, что «синтаксис не имеет значения», попросите их быть последовательными и попробуйте исчисление SKI. Им придется признать, что немного синтаксис не так уж и плох.

Я не думаю, что это имеет значение вне личных предпочтений. При прочих равных условиях (производительность, возможности и т. Д.) Я понимаю, почему можно было бы придавать большее значение синтаксису языка, но предпочел бы пропустить производительность таких языков, как c / c ++ или любого другого языка, более подходящего для этой работы, просто из-за Синтаксис кажется плохой идеей.

Да, синтаксис имеет значение, хотя на самом деле только для удобства чтения. Для сравнения:

for i in range(10):
   print(i)

(Да, это Питон) с

FOR(i<-RNG-<10){PRN<-i}

(Да, это язык, который я только что придумал) Оба будут делать одно и то же, одинаково, но синтаксис другой, и Python легче читать. Так что да, синтаксис определенно имеет значение. Даже "синтаксический сахар" имеет значение.

 @property
 def year(self):
     return self._date.year

Легче читать, чем

 def year(self):
     return self._date.year
 year = property(year)

Да, конечно.

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

void foo() {
  // blah
}

В.С.

void foo()
{
  // blah
}

или даже VS

void foo() 
{ // blah
}

И это точно такой же язык! Кроме того, спросите их о местах, где они их размещают (имя функции и скобки, операторы и т. Д.).

1000 ответов гарантированы!

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

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

Тем не менее, если это слишком многословно, то оно может добраться до точки, где это влияет на читабельность. Я бы предпочел увидеть что-то вроде:

foreach (String in stringList)

Для того, чтобы:

для каждой строки в списке, на которую ссылается переменная stringlist

...любой день!

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

Очень кратко и непрозрачно (Perl) так же плохо, как чрезмерно многословно и многословно (AppleScript).

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

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

Проще говоря: синтаксис как таковой не имеет значения. Семантика, которую вы можете выразить, имеет значение.