Smalltalk

Объектно-ориентированный язык программирования, впервые выпущенный в 1972 году.

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

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

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

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

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

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

История

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

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

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

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

ANSI Smalltalk является стандартным языковым справочником с 1998 года. ^[14] Два популярных в настоящее время варианта реализации 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. ^[15] ( Дэн Ингаллс позже портировал Hobbes на Squeak.)

В конце 1980-х и середине 1990-х годов среды Smalltalk, включая поддержку, обучение и дополнения, продавались двумя конкурирующими организациями: ParcPlace Systems и Digitalk, обе из Калифорнии. ParcPlace Systems, как правило, фокусировалась на рынке микросистем Unix/Sun, в то время как Digitalk сосредоточилась на ПК на базе Intel под управлением Microsoft Windows или OS/2 от IBM. Обе компании боролись за то, чтобы сделать Smalltalk популярным из-за значительных потребностей Smalltalk в памяти, ограниченной производительности во время выполнения и изначального отсутствия поддерживаемого подключения к серверам реляционных баз данных на основе SQL . В то время как высокая цена ParcPlace Smalltalk ограничивала его проникновение на рынок средними и крупными коммерческими организациями, продукты Digitalk изначально пытались охватить более широкую аудиторию с помощью более низкой цены. IBM изначально поддерживала продукт Digitalk, но затем вышла на рынок с продуктом Smalltalk в 1995 году под названием VisualAge/Smalltalk. В это время Easel представила Enfin для Windows и OS/2. Enfin стал гораздо более популярным в Европе, поскольку IBM представила его в IT-магазинах до разработки 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 . ^[16] VisualWorks была продана Cincom и теперь является частью Cincom Smalltalk. Cincom активно поддерживает Smalltalk, выпуская по несколько новых версий VisualWorks и ObjectStudio каждый год с 1999 года.

Cincom , GemTalk и Instantiations продолжают продавать среды Smalltalk. IBM завершила VisualAge Smalltalk, решив в конце 1990-х годов вместо этого поддержать Java, и с 2005 года ^{[обновлять]}поддерживается Instantiations, Inc. ^[17] 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 . ^[18] Smalltalk также является одним из самых влиятельных языков программирования. ^{[ требуется ссылка ]} Практически все объектно-ориентированные языки, которые появились позже — Flavors , ^[19] CLOS , Objective-C , Java , Python , Ruby , ^[20] и многие другие — были под влиянием Smalltalk. Smalltalk также был одним из самых популярных языков для гибких методов разработки программного обеспечения , быстрой разработки приложений (RAD) или прототипирования и шаблонов проектирования программного обеспечения . ^[21] Высокопроизводительная среда, предоставляемая платформами Smalltalk, сделала их идеальными для быстрой итеративной разработки.

Smalltalk появился из более крупной программы Advanced Research Projects Agency (ARPA), финансируемой исследованиями, которые во многом определили современный мир вычислений. В дополнение к Smalltalk, рабочие прототипы таких вещей, как гипертекст , графические интерфейсы, мультимедиа , мышь, телеприсутствие и Интернет были разработаны исследователями ARPA в 1960-х годах. ^{[22] [23]} Алан Кей (один из изобретателей Smalltalk) также описал планшетный компьютер, который он назвал Dynabook , который напоминает современные планшетные компьютеры, такие как iPad. ^[4]

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

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

Smalltalk использует несколько команд, которые рифмуются с суффиксом "-ect". Это было вдохновлено строкой из монолога Арло Гатри 1967 года " Ресторанная резня Элис ", в котором Гатри подвергся череде "инъекций, осмотров, обнаружения, заражения, игнорирования и отбора". ^[26]

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

Smalltalk-80: Язык и его реализация , также известная как «Синяя книга», оригинальная книга о языке

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

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

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

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

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

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

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

Отражение

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

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

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

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

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

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

Синтаксис

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

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

exampleWithNumber:  x  | y |  true  &  false  not  & ( nil  isNil ) ifFalse: [ self  halt ] .  y  :=  self  size  +  super  size .  #( $a  #a  'a'  1  1.0 )  do: [ : each  |  Транскрипт  show: ( each  имя класса ) ; show: ' ' ] . ^ x < y     

Литералы

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

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

42 - 42 123 . 45 1 . 2345e2 2r10010010 16 rA000

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

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

$А

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

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

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

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

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

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

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

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

# 'фу'

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

#фу

Массивы:

#( 1  2  3  4 )

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

#(( 1  2  3  4 )  [ 1  2  3  4 ]  'четыре'  4.0  #четыре)

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

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

# [ 1  2  3  4 ]

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

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

[... Какой-то  код smalltalk  ... ]

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

[ : а  : б |  а  <  б ]

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

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

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

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

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

| индекс |

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

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

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

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

Назначение

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

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

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

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

Сообщения

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

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

42  факториал

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

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

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

2  поднятоДо:  4

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

'привет мир'  indexOf:  $o  startingAt:  6

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

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

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

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

Ширина прямоугольника  :  100,  высота:  200

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

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

3  +  4

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

3  >  4

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

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

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

Выражения

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

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

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

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

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

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

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

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

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

3  +  4  *  5

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

3  + ( 4  *  5 )

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

3  факториал  факторный  логарифм

что отправляет «factorial» к 3, затем «factorial» к результату (6), затем «log» к результату (720), давая результат 2,85733.

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

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

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

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

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

Блоки кода

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

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

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

[ : х  |  х  +  1 ]

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

${\displaystyle f(x)=x+1}$

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

${\displaystyle \lambda x.x+1}$

и

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

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

${\displaystyle f(3)=3+1}$

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

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

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

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

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

expr  ifTrue: [ выражения  для  оценки,  если  expr ] ifFalse: [ выражения  для  оценки  , если  не  expr ]

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

ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock 
     ^значение trueAlternativeBlock

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

ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock 
    значение ^falseAlternativeBlock

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

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

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

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

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

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

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

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

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

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

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

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

[ некоторая  операция
] на: Ошибка  do: [ : ex  |  обработчик - код  ex  return]

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

Классы

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

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

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

Методы

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

опубликовать  Транскрипт  шоу:  «Привет, мир!»

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

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

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

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

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

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

СообщениеИздатель  новый

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

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

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

СообщениеИздатель  новая  публикация

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

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

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

Браузер

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

Рабочее пространство

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

Рабочее пространство

Транскрипт

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

Инспектор

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

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

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

Отправка сообщения self haltвызывает исключение, которое открывает уведомитель, предоставляя простую возможность точки останова (обычно возможности точки останова предоставляют больше, чем просто остановку, но это была первая такая возможность). Рабочие области также предоставляют оценщик "debug it", который открывает отладчик для выбранного выражения, расположенного в первом сообщении, отправленном в выражении. Таким образом, выбор 52 factorialи выбор "debug it" из всплывающего меню открывает отладчик с выбранным "doit context" и factorialвыделенным селектором. Отладчик предоставляет кнопки для выполнения "step into", "step over" и т. д. Следовательно, выбрав "step into", можно исследовать оценку 52 factorial. Таким образом, отладчик предоставляет инспектора процесса, позволяя исследовать остановленное вычисление.

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

Пример «Привет, мир»

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

Транскрипт  шоу:  «Привет, мир!» .

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

Устойчивость на основе изображения

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

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

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

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

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

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

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

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

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

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

OpenSmalltalk

OpenSmalltalk VM (OS VM) — это относительно высокопроизводительная реализация виртуальной машины Smalltalk, на которой основаны несколько современных диалектов Smalltalk с открытым исходным кодом. ^{[41] [42]} OS VM происходит от оригинального интерпретатора Back-to-the-Future ^[43] (BTTF) Squeak, реализованного Дэном Ингаллсом, Тедом Кхэлером, Джоном Мэлони и многими другими участниками. Как и в случае с BTTF VM, OS VM транспилируется из системы Smalltalk, в которой она разработана (используя подмножество Smalltalk под названием Slang), в исходный код на родном языке C , ^[44] который, в свою очередь, компилируется для определенной платформы и архитектуры оборудования, что фактически позволяет выполнять образы Smalltalk на кроссплатформенной основе. OS VM отличается от BTTF VM тем,

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

Известные диалекты Smalltalk, основанные на ОС VM: ^[45]

• Squeak , оригинальный Smalltalk с открытым исходным кодом, для которого была создана виртуальная машина OpenSmalltalk ^{[45] : 2} , который происходит от Smalltalk-80 v1 от Xerox PARC
• Pharo Smalltalk — кроссплатформенный язык с открытым исходным кодом , созданный на основе Squeak.
• Croquet , виртуальная машина Smalltalk, связанная с Squeak, для проекта Croquet
• Cuis Smalltalk, который происходит от Squeak

Другие

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

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

• Дарт
• Objective-C
• Новояз
• Рубин
• Себя
• Strongtalk
• GLASS (пакет программного обеспечения)
• Архитектура распределенного управления данными

Ссылки

1. "Alto I Schematics" (PDF) . Bitsavers . стр. 54 . Получено 21 июля 2016 г. .
2. "История компьютеров и вычислительной техники, Рождение современного компьютера, Персональный компьютер, Xerox Alto" . Получено 19 апреля 2016 г.
3. Кей, Алан; Рам, Стефан (2003-07-23). ​​"E-Mail от 2003-07-23". Доктор Алан Кей о значении "объектно-ориентированного программирования". Получено 2009-01-03 .
4. Кей, Алан. "Ранняя история Smalltalk" . Получено 13 сентября 2007 г.
5. "ANSI Smalltalk Standard". Smalltalk.org. 2004. Архивировано из оригинала 2006-02-16 . Получено 2021-03-02 .
6. «Опрос разработчиков Stack Overflow 2017».
7. «Опрос разработчиков Stack Overflow 2018».
8. "Версии". Smalltalk.org. Архивировано из оригинала 2015-09-08 . Получено 2007-09-13 .
9. "Приглашение Tektronix на Первую международную конференцию разработчиков Smalltalk-80" (PDF) . Архив документов Tektronix Smalltalk . 27 августа 1981 г.
10. "Список участников Первой международной конференции разработчиков Smalltalk-80" (PDF) . Архив документов Tektronix Smalltalk . 24 сентября 1981 г.
11. «Представляем Smalltalk Zoo». CHM . 17 декабря 2020 г.
12. "VI Release Notes" (PDF) . 20 ноября 1981 г.
13. Ingalls, Daniel (2020). «Эволюция Smalltalk: от Smalltalk-72 до Squeak». Труды ACM по языкам программирования . 4 : 1–101. doi : 10.1145/3386335 . S2CID  219603700.
14. "ANSI Smalltalk Standard". Smalltalk.org. Архивировано из оригинала 2015-09-07 . Получено 2007-09-13 .
15. "Гоббс". Архивировано из оригинала 19 апреля 2003 года.
16. "История". Seagull Software. Архивировано из оригинала 2002-08-06 . Получено 2007-09-13 .
17. «Часто задаваемые вопросы о переходе VisualAge Smalltalk».
18. Язык Simula также был объектно-ориентированным и предшествовал языку Smalltalk (и, как признано, оказал на него влияние), но это был язык моделирования, а не язык программирования общего назначения.
19. Кэннон, Ховард. "Вкусы. Неиерархический подход к объектно-ориентированному программированию" (PDF) . softwarepreservation.org . Получено 17 декабря 2013 г. .
20. "О Ruby". ruby-lang.org . Получено 17 декабря 2013 г. .
21. "Откуда взялся рефакторинг?". sourcemaking.com . Получено 17 декабря 2013 г. .
22. "DARPA – ARPA". livinginternet.com . Получено 16 декабря 2013 г. Чтобы удовлетворить эту потребность, ARPA создала IPTO в 1962 году с мандатом на создание отказоустойчивой компьютерной сети для соединения основных компьютеров Министерства обороны в Пентагоне, Шайенн-Маунтин и штаб-квартире SAC.
23. "Роль Энгельбарта в ранних компьютерных сетях". dougengelbart.org . Получено 17 декабря 2013 г. .
24. Краснер, Глен; Поуп, Стивен (август–сентябрь 1988 г.). «Книга рецептов использования парадигмы пользовательского интерфейса «модель-представление-контроллер» в Smalltalk -80». Журнал объектно-ориентированного программирования .
25. "Наше влияние". cincomsmalltalk.com . Получено 16 декабря 2013 г. .
26. «Введено, проверено, обнаружено, инфицировано, забыто и отобрано». The Weekly Squeak . 2014-04-29 . Получено 2024-04-15 .
27. Кей, Алан (10 октября 1998 г.). «Прототипы против классов (электронная почта в списке рассылки Squeak)».
28. Голдберг, Адель ; Робсон, Дэвид (1989). Smalltalk-80 Язык . Эддисон Уэсли. стр. 31, 75–89. ISBN 0-201-13688-0.
29. Кларк, AN (18 сентября 1997 г.). «Метаклассы и рефлексия в Smalltalk». arXiv : 1804.07272 [cs.SE].
30. Дюкасс, Стефан; Линхард, Адриан; Ренггли, Лукас. «Seaside — платформа веб-приложений с множественными потоками управления» (PDF) . scg.unibe.ch . Группа композиции программного обеспечения Институт информатики и математического анализа Университета Берна, Швейцария . Проверено 16 декабря 2013 г.
31. Фут, Брайан; Джонсон, Ральф (1–6 октября 1989 г.). «Рефлексивные возможности в Smalltalk-80». Труды конференции по объектно-ориентированным системам программирования, языкам и приложениям . стр. 327–335. doi : 10.1145/74877.74911 . ISBN 0-89791-333-7. S2CID  14207536 . Получено 16 декабря 2013 г. .
32. Смит, Брайан С. (1982-01-01). «Процедурная рефлексия в языках программирования». Технический отчет MIT (MIT-LCS-TR-272) . Получено 16 декабря 2013 г.
33. Пек, Мариано Мартинес; Буракади, Нури; Денкер, Маркус; Дюкасс, Стефан; Фабресс, Люк (23 августа 2011 г.). Эффективные прокси в Smalltalk . АКМ. п. 1–16. дои : 10.1145/2166929.2166937. hdl : 20.500.12210/28011 . ISBN 978-1-4503-1050-5.
34. Дюкасс, Стефан (2001). «Писк: Минималистский синтаксис / Писк: Минималистский синтаксис!» (PDF) . Программаз! Журнал Le Magazine du Développement . 1 . Проверено 15 января 2024 г.
35. Дюкасс, Стефан. «Объектно-ориентированное проектирование с Smalltalk — чистый объектный язык и его среда» (PDF) . Software Composition Group (Университет Берна) . Получено 15 января 2024 г. .
36. Голдберг, Адель ; Робсон, Дэвид (1989). Smalltalk-80 Язык . Эддисон Уэсли. стр. 17–37. ISBN 0-201-13688-0.
37. Голдберг, Адель ; Робсон, Дэвид (1989). Smalltalk-80 Язык . Эддисон Уэсли. стр. 39–53. ISBN 0-201-13688-0.
38. "Image-Based Persistence". book.seaside.st . Получено 17 декабря 2013 г. .
39. Кей, Аллен (1968). «FLEX – гибкий расширяемый язык». Диссертация магистра наук Университета Юты .
40. Фаулер, Мартин. "Memory Image". martinfowler.com . Архивировано из оригинала 2011-10-07 . Получено 17 декабря 2013 .
41. "opensmalltalk-vm", OpenSmalltalk , Git hub, 2020-11-03 , получено 2020-11-08
42. Элиот Миранда; Клемент Бера; Элиза Гонсалес Буа; Дэн Ингаллс (2018). Два десятилетия разработки виртуальных машин Smalltalk: разработка виртуальных машин в реальном времени с помощью инструментов моделирования; Виртуальные машины и языковые реализации VMIL 2018, Бостон, США (отчет). hal.archives-ouvertes.fr. doi :10.1145/3281287.3281295. Архивировано из оригинала 2022-11-05.
43. Ингаллс, Дэн; Келер, Тед; Малони, Джон; Уоллес, Скотт; Кей, Алан (1997). «Назад в будущее: история Squeak, практического Smalltalk, написанного в себе». ACM SIGPLAN Notices . 32 (10). ACM Digital Library: 318–326. doi : 10.1145/263700.263754 .
44. "Сленг". Писк . Получено 2020-11-08 .
45. Миранда, Элиот; Бера, Клеман; Гонсалес Буа, Элиза; Дэн, Ингаллс (8 октября 2018 г.). «Два десятилетия разработки виртуальных машин Smalltalk: разработка виртуальных машин в реальном времени с помощью инструмента моделирования» (PDF) .
46. "Strongtalk: высокопроизводительный Smalltalk с открытым исходным кодом и дополнительной системой типов" . Получено 25.11.2021 .

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

• Голдберг, Адель (декабрь 1983 г.). Smalltalk-80: интерактивная среда программирования . Addison-Wesley. ISBN 0-201-11372-4.
• Goldberg, Adele ; Kay, Alan , ред. (март 1976 г.). Руководство по эксплуатации Smalltalk-72 (PDF) . Пало-Альто, Калифорния: Исследовательский центр Xerox в Пало-Альто . Получено 11 ноября 2011 г.
• Голдберг, Адель ; Робсон, Дэвид (май 1983). Smalltalk-80: Язык и его реализация . Эддисон-Уэсли. ISBN 0-201-11371-6.
• Голдберг, Адель ; Робсон, Дэвид (11 января 1989 г.). Smalltalk 80: The Language . Addison-Wesley. ISBN 0-201-13688-0.
• Кей, Алан С. (март 1993 г.). «Ранняя история Smalltalk» (PDF) . Уведомления ACM SIGPLAN . 28 (3). ACM : 69–95. doi :10.1145/155360.155364. Архивировано из оригинала (PDF) 3 мая 2023 г.
• Краснер, Глен, ред. (август 1983 г.). Smalltalk-80: Bits of History, Words of Advice. Addison-Wesley. ISBN 0-201-11669-3.
• Ниерштрас, Оскар; Дюкасс, Стефан; Полле, Дэмиен; Блэк, Эндрю П. (2009-10-07). Писк на примере. Керзац, Швейцария: Square Bracket Associates. ISBN 978-3-9523341-0-2.
• Ниерштрас, Оскар; Дюкасс, Стефан; Полле, Дэмиен; Блэк, Эндрю П. (23 февраля 2010 г.). Pharo by Example. Керзац, Швейцария: Square Bracket Publishing. ISBN 978-3-9523341-4-0. Архивировано из оригинала 21 октября 2009 года.
• Уинстон, Патрик Генри (3 сентября 1997 г.). На Smalltalk . Массачусетский технологический институт, США: Addison Wesley. ISBN 978-0-201-49827-1.
• Брауэр, Йоханнес (2015). Программирование Smalltalk – объектно-ориентированное программирование с самого начала . Springer. ISBN 978-3-658-06823-3.
• «Специальный выпуск о Smalltalk». Байт . 6 (8). McGraw-Hill. Август 1981. Получено 18 октября 2013 г.
  • Голдберг, Адель (август 1981 г.). «Введение в систему Smalltalk-80». Байт . 6 (8). McGraw-Hill . Получено 18 октября 2013 г.
  • Ингаллс, Дэн (август 1981 г.). «Принципы проектирования Smalltalk». Байт . 6 (8). McGraw-Hill . Получено 11 ноября 2011 г.
  • Теслер, Ларри (август 1981 г.). «Среда Smalltalk». Байт . 6 (8). McGraw-Hill . Получено 2016-05-02 .

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

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