Болтовня - Smalltalk - Wikipedia

Эта статья о языке программирования. Для использования в других целях см. Светская беседа (значения).
Болтовня
Smalltalk80book.jpg
ПарадигмаОбъектно-ориентированный
РазработаноАлан Кей, Дэн Ингаллс, Адель Голдберг
РазработчикАлан Кей, Дэн Ингаллс, Адель Голдберг, Тед Келер, Диана Мерри Скотт Уоллес, Питер Дойч и Xerox PARC
Впервые появился1972; 48 лет назад (1972) (разработка началась в 1969 г.)
Стабильный выпуск
Smalltalk-80 версия 2/1980; 40 лет назад (1980)
Печатная дисциплинаСильный, динамичный
Операционные системыКроссплатформенность (мультиплатформенность)
Основной реализации
Янтарь, Дельфин Smalltalk, GemStone / S, GNU Smalltalk, Pharo, Smalltalk / X, Писк, В.А. Smalltalk, VisualWorks
Под влиянием
Лисп,[1] Симула,[1] Эйлер,[1] IMP,[1] Планировщик,[1] Логотип,[2] Блокнот,[1] ARPAnet,[1] Берроуз B5000[1]
Под влиянием
AppleScript, Общая объектная система Lisp, Дротик, Дилан, Erlang, Etoys, Идти, Groovy, Ио, Иоке, Ява, Лассо, Logtalk, Новояз, NewtonScript, Объект REXX, Цель-C, PHP 5, Python, Раку, Рубин, Scala, Царапать, Себя

Болтовня является объектно-ориентированный, динамически типизированный отражающий язык программирования. Smalltalk был создан как язык, лежащий в основе «нового мира» вычислений, примером которого является «симбиоз человека и компьютера».[2] Он был разработан и создан частично для образовательный использовать, специально для конструктивистское обучение, в Learning Research Group (LRG) Xerox PARC к Алан Кей, Дэн Ингаллс, Адель Голдберг, Тед Келер, Диана Мерри, Скотт Уоллес и другие в 1970-е годы.

Впервые язык был выпущен как Smalltalk-80. Языки, подобные Smalltalk, активно развиваются и собрали вокруг себя лояльные сообщества пользователей. ANSI Smalltalk был ратифицирован в 1998 году и представляет собой стандартную версию Smalltalk.[3]

Smalltalk занял второе место в рейтинге «Самый любимый язык программирования» Переполнение стека Опрос разработчиков в 2017 г.,[4] но он не входил в число 26 самых любимых языков программирования в опросе 2018 года.[5]

История

Существует большое количество вариантов Smalltalk.[6] Безусловное слово Болтовня часто используется для обозначения языка Smalltalk-80, первой общедоступной версии, созданной в 1980 году. Первыми аппаратными средами, на которых выполнялись виртуальные машины Smalltalk, были Xerox Alto компьютеры.

Smalltalk был продуктом исследований, проведенных Алан Кей в Исследовательский центр Xerox в Пало-Альто (PARC); Алан Кей разработал большинство ранних версий Smalltalk, Адель Голдберг написал большую часть документации и Дэн Ингаллс реализовано большинство ранних версий. Первая версия, получившая название Smalltalk-71, была создана Кей за несколько утра, сделав ставку на то, что язык программирования, основанный на идее передача сообщений вдохновлен Симула может быть реализован на «странице кода».[2] Более поздний вариант, используемый для исследовательской работы, теперь называется Smalltalk-72 и повлиял на разработку Актерская модель. Его синтаксис и модель исполнения сильно отличались от современных вариантов Smalltalk.

После значительных исправлений, которые заморозили некоторые аспекты семантики выполнения для повышения производительности (путем принятия Симула -подобный класс наследование модель исполнения), был создан Smalltalk-76. Эта система имела среда разработки с большинством уже знакомых инструментов, включая браузер / редактор кода библиотеки классов. Добавлен Smalltalk-80 метаклассы, чтобы помочь поддерживать парадигму «все является объектом» (кроме переменных частного экземпляра) путем связывания свойств и поведения с отдельными классами и даже примитивами, такими как целые и логические значения (например, для поддержки различных способов создания экземпляров).

Smalltalk-80 был первым языковым вариантом, доступным за пределами PARC, сначала как Smalltalk-80 Version 1, предоставленным небольшому количеству фирм (Hewlett Packard, Компьютер Apple, Tektronix, и Корпорация цифрового оборудования (DEC)) и университеты (Калифорнийский университет в Беркли ) за экспертная оценка и внедряют на своих платформах. Позже (в 1983 г.) была выпущена общедоступная реализация под названием Smalltalk-80 Version 2 в виде образа (независимый от платформы файл с определениями объектов) и виртуальная машина Технические характеристики. ANSI Smalltalk является стандартным справочником по языку с 1998 года.[7]

