Болтовня

Эта статья о языке программирования. Чтобы узнать о других значениях, см. Светская беседа (значения) .

Болтовня

Парадигма	Объектно-ориентированный
Разработано	Адель Голдберг , Дэн Ингаллс , Алан Кэй
Разработчик	Питер Дойч , Адель Голдберг, Дэн Ингаллс, Тед Келер , Алан Кей, Дайана Мерри , Скотт Уоллес и Xerox PARC
Впервые появился	1972 год ( 1972 ) (разработка началась в 1969 г.)
Стабильная версия	Смоллток-80 версия 2 / 1980 ( 1980 )
Дисциплина набора текста	объекты , но в некоторых реализациях сильные или динамические
Объем	Лексический (статический)
Язык реализации	Болтовня
Платформа	Ксерокс Альт ( 74181 )
ТЫ	Кроссплатформенность (мультиплатформенность)
Основные реализации
Amber , Dolphin Smalltalk , GemStone/S , GNU Smalltalk , Pharo , Smalltalk/X, Squeak , Cuis Smalltalk , Haver, VA Smalltalk , VisualWorks
Под влиянием
Лисп , Начало , Эйлер , ИМП , Планировщик , Логотип , Альбом для рисования , АРПАнет , Берроуз B5000
Под влиянием
AppleScript , Common Lisp Object System , Dart , Dylan , Erlang , Etoys , Go , Groovy , Io , Ioke , Java , Lasso , Logtalk , Newspeak , NewtonScript , Object REXX , Objective-C , PHP 5, Python , Raku , Ruby , Scala , Царапина , На себя , Свифт
Smalltalk в Wikibooks

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

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

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

С момента своего создания язык обеспечивал интерактивное программирование через интегрированную среду разработки . Это требует отражения и позднего связывания при языковом исполнении кода . Дальнейшее развитие привело по крайней мере к одному экземпляру среды выполнения Smalltalk, в котором отсутствует такой интегрированный графический интерфейс пользователя или интерфейсная часть.

Языки, подобные Smalltalk, находятся в активной разработке и собрали вокруг себя сообщества пользователей. Американский национальный институт стандартов (ANSI) Smalltalk был ратифицирован в 1998 году и представляет собой стандартную версию Smalltalk.

Smalltalk занял второе место в категории «Самый любимый язык программирования» в опросе разработчиков Stack Overflow в 2017 году. но он не вошел в число 26 самых любимых языков программирования по результатам опроса 2018 года.

История

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

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

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

Smalltalk-80 был первым языковым вариантом, доступным за пределами PARC. В 1981 году он был передан Tektronix , Hewlett-Packard , Apple Computer и DEC для проверки и отладки на их платформах. Августовский номер журнала Byte Magazine за 1981 год был посвящен Smalltalk-80 и донес его идеи до широкой аудитории. Также было опубликовано несколько книг по Smalltalk-80. Smalltalk-80 стал основой для всех будущих коммерческих версий Smalltalk. Последний выпуск Smalltalk-80 версии 1 состоялся в ноябре 1981 года. Xerox распространяла версию 1 только среди Apple, DEC, HP и Tektronix, но этим компаниям было разрешено неограниченное распространение через любую созданную ими систему. Это способствовало широкому распространению Smalltalk. Позже, в 1983 году, Xerox выпустила Smalltalk-80 версии 2. Эта версия была общедоступной, хотя и под ограниченной лицензией. Версии 1 и 2 были очень похожи, хотя версия 2 имела некоторые дополнительные функции, такие как корректор орфографии. Каждый выпуск состоял из виртуального образа (независимого от платформы файла с определениями объектов) и спецификации виртуальной машины .

ANSI Smalltalk является стандартным справочником по языку с 1998 года. Два популярных в настоящее время варианта реализации Smalltalk являются потомками исходных образов Smalltalk-80. Squeak — это реализация с открытым исходным кодом , созданная на основе Smalltalk-80 версии 1 посредством Apple Smalltalk. VisualWorks является производным от Smalltalk-80 версии 2 посредством Smalltalk-80 2.5 и ObjectWorks (оба продукта ParcPlace Systems, дочерней компании Xerox PARC, созданной для вывода Smalltalk на рынок). В качестве интересного связующего звена между поколениями в 2001 году Василий Быков внедрил Hobbes, виртуальную машину под управлением Smalltalk-80 внутри VisualWorks. ( Дэн Ингаллс позже портировал Хоббса на 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). Позднее компания Enfin была приобретена Cincom Systems , теперь продается под названием ObjectStudio и является частью пакета продуктов Cincom Smalltalk.

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

