Misplaced Pages

#652347

69-781: Context menus first appeared in the Smalltalk environment on the Xerox Alto computer, where they were called pop-up menus ; they were invented by Dan Ingalls in the mid-1970s. Microsoft Office v3.0 introduced the context menu for copy and paste functionality in 1990. Borland demonstrated extensive use of the context menu in 1991 at the Second Paradox Conference in Phoenix Arizona. Lotus 1-2-3 /G for OS/2 v1.0 added additional formatting options in 1991. Borland Quattro Pro for Windows v1.0 introduced

138-721: A TFoo class has been declared in a unit called Unit1 : The following is an example in eC: The following is an example in Go : The following is an example in Java : The following is an example in JavaScript : The following is an example in Julia : The following is an example in Objective-C , implying either the OpenStep or Foundation Kit framework is used: The following

207-412: A string literal . For example: If the sequence does not include whitespace or punctuation characters, this can also be written as: Arrays: defines an array of four integers. defines a seven element array whose first element is a literal array, second element a byte array, third element the string 'four', and so on. Many implementations support the following literal syntax for ByteArrays: defines

276-526: A ByteArray of four integers. And last but not least, blocks ( anonymous function literals) Reflective programming In computer science , reflective programming or reflection is the ability of a process to examine, introspect , and modify its own structure and behavior. The earliest computers were programmed in their native assembly languages , which were inherently reflective, as these original architectures could be programmed by defining instructions as data and using self-modifying code . As

345-462: A class's method dictionary. The part of the class hierarchy that defines classes can add new classes to the system. The system is extended by running Smalltalk-80 code that creates or defines classes and methods. In this way a Smalltalk-80 system is a "living" system, carrying around the ability to extend itself at run time. One can even extend the compiler at run-time; indeed this is how the Compiler

414-460: A code snippet by Ralph Johnson , demonstrating all the basic standard syntactic elements of methods: The following examples illustrate the most common objects which can be written as literal values in Smalltalk-80 methods. Numbers. The following list illustrates some of the possibilities. The last two entries are a binary and a hexadecimal number, respectively. The number before the 'r'

483-469: A larger program of Advanced Research Projects Agency (ARPA) funded research that in many ways defined the modern world of computing. In addition to Smalltalk, working prototypes of things such as hypertext , GUIs, multimedia , the mouse, telepresence , and the Internet were developed by ARPA researchers in the 1960s. Alan Kay (one of the inventors of Smalltalk) also described a tablet computer he named

552-569: A map of a database or entity relations. Reflection makes a language more suited to network-oriented code. For example, it assists languages such as Java to operate well in networks by enabling libraries for serialization, bundling and varying data formats. Languages without reflection such as C are required to use auxiliary compilers for tasks like Abstract Syntax Notation to produce code for serialization and bundling. Reflection can be used for observing and modifying program execution at runtime . A reflection-oriented program component can monitor

621-421: A non-public property. It is also possible to find non-public methods of classes and types and manually invoke them. This works for project-internal files as well as external libraries such as .NET 's assemblies and Java's archives. A language supporting reflection provides a number of features available at runtime that would otherwise be difficult to accomplish in a lower-level language. Some of these features are

690-648: A number of facilities such as distributed Smalltalk where messages are exchanged between multiple Smalltalk systems, database interfaces where objects are transparently faulted out of a database, promises , etc. The design of distributed Smalltalk influenced such systems as CORBA . Smalltalk-80 syntax is rather minimalist, based on only a handful of declarations and reserved words. In fact, only six "keywords" are reserved in Smalltalk: true , false , nil , self , super , and thisContext . These are properly termed pseudo-variables , identifiers that follow

759-457: A spelling corrector. Each release consisted of a virtual image (platform-independent file with object definitions) and a virtual machine specification. ANSI Smalltalk has been the standard language reference since 1998. Two currently popular Smalltalk implementation variants are descendants of those original Smalltalk-80 images. Squeak is an open source implementation derived from Smalltalk-80 Version 1 by way of Apple Smalltalk. VisualWorks

SECTION 10

#1732782819653

828-514: A string: Two equal strings (strings are equal if they contain all the same characters) can be different objects residing in different places in memory. In addition to strings, Smalltalk has a class of character sequence objects named Symbol. Symbols are guaranteed to be unique—there can be no two equal symbols which are different objects. Because of that, symbols are very cheap to compare and are often used for language artifacts such as message selectors (see below). Symbols are written as # followed by