Два из популярных в настоящее время вариантов реализации Smalltalk являются потомками исходных образов Smalltalk-80. Писк является Открытый исходный код реализация происходит от Smalltalk-80 версии 1 посредством Apple Smalltalk. VisualWorks является производным от Smalltalk-80 версии 2 посредством Smalltalk-80 2.5 и ObjectWorks (оба продукта ParcPlace Systems, дочерней компании Xerox PARC, созданной для вывода Smalltalk на рынок). В качестве интересного связующего звена между поколениями в 2001 году Василий Быков внедрил Hobbes, виртуальную машину, работающую на Smalltalk-80 внутри VisualWorks.[8] (Дэн Ингаллс позже перенес Гоббса в Squeak.)

В период с конца 1980-х до середины 1990-х годов среды Smalltalk, включая поддержку, обучение и надстройки, продавались двумя конкурирующими организациями: ParcPlace Systems и Digitalk, базирующимися в Калифорнии. ParcPlace Systems имела тенденцию фокусироваться на рынке микросистем Unix / Sun, в то время как Digitalk сосредоточивалась на ПК на базе Intel, работающих под управлением Microsoft Windows или IBM OS / 2. Обе фирмы изо всех сил пытались сделать Smalltalk массовым из-за значительных потребностей Smalltalk в памяти, ограниченной производительности во время выполнения и первоначального отсутствия поддерживаемого подключения к SQL -основан реляционная база данных серверы. В то время как высокая цена ParcPlace Smalltalk ограничивала его проникновение на рынок средними и крупными коммерческими организациями, продукты Digitalk изначально пытались охватить более широкую аудиторию по более низкой цене. Первоначально IBM поддерживала продукт Digitalk, но затем в 1995 году вышла на рынок с продуктом Smalltalk под названием VisualAge / Smalltalk. Easel представила Enfin в это время для Windows и OS / 2. Enfin стал гораздо более популярным в Европе, поскольку IBM представила его в ИТ-магазинах до разработки IBM Smalltalk (позже VisualAge). Позже Энфин был приобретен Cincom Systems, и теперь продается под названием ObjectStudio, и является частью пакета продуктов Cincom Smalltalk.

В 1995 году ParcPlace и Digitalk объединились в ParcPlace-Digitalk, а затем в 1997 году переименовали его в ObjectShare, расположенный в Ирвине, Калифорния. ObjectShare (NASDAQ: OBJS) торговалась публично до 1999 года, когда она была исключена из листинга и ликвидирована. Объединенной фирме так и не удалось найти эффективный ответ на Ява что касается рыночного позиционирования, и к 1997 году ее владельцы хотели продать бизнес. В 1999 году Seagull Software приобрела лабораторию разработки Java ObjectShare (включая первоначальную команду разработчиков Smalltalk / V и Visual Smalltalk) и по-прежнему владеет VisualSmalltalk, хотя права на распространение продукта Smalltalk во всем мире остались у ObjectShare, который затем продал их компании. Cincom.[9] VisualWorks был продан Cincom и теперь является частью Cincom Smalltalk. Cincom решительно поддерживает Smalltalk, выпуская несколько новых версий VisualWorks и ObjectStudio каждый год с 1999 года.

Cincom, GemTalk и Instantiations продолжают продавать среды Smalltalk. Компания IBM закончила свой жизненный цикл VisualAge Smalltalk, поскольку в конце 1990-х годов решила поддержать Java вместо этого, и с 2005 г.при поддержке Instantiations, Inc.[10] которые переименовали продукт в VA Smalltalk (платформа VAST) и продолжают выпускать новые версии ежегодно. Открыто Писк реализация имеет активное сообщество разработчиков, в том числе многие из первоначального сообщества Smalltalk, и недавно была использована для обеспечения среды Etoys на OLPC проект, инструментарий для разработки совместных приложений Крокет Проект, а Открытый кобальт приложение виртуального мира. GNU Smalltalk это бесплатно программное обеспечение реализация производной Smalltalk-80 от GNU проект. Pharo Smalltalk - это ответвление Писк ориентированы на исследования и использование в коммерческой среде.

Существенным событием, которое распространилось на все среды Smalltalk с 2016 года, является растущее использование двух веб-фреймворков, Приморский и AIDA / Интернет, чтобы упростить создание сложных веб-приложений. Seaside вызвала значительный рыночный интерес: Cincom, Gemstone и Instantiations включили и расширили его.

Влияния

Smalltalk был одним из многих объектно-ориентированных языков программирования, основанных на Симула.[11] Smalltalk также является одним из самых влиятельных языков программирования. Практически все объектно-ориентированные языки, появившиеся после -Ароматизаторы,[12] ЗАКРЫТЬ, Цель-C, Ява, Python, Рубин,[13] и многие другие - испытали влияние Smalltalk. Smalltalk также был одним из самых популярных языков с Гибкие методы, Быстрое прототипирование, и Программные шаблоны[14] сообщества. Высокопроизводительная среда, предоставляемая платформами Smalltalk, сделала их идеальными для быстрой итеративной разработки.