Cincom , GemTalk и Instantiations продолжают продавать среды Smalltalk. IBM прекратила использование VisualAge Smalltalk, решив в конце 1990-х вместо этого поддержать Java, и с 2005 г. , поддерживается Instantiations, Inc. Компания Instantiations переименовала продукт в VA Smalltalk (VAST Platform) и продолжает выпускать новые версии ежегодно. Открытая реализация Squeak имеет активное сообщество разработчиков, включая многих из исходного сообщества Smalltalk, и использовалась для предоставления среды Etoys в проекте One Laptop per Child (OLPC), набора инструментов для разработки приложений для совместной работы Croquet Project и Open Cobalt Приложение виртуального мира . GNU Smalltalk — это бесплатная программная реализация производной Smalltalk-80 из проекта GNU . Pharo Smalltalk — это ответвление Squeak, ориентированное на исследования и использование в коммерческих средах.

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

Влияния

Smalltalk был одним из многих объектно-ориентированных языков программирования, основанных на Simula . Smalltalk также является одним из самых влиятельных языков программирования. Практически все объектно-ориентированные языки, появившиеся после него — Flavors , CLOS , Objective-C , Java , Python , Ruby , и многие другие — находились под влиянием Smalltalk. Smalltalk также был одним из самых популярных языков для гибких методов разработки программного обеспечения, быстрой разработки приложений (RAD) или прототипирования, а также шаблонов проектирования программного обеспечения . Высокопроизводительная среда, обеспечиваемая платформами Smalltalk, сделала их идеальными для быстрой итеративной разработки.

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

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

Помимо шаблона MVC, язык и среда Smalltalk оказали влияние на историю графического пользовательского интерфейса (GUI), а также пользовательского интерфейса «что видишь, то и получаешь» ( WYSIWYG ), редакторов шрифтов и метафор рабочего стола для дизайна пользовательского интерфейса. Мощные встроенные инструменты отладки и проверки объектов, поставляемые со средами Smalltalk, установили стандарт для всех интегрированных сред разработки , начиная с сред Lisp Machine , которые появились позже.

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

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

Smalltalk-80: The Language and his Implementation , также известная как «Синяя книга», оригинальная книга по языку.

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

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

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

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

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

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

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

Отражение

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

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

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

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

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

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

Создав класс, который понимает (реализует) только метод doNotUnderstand:, можно создать экземпляр, который сможет перехватывать любое сообщение, отправленное ему через метод doNotUnderstand:. Такие экземпляры называются прозрачными прокси. Такие прокси затем можно использовать для реализации ряда средств, таких как распределенный Smalltalk, где сообщения обмениваются между несколькими системами Smalltalk, интерфейсы базы данных, где объекты прозрачно выводятся из базы данных, обещания и т. д. Конструкция распределенного Smalltalk повлияла на такие системы, как КОРБА .

Синтаксис

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

Поговорка о том, что «синтаксис Smalltalk умещается на открытке », возможно, возникла из оригинальной концепции языка Алана Кея, изложенной им практически в каждой из десятков или сотен публичных лекций, op. cit., или, возможно, это могло бы относиться к фрагменту кода Ральфа Джонсона , демонстрирующему все основные стандартные синтаксические элементы методов:

примерСномером:   х 
     |   й  | 
      true   и   false   not   &  (  nil   isNil  )  ifFalse  [  самоостановка   ]  .  : 
      y   :   собственный   размер   +   суперразмер   .  = 
      #(  $a   #a   'a'   1   1.0  ) 
         do:  [  :  каждый   | 
              Расшифровка   шоу:  (  каждого   класса   имя  )  ; 
                         показывать:   ' '  ]  . 
      ^  х   <   у 

Литералы

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

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

42 
 -  42 
 123  .   45 
 1  .   2345е2 
 2р10010010 
 16  рА000 

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

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

$А 

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

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

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

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

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

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

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

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

#  'фу' 

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

#фу 

Массивы:

#( 1  2  3  4 ) 

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

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

# [ 1  2  3  4 ]
 

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