897-525: A toolkit for developing collaborative applications Croquet Project , and the Open Cobalt virtual world application. GNU Smalltalk is a free software implementation of a derivative of Smalltalk-80 from the GNU project. Pharo Smalltalk is a fork of Squeak oriented toward research and use in commercial environments. As of 2016, a significant development that has spread across all Smalltalk environments

966-476: A user to create unexpected control flow paths through an application, potentially bypassing security measures. This may be exploited by attackers. Historical vulnerabilities in Java caused by unsafe reflection allowed code retrieved from potentially untrusted remote machines to break out of the Java sandbox security mechanism. A large scale study of 120 Java vulnerabilities in 2013 concluded that unsafe reflection

1035-404: Is a list of the methods by which the current verb was eventually called, performing tests on callers ()[0] (the command invoked by the original user) allows the verb to protect itself against unauthorised use. Compiled languages rely on their runtime system to provide information about the source code. A compiled Objective-C executable, for example, records the names of all methods in a block of

1104-517: Is a structurally reflective system which structure is defined by Smalltalk-80 objects. The classes and methods that define the system are also objects and fully part of the system that they help define. The Smalltalk compiler, which is itself written in Smalltalk and exists alongside all the other code in the system, compiles textual source code into method objects, typically instances of CompiledMethod . These get added to classes by storing them in

1173-421: Is always private to that object. Other objects can query or change that state only by sending requests (messages) to the object to do so. Any message can be sent to any object: when a message is received, the receiver determines whether that message is appropriate. If the message is not understood by the object then the virtual machine sends the doesNotUnderstand: message with the original message as an argument, and

1242-621: Is derived from Smalltalk-80 version 2 by way of Smalltalk-80 2.5 and ObjectWorks (both products of ParcPlace Systems, a Xerox PARC spin-off company formed to bring Smalltalk to the market). As an interesting link between generations, in 2001, Vassili Bykov implemented Hobbes, a virtual machine running Smalltalk-80 inside VisualWorks. ( Dan Ingalls later ported Hobbes to Squeak.) During the late 1980s to mid-1990s, Smalltalk environments, including support, training and add-ons, were sold by two competing organizations: ParcPlace Systems and Digitalk, both California based. ParcPlace Systems tended to focus on

1311-425: Is developed and maintained. Since the classes are objects, they can be asked questions such as "what methods do you implement?" or "what fields/slots/instance variables do you define?". So objects can easily be inspected, copied, (de) serialized and so on with generic code that applies to any object in the system. Smalltalk-80 also provides computational reflection, the ability to observe the computational state of

1380-574: Is implemented on top of the built-in constructs by the standard Smalltalk class library. (For performance reasons, implementations may recognize and treat as special some of those messages; however, this is only an optimization and is not coded into the language syntax.) The adage that "Smalltalk syntax fits on a postcard " may have originated in Alan Kay's original conception of the language, as related by him in practically every of tens or hundreds of public lectures, op. cit., or perhaps it could refer to

1449-535: Is implemented using this facility. One of the more interesting uses of this is in the Seaside web framework which relieves the programmer of dealing with the complexity of a Web Browser's back button by storing continuations for each edited page and switching between them as the user navigates a web site. Programming the web server using Seaside can then be done using a more conventional programming style. As with message sending Smalltalk-80 virtual machines optimize away

SECTION 20

#1732782819653

1518-471: Is now termed Smalltalk-72 and influenced the development of the Actor model . Its syntax and execution model were very different from modern Smalltalk variants. After significant revisions which froze some aspects of execution semantics to gain performance (by adopting a Simula -like class inheritance model of execution), Smalltalk-76 was created. This system had a development environment featuring most of

1587-410: Is often used as part of software testing , such as for the runtime creation/instantiation of mock objects . Reflection is also a key strategy for metaprogramming . In some object-oriented programming languages such as C# and Java , reflection can be used to bypass member accessibility rules. For C#-properties this can be achieved by writing directly onto the (usually invisible) backing field of