Smalltalk возник из более крупной программы ARPA финансировал исследования, которые во многом определили современный мир вычислений. Помимо Smalltalk, рабочие прототипы таких вещей, как гипертекст, Графические интерфейсы, мультимедиа, мышь, телеприсутствие, и Интернет были разработаны исследователями ARPA в 1960-х годах.[15][16] Алан Кей (один из изобретателей Smalltalk) также описал планшетный компьютер, который он назвал Dynabook который напоминает современные планшетные компьютеры, такие как iPad.[17]

Среды Smalltalk часто были первыми, кто разработал то, что сейчас является обычными шаблонами проектирования объектно-ориентированного программного обеспечения. Один из самых популярных - модель – представление – контроллер (MVC) шаблон для пользовательский интерфейс дизайн. Шаблон MVC позволяет разработчикам иметь несколько согласованных представлений одних и тех же базовых данных. Он идеально подходит для сред разработки программного обеспечения, где существуют различные представления (например, отношение сущностей, поток данных, объектная модель и т. Д.) Одной и той же базовой спецификации. Кроме того, для симуляций или игр, в которых базовая модель может рассматриваться под разными углами и уровнями абстракции.[18]

В дополнение к паттерну MVC, язык и среда Smalltalk оказали большое влияние на историю графический интерфейс пользователя (GUI) и что ты видишь, то и получаешь (WYSIWYG ) пользовательский интерфейс, редакторы шрифтов и метафоры рабочего стола для дизайна пользовательского интерфейса. Мощные встроенные инструменты отладки и проверки объектов, которые поставляются со средами Smalltalk, устанавливают стандарт для всех интегрированные среды разработки, начиная с Лисп-машина среды, пришедшие после.[19]

Объектно-ориентированного программирования

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

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

Объект Smalltalk может делать ровно три вещи:

  1. Состояние удержания (ссылки на другие объекты).
  2. Получите сообщение от себя или другого объекта.
  3. В процессе обработки сообщения отправляйте сообщения себе или другому объекту.

Состояние объекта всегда является частным для этого объекта. Другие объекты могут запрашивать или изменять это состояние только путем отправки запросов (сообщений) объекту для этого. Любое сообщение может быть отправлено любому объекту: когда сообщение получено, получатель определяет, подходит ли это сообщение. Алан Кей прокомментировал, что, несмотря на внимание, уделяемое объектам, обмен сообщениями является наиболее важной концепцией в Smalltalk: «Большая идея - это« обмен сообщениями »- вот в чем суть Smalltalk / Squeak (и это то, что никогда не было полностью завершено на этапе Xerox PARC) ".[20]

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

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

Поскольку все ценности являются объектами, классы тоже объекты. Каждый класс является экземпляром метакласс этого класса. Метаклассы, в свою очередь, также являются объектами, и все они являются экземплярами класса, называемого Метаклассом. Блоки кода —Smalltalk способ выражения анонимные функции - тоже объекты.[21]

Отражение

Отражение это термин, который компьютерные ученые применяют к программам, которые могут проверять свою структуру, например дерево синтаксического анализа или же типы данных входных и выходных параметров. Отражение - это функция динамических интерактивных языков, таких как Smalltalk и Lisp. Интерактивные программы с отражением (интерпретируемые или скомпилированные) поддерживают состояние всех объектов в памяти, включая сам объект кода, которые генерируются во время синтаксического анализа / компиляции и доступны программно и могут быть изменены.

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

Smalltalk-80 - это полностью отражающая система, реализованная в Smalltalk-80. Smalltalk-80 обеспечивает как структурное, так и вычислительное отражение. Smalltalk - это структурно отражающая система, структура которой определяется объектами Smalltalk-80. Классы и методы, определяющие систему, также являются объектами и полностью частью системы, которую они определяют. Компилятор Smalltalk компилирует текстовый исходный код в объекты методов, обычно экземпляры CompiledMethod. Они добавляются к классам, сохраняя их в словаре методов класса. Часть иерархии классов, которая определяет классы, может добавлять новые классы в систему. Система расширяется за счет запуска кода Smalltalk-80, который создает или определяет классы и методы. Таким образом, система Smalltalk-80 является «живой» системой, обладающей способностью расширяться во время выполнения.

Поскольку классы являются объектами, им можно задавать такие вопросы, как «какие методы вы реализуете?» или «какие поля / слоты / переменные экземпляра вы определяете?». Таким образом, объекты можно легко проверить, скопировать, (де)сериализованный и так далее с помощью универсального кода, который применяется к любому объекту в системе.[22]

Smalltalk-80 также обеспечивает вычислительное отражение, возможность наблюдать вычислительное состояние системы. В языках, производных от исходного Smalltalk-80, текущая активация метода доступна как объект, названный через псевдопеременную (одно из шести зарезервированных слов), thisContext. Отправляя сообщения на thisContext при активации метода могут быть заданы вопросы типа «кто отправил мне это сообщение». Эти средства позволяют реализовать совместные процедуры или же Пролог -как обратное отслеживание без изменения виртуальной машины. Система исключений реализована с использованием этого средства. Одно из наиболее интересных применений этого метода - Приморский веб-фреймворк, который избавляет программиста от сложности кнопки «Назад» в веб-браузере, сохраняя продолжения для каждой редактируемой страницы и переключаясь между ними, когда пользователь перемещается по веб-сайту. Затем программирование веб-сервера с помощью Seaside может быть выполнено с использованием более обычного стиля программирования.[23]

Примером того, как Smalltalk может использовать отражение, является механизм обработки ошибок. Когда объекту отправляется сообщение, которое он не реализует, виртуальная машина отправляет объекту не понимает: сообщение с овеществление сообщения в качестве аргумента. Сообщение (другой объект, экземпляр Сообщение) содержит селектор сообщения и Множество своих аргументов. В интерактивной системе Smalltalk реализация по умолчанию не понимает: - это окно, открывающее окно ошибки (средство уведомления), сообщающее об ошибке пользователю. Посредством этого и средств отражения пользователь может изучить контекст, в котором произошла ошибка, переопределить код нарушения и продолжить работу внутри системы, используя средства отражения Smalltalk-80.[24][25]

Создав класс, который понимает (реализует) только doesNotUnderstand :, можно создать экземпляр, который может перехватывать любое сообщение, отправленное ему через его метод doesNotUnderstand:. Такие экземпляры называются прозрачными прокси.[26] Такие прокси-серверы могут затем использоваться для реализации ряда средств, таких как распределенный Smalltalk, где сообщениями обмениваются между несколькими системами Smalltalk, интерфейсы баз данных, где объекты прозрачно извлекаются из базы данных, обещания и т.д. Дизайн распределенного Smalltalk повлиял на такие системы, как CORBA.

Синтаксис

Smalltalk-80 синтаксис довольно минималистичен, основан только на нескольких объявлениях и зарезервированных словах. Фактически, в Smalltalk зарезервировано только шесть «ключевых слов»: истинный, ложный, ноль, себя, супер, и thisContext. Их правильно называют псевдопеременные, идентификаторы, которые соответствуют правилам для идентификаторов переменных, но обозначают привязки, которые программист не может изменить. В истинный, ложный, и ноль псевдопеременные одиночка экземпляры. себя и супер относится к получателю сообщения в методе, активированном в ответ на это сообщение, но отправляет супер ищутся в суперклассе класса, определяющего метод, а не в классе получателя, что позволяет методам в подклассах вызывать методы с тем же именем в суперклассах. thisContext относится к текущей записи активации. Единственные встроенные языковые конструкции - это отправка сообщений, присваивание, возврат метода и буквальный синтаксис для некоторых объектов. Изначально как язык для детей всех возрастов, стандартный синтаксис Smalltalk использует знаки препинания больше похожими на английский, чем на основные языки программирования. Остальная часть языка, включая управляющие структуры для условной оценки и итерации, реализована поверх встроенных конструкций стандартной библиотекой классов Smalltalk. (Из соображений производительности реализации могут распознавать и обрабатывать некоторые из этих сообщений как особые; однако это всего лишь оптимизация и не встроена в синтаксис языка.)

Поговорка о том, что «синтаксис Smalltalk подходит для открытка "относится к фрагменту кода Ральф Джонсон, демонстрируя все основные стандартные синтаксические элементы методов:[27]

exampleWithNumber: Икс    | у |    истинный & ложный нет & (ноль isNil) ifFalse: [себя остановка].    у := себя размер + супер размер.    #($ а #a 'а' 1 1.0)        делать: [ :каждый |            Стенограмма Показать: (каждый учебный класс имя);                       Показать: ' '].    ^Икс < у

Литералы

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

Числа. В следующем списке показаны некоторые из возможностей.

42-42123.451.2345e22r1001001016rA000

Последние две записи представляют собой двоичное и шестнадцатеричное число соответственно. Число перед буквой r - это основание или база. База не обязательно должна быть степенью двойки; например 36rSMALLTALK - допустимое число, равное 80738163270632 в десятичной системе.

Символы пишутся со знаком доллара перед ними:

$ A

Строки - это последовательности символов, заключенные в одинарные кавычки:

'Привет, мир!'

Чтобы включить кавычку в строку, используйте вторую кавычку:

Я сказал им: «Привет, мир!».

Двойные кавычки не нуждаются в экранировании, так как одинарные кавычки разделяют строку:

Я сказал: «Привет, мир!» им.'

Две равные строки (строки равны, если они содержат все одинаковые символы) могут быть разными объектами, находящимися в разных местах памяти. В дополнение к строкам в Smalltalk есть класс объектов символьной последовательности, называемый символом. Символы гарантированно уникальны - не может быть двух одинаковых символов, которые являются разными объектами. Из-за этого символы очень дешевы для сравнения и часто используются для языковых артефактов, таких как селекторы сообщений (см. Ниже).

Символы записываются как #, за которым следует строковый литерал. Например:

#'фу'

Если последовательность не содержит пробелов или знаков пунктуации, это также можно записать как:

#foo

Массивы:

#(1 2 3 4)

определяет массив из четырех целых чисел.

Многие реализации поддерживают следующий буквальный синтаксис для ByteArrays:

#[1 2 3 4]

определяет ByteArray из четырех целых чисел.

И, наконец, что не менее важно, блоки (анонимная функция литералы)

[... Немного болтовня код...]

Блоки подробно описаны далее в тексте.

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

Объявления переменных

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

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

| индекс |

объявляет временную переменную с именем index, которая изначально содержит значение ноль.

В одном наборе полосок можно объявить несколько переменных: 

| индексные гласные |

объявляет две переменные: индекс и гласные. Все переменные инициализированы. Переменные инициализируются значением nil, за исключением индексированных переменных Strings, которые инициализируются нулевым символом или ByteArrays, которые инициализируются значением 0.

Назначение

Переменной присваивается значение через ':='синтаксис. Так:

гласные := 'aeiou'

Назначает строку 'aeiou' к ранее объявленной переменной гласных. Строка - это объект (последовательность символов в одинарных кавычках - синтаксис для буквальных строк), созданный компилятором во время компиляции.

На исходном изображении Parc Place глиф символа подчеркивания ⟨_⟩ появился в виде стрелки ⟨←⟩, направленной влево (как в версии 1963 года ASCII код). Smalltalk изначально принял эту стрелку влево как единственный оператор присваивания. Некоторый современный код по-прежнему содержит то, что выглядит как подчеркивание, действующее как присваивание, возвращающееся к этому первоначальному использованию. Большинство современных реализаций Smalltalk принимают синтаксис либо подчеркивания, либо двоеточия.

Сообщения

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

В следующем примере на номер 42 отправляется сообщение «факториал»:

42 факториал

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

aRatherBigNumber := 42 факториал

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

2 поднялTo: 4

В этом выражении задействованы два объекта: 2 как получатель и 4 как аргумент сообщения. Результат сообщения, или, говоря языком Smalltalk, ответ должно быть 16. Такие сообщения называются сообщения с ключевыми словами. Сообщение может иметь больше аргументов, используя следующий синтаксис:

'Привет, мир' индекс: $ o начинается с: 6

который отвечает на индекс символа 'o' в строке получателя, начиная поиск с индекса 6. Селектор этого сообщения - "indexOf: startAt:", состоящий из двух частей, или ключевые слова.

Такое чередование ключевых слов и аргументов предназначено для улучшения читаемости кода, поскольку аргументы объясняются их предшествующими ключевыми словами. Например, выражение для создания прямоугольника с использованием синтаксиса, подобного C ++ или Java, может быть записано как:

новый Прямоугольник(100, 200);

Непонятно, какой аргумент есть какой. Напротив, в Smalltalk этот код будет записан как:

Прямоугольник ширина: 100 высота: 200

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

Наконец, большинство специальных (не алфавитных) символов можно использовать как так называемые двоичные сообщения. Это позволяет записывать математические и логические операторы в их традиционной форме:

3 + 4

который отправляет сообщение «+» получателю 3 с переданным аргументом 4 (ответом будет 7). По аналогии,

3 > 4

это сообщение ">", отправленное на 3 с аргументом 4 (ответ будет ложным).

Обратите внимание, что сам язык Smalltalk-80 не подразумевает значения этих операторов. Результат вышеизложенного определяется только тем, как получатель сообщения (в данном случае экземпляр Number) реагирует на сообщения «+» и «>».

Побочным эффектом этого механизма является перегрузка оператора. Сообщение «>» также может быть понято другими объектами, что позволяет использовать выражения формы «a> b» для их сравнения.

Выражения

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

3 факториал + 4 факториал между: 10 и: 100

оценивается следующим образом:

  1. 3 получает сообщение "факториал" и отвечает 6
  2. 4 получает сообщение "факториал" и отвечает 24
  3. 6 получает сообщение "+" с аргументом 24 и отвечает на 30.
  4. 30 получает сообщение «между: и:» с 10 и 100 в качестве аргументов и отвечает истина

Ответ последнего отправленного сообщения является результатом всего выражения.

При необходимости скобки могут изменить порядок оценки. Например,

(3 факториал + 4) факториал между: 10 и: 100

изменит значение так, что выражение сначала вычисляет «3 факториала + 4», что дает 10. Затем этот 10 получает второе сообщение «факториал», в результате чего получается 3628800. Затем 3628800 получает «между: и:», отвечая ложно.

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

3 + 4 * 5

оценивается как "(3 + 4) * 5", что дает 35. Чтобы получить ожидаемый ответ 23, необходимо использовать круглые скобки для явного определения порядка операций:

3 + (4 * 5)

Унарные сообщения могут быть прикованный записывая их один за другим:

3 факториал факториал бревно

который отправляет «факториал» в 3, затем «факториал» в результат (6), затем «журнал» в результат (720), что дает результат 2,85733.

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

 | окно |  окно := Окно новый.  окно метка: 'Привет'.  окно открыто

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

  Окно новый    метка: 'Привет';    открыто

Это переписывание предыдущего примера в виде одного выражения позволяет избежать необходимости сохранять новое окно во временной переменной. Согласно обычным правилам приоритета, сначала отправляется унарное сообщение «новое», а затем в ответ «новый» отправляются «label:» и «open».

Блоки кода

Блок кода (анонимная функция) может быть выражен как буквальное значение (которое является объектом, поскольку все значения являются объектами). Это достигается с помощью квадратных скобок:

[ :параметры | <сообщение-выражения> ]

Где : params это список параметров, которые может принимать код. Это означает, что код Smalltalk:

[:Икс | Икс + 1]

можно понимать как:

 :

или выражается в лямбда-выражениях как:

 :

и

[:Икс | Икс + 1] ценить: 3

можно оценить как

Или в лямбда-терминах:

Результирующий блочный объект может образовывать закрытие: он может получить доступ к переменным его включающих лексических областей в любое время. Блоки первоклассные объекты.

Блоки могут быть выполнены, отправив им ценить сообщение (существуют составные варианты для предоставления параметров блоку, например, 'value: value:' и 'valueWithArguments:').

Буквальное представление блоков было нововведением, которое, с одной стороны, позволило сделать определенный код значительно более читаемым; это позволяло кодировать алгоритмы, включающие итерацию, ясным и кратким образом. Код, который обычно пишется с циклами на некоторых языках, можно кратко написать на Smalltalk, используя блоки, иногда в одну строку. Но что более важно, блоки позволяют выражать структуру управления с помощью сообщений и полиморфизм, поскольку блоки откладывают вычисление, и полиморфизм может использоваться для выбора альтернатив. Итак, if-then-else в Smalltalk написано и реализовано как

expr если правда: [заявления к оценивать если expr] ifFalse: [заявления к оценивать если нет expr]

Истинные методы оценки

если правда: trueAlternativeBlock ifFalse: falseAlternativeBlock
  ^ trueAlternativeBlock значение

Ложные методы оценки

если правда: trueAlternativeBlock ifFalse: falseAlternativeBlock
 ^ falseAlternativeBlock значение
PositiveAmounts := allAmounts Выбрать: [:количество | количество isPositive]

Обратите внимание, что это связано с функциональное программирование, где шаблоны вычисления (здесь выбор) являются абстрагированный в функции высшего порядка. Например, сообщение Выбрать: в коллекции эквивалентна функции высшего порядка фильтр на соответствующем функтор.[28]

Структуры управления

Структуры управления в Smalltalk не имеют специального синтаксиса. Вместо этого они реализованы как сообщения, отправленные объектам. Например, условное выполнение реализуется путем отправки сообщения ifTrue: логическому объекту с передачей в качестве аргумента блока кода, который должен быть выполнен, тогда и только тогда, когда логический получатель имеет значение true.

Следующий код демонстрирует это:

результат := а > б    если правда:[ 'больше' ]    ifFalse:[ 'меньше или равно' ]

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

| aString гласные |строка := 'Это строка'.гласные := строка Выбрать: [:характер | характер isVowel].

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

Объект String отвечает на сообщение «select:» путем итерации по своим членам (отправляя самому себе сообщение «do:»), однократно оценивая блок выбора («aBlock») с каждым символом, который он содержит в качестве аргумента. При оценке (путем отправки сообщения «значение: каждый») блок выбора (на который ссылается параметр «aBlock» и определяется литералом блока «[: aCharacter | aCharacter isVowel]») отвечает на логическое значение, которое является затем отправил «ifTrue:». Если логическое значение имеет объект true, символ добавляется в строку, которая должна быть возвращена. Поскольку метод «select:» определен в абстрактном классе Collection, его также можно использовать следующим образом:

| прямоугольники aPoint коллизии |прямоугольники := OrderedCollection  с: (Прямоугольник оставили: 0 верно: 10 верх: 100 Нижний: 200)  с: (Прямоугольник оставили: 10 верно: 10 верх: 110 Нижний: 210).точка := Точка Икс: 20 y: 20.столкновения := прямоугольники Выбрать: [:aRect | aRect containsPoint: точка].

Механизм обработки исключений использует блоки в качестве обработчиков (аналогично обработке исключений в стиле CLOS):

[  немного операция] на:Ошибка делать:[:бывший |  обработчик-код  бывший возвращаться]

Аргумент «ex» обработчика исключений обеспечивает доступ к состоянию приостановленной операции (кадр стека, номер строки, получатель, аргументы и т. Д.), А также используется для управления продолжением вычислений (путем отправки одного из «ex continue» "," ex reject "," ex restart "или" ex return ").

Классы

Это определение класса акций:[29]

Объект подкласс: #MessagePublisher    instanceVariableNames: ''    classVariableNames: ''    пулСловари: ''    категория: 'Примеры Smalltalk'

Часто большую часть этого определения заполняет среда. Обратите внимание, что это сообщение для Объект класс для создания подкласса с именем MessagePublisher. Другими словами: классы первоклассные объекты в Smalltalk, который может получать сообщения, как и любой другой объект, и может быть создан динамически во время выполнения.

Методы

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

публиковать    Стенограмма Показать: 'Привет, мир!'

Следующий метод демонстрирует получение нескольких аргументов и возврат значения:

quadMultiply: i1 и: i2    «Этот метод умножает данные числа друг на друга, а результат умножается на 4.»    | мул |    мул := i1 * i2.    ^мул * 4

Имя метода #quadMultiply: и:. Возвращаемое значение указывается с помощью ^ оператор.

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

Создание экземпляров классов

Следующий код:

MessagePublisher новый

создает (и возвращает) новый экземпляр класса MessagePublisher. Обычно это присваивается переменной:

издатель := MessagePublisher новый

Однако также можно отправить сообщение временному анонимному объекту:

MessagePublisher новый публиковать

Пример Hello World

В Привет, мир программа используется практически во всех текстах на новых языках программирования, поскольку первая программа научилась отображать самый основной синтаксис и среду языка. Программа для Smalltalk предельно проста в написании. The following code, the message "show:" is sent to the object "Transcript" with the String literal 'Hello, world!' as its argument. Invocation of the "show:" method causes the characters of its argument (the String literal 'Hello, world!') to be displayed in the transcript ("terminal") window.

Стенограмма Показать: 'Hello, world!'.

Note that a Transcript window would need to be open in order to see the results of this example.

Image-based persistence

Most popular programming systems separate static program code (in the form of class definitions, functions or procedures) from dynamic, or время выполнения, program state (such as objects or other forms of program data). They load program code when a program starts, and any prior program state must be recreated explicitly from configuration files or other data sources. Any settings the program (and programmer) does not explicitly save must be set up again for each restart. A traditional program also loses much useful document information each time a program saves a file, quits, and reloads. This loses details such as undo history or cursor position. Image based systems don't force losing all that just because a computer is turned off, or an OS updates.

Many Smalltalk systems, however, do not differentiate between program data (objects) and code (classes). In fact, classes are objects. Thus, most Smalltalk systems store the entire program state (including both Class and non-Class objects) in an изображение файл. The image can then be loaded by the Smalltalk виртуальная машина to restore a Smalltalk-like system to a prior state.[30] This was inspired by FLEX, a language created by Алан Кей and described in his M.Sc. Тезис.[31]

Smalltalk images are similar to (restartable) core dumps and can provide the same functionality as core dumps, such as delayed or remote debugging with full access to the program state at the time of error. Other languages that model application code as a form of data, such as Лисп, often use image-based persistence as well. This method of persistence is powerful for rapid development because all the development information (e.g. parse trees of the program) is saved which facilitates debugging. However, it also has serious drawbacks as a true persistence mechanism. For one thing, developers may often want to hide implementation details and not make them available in a run time environment. For reasons of legality and maintenance, allowing anyone to modify a program at run time inevitably introduces complexity and potential errors that would not be possible with a compiled system that exposes no source code in the run time environment. Also, while the persistence mechanism is easy to use, it lacks the true persistence abilities needed for most multi-user systems. The most obvious is the ability to do transactions with multiple users accessing the same database in parallel.[32]

Level of access

Everything in Smalltalk-80 is available for modification from within a running program. This means that, for example, the IDE can be changed in a running system without restarting it. In some implementations, the syntax of the language or the вывоз мусора implementation can also be changed on the fly. Even the statement true become: false is valid in Smalltalk, although executing it is not recommended.

Своевременная компиляция

Основная статья: Своевременная компиляция

Smalltalk programs are usually compiled to байт-код, which is then interpreted by a виртуальная машина or dynamically translated into machine-native code.

Список реализаций

OpenSmaltalk

OpenSmaltalk VM (OS VM), is a notable implementation of the Smalltalk Runtime environment on which many modern Smalltalk VMs are based or derived from.[33] OS VM itself is transpiled from a set of Smalltalk source code files (which is called VMMaker) to native C language source code (by using transpiler called Slang)[34][35], which is in turn compiled against specific platform and architecture of the hardware practically enabling cross-platform execution of the Smalltalk images. The source code is available on GitHub and distributed under Лицензия MIT. The known derivatives of the OS VM are:

Другие

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

Рекомендации

  1. ^ а б c d е ж грамм час Kay, Alan; Ram, Stefan (2003-07-23). "E-Mail of 2003-07-23". Dr. Alan Kay on the Meaning of 'Object-Oriented Programming'. Получено 2009-01-03.
  2. ^ а б c Кей, Алан. "The Early History of Smalltalk". Получено 2007-09-13.
  3. ^ "Smalltalk.org™ | versions | ANSIStandardSmalltalk.html". Smalltalk.org. Архивировано из оригинал на 2006-02-16. Получено 2013-06-25.
  4. ^ Stack Overflow Developer Survey 2017
  5. ^ Stack Overflow Developer Survey 2018
  6. ^ "Версии". Smalltalk.org. Архивировано из оригинал на 2015-09-08. Получено 2007-09-13.
  7. ^ "ANSI Smalltalk Standard". Smalltalk.org. Архивировано из оригинал на 2015-09-07. Получено 2007-09-13.
  8. ^ Гоббс
  9. ^ "История". Seagull Software. Архивировано из оригинал на 2002-08-06. Получено 2007-09-13.
  10. ^ VisualAge Smalltalk Transition FAQ
  11. ^ The Simula language was also object-oriented and preceded (and was acknowledged as an influence on) Smalltalk but it was a simulation language, not a general purpose programming language.
  12. ^ Cannon, Howard. "Flavors A non-hierarchical approach to object-oriented programming" (PDF). softwarepreservation.org. Получено 17 декабря 2013.
  13. ^ "About Ruby". ruby-lang.org. Получено 17 декабря 2013.
  14. ^ "Where Did Refactoring Come From?". sourcemaking.com. Получено 17 декабря 2013.
  15. ^ "DARPA / ARPA". livinginternet.com. Получено 16 декабря 2013. To meet this need, ARPA established the IPTO in 1962 with a mandate to build a survivable computer network to interconnect the DoD's main computers at the Pentagon, Cheyenne Mountain, and SAC HQ.
  16. ^ "Engelbart's Role in Early Computer Networking". dougengelbart.org. Получено 17 декабря 2013.
  17. ^ Kay, Allen. "The Early History of Smalltalk". gagne.homedns.org. Получено 16 декабря 2013.
  18. ^ Krasner, Glen; Pope, Stephen (August–September 1988). "A Cookbook for Using the Model-View-Controller User Interface Paradigm in Smalltalk -80". Журнал объектно-ориентированного программирования.
  19. ^ "Our Influence". cincomsmalltalk.com. Получено 16 декабря 2013.
  20. ^ Kay, Alan (October 10, 1998). "Prototypes vs Classes (e-mail on Squeak list)".
  21. ^ Goldberg, Adele; Robson, David (1989). Smalltalk-80 Язык. Эддисон Уэсли. pp. 31, 75–89. ISBN  0-201-13688-0.
  22. ^ Clark, A.N. (1997). "Metaclasses and Reflection in Smalltalk". CiteSeerX  10.1.1.33.5755. Цитировать журнал требует | журнал = (помощь)
  23. ^ Ducasse, Stéphane; Lienhard, Adrian; Renggli, Lukas. "Seaside – A Multiple Control Flow Web Application Framework" (PDF). scg.unibe.ch. Software Composition Group Institut fur Informatik und angewandte Mathematik Universitaat Bern, Switzerland. Получено 16 декабря 2013.
  24. ^ Foote, Brian; Johnson, Ralph (1–6 October 1989). "Reflective Facilities in Smalltalk-80". Oopsla '89: 327–335. Дои:10.1145/74877.74911. ISBN  0897913337. Получено 16 декабря 2013.
  25. ^ Smith, Brian C (1982-01-01). "Procedural Reflection in Programming Languages". MIT Technical Report (MIT-LCS-TR-272). Получено 16 декабря 2013.
  26. ^ Denker, Marcus; Peck, Mariano Martinez; Bouraqadi, Noury; Fabresse, Luc; Ducasse, Stéphane. "Efficient Proxies in Smalltalk" (PDF). Цитировать журнал требует | журнал = (помощь)
  27. ^ [1][2]
  28. ^ Goldberg, Adele; Robson, David (1989). Smalltalk-80 Язык. Эддисон Уэсли. С. 17–37. ISBN  0-201-13688-0.
  29. ^ Goldberg, Adele; Robson, David (1989). Smalltalk-80 Язык. Эддисон Уэсли. С. 39–53. ISBN  0-201-13688-0.
  30. ^ "Image-Based Persistence". book.seaside.st. Получено 17 декабря 2013.
  31. ^ Kay, Allen (1968). "FLEX – A flexible extendable language". University of Utah MSC Thesis.
  32. ^ Fowler, Martin. "Memory Image". martinfowler.com. Получено 17 декабря 2013.
  33. ^ OpenSmalltalk/opensmalltalk-vm, OpenSmalltalk, 2020-11-03, получено 2020-11-08
  34. ^ "Slang". wiki.squeak.org. Получено 2020-11-08.
  35. ^ "A Guide to the S-Lang Language (v2.3.0): Preface". jedsoft.org. Получено 2020-11-08.

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

внешняя ссылка