Смолток

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

Смолток

Парадигма	Объектно-ориентированный
Разработано	Адель Голдберг , Дэн Ингаллс , Алан Кэй
Разработчик	Питер Дойч , Адель Голдберг, Дэн Ингаллс, Тед Келер , Алан Кей, Дайана Мерри , Скотт Уоллес и 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. В ходе обработки сообщения отправляйте сообщения самому себе или другому объекту.

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

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

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

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

Отражение

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

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

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

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

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

Примером того, как 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., или, возможно, это могло бы относиться к фрагменту кода Ральфа Джонсона , демонстрирующему все основные стандартные синтаксические элементы методов:

exampleWithNumber: x
    | y |
    true & false not & (nil isNil) ifFalse: [self halt].
    y := self size + super size.
    #($a #a 'a' 1 1.0)
        do: [ :each |
            Transcript show: (each class name);
                       show: ' '].
    ^x < y

Литералы

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

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

42
-42
123.45
1.2345e2
2r10010010
16rA000

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

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

$A

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

'Hello, world!'

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

'I said, ''Hello, world!'' to them.'

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

'I said, "Hello, world!" to them.'

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

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

#'foo'

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

#foo

Массивы:

#(1 2 3 4)

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

#((1 2 3 4) [1 2 3 4] 'four' 4.0 #four)

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

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

#[1 2 3 4]

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

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

[... Some smalltalk code...]

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

[:a :b| a < b]

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

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

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

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

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

| index |

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

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

| index vowels |

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

Назначение

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

vowels := 'aeiou'

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

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

Сообщения

Сообщение — это самая фундаментальная языковая конструкция в Smalltalk. Даже структуры управления реализуются при отправке сообщений . Smalltalk по умолчанию принимает стратегию динамической отправки и одиночной отправки (в отличие от множественной отправки , используемой в некоторых других объектно-ориентированных языках). Существует три типа отправки сообщений: унарные сообщения, имеющие одно ключевое слово, например: class и size, двоичные сообщения, которые, например, используются для арифметических операций, таких как a < b, a ~= bи сообщения с ключевыми словами, в которых ключевое слово, за которым следует двоеточие, предшествует каждому аргументу в сообщении, так что a between: b and: c отправляет #between:and: сообщение для a с аргументами b и c. Унарные сообщения имеют более высокий приоритет, чем двоичные сообщения, которые имеют более высокий приоритет, чем сообщения с ключевыми словами, и оценка производится строго слева направо. Арифметического приоритета нет. 1 + 2 * 3 оценивается в 9, а не в 7.

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

42 factorial

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

aRatherBigNumber := 42 factorial

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

2 raisedTo: 4

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

'hello world' indexOf: $o startingAt: 6

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

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

new Rectangle(100, 200);

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

Rectangle width: 100 height: 200

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

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

3 + 4

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

3 > 4

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

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

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

Выражения

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

3 factorial + 4 factorial between: 10 and: 100

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

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

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

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

(3 factorial + 4) factorial between: 10 and: 100

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

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

3 + 4 * 5

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

3 + (4 * 5)

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

3 factorial factorial log

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

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

 | window |
  window := Window new.
  window label: 'Hello'.
  window open

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

  Window new
    label: 'Hello';
    open

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

Блоки кода

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

[ :params | <message-expressions> ]

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

[:x | x + 1]

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

$f(x)=x+1$

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

$\lambda x.x+1$

и

[:x | x + 1] value: 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: [statements to evaluate if expr] ifFalse: [statements to evaluate if not expr]

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

ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock

     ^trueAlternativeBlock value

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

ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock

    ^falseAlternativeBlock value

positiveAmounts := allAmounts select: [:anAmount | anAmount isPositive]

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

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

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

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

result := a > b
    ifTrue:[ 'greater' ]
    ifFalse:[ 'less or equal' ]

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

| aString vowels |
aString := 'This is a string'.
vowels := aString select: [:aCharacter | aCharacter isVowel].

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

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

| rectangles aPoint collisions |
rectangles := OrderedCollection
  with: (Rectangle left: 0 right: 10 top: 100 bottom: 200)
  with: (Rectangle left: 10 right: 10 top: 110 bottom: 210).
aPoint := Point x: 20 y: 20.
collisions := rectangles select: [:aRect | aRect containsPoint: aPoint].

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

[
  some operation
] on:Error do:[:ex |
  handler-code
  ex return
]

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

Классы

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

Object subclass: #MessagePublisher
    instanceVariableNames: ''
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Smalltalk Examples'

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

Методы

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

publish
    Transcript show: 'Hello World!'

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

quadMultiply: i1 and: i2
    "This method multiplies the given numbers by each other and the result by 4."
    | mul |
    mul := i1 * i2.
    ^mul * 4

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

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

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

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

MessagePublisher new

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

publisher := MessagePublisher new

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

MessagePublisher new publish

Интегрированная среда разработки

Smalltalk — одна из первых систем, основанных на интегрированной среде разработки . Существует множество инструментов для поддержки разработки кода и других действий, таких как графика и музыка. Smalltalk был первой системой, в которой современная парадигма рабочего стола Windows, значков, меню и указателей ( WIMP была создана ). Хотя указатели уже были изобретены, Smalltalk был первой системой, реализовавшей перекрывающиеся окна и всплывающие меню. Хотя существует несколько инструментов программирования, мы опишем следующие пять основных инструментов. Изображения инструментов взяты из системы Squeak 2024 года.

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

Браузер

Системы, производные от Smalltalk-80, организуют классы внутри «системных категорий», таких как Kernel-Numbers, Kernel-Objects, Collections-Abstract, Collections-Sequenceableи т. д., а внутри классов методы организованы в именованные категории, такие как accessing, arithmetic, instance creationи т. д. Отсюда следует классический пятипанельный браузер с четырьмя панелями в верхней половине окна, содержащими сверху вниз список системных категорий, который при выборе одной из них отображает во втором окне список классов в этой категории. , что при выборе одной из них отображается список категорий сообщений в выбранном классе, что при выборе одной из них отображаются на последней панели селекторы методов в выбранной категории в выбранном классе. Когда выбран один из селекторов на четвертой панели, источник для этого метода отображается на пятой панели. Если выбрана только категория, а не метод, на пятой панели отображается шаблон для определения нового метода. Если выбрана системная категория, но нет класса, отображается шаблон для создания класса в категории. Различные всплывающие меню позволяют запрашивать инструмент, например искать класс по имени, находить всех отправителей выбранного сообщения или всех разработчиков сообщения и т. д. Таким образом, браузер является одновременно инструментом чтения кода и исследования системы, а также инструментом разработки кода.

Рабочая область

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

Стенограмма

Расшифровка — это специальная рабочая область, связанная с глобальной транскриптом. Итак, оценивая Transcript print: 52 factorial; cr; flush вызывает 80658175170943878571660636856403766975289505440883277824000000000000, за которым следует новая строка, чтобы появиться в окне стенограммы. Таким образом, стенограмма служит местом для отправки сообщений журнала, хотя она также может функционировать как рабочая область.

Инспектор

Существуют различные инспекторы, некоторые из которых предназначены для отображения различных типов объектов. Самый простой инспектор имеет две панели. Слева находится список самого объекта (с меткой «self»), за которым следуют переменные экземпляра в объекте, который будет включать пронумерованные переменные экземпляра v в таких последовательностях, как строки и массивы. Справа находится панель рабочей области. При выборе имени в списке содержимое рабочей области заменяется строкой печати выбранной переменной. Редактирование и «принятие» текста на панели рабочей области при выборе переменной экземпляра присвоит результат оценки выбранной переменной. Можно «углубиться», используя команду «проверить» в меню списка, которая будет применяться к выбранной переменной экземпляра. Более сложные инспекторы поддерживают каскадирование, так что структуру объекта можно просматривать, не открывая дополнительных окон.

Уведомление/Отладка

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

Отправка сообщения self halt вызывает исключение, которое открывает уведомитель, предоставляя простую возможность точки останова (обычно средства точки останова обеспечивают нечто большее, чем просто остановку, но это была первая такая возможность). Рабочие области также предоставляют оценщик «отладки», который открывает отладчик для выбранного выражения, расположенного в первом сообщении, отправленном в выражении. Итак, выбрав 52 factorial и выбор «отладить» во всплывающем меню открывает отладчик с выбранным «контекстом doit» и factorial селектор выделен. В отладчике предусмотрены кнопки для выполнения действий «шаг», «переход» и т. д. Следовательно, выбрав «шаг в», можно изучить оценку 52 factorial. Таким образом, отладчик предоставляет инспектор процесса, позволяющий исследовать остановленные вычисления.

Если исключение возникает в результате отправки doNotUnderstand: или subclassResponsibility, то уведомитель будет включать кнопку «Создать», позволяющую программисту выбрать, где в иерархии получателя определить «начальный проект» метода, который будет реализован. Переопределение метода в отладчике приводит к тому, что выбранный контекст возвращается к первому оператору (аргументы не подлежат изменению в Smalltalk, поэтому состояние выполнения возвращается к началу метода). Таким образом, отладчик поддерживает живое программирование, определяя методы по мере выполнения вычислений. Это чрезвычайно продуктивный и приятный способ программирования. Все в системе у вас под рукой. У вас есть все возможности рабочих пространств для оценки подвыражений и браузера для поиска вспомогательного кода в одной программе.

Привет, мир, пример

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

Transcript show: 'Hello, world!'.

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

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

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

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

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

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

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

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

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

Компиляция точно в срок

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

Программы Smalltalk обычно компилируется в байт-код , который затем интерпретируется виртуальной машиной или динамически транслируется в собственный машинный код. Результаты предыдущих поисков сообщений кэшируются в самомодифицирующемся машинном коде, что приводит к очень высокой производительности отправки, которая может превосходить по производительности косвенные вызовы функций в вызовах виртуальных методов C++.

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

OpenSmalltalk

OpenSmalltalk VM (OS VM) — это относительно высокопроизводительная реализация виртуальной машины Smalltalk, на которой основано несколько современных диалектов Smalltalk с открытым исходным кодом. Виртуальная машина ОС основана на оригинальной версии «Назад в будущее». (BTTF) Интерпретатор Squeak, реализованный Дэном Ингаллсом, Тедом Халером, Джоном Мэлони и многими другими участниками. Как и в случае с виртуальной машиной BTTF, виртуальная машина ОС переносится из системы Smalltalk, в которой она разработана (с использованием подмножества Smalltalk под названием Slang) C. , в исходный код на родном языке который, в свою очередь, компилируется для конкретной платформы и архитектуры аппаратного обеспечения, что практически обеспечивает кросс-платформенное выполнение изображений Smalltalk. Виртуальная машина ОС отличается от виртуальной машины BTTF тем, что

• введение JIT-компилятора в собственный машинный код, включая сложные методы кэширования методов машинного кода.
• использование «сопоставления контекста со стеком», чтобы значительно сократить накладные расходы объектов контекста
• поддержка как исходного представления объектов BTTF, так и Spur, гораздо более эффективной и встроенной 32-битной и 64-битной схемы со значительно улучшенным сборщиком мусора, закреплением объектов и отложенным преобразованием.

Известные диалекты Smalltalk, основанные на виртуальной машине ОС:

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

Другие

• Amber Smalltalk , работает на JavaScript посредством транспиляции.
• Дельфин Smalltalk из Object Arts
• Etoys — система визуального программирования для обучения, встроенная в Squeak.
• GemStone/S от GemTalk Systems
• GNU Smalltalk , безголовая (без графического интерфейса) реализация Smalltalk
• Smalltalk MT Smalltalk для Windows от Object Connect
• ObjectStudio от Cincom
• Создайте систему визуального программирования (только версии до 2.0 основаны на Smalltalk)
• StepTalk , среда сценариев GNUstep использует язык Smalltalk в Objective-C. среде выполнения
• Strongtalk , версия с открытым исходным кодом (с 2006 года) только для Windows, предлагает дополнительную строгую типизацию ; Первоначально созданный в Sun Microsystem Labs .
• VisualAge Smalltalk от IBM
• Visual Smalltalk Enterprise и его семейство, включая Smalltalk/V
• VisualWorks от Cincom , потомок оригинального Xerox PARC Smalltalk-80 v2

См. также

• Дарт
• Цель-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
• Cuis 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