Самостоятельная (язык программирования) - Self (programming language)

Я
Логотип
Парадигмаобъектно-ориентированный (на основе прототипа )
РазработаноДэвид Ангар, Рэндалл Смит
РазработчикДэвид Ангар, Рэндалл Смит, Стэндфордский Университет, Sun Microsystems
Впервые появился1987; 33 года назад (1987)
Стабильный выпуск
2017.1 / 24 мая 2017 г.; 3 года назад (2017-05-24)
Печатная дисциплинадинамичный, сильный
ЛицензияBSD-подобная лицензия
Интернет сайтwww.selflanguage.org
Главный реализации
Я
Под влиянием
Болтовня
Под влиянием
NewtonScript, JavaScript, Ио, Агора, Писк, Lua, Фактор, REBOL

Я является объектно-ориентированного программирования язык основанный на концепции прототипы. Самость началась как диалект Болтовня, будучи динамически типизированный и используя своевременная компиляция (JIT), а также подход к объектам на основе прототипов: он впервые был использован в качестве экспериментальной тестовой системы для языкового дизайна в 1980-х и 1990-х годах. В 2006 году Self все еще разрабатывался как часть проекта Klein, который представлял собой виртуальную машину Self, полностью написанную на Self. Последняя версия - 2017.1 выпущена в мае 2017 года.[1]

Несколько методов своевременной компиляции были впервые применены и улучшены в Самоисследовании, поскольку они должны были позволить объектно-ориентированному языку очень высокого уровня работать со скоростью до половины скорости оптимизированного C.Большая часть развития Self происходила на Sun Microsystems, а разработанные ими методы позже были применены для Ява с HotSpot виртуальная машина.

В какой-то момент версия Smalltalk была реализована в Self. Поскольку он мог использовать JIT, это также давало чрезвычайно хорошую производительность.[2]

История

Self был разработан в основном Дэвид Ангар и Рэндалл Смит в 1986 году, работая в Xerox PARC. Их цель состояла в том, чтобы продвигать современные достижения в области исследования объектно-ориентированного языка программирования, когда-то Smalltalk-80 был выпущен лабораториями и начал серьезно восприниматься промышленностью. Они переехали в Стэндфордский Университет и продолжил работу над языком, создав первый работающий компилятор Self в 1987 году. В этот момент фокус сместился на попытку вывести на язык Self целую систему, а не только язык.

Первый публичный релиз был в 1990 году, а в следующем году команда переехала в Sun Microsystems где продолжили работу над языком. За этим последовало несколько новых выпусков, пока в 1995 г. не вышла версия 4.0. Версия 4.3 была выпущена в 2006 году и работала на Mac OS X и Солярис. Новый выпуск 2010 г.[3], версия 4.4, была разработана группой, состоящей из некоторых из первоначальной команды и независимых программистов, и доступна для Mac OS X и Linux, как и все последующие версии. Следующая версия 4.5 была выпущена в январе 2014 года.[4], а три года спустя в мае 2017 года была выпущена версия 2017.1.

Self также вдохновил ряд языков, основанных на его концепциях. Наиболее заметными, пожалуй, были NewtonScript для Яблочный Ньютон и JavaScript используется во всех современных браузерах. Другие примеры включают Ио, Лизаак и Агора. В IBM Tivoli Framework Распределенная объектная система, разработанная в 1990 году, на самом низком уровне представляла собой объектную систему, основанную на прототипах, вдохновленную Self.

Языки программирования на основе прототипов

Основная статья: Программирование на основе прототипов

Традиционные объектно-ориентированные языки на основе классов основаны на глубоко укоренившейся двойственности:

  1. Классы определять основные качества и поведение объектов.
  2. Экземпляры объектов являются частными проявлениями класса.

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

Этот пример показывает одну из проблем этого подхода: автомобиль Боба, который является спортивным автомобилем, не может перевозить и доставлять строительные материалы (в любом значимом смысле), но это возможность, которая Средство передвиженияs моделируются как имеющие. Более полезная модель возникает при использовании подклассы создать специализации Средство передвижения; Например Спортивная машина и Бортовой грузовик. Только объекты класса Бортовой грузовик необходимо предоставить механизм для доставить строительные материалы; спортивные автомобили, которые плохо подходят для такой работы, нужно только гони. Однако эта более глубокая модель требует большего понимания во время проектирования, понимания, которое может проявиться только при возникновении проблем.

Этот вопрос - один из мотивирующих факторов прототипы. Если невозможно с уверенностью предсказать, какими качествами будет обладать набор объектов и классов в отдаленном будущем, невозможно правильно спроектировать иерархию классов. Слишком часто программе в конечном итоге потребовалось бы дополнительное поведение, а разделы системы пришлось бы перепроектировать (или рефакторинг ), чтобы разбить предметы по-другому.[нужна цитата ] Опыт работы с ранними ОО-языками, такими как Болтовня показал, что подобные проблемы возникают снова и снова. Системы будут иметь тенденцию вырастать до определенной точки, а затем становиться очень жесткими, поскольку базовые классы глубоко под кодом программиста становились просто «неправильными». Без возможности легко изменить исходный класс могут возникнуть серьезные проблемы.[нужна цитата ]

