Я (язык программирования)

Себя
	Собственный логотип
Парадигмы	объектно-ориентированный ( на основе прототипов )
Семья	Болтовня
Разработано	Дэвид Унгар , Рэндалл Смит
Разработчики	Дэвид Унгар, Рэндалл Смит, ; Стэндфордский Университет , ; Сан Микросистемс
Впервые появился	1987 год ; 37 лет назад
Стабильная версия	Мандарин 2017.1 / 24 мая 2017 г .; 7 лет назад
Дисциплина набора текста	динамичный , сильный
ТЫ	Кроссплатформенность : Unix-подобная , macOS , Windows.
Лицензия	BSD -подобный
Веб-сайт	www .selflanguage .org
Основные реализации
	Себя
Под влиянием
	Смоллток , APL
Под влиянием
	NewtonScript , JavaScript , Io , Agora , Squeak , Lua , Factor , Rebol

Self — это общего назначения основанный высокого уровня , объектно-ориентированный язык программирования на концепции прототипов . Self начинался как диалект Smalltalk , который был динамически типизирован и использовал JIT- компиляцию с подходом к объектам, основанным на прототипах: впервые он использовался в качестве экспериментальной тестовой системы для проектирования языка в 1980-х и 1990-х годах. В 2006 году Self все еще разрабатывался в рамках проекта Кляйна, который представлял собой виртуальную машину Self, полностью написанную на Self. Последняя версия 2017.1 была выпущена в мае 2017 года. ^[2]

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

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

История [ править ]

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

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

Morphic Среда создания пользовательского интерфейса была первоначально разработана Рэнди Смитом и Джоном Мэлони для языка программирования Self. ^[6] Morphic был портирован на другие известные языки программирования, включая Squeak , JavaScript , Python и Objective-C .

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

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

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

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

Например, предположим, что объекты Vehicle Класс имеет имя и возможность выполнять различные действия, например ездить на работу и доставлять стройматериалы . Bob's car это конкретный объект (экземпляр) класса Vehicle, с названием «Машина Боба». Теоретически можно затем отправить сообщение Bob's car, сказав ему доставить стройматериалы .

Этот пример показывает одну из проблем такого подхода: автомобиль Боба, который является спортивным автомобилем, не способен перевозить и доставлять строительные материалы (в каком-либо значимом смысле), но это возможность, которую Vehicles созданы для того, чтобы иметь. Более полезная модель возникает при использовании подклассов для создания специализаций Vehicle; например Sports Car и Flatbed Truck. Только объекты класса Flatbed Truckнеобходимо обеспечить механизм доставки строительных материалов ; спортивным автомобилям, которые плохо подходят для такой работы, достаточно быстро ездить . Однако эта более глубокая модель требует большего понимания во время проектирования, понимания, которое может проявиться только по мере возникновения проблем.

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

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

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

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

Описание [ править ]

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

моеЛичное   имя

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

мое   имя:  'фу'

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

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

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

Основной синтаксис [ править ]

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

унарный: receiver slot_name
двоичный: receiver + argument
ключевое слово: receiver keyword: arg1 With: arg2

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

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

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

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

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

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

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

В Smalltalk-80 то же выражение будет записано как:

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

предполагая base, ligature, height и scale не были переменными экземпляра self но были, по сути, методами.

Создание новых объектов [ править ]

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

labelWidget   копирует   метку:   «Привет, мир!»   .

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

(  рабочий стол   activeWindow  )  draw:  (  labelWidget   копирует   метку:   «Hello, World!»  )  .

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

Делегирование [ править ]

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

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

Черты [ править ]

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

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

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

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

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

Добавление слотов [ править ]

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

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

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

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

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

автомобиль   _  AddSlots:  (  |   имя   <-   'автомобиль'  |  )  .

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

_  AddSlots:  (  |   SportsCar   <-   автомобиля   копия   |  )  . 
  SportsCar   _  AddSlots:  (  |   DriveToWork   =  (  '  какой-то   ,   это   метод   код   '  ''  )  |  )  .

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

_  AddSlots:  (  |   porsche911   <-   спортивного автомобиля   копия   |  )  . 
  Название porsche911   :  «Порше Боба»  .

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

Окружающая среда [ править ]

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

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

Производительность [ править ]

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

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

Сбор мусора [ править ]

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

Оптимизации [ править ]

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

