Как Java вдохновлен Lisp?

Ответ 1

Возьмите знаменитый список Пуля Грэма и сравните:

• Условные обозначения: Java имеет условные обозначения. Ну, С++ тоже их тоже.

• Тип функции: Java не имеет функций первого класса. У С++ тоже не было их.

• Рекурсия: Java поддерживает рекурсию. С++ тоже поддерживал его.

• Динамический ввод: Java статически типизирована. Так же был С++.

• Коллекция мусора: Java имеет сбор мусора. С++ не делает.

• Программы, состоящие из выражений: И Java, и С++ делают различие между операторами и выражениями. Поэтому оба не могут удовлетворить эту точку.

• Тип символа: Ни Java, ни С++ не поддерживают это как часть языка. Это очень легко реализовать.

• Homoiconicity: Опять же, ни Java, ни С++ не гомомикны.

• Весь язык там все время: Нет, опять.

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

Вывод: (субъективный) Гай Стил вышеприведенная цитата - идиотская. Период.

Очень интересная цитата из comp.lang.scheme:

Вы отправляете группу Scheme. Вокруг здесь, утверждая, что Java лучше, чем С++, похоже на утверждение, что кузнечики лучше, чем дерево. & ЕПРС; — Thant Tessman, comp.lang.scheme

: -)

Ответ 2

Guy L. Steele очень хорошо известен в мире Lisp (он совместно разработал один из двух основных диалектов Lisp, используемых сегодня) и, по-видимому, был приглашен в группу дизайна Java в Sun после того, как язык был разработан для написания спецификации, поскольку он был хорошо известен для написания хороших спецификаций для существующих языков.

"На полпути до Lisp", на мой взгляд, не так много в синтаксисе языка Java (который намеренно моделирует C), как и в мышлении JVM. "Ты не будешь беспокоиться о сборке мусора". "Вы не будете беспокоиться о указателях, кроме ссылочных объектов". Сегодня эти вещи кажутся естественными, но были еретичными для некоторых, когда появилась Java.

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

Ответ 3

Основной момент в эволюции от С++ к Java - с точки зрения Lisp - это использование так называемой "управляемой памяти":

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

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

Например, Interlisp от BBN и Xerox имел виртуальную машину (в 1970-х годах). Были также рабочие места Interlisp (1970-1980-е годы), где набор инструкций был предоставлен на уровне процессора (микрокодировано). Инструкции проверяются во время выполнения (есть + имеют правильные аргументы). Это также очень похоже на то, что использовалось во время работы в Smalltalk. Системы Xerox Smalltalk и InterLisp работали на одном и том же оборудовании, но с различным микрокодом.

Это означает, что вы можете искать в отладчике данные JVM, и отладчик всегда знает, какие примитивные типы есть. Отражение может использоваться для получения информации. Это похоже на то, как вы можете смотреть в Lisp с отладчиком на объектах. В С++ это возможно только тогда, когда присутствует отладочная информация, которая, как правило, имеет значение только в случае разработки.

Итак, JVM выглядит в некотором роде аналогично типичной Lisp 'runtime'.

Это отличается от С++, где С++ - это низкоуровневые биты (обычно) и не было "управляемой памяти".

Джеймс Гослинг ( "отец" Java) немного знал о Lisp от реализации Gosling Emacs в C на Unix в начале 1980-й года. У его Emacs был странный диалект Lisp для расширения редактора: Mocklisp.

Кроме того, что Java и Lisp отличаются друг от друга, так что "на полпути" может быть не так, но это помогло, например, преодолеть враждебность против чего-то вроде "сборки мусора". К сожалению, особенно в ранние времена Java, Java и JVM также были раздуты, и через некоторое время проблемы с производительностью стали очевидными. Это была некоторая причина смерти настольных приложений, которые были вялыми для использования (плохое время запуска, медленное время отклика,...).

Ответ 4

Некоторые аспекты Java, которые делают его более "Lisp -like", чем С++:

• сбор мусора
• безопасный тип безопасности
• отражение
• нет препроцессора (но Common Lisp имеет макросы!)

ИЗМЕНИТЬ

Кстати, цитата Гай Стил приходит из этой рассылки в 2003 году:

http://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg04045.html

(Google - мой друг:-))

Ответ 5

Я не думаю, что Java очень похож на Lisp -ish, но С++ даже меньше Lisp -ish. В качестве примера рассмотрим этот вызов CollectionUtils.filter():

void foo(final int n) {
    CollectionUtils.filter(collection, new Predicate() {
        public boolean evaluate(Object input) { return input.equals(n); }
    });
}

Я нахожу этот стиль более Lisp -ish, чем эквивалентная версия С++:

void foo(int n) {
    // C++ does not have anonymous classes in the Java sense, so
    // we need a separate definition
    struct Predicate {
        // This class does not have access to variables defined
        // in the enclosing scope, so we need to explicitly pass
        // whatever we need
        int n;
        Predicate(int n) : n(n) { }

        bool operator()(int x) { return x == n; }       
    };

    CollectionUtils::filter(collection, Predicate(n));
}

Ответ 6

Есть более чем несколько языков, которые могут сказать, что они двигаются к Lisp. Жесткая Java не является одним из них.

Это должен был быть ответ на щеку или, может быть, он спускался с 3-дневного бендера.