Динамические языки, такие как Smalltalk, допускали такого рода изменения с помощью хорошо известных методов в классах; изменяя класс, объекты, основанные на нем, изменяют свое поведение. Однако такие изменения нужно было делать очень осторожно, поскольку другие объекты, основанные на том же классе, могли ожидать этого «неправильного» поведения: «неправильное» часто зависит от контекста. (Это одна из форм проблема хрупкого базового класса.) Далее, на языках вроде C ++, где подклассы могут быть скомпилированы отдельно от суперклассов, изменение суперкласса может фактически нарушить предварительно скомпилированные методы подкласса. (Это еще одна форма проблемы хрупкого базового класса, а также одна из форм проблема хрупкого двоичного интерфейса.)

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

Вместо того, чтобы иметь «экземпляр» объекта, основанный на каком-то «классе», в Self создается копия существующего объекта и изменяется его. Так Машина Боба будет создан путем создания копии существующего объекта «Автомобиль» и последующего добавления гони метод, моделирующий тот факт, что это Порше 911. Основные объекты, которые используются в основном для создания копий, известны как прототипы. Утверждается, что этот метод значительно упрощает динамизм. Если существующий объект (или набор объектов) оказывается неадекватной моделью, программист может просто создать измененный объект с правильным поведением и использовать его вместо этого. Код, использующий существующие объекты, не изменяется.

Описание

Самостоятельные объекты - это набор «слотов». Слоты - это методы доступа, которые возвращают значения, и установка двоеточия после имени слота устанавливает значение. Например, для слота "имя"

мой человек имя

возвращает значение в имени, а

мой человек имя:'фу'

устанавливает это.

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

Обратите внимание, что в Self нет различия между полями и методами: все - это слот. Поскольку доступ к слотам через сообщения составляет большую часть синтаксиса в Self, многие сообщения отправляются на «self», а «self» можно не указывать (отсюда и название).

Базовый синтаксис

Синтаксис доступа к слотам аналогичен синтаксису Smalltalk. Доступны три вида сообщений:

унарный
получатель slot_name
двоичный
получатель + аргумент
ключевое слово
получатель ключевое слово: arg1 С участием: arg2

Все сообщения возвращают результаты, поэтому получатель (если есть) и аргументы сами могут быть результатом других сообщений. После сообщения точкой означает, что Self отбросит возвращаемое значение. Например:

'Привет мир!' Распечатать.

Это собственная версия Привет мир программа. В ' синтаксис указывает на буквальный строковый объект. Другие литералы включают числа, блоки и общие объекты.

Группировку можно принудительно использовать круглыми скобками. При отсутствии явной группировки считается, что унарные сообщения имеют наивысший приоритет, за ними следуют двоичные (группировка слева направо) и ключевые слова, имеющие наименьший приоритет. Использование ключевых слов для присваивания привело бы к некоторым дополнительным скобкам, в которых выражения также содержали сообщения с ключевыми словами, поэтому, чтобы избежать этого, Self требует, чтобы первая часть селектора сообщения с ключевым словом начиналась с буквы нижнего регистра, а последующие части начинались с буквы верхнего регистра.

действительный: база дно          между: лигатура дно + рост          И: база верх / масштаб фактор.

может быть разобран однозначно и означает то же, что и:

действительный: ((база дно)            между: ((лигатура дно) + рост)            И: ((база верх) / (масштаб фактор))).

В Smalltalk-80 это же выражение выглядело бы так:

действительный := я база дно             между: я лигатура дно + я рост             и: я база верх / я масштаб фактор.

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

Создание новых объектов

Рассмотрим чуть более сложный пример:

labelWidget копировать метка: 'Привет мир!'.

делает копию объекта «labelWidget» с сообщением о копировании (на этот раз без ярлыка), затем отправляет ему сообщение, чтобы поместить «Hello, World» в слот, называемый «label». Теперь что-нибудь с этим сделать:

(рабочий стол activeWindow) привлечь: (labelWidget копировать метка: 'Привет мир!').

В этом случае (рабочий стол activeWindow) выполняется сначала, возвращая активное окно из списка окон, о которых знает объект рабочего стола. Затем (читать от внутреннего к внешнему, слева направо) код, который мы исследовали ранее, возвращает labelWidget. Наконец, виджет отправляется в слот отрисовки активное окно.

Делегация

Основная статья: Делегирование (объектно-ориентированное программирование)

Теоретически каждый объект «Я» представляет собой отдельную сущность. У себя нет ни классов, ни метаклассов. Изменения одного объекта не влияют на другие, но в некоторых случаях желательно, если они повлияли. Обычно объект может понимать только сообщения, соответствующие его локальным слотам, но имея один или несколько слотов, указывающих родитель объекты, объект может делегировать любое сообщение, которое он сам не понимает, родительскому объекту. Любой слот можно сделать родительским указателем, добавив звездочку в качестве суффикса. Таким образом, Self выполняет обязанности, которые наследство в классовых языках. Делегирование также можно использовать для реализации таких функций, как пространства имен и лексическая область видимости.

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