И последнее, но не менее важное: блоки ( анонимные функциональные литералы).

[...  Некоторый   небольшой   код  .   ..] 
 

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

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

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

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

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

|   индекс  | 

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

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

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

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

Назначение

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

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

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

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

Сообщения

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

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

42   факториал 

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

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

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

2   поднятДо:   4 

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

'привет, мир'   indexOf:   $o   начиная с:   6 

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

Такое чередование ключевых слов и аргументов предназначено для улучшения читаемости кода, поскольку аргументы объясняются предшествующими им ключевыми словами. Например, выражение для создания прямоугольника с использованием синтаксиса, подобного 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, сохраняется его в переменной, а затем отправляются ему два сообщения.

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

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

   метка окна  Новая 
     :   «Привет»  ; 
      открыть 

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

Блоки кода

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

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

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

[  :  х   |    х   +   1  ] 
 

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

$f(x)=x+1$

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

$\lambda x.x+1$

и

[  :  х   |    x   +   1  ]  значение:   3 

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

$f(3)=3+1$

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

$(\lambda x.x+1)\,3{\underset {\beta }{\rightarrow }}3+1$

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

Блоки можно выполнить, отправив им сообщение о значении . Существуют составные варианты для предоставления параметров блоку, например: value:value: и valueWithArguments:.

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

expr   ifTrue:  [  инструкции   для   оценки   if   expr  ]  ifFalse:  [  инструкции   для   оценки   if   not   expr  ]
 

Настоящие методы оценки

ifTrue:  trueAlternativeBlock  ifFalse:  falseAlternativeBlock 

     Значение ^trueAlternativeBlock 

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

ifTrue:  trueAlternativeBlock  ifFalse:  falseAlternativeBlock 

    Значение ^falseAlternativeBlock 

позитивные суммы   :=   allAmounts   выберите:  [  :  anAmount   |    anAmount   isPositive  ] 
 

Это связано с функциональным программированием , в котором шаблоны вычислений (в данном случае выбор) абстрагируются в функции более высокого порядка . Например, сообщение select: on a Collection эквивалентно фильтру функции высшего порядка для соответствующего функтора .

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

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

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

результат   :=   a   >   b 
     ifTrue:  [  'больше'  ] 
      ifFalse:  [  'меньше или равно'  ] 
 

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

|   aString гласные  | 
  aString   :=   'Это строка'  . 
  гласные   :=   aString   select:  [  :  aCharacter   |    aCharacter   isVowel  ]  . 

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

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

|   прямоугольники aPoint столкновения  | 
  прямоугольники   : =   OrderedCollection 
   с:  (  Прямоугольник   слева:   0   справа:   10   сверху:   100   снизу:   200  ) 
    с:  (  Прямоугольник   слева:   10   справа:   10   сверху:   110   снизу:   210  )  . 
  aPoint   :=   Точка   x:   20   y:   20  . 
  коллизии   :=   прямоугольники   select:  [  :  aRect   |    aRect   содержитPoint:   aPoint  ]  . 

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

[ 
    какая-то   операция 
  ]  on:  Ошибка   do:  [  :  ex   | 
    обработчик  —  код 
   возврата  ​ 
  ] 
 

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

Классы

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

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

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

Методы

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

опубликовать 
     стенограмму   шоу:   «Hello World!» 

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

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

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

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

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

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

СообщениеPublisher   новое 

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

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

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

 MessagePublisher  Новая   публикация 

Пример Hello World

Программа Hello world используется практически во всех текстах новых языков программирования, поскольку это первая программа, которая научилась отображать самый базовый синтаксис и среду языка. Для Smalltalk программу написать чрезвычайно просто. В следующем коде сообщение «show:» отправляется объекту «Transcript» со строковым литералом «Hello, world!». в качестве его аргумента. Вызов метода «show:» приводит к отображению символов его аргумента (строкового литерала «Hello, world!») в окне расшифровки («терминала»).

Стенограмма   шоу:   «Привет, мир!»   . 

Чтобы увидеть результаты этого примера, необходимо открыть окно «Транскрипт».

Сохранение на основе изображений

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