1656-425: Is released, so the user has to click again to select a context menu item. This behavior differs from that of macOS and most free software GUIs. Context menus are sometimes hierarchically organized, allowing navigation through different levels of the menu structure. The implementations differ: Microsoft Word was one of the first applications to only show sub-entries of some menu entries after clicking an arrow icon on

1725-641: Is summarized in the commonly heard phrase "In Smalltalk everything is an object", which may be more accurately expressed as "all values are objects", as variables are not. Since all values are objects, classes are also objects. Each class is an instance of the metaclass of that class. Metaclasses in turn are also objects, and are all instances of a class named Metaclass. Classes contain method dictionaries that map selectors (the equivalent of function procedure names in other languages) to method objects, objects that are executed to evaluate messages. Classes inherit from other classes, with either Object or ProtoObject at

1794-404: Is the radix or base. The base does not have to be a power of two; for example 36rSMALLTALK is a valid number equal to 80738163270632 decimal. Characters are written by preceding them with a dollar sign: Strings are sequences of characters enclosed in single quotes: To include a quote in a string, escape it using a second quote: Double quotes do not need escaping, since single quotes delimit

1863-419: Is the increasing usage of two web frameworks, Seaside and AIDA/Web , to simplify the building of complex web applications. Seaside has seen considerable market interest with Cincom, Gemstone, and Instantiations incorporating and extending it. Smalltalk was one of many object-oriented programming languages based on Simula . Smalltalk is also one of the most influential programming languages. Virtually all of

1932-643: Is the most common vulnerability in Java, though not the most exploited. The following code snippets create an instance foo of class Foo and invoke its method PrintHello . For each programming language , normal and reflection-based call sequences are shown. The following is an example in Common Lisp using the Common Lisp Object System : The following is an example in C# : This Delphi and Object Pascal example assumes that

2001-486: Is the part of the system that implements the programming system itself, and developers can use the meta-model to do things like walk through, examine, and modify code in the running system, or find all the instances of a certain kind of structure (e.g., all instances of the Method class in the meta-model). Smalltalk-80 is a totally reflective system. Smalltalk-80 provides both structural and computational reflection. Smalltalk

2070-577: The Dynabook which resembles modern tablet computers like the iPad. Smalltalk environments were often the first to develop what are now common object-oriented software design patterns. One of the most popular is the model–view–controller (MVC) pattern for user interface design. The MVC pattern enables developers to have multiple consistent views of the same underlying data. It's ideal for software development environments, where there are various views (e.g., entity-relation, dataflow, object model, etc.) of

2139-603: The Stack Overflow Developer Survey in 2017, but it was not among the 26 most loved programming languages of the 2018 survey. There are a large number of Smalltalk variants. The unqualified word Smalltalk is often used to indicate the Smalltalk-80 language and compatible VM, the first version to be made publicly available and created in 1980. The first hardware-environments which ran the Smalltalk VMs were Xerox Alto computers. Smalltalk

Context menu - Misplaced Pages Continue

2208-526: The Digitalk products initially tried to reach a wider audience with a lower price. IBM initially supported the Digitalk product, but then entered the market with a Smalltalk product in 1995 named VisualAge/Smalltalk. Easel introduced Enfin at this time on Windows and OS/2. Enfin became far more popular in Europe, as IBM introduced it into IT shops before their development of IBM Smalltalk (later VisualAge). Enfin

2277-514: The Properties context menu option in 1992. Context menus are opened via various forms of user interaction that target a region of the GUI that supports context menus. The specific form of user interaction and the means by which a region is targeted vary: Windows mouse click behavior is such that the context menu doesn't open while the mouse button is pressed, but only opens the menu when the button

2346-491: The Smalltalk programming environment. Having undergone significant industry development toward other uses, including business and database functions, Smalltalk is still in use today. When first publicly released, Smalltalk-80 presented numerous foundational ideas for the nascent field of object-oriented programming (OOP). Since inception, the language provided interactive programming via an integrated development environment . This requires reflection and late binding in

2415-510: The Unix/Sun microsystems market, while Digitalk focused on Intel-based PCs running Microsoft Windows or IBM's OS/2. Both firms struggled to take Smalltalk mainstream due to Smalltalk's substantial memory needs, limited run-time performance, and initial lack of supported connectivity to SQL -based relational database servers. While the high price of ParcPlace Smalltalk limited its market penetration to mid-sized and large commercial organizations,