Черты

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

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

Чем это отличается от традиционного класса? Хорошо подумайте о значении:

myObject родитель: someOtherObject.

Этот отрывок изменяет «класс» myObject во время выполнения, изменяя значение, связанное со слотом «родительский *» (звездочка является частью имени слота, но не соответствующими сообщениями). В отличие от наследования или лексической области видимости, объект делегата может быть изменен во время выполнения.

Добавление слотов

Объекты в Self можно изменить, добавив в них дополнительные слоты. Это можно сделать в графической среде программирования или с помощью примитива «_AddSlots:». А примитивный имеет тот же синтаксис, что и обычное сообщение с ключевым словом, но его имя начинается с символа подчеркивания. Примитива _AddSlots следует избегать, потому что он остался от ранних реализаций. Однако мы покажем это в приведенном ниже примере, потому что это делает код короче.

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

_AddSlots: (| средство передвижения <- (|родитель* = черты клонируемый |) |).

Поскольку получатель примитива '_AddSlots:' не указан, это "self". В случае выражений, вводимых в командной строке, это объект, называемый «вестибюль». Аргумент для '_AddSlots:' - это объект, чьи слоты будут скопированы в получатель. В данном случае это буквальный объект с одним слотом. Имя слота - «транспортное средство», а его значение - еще один буквальный объект. Обозначение «<-» подразумевает второй слот под названием «vehicle:», который можно использовать для изменения значения первого слота.

Знак "=" указывает на постоянный слот, поэтому соответствующего родительского элемента нет. Литеральный объект, который является начальным значением «vehicle», включает в себя единственный слот, поэтому он может понимать сообщения, связанные с клонированием. Действительно пустой объект, обозначенный как (| |) или, проще говоря, как (), вообще не может получать никаких сообщений.

средство передвижения _AddSlots: (| имя <- 'автомобиль'|).

Здесь получатель - это предыдущий объект, который теперь будет включать слоты name и name: в дополнение к родительскому объекту *.

_AddSlots: (| спортивная машина <- средство передвижения копировать |).спортивная машина _AddSlots: (| ехать на работу = (''немного код, этот является а метод'') |).

Хотя раньше «автомобиль» и «спортивный автомобиль» были абсолютно одинаковы, теперь последний включает новый слот с методом, которого нет в оригинале. Методы могут быть включены только в постоянные слоты.

_AddSlots: (| porsche911 <- спортивная машина копировать |).porsche911 имя:'Бобы Порше'.

Новый объект «porsche911» начинался точно так же, как «sportsCar», но последнее сообщение изменило значение его слота «name». Обратите внимание, что у обоих по-прежнему одинаковые слоты, хотя у одного из них другое значение.

Окружающая среда

Одна из особенностей «Я» состоит в том, что она основана на таком же виртуальная машина система, которую использовали более ранние системы Smalltalk. То есть программ нет автономный сущности, как они есть на таких языках, как C, но для запуска требуется вся их среда памяти. Для этого необходимо, чтобы приложения поставлялись в виде блоков сохраненной памяти, известных как снимки или картинки. Одним из недостатков этого подхода является то, что изображения иногда бывают большими и громоздкими; однако отладка образа часто бывает проще, чем отладка традиционных программ, поскольку состояние времени выполнения легче проверять и изменять. (Разница между разработкой на основе исходного кода и разработкой на основе изображений аналогична разнице между программированием на основе классов и прототипным объектно-ориентированным программированием.)

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

Спектакль

В некоторых тестах производительность собственных виртуальных машин была примерно вдвое меньше, чем у оптимизированного языка C.[5]

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

Вывоз мусора

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

Оптимизация

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

Смотрите также

использованная литература

  1. ^ «Самостоятельная» Мандаринка «2017.1». 24 мая 2017. Архивировано с оригинал 24 мая 2017 г.. Получено 24 мая 2017.
  2. ^ Волчко, Марио (1996). "self включает: Smalltalk". Семинар по языкам на основе прототипов, ECOOP '96, Линц, Австрия.
  3. ^ «Самостоятельная версия 4.4 выпущена». 16 июля 2010 г. Архивировано с оригинал 5 декабря 2017 г.. Получено 24 мая 2017.
  4. ^ «Выпущен Self Mallard (4.5.0)». 12 января 2014. Архивировано с оригинал 6 декабря 2017 г.. Получено 24 мая 2017.
  5. ^ Агесен, Оле (март 1997 г.). «Разработка и реализация Pep, оперативного переводчика Java». sun.com. Архивировано из оригинал 24 ноября 2006 г.
  6. ^ [1][мертвая ссылка ]

дальнейшее чтение

внешние ссылки