См. также [ править ]

Ссылки [ править ]

^ Унгар, Дэвид; Смит, Рэндалл Б. (2007). "Себя". Материалы третьей конференции ACM SIGPLAN по истории языков программирования . дои : 10.1145/1238844.1238853 . ISBN 9781595937667 . S2CID 220937663 .
^ «Автомобиль «Мандарин» 2017.1» . 24 мая 2017 года. Архивировано из оригинала 24 мая 2017 года . Проверено 24 мая 2017 г.
^ Вольчко, Марио (1996). self включает в себя: Smalltalk . Семинар по языкам-прототипам, ECOOP '96. Линц, Австрия.
^ «Выпущено Self 4.4» . 16 июля 2010 года. Архивировано из оригинала 5 декабря 2017 года . Проверено 24 мая 2017 г.
^ «Выпущен Self Mallard (4.5.0)» . 12 января 2014 года. Архивировано из оригинала 6 декабря 2017 года . Проверено 24 мая 2017 г.
^ Мэлони, Джон Х.; Смит, Рэндалл Б. (1995). «Непосредственность и живость в среде построения морфического пользовательского интерфейса» . Материалы 8-го ежегодного симпозиума ACM по пользовательскому интерфейсу и программным технологиям . стр. 21–28. дои : 10.1145/215585.215636 . ISBN 089791709X . S2CID 14479674 . Проверено 24 марта 2020 г.
^ Агесен, Оле (март 1997 г.). «Проектирование и реализация Pep, оперативного переводчика Java» . Теория и практика объектных систем . 3 (2): 127–155. doi : 10.1002/(SICI)1096-9942(1997)3:2<127::AID-TAPO4>3.0.CO;2-S . Архивировано из оригинала 24 ноября 2006 года.
^ Чемберс, Крейг (13 марта 1992 г.). Проектирование и реализация SELF-компилятора, оптимизирующего компилятора для объектно-ориентированных языков программирования (PDF) (докторская диссертация). Стэндфордский Университет .

Дальнейшее чтение [ править ]

Опубликованные статьи о себе
Чемберс, К. (1992), Проектирование и реализация самокомпилятора, оптимизирующего компилятора для объектно-ориентированных языков программирования , Стэнфордский университет , CiteSeerX 10.1.1.30.1652
Серия из четырех статей «Среда и язык программирования Self»

Внешние ссылки [ править ]

[1] Унгар, Дэвид; Смит, Рэндалл Б. (2007). "Себя". Материалы третьей конференции ACM SIGPLAN по истории языков программирования . дои : 10.1145/1238844.1238853 . ISBN 9781595937667 . S2CID 220937663 .

[2] «Автомобиль «Мандарин» 2017.1» . 24 мая 2017 года. Архивировано из оригинала 24 мая 2017 года . Проверено 24 мая 2017 г.

[3] Вольчко, Марио (1996). self включает в себя: Smalltalk . Семинар по языкам-прототипам, ECOOP '96. Линц, Австрия.

[4] «Выпущено Self 4.4» . 16 июля 2010 года. Архивировано из оригинала 5 декабря 2017 года . Проверено 24 мая 2017 г.

[5] «Выпущен Self Mallard (4.5.0)» . 12 января 2014 года. Архивировано из оригинала 6 декабря 2017 года . Проверено 24 мая 2017 г.

[6] Мэлони, Джон Х.; Смит, Рэндалл Б. (1995). «Непосредственность и живость в среде построения морфического пользовательского интерфейса» . Материалы 8-го ежегодного симпозиума ACM по пользовательскому интерфейсу и программным технологиям . стр. 21–28. дои : 10.1145/215585.215636 . ISBN 089791709X . S2CID 14479674 . Проверено 24 марта 2020 г.

[7] Агесен, Оле (март 1997 г.). «Проектирование и реализация Pep, оперативного переводчика Java» . Теория и практика объектных систем . 3 (2): 127–155. doi : 10.1002/(SICI)1096-9942(1997)3:2<127::AID-TAPO4>3.0.CO;2-S . Архивировано из оригинала 24 ноября 2006 года.

[8] Чемберс, Крейг (13 марта 1992 г.). Проектирование и реализация SELF-компилятора, оптимизирующего компилятора для объектно-ориентированных языков программирования (PDF) (докторская диссертация). Стэндфордский Университет .

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]