На что был бы похож Ваш собственный язык программирования? [закрытый]

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

// I forget the C# syntax for delegates, since I normally code in vb
delegate void RefAction<T1, T2, T3>(ref T1 p1, ref T2 t2, ref T3 p3);

Point myPoints[];

void DoSomethingWithIndexedPoint<XT1, XT2>(int index, 
  RefAction<Point, XT1, XT2) theAction, 
  ref XT1 xp1, 
  ref XT2 xp2)
{
  theAction(myPoints[index], xp1, xp2);  
}

Мой предпочтительный синтаксис будет выглядеть примерно так:

delegate void RefAction<T1, T2, T3>(ref T1 p1, ref T2 t2, ref T3 p3);

Point myPoints[];

void DoSomethingWithIndexedPoint<ref ...>(int index, 
  RefAction<Point, ref ...>, ref ...) theAction, 
  ref XT1 xp1, 
  ref XT2 xp2)
{
  theAction(myPoints[index], ...);  
}

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

  Interlocked.CompareExchange(SomeObject["George"], SomeValue, SomeOtherValue);

, который компилятор мог бы переписать как нечто похожее на:

  SomeObject.ActUponProperty("George",
    (ref dest, ref p1, ref p2) => {Interlocked.CompareExchange(dest, p1, p2);},
    SomeValue, SomeOtherValue);

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

Это было бы машиночитаемым / записываемым, и это было бы написано интеллектуальным программным обеспечением, которое принимает инструкции голосом.

Мой оптимальный язык много походил бы на Nemerle (минус произвольные ограничения). Действительно это сводится к средствам метапрограммирования; я должен смочь произвольно расшириться, или изменить язык всегда я считаю целесообразным (период) для установки домену отлично.

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

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

Я начну с ключевых особенностей:

• Это должен быть гомоиконический язык с мощной поддержкой макропрограммирования на основе макросов. Это огромное преимущество для производительности (см. Пола Грэхема, опередившего средние )
• . Он должен работать на любых платформах и иметь большую поддержку для запуска распределенной системы. код . Настройка облака машин должна быть простой задачей.
• Это должен быть с открытым исходным кодом .
• Он должен иметь как можно большую библиотечно-инструментальную экосистему . Практически это означает, что вам необходим доступ к экосистеме Java, поэтому по этой причине он, вероятно, должен быть языком JVM.
• Он должен поддерживать вывод типа . Жизнь слишком коротка, чтобы компилятор не разбирал детали типа за вас .....
• Это должен быть функционал с акцентом на неизменность структуры данных. Это будущее для продвинутых языков (я не оспариваю, что функциональные языки трудно освоить, но этот язык не для начинающих ....)
• Он должен поддерживать интерактивную разработку , предпочтительнее в среде, подобной REPL, где вы можете взаимодействовать с работающей (потенциально распределенной) средой кода.
• Он должен обеспечивать превосходную поддержку параллельного доступа без блокировки . По мере того, как мы продвигаемся в массовом многоядерном мире, подходы на основе блокировок просто не будут масштабироваться. Программная транзакционная память - это , вероятно, путь вперед.
• Он должен поддерживать низкоуровневое кодирование , где это необходимо для производительности. Высокоуровневое кодирование прекрасно в 95% случаев, но иногда вам просто нужно манипулировать байтами напрямую .....

В настоящее время наиболее близким к моему списку пожеланий является Clojure , который отвечает большинству этих требований.

Поскольку OP ссылается на синтаксис, я приведу несколько примеров кода:

Правильные функции переменной арности с поддержкой больших списков аргументов:

(+ 1 2 3 4 5)
=> 15

(apply + (range 10000))
=> 49995000

Интерактивный доступ к компилятор во время выполнения:

(def function-string "+")

(def function (compile-string function-string))

(function 7 8 9)
=> 24

Выполнение распределенного кода (стиль MapReduce). Обратите внимание, что это означает, что язык / библиотека может взять локально определенный some-long-running-function и прозрачно распределить его по всем узлам кластера для выполнения во время выполнения .

(def my-cluster 
     (create-compute-cluster :nodes 100 :service "Amazon"))

(defn some-long-running-function [input]
  ....)

(def reduction-function 
  (fn [a b] 
    (do-something-to-reduce a b)))

(def lots-of-inputs (range 10000))

(distributed-map-reduce
  my-cluster
  some-long-running-function
  inputs
  reduction-function)
=> (whatever the result of the mapreduce is over the cluster)

Правильный вывод типа (т. Е. Компилятор выясняет, что my-function всегда возвращает String и соответственно делает оптимизации / выводы:

(def my-function [name]
   (str "Hello " name "!"))

(my-function "Bob")
=> "Hello Bob!"

(compile-time-type my-function)
=> [java.lang.String :not-null]

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

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

Я хочу, чтобы это произошло, но при этом было легко писать и легко читать.

Язык, что функции никакая структура или переменные, всего одна функция.

doEverything ();//автоматическая генерация всех на основе содержимого на уже предсказанном входе

Clojure становится довольно близко ...

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

Node foundNode = null;  // need stupid null value here to keep track if it was not found
foreach (Node testNode in nodes) {
  if (testNode.YesItsMe) {
    foundNode = testNode;
    break;
  }
}
if (foundNode == null) {
  // create new instance
  foundNode = new Node(blabla);
}

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

Node foundNode;  // no need to initialize anymore
foreach (Node testNode in nodes) {
  if (testNode.YesItsMe) {
    foundNode = testNode;
    break;
  }
} guard {  // we get here if break was never called
  // create new instance
  foundNode = new Node(blabla);
}

Мультимедийная.

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

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

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

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

• палочки с данными в серии Lt Leary Дэвида Дрейка (некоторые из которых доступны бесплатно из Baen )
• мультимодальные любимые наборы жестов и вокализаций в Matadora и других случайных упоминаниях в серии Perry's Matador
• перьевых и жестовых интерфейсов, включая подписание к печать журнала в Fool's War

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

Я предположил бы, что мой будет где-нибудь между Brainf*ck и LOLCODE кроме с НАМНОГО больше круглые скобки .

Это не очень отличалось бы от взятия лучших идей Eiffel и C# (потому что, явно, у меня нет знания для предложения чего-либо лучше - я не изучил CS во-первых).

Однако мое основное практическое беспокойство было бы движением к один шаг вне классического "текстового подхода" исходного кода . Я знаю, что это (или походит), вещь IDE, но почему не может я иметь настраиваемое представление кода со столбцами, такими как предварительные условия/тело/постусловия вместо "линейной" формы (i):

  function f
  // f's preconditions
  // f's body
  // f's postconditions
  end

  function g
  // g's preconditions
  // g's body
  // g's postconditions
  end

, Почему не (ii) - воображают, это таблица (с границами):

f      f's parameters    f's prec      f's body      f's postc    f's comments
g      g's parameters    g's prec      g's body      g's postc    g's comments

И также, почему я не могу выбрать, как функции "начинаются" и "заканчиваются" (фигурные скобки, ключевые слова...) в стиле (i)? Почему я не могу немедленно показать или скрыть частных или защищенных участников? Почему я не могу немедленно видеть "плоскую версию" со всеми наследованными функциями внутри? и т.д.

точка не должна была бы иметь одного святого файла кода, где Вы редактируете и затем несколько "прохладных представлений", но смочь отредактировать и добавить код в обоих (i), (ii) и безотносительно формы являются самыми полезными для Вас.

В некотором смысле, говоря о "IDE" может казаться вне темы здесь. Но OTOH, я думаю, что это собирается изменить способ, которым мы пишем и читаем код рано или поздно. И это будет в конечном счете влиять на способ, которым развиваются языки. Будущие цели состояли бы в том, чтобы улучшить не только удобочитаемость, но также и "понятность" и интерактивность.

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

В этих примерах я использую фигурные скобки для идентификации метакода. Вы сможете запустить исходный код через «препроцессор» для расширения метакода. В противном случае он будет расширен только один раз во время выполнения.

print "Your product ID is: ", { print '"', generateGUID(), '"' }

или

lookupTable[] = {
                  /* insert code to generate table here
                   *
                   * This lets you modify the algorithm easily
                   * but speeds up the final program.
                   * 
                   * This would be especially appropriate in
                   * cases where you would otherwise type out
                   * the table as a literal (yuck)
                   */
                }

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

Совершенные языки программирования обычно встречаются в фантастических романах. Например:

• Серия Эндер Орсона Скотта Карда - Чтобы творить, вы должны пойти в другое измерение и сформировать чистую мысль в своем уме. Когда вы вернетесь, это так.
• Роберт А. Хайнлайн исследовал концепцию мира как мифа в Number of the Beast
• Earth Дэвида Брина имеет программирование посредством суб-вокала в сочетании с глазом и пальцем движения.

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

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

Мой идеальный язык позволил бы мне углублять функциональность, поскольку мне нужен он. Если я должен записать маленькую прямую утилиту без классов, я мог. Если бы я должен был использовать классы, то я мог бы сделать это также, и если бы я хотел записать абсолютно объектно-ориентированное решение, то я смог бы сделать это также. Компоновщик был бы достаточно умен, чтобы позволить мне создать маленькие быстрые утилиты командной строки (без зависимостей во время выполнения) или самое большое чрезмерно увеличенное в размерах ООП приложение для GUI, которое я мог вообразить.

проблема состоит в том, что то, что я люблю, имеет противостоящие цели, и таким образом я всегда принуждался к использованию совершенно других языков. Я в настоящее время использую без определенного порядка PowerShell, VBScript, PowerBasic, Java и C# (и иногда VB.NET, VB 6, C++, Python и Perl).

Теперь, если я мог бы сделать все это с одним C# как язык, который имел глобальные функции без зависимостей во время выполнения при создании тех небольших приложений, но позволяют мне полностью использовать питание Платформы.NET и Java SDK, когда я должен был, я буду счастлив.

Это было бы похоже на C #. Я хотел бы иметь Microsoft!

У меня нет понятия "идеального" языка программирования, потому что нет всего одной задачи, которая будет выполнена.

Различные задачи удовлетворяют различным языкам и парадигмам.

Немного загадочно, но это то, что я хотел бы:

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

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

, К сожалению, я не инвестировал достаточно воображения придумать что-либо более определенное.

Крупный параллелизм уполномочен Amazon Mechanical Turk.

job = "Upvote this answer"
@price = "$0.01"
fork(10000, job, @price)

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

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

Я разработал и реализовал его в системах x86 SMP, и он использовался около 10 лет в качестве основы для крупномасштабного инструменты анализа программного обеспечения.

Главное было позволить мне (нам) указать параллелизм легко:

(|| A B)

выполняет A и B параллельно, и пусть компилятор генерировать всю грязь, которая делает это возможным. Нас не заботило, был ли синтаксис инфикс или нет, поэтому мы выбрали стиль LISP, чтобы избежать аргументы.

Документ с описанием языка и ряда параллельные приложения можно найти на http://www.semanticdesigns.com/Company/Publications/parallelism-in-symbolic-computation.pdf

В документе кратко обсуждается, как мы не удается избежать споров по поводу синтаксиса несмотря на наше решение.

Хм. Это сложный вопрос. Мои предпочтения сводятся к легко понятным людям и легким языкам сценариев (хотя я верю, что это может сработать для более крупных приложений). См. Фрагмент кода:

function Foo takes x as string, y as boolean //can add returns [return type] if one wishes to be explicit
    //explicit variable declaration
    z as number
    //explicit cast from boolean to number
    z is y as number
    //implicit variable declaration
    bar is 3 * 5
    //function call
    print x
    return z / bar //since we casted z to a number, it returns a number