Однако многие системы Smalltalk не делают различия между данными программы (объектами) и кодом (классами). Фактически классы — это объекты. Таким образом, большинство систем Smalltalk хранят все состояние программы (включая объекты класса и некласса) в файле изображения . Затем образ может быть загружен виртуальной машиной Smalltalk , чтобы восстановить систему, подобную Smalltalk, до предыдущего состояния. Это было вдохновлено FLEX, языком, созданным Аланом Кеем и описанным в его магистерской работе. Тезис.

Образы Smalltalk подобны (перезапускаемым) дампам ядра и могут обеспечивать ту же функциональность, что и дампы ядра, например отложенную или удаленную отладку с полным доступом к состоянию программы на момент ошибки.

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

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

Уровень доступа

Все в Smalltalk-80, если оно не настроено во избежание такой возможности, доступно для изменения из работающей программы. Это означает, что, например, IDE можно изменить в работающей системе, не перезапуская ее. В некоторых реализациях синтаксис языка или реализация сборки мусора также могут быть изменены на лету. Даже заявление true become: false допустим в Smalltalk, хотя его выполнение не рекомендуется, за исключением демонстрационных целей (см. виртуальные машины , сохранение на основе образов и резервные копии ).

Сборка точно в срок

Основная статья: Сборка точно в срок

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

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

OpenSmalltalk

OpenSmalltalk VM (OS VM) — это реализация виртуальной машины Smalltalk, на которой основаны или получены многие современные реализации Smalltalk. Сама виртуальная машина ОС транслируется из набора файлов исходного кода Smalltalk (с использованием подмножества Smalltalk с именем Slang) в исходный код на родном языке C (с использованием транспилятора с именем VMMaker), который, в свою очередь, компилируется для конкретной платформы и архитектуры аппаратного обеспечения, что практически обеспечивает кросс-платформенное выполнение изображений Smalltalk. Исходный код доступен на GitHub и распространяется по лицензии MIT . Известные реализации Smalltalk на базе виртуальной машины ОС:

• Squeak — оригинальный Smalltalk с открытым исходным кодом, для которого была создана виртуальная машина OpenSmalltalk.
• Pharo Smalltalk — кроссплатформенный язык с открытым исходным кодом.
• Cuis-Smalltalk — небольшая, чистая и совместимая со Smalltalk-80 версия Squeak с открытым исходным кодом.
• Haver-Smalltalk — расширение Cuis с полной системой модулей.
• Croquet VM — виртуальная машина Smalltalk, связанная с Squeak, для проекта Croquet.

Другие

• Amber Smalltalk , работает на JavaScript посредством транспиляции.
• Дельфин Smalltalk из Object Arts
• Etoys — система визуального программирования для обучения.
• F-Script, реализация только для macOS, написанная в 2009 году.
• GemStone/S от GemTalk Systems
• GNU Smalltalk , безголовая (без графического интерфейса) реализация Smalltalk
• Маленький разговор
• Smalltalk MT Smalltalk для Windows от Object Connect
• ObjectStudio от Cincom
• Pocket Smalltalk, работает на Palm Pilot
• Rosetta Smalltalk, разработанный Скоттом Уорреном в 1979 году и анонсированный как картридж для компьютера Exidy Sorcerer, но так и не выпущенный.
• Создайте систему визуального программирования (только версии до 2.0 основаны на Smalltalk)
• SmallJ , Smalltalk с открытым исходным кодом, основанный на Java, полученный из SmallWorld.
• SmallJS — компилятор Smalltalk в JavaScript, позволяющий разрабатывать Smalltalk в современных браузерах и в Node.js.
• Smalltalk/X , разработанный Клаусом Гиттингером.
• StepTalk , среда сценариев GNUstep использует язык Smalltalk в Objective-C. среде выполнения
• Strongtalk , версия с открытым исходным кодом (с 2006 года) только для Windows, предлагает дополнительную строгую типизацию ; Первоначально созданный в Sun Microsystem Labs .
• TruffleSqueak , виртуальная машина Squeak/Smalltalk и среда программирования Polyglot для GraalVM (больше реализаций Smalltalk на базе GraalVM можно найти здесь )
• Платформа VAST (VA Smalltalk), разработанная Instantiations, Inc.
• VisualAge Smalltalk от IBM
• Visual Smalltalk Enterprise и его семейство, включая Smalltalk/V
• VisualWorks от Cincom
• Zag , виртуальная машина Smalltalk, написанная на Zig, с аннотациями типов с методами, хранящимися в виде абстрактных синтаксических деревьев (AST).

JavaScript виртуальная машина

• PharoJS - с открытым исходным кодом транспилятор из Smalltalk в JavaScript, расширяющий Pharo. среду
• SqueakJS — совместимая с OpenSmalltalk виртуальная машина для Интернета, также запускает старые приложения Squeak, такие как Etoys или Scratch.

См. также

• Цель-C
• СТЕКЛО (комплект программного обеспечения)
• Распределенная архитектура управления данными

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

• Гольдберг, Адель (декабрь 1983 г.). Smalltalk-80: Интерактивная среда программирования . Аддисон-Уэсли. ISBN  0-201-11372-4 .
• Гольдберг, Адель ; Кей, Алан , ред. (март 1976 г.). Инструкция по эксплуатации Smalltalk-72 (PDF) . Пало-Альто, Калифорния: Xerox Исследовательский центр Пало-Альто . Проверено 11 ноября 2011 г.
• Гольдберг, Адель ; Робсон, Дэвид (май 1983 г.). Smalltalk-80: Язык и его реализация . Аддисон-Уэсли. ISBN  0-201-11371-6 .
• Гольдберг, Адель ; Робсон, Дэвид (11 января 1989 г.). Smalltalk 80: Язык . Аддисон-Уэсли. ISBN  0-201-13688-0 .
• Кей, Алан К. (март 1993 г.). «Ранняя история Smalltalk» (PDF) . Уведомления ACM SIGPLAN . 28 (3). АКМ : 69–95. дои : 10.1145/155360.155364 . Архивировано из оригинала (PDF) 3 мая 2023 года.
• Краснер, Глен, изд. (август 1983 г.). Smalltalk-80: Немного истории, советы . Аддисон-Уэсли. ISBN  0-201-11669-3 .
• Ньерстраз, Оскар; Дюкасс, Стефан; Поллет, Дэмиен; Блэк, Эндрю П. (07 октября 2009 г.). Писк на примере . Керзац, Швейцария: Square Bracket Associates. ISBN  978-3-9523341-0-2 .
• Ньерстраз, Оскар; Дюкасс, Стивен; Поллет, Дэмиен; Блэк, Эндрю П. (23 февраля 2010 г.). Фараон своим примером Керзац, Швейцария: Издательство Square Bracket Publishing. ISBN  978-3-9523341-4-0 . Архивировано из оригинала 21 октября 2009 года.
• Уинстон, Патрик Генри (3 сентября 1997 г.). Переходим к Smalltalk . Массачусетский технологический институт, США: Эддисон Уэсли. ISBN  978-0-201-49827-1 .
• Брауэр, Йоханнес (2015). Программирование на Smalltalk — объектная ориентация с самого начала . Спрингер. ISBN  978-3-658-06823-3 .
• «Специальный выпуск по Smalltalk» . Байт . 6 (8). МакГроу-Хилл. Август 1981 года . Проверено 18 октября 2013 г.
  • Гольдберг, Адель (август 1981 г.). «Представляем систему Smalltalk-80» . Байт . 6 (8). МакГроу-Хилл . Проверено 18 октября 2013 г.
  • Ингаллс, Дэн (август 1981 г.). «Принципы проектирования, лежащие в основе Smalltalk» . Байт . 6 (8). МакГроу-Хилл . Проверено 11 ноября 2011 г.
  • Теслер, Ларри (август 1981 г.). «Среда Smalltalk» . Байт . 6 (8). МакГроу-Хилл . Проверено 2 мая 2016 г.

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

• Бесплатные онлайн-книги по Smalltalk
• Кук Смолток
• Фаро Смолток
• Писк
• Cincom Smalltalk ObjectStudio
• Cincom Smalltalk VisualWorks
• Дельфин Smalltalk
• GNU Смоллток
• Смолток/X
• StrongTalk
• Эмбер Смолток
• Красная линия Smalltalk
• Скарлет Smalltalk
• В. А. Смоллток
• драгоценный камень
• GLASS (GemStone, Linux, Apache, Seaside и Smalltalk)
• Смоллток МТ
• Онлайн-эмулятор Smalltalk-78
• Кроссплатформенная виртуальная машина OpenSmalltalk для Squeak, Pharo, Cuis и Newspeak
• Реализации Smalltalk-80 Bluebook на C++: авторы dbanay и rochus-keller на GitHub