2484-442: The abilities to: These features can be implemented in different ways. In MOO , reflection forms a natural part of everyday programming idiom. When verbs (methods) are called, various variables such as verb (the name of the verb being called) and this (the object on which the verb is called) are populated to give the context of the call. Security is typically managed by accessing the caller stack programmatically: Since callers ()

2553-401: The bulk of programming moved to higher-level compiled languages such as Algol , Cobol , Fortran , Pascal , and C , this reflective ability largely disappeared until new programming languages with reflection built into their type systems appeared. Brian Cantwell Smith 's 1982 doctoral dissertation introduced the notion of computational reflection in procedural programming languages and

2622-701: The business. In 1999, Seagull Software acquired the ObjectShare Java development lab (including the original Smalltalk/V and Visual Smalltalk development team), and still owns VisualSmalltalk, although worldwide distribution rights for the Smalltalk product remained with ObjectShare who then sold them to Cincom . VisualWorks was sold to Cincom and is now part of Cincom Smalltalk. Cincom has backed Smalltalk strongly, releasing multiple new versions of VisualWorks and ObjectStudio each year since 1999. Cincom , GemTalk, and Instantiations, continue to sell Smalltalk environments. IBM ended VisualAge Smalltalk, having in

2691-770: The central concept in Smalltalk-80 (but not in Smalltalk-72) is that of an object . An object is always an instance of a class . Classes are "blueprints" that describe the properties and behavior of their instances. For example, a GUI's window class might declare that windows have properties such as the label, the position and whether the window is visible or not. The class might also declare that instances support operations such as opening, closing, moving and hiding. Each particular window object would have its own values of those properties, and each of them would be able to perform operations defined by its class. A Smalltalk object can do exactly three things: The state an object holds

2760-523: The context menu, otherwise executing an action associated with the parent entry. This makes it possible to quickly repeat an action with the parameters of the previous execution, and to better separate options from actions. The following window managers provide context menu functionality: Context menus have received some criticism from usability analysts when improperly used, as some applications make certain features only available in context menus, which may confuse even experienced users (especially when

2829-411: The context menus can only be activated in a limited area of the application's client window). Context menus usually open in a fixed position under the pointer , but when the pointer is near a screen edge the menu will be displaced - thus reducing consistency and impeding use of muscle memory . If the context menu is being triggered by keyboard, such as by using Shift + F10, the context menu appears near

Context menu - Misplaced Pages Continue

2898-471: The default implementation of doesNotUnderstand: raises an exception that if not caught opens the system's debugger. Alan Kay has commented that despite the attention given to objects, messaging is the most important concept in Smalltalk: "The big idea is 'messaging'—that is what the kernel of Smalltalk/Squeak is all about (and it's something that was never quite completed in our Xerox PARC phase)." Unlike most other languages, Smalltalk code can be modified while

2967-480: The executable, providing a table to correspond these with the underlying methods (or selectors for these methods) compiled into the program. In a compiled language that supports runtime creation of functions, such as Common Lisp , the runtime environment must include a compiler or an interpreter. Reflection can be implemented for languages without built-in reflection by using a program transformation system to define automated source-code changes. Reflection may allow

3036-501: The execution of an enclosure of code and can modify itself according to a desired goal of that enclosure. This is typically accomplished by dynamically assigning program code at runtime. In object-oriented programming languages such as Java , reflection allows inspection of classes, interfaces, fields and methods at runtime without knowing the names of the interfaces, fields, methods at compile time . It also allows instantiation of new objects and invocation of methods. Reflection

3105-423: The expensive use of contexts internally, providing the illusion and flexibility of a spaghetti stack without most its costs. Essentially context objects are created lazily as required, for example when a message is sent to the thisContext variable. An example of how Smalltalk can use reflection is the mechanism for handling errors. When an object is sent a message that it does not implement, the virtual machine sends

3174-436: The first being the sender of the former. In this way the stack is a linked list of context objects, and the debugger is essentially an inspector of this "spaghetti stack". By sending messages to thisContext a method activation can ask questions like "who sent this message to me". These facilities make it possible to implement coroutines or Prolog -like back-tracking without modifying the virtual machine. The exception system

3243-441: The focused widget instead of the position of the pointer, to save recognition efforts. Microsoft's guidelines call for always using the term context menu , and explicitly deprecate shortcut menu . Smalltalk Smalltalk is a purely object oriented programming language (OOP) that was originally created in the 1970s for educational use, specifically for constructionist learning , but later found use in business. It

3312-496: The language execution of code . Later development has led to at least one instance of Smalltalk execution environment which lacks such an integrated graphical user interface or front-end. Smalltalk-like languages are in active development and have gathered communities of users around them. American National Standards Institute (ANSI) Smalltalk was ratified in 1998 and represents the standard version of Smalltalk. Smalltalk took second place for "most loved programming language" in

3381-646: The last two being vectors of bytes. Consequently Smalltalk can evaluate 52 factorial to produce 80658175170943878571660636856403766975289505440883277824000000000000. The transition from small to large integers is transparent to the programmer; variables do not require type declarations. This makes the system both concise and flexible. A programmer can change or extend (through subclassing ) the classes that implement what in other languages would be primitive values, so that new behavior can be defined for their instances—for example, to implement new control structures—or even so that their existing behavior will be changed. This fact

3450-534: The late 1990s decided to back Java instead and, as of 2005 , is supported by Instantiations, Inc. Instantiations renamed the product VA Smalltalk (VAST Platform) and continue to release new versions yearly. The open Squeak implementation has an active community of developers, including many of the original Smalltalk community, and was used to provide the Etoys environment on the One Laptop per Child (OLPC) project,

3519-461: The notion of the meta-circular interpreter as a component of 3-Lisp . Reflection helps programmers make generic software libraries to display data, process different formats of data, perform serialization and deserialization of data for communication, or do bundling and unbundling of data for containers or bursts of communication. Effective use of reflection almost always requires a plan: A design framework, encoding description, object library,

SECTION 50

#1732782819653

3588-452: The now familiar tools, including a class library code browser/editor. Smalltalk-80 added metaclasses , to help maintain the "everything is an object" (except variables) paradigm by associating properties and behavior with individual classes, and even primitives such as integer and Boolean values (for example, to support different ways to create instances). Smalltalk-80 was the first language variant made available outside of PARC. In 1981, it

3657-411: The object the doesNotUnderstand: message with a reification of the message as an argument. The message (another object, an instance of Message ) contains the selector of the message and an Array of its arguments. In an interactive Smalltalk system the default implementation of doesNotUnderstand: is one that opens an error window (a Notifier) reporting the error to the user. Through this and

3726-476: The object-oriented languages that came after— Flavors , CLOS , Objective-C , Java , Python , Ruby , and many others—were influenced by Smalltalk. Smalltalk was also one of the most popular languages for agile software development methods, rapid application development (RAD) or prototyping, and software design patterns . The highly productive environment provided by Smalltalk platforms made them ideal for rapid, iterative development. Smalltalk emerged from

3795-471: The reflective facilities the user can examine the context in which the error occurred, redefine the offending code, and continue, all within the system, using Smalltalk-80's reflective facilities. By creating a class that understands (implements) only doesNotUnderstand:, one can create an instance that can intercept any message sent to it via its doesNotUnderstand: method. Such instances are called transparent proxies. Such proxies can then be used to implement

3864-410: The root of the class hierarchy. Sending a message to an object at the most abstract involves fetching the class of the receiver (the object being sent the message) and looking up the message's selector in the class's method dictionary, followed by the superclass and so on until the method is found or doesNotUnderstand is sent. Smalltalk virtual machines use various techniques to speed up message lookup so

3933-462: The rules for variable identifiers but denote bindings that a programmer cannot change. The true , false , and nil pseudo-variables are singleton instances. self and super refer to the receiver of a message within a method activated in response to that message, but sends to super are looked up in the superclass of the method's defining class rather than the class of the receiver, which allows methods in subclasses to invoke methods of

4002-473: The same name in superclasses. thisContext refers to the current activation record. The only built-in language constructs are message sends, assignment, method return and literal syntax for some objects. From its origins as a language for children of all ages, standard Smalltalk syntax uses punctuation in a manner more like English than mainstream coding languages. The remainder of the language, including control structures for conditional evaluation and iteration,

4071-568: The same underlying specification. Also, for simulations or games where the underlying model may be viewed from various angles and levels of abstraction. In addition to the MVC pattern, the Smalltalk language and environment were influential in the history of the graphical user interface (GUI) and the what you see is what you get ( WYSIWYG ) user interface, font editors, and desktop metaphors for UI design. The powerful built-in debugging and object inspection tools that came with Smalltalk environments set

4140-406: The sense that they are instances of corresponding classes, and operations on them are invoked by sending messages. For efficiency and generality integers are implemented by four classes, Integer, the abstract superclass of all integers, SmallInteger, whose instances fit in a machine word, for example having a 61-bit signed range in a 64-bit implementation, LargePositiveInteger and LargeNegativeInteger,

4209-449: The standard for all the integrated development environments , starting with Lisp Machine environments, that came after. Smalltalk uses several commands that rhyme with the "-ect" suffix. This was inspired by a line from the 1967 Arlo Guthrie monologue " Alice's Restaurant Massacree ," in which Guthrie underwent a battery of being "injected, inspected, detected, infected, neglected and selected." As in other object-oriented languages,

SECTION 60

#1732782819653

4278-502: The system is running. Live coding and applying fixes 'on-the-fly' is a dominant programming methodology for Smalltalk and is one of the main reasons for its productivity. Smalltalk is a "pure" object-oriented programming language, meaning that, unlike C++ and Java , there are no primitive types. All values are represented as objects and computation on integers uses message sending just like any other object. In Smalltalk, types such as integers, Booleans and characters are also objects, in

4347-465: The system provides both a simple consistent message binding mechanism and good efficiency. Code blocks —Smalltalk's way of expressing anonymous functions —are also objects. They have a very lightweight syntax and are used throughout the system to implement control structures, especially for the Collection hierarchy. Reflection is a feature of having a meta-model as Smalltalk does. The meta-model

4416-410: The system. In languages derived from the original Smalltalk-80 the current activation of a method is accessible as an object named via a pseudo-variable (one of the six reserved words), thisContext , which corresponds to a stack frame in conventional language implementations, and is called a "context". Sending a message is done within some context, and to evaluate the message another context is created,

4485-563: Was created at Xerox PARC by Learning Research Group (LRG) scientists, including Alan Kay , Dan Ingalls , Adele Goldberg , Ted Kaehler , Diana Merry , and Scott Wallace. In Smalltalk, executing programs are built of opaque, atomic, so-called objects, which are instances of template code stored in classes. These objects intercommunicate by passing of messages, via an intermediary virtual machine environment (VM). A relatively small number of objects, called primitives, are not amenable to live redefinition, sometimes being defined independently of

4554-519: Was in November 1981. Xerox only distributed Version 1 to Apple, DEC, HP, and Tektronix, but these companies were allowed unrestricted redistribution via any system they built. This encouraged the wide spread of Smalltalk. Later, in 1983, Xerox released Smalltalk-80 Version 2. This version was generally available to the public, although under a restrictive license. Versions 1 and 2 were fairly similar, although Version 2 did have some added features such as

4623-625: Was later acquired by Cincom Systems , and is now sold under the name ObjectStudio , and is part of the Cincom Smalltalk product suite. In 1995, ParcPlace and Digitalk merged into ParcPlace-Digitalk and then rebranded in 1997 as ObjectShare, located in Irvine, CA. ObjectShare ( NASDAQ : OBJS) was traded publicly until 1999, when it was delisted and dissolved. The merged firm never managed to find an effective response to Java as to market positioning, and by 1997 its owners were looking to sell

4692-406: Was shared with Tektronix , Hewlett-Packard , Apple Computer , and DEC for review and debugging on their platforms. The August 1981 issue of Byte Magazine was devoted to Smalltalk-80 and brought its ideas to a large audience. Several books on Smalltalk-80 were also published. Smalltalk-80 became the basis for all future commercial versions of Smalltalk. The final release of Smalltalk-80 Version 1

4761-510: Was the product of research led by Alan Kay at Xerox Palo Alto Research Center (PARC); Alan Kay designed most of the early Smalltalk versions, Adele Goldberg wrote most of the documentation, and Dan Ingalls implemented most of the early versions. The first version, termed Smalltalk-71, was created by Kay in a few mornings on a bet that a programming language based on the idea of message passing inspired by Simula could be implemented in "a page of code". A later variant used for research work

#652347