Mixins in strongtalk

ACM SIGPLAN Notices, 1986

We have implemented Smalltalk-80 on an instruction-level simulator for a RISC microcomputer called SOAR. Measurements suggest that even a conventional computer can provide high performance for Smalltalk-80 by abandoning the 'Smalltalk Virtual Machine' in favor of compiling Smalltalk directly to SOAR machine code, linearizing the activation records on the machine stack, eliminating the object table, and replacing reference counting with a new technique called Generation Scavenging. In order to implement these techniques, we had to find new ways of hashing objects, accessing often-used objects, invoking blocks, referencing activation records, managing activation record stacks, and converting the virtual machine images.

2011

Paper presented at 10th ACM SIGPLAN Int. Workshop on Virtual Machines and Intermediate Languages (see http://design.cs.iastate.edu/vmil/2011/index.html) but not archived as part of the proceedings.

1993

A "first" implementation of the Modular Smalltalk object-oriented programming language is presented. The implementation includes an object-oriented parser, object-oriented representation for code fragments and an object-oriented C-code generator, all implemented in Smalltalk-80. This implementation validates two of the five design principles of the Modular Smalltalk language and provides a vehicle for validating the other three design principles. The macro-based C-code generator is easily adaptable to generating production code in other languages like assembler. In addition, the generation technique applies to source languages other than Modular Smalltalk. The implementation includes an efficient method dispatch based on new extensions to incremental cache table coloring.

1996

This paper studies why and how Smalltalk, although designed as a mono-user and mono-processor programming language, is a very good foundation for concurrent and distributed programming. The two main reasons behind this likely paradox are: the rich and reusable library of classes, and the extreme exibility of Smalltalk. These two speci cities complement more general object-oriented characteristics and advantages. As examples supporting our claim, we overview two di erent Smalltalkbased software platforms for concurrent and distributed programming.

2009

Abstract Integration of multiple languages into each other and into an existing development environment is a difficult task. As a consequence, developers often end up using only internal DSLs that strictly rely on the constraints imposed by the host language. Infrastructures do exist to mix languages, but they often do it at the price of losing the development tools of the host language.

Conference proceedings on Object-oriented programming systems, languages and applications - OOPLSA '86, 1986

Two varieties of object-oriented systems exist: one based on classes as in Smalltalk and another based on exemplars (or prototypicai objects) as in Act/l. By converting Smalltalk from a class based orientation to an exemplar base, independent instance hierarchies and class hierarchies can be provided. Decoupling the two hierarchies in this way enables the user's (logical) view of a data type to be separated from the implementer's (physical) view. It permits the instances of a class to have a representation totally different from the instances of a superclass. Additionally, it permits the notion of multiple representations to be provided without the need to introduce specialized classes for each representation. In the context of multiple inheritance, it leads to a novel view of inheritance (or-inheritance) that differentiates it from the more traditional multiple inheritance notions (and-inheritance). In general, we show that exemplar based systems are more powerful than class based systems. We also describe how an existing class based Smalltalk can be transformed into an exemplar-based Smalltalk and discuss possible approaches for the implementation of both and-inheritance and or-inheritance. l Introduction Although Smalltalk [Goldberg 83] is a small, well designed language with a rich programming environment, it lacks some of the generality that might be expected of an object-oriented system. In particular, it fails to distinguish between class hierarchies and instance hierarchies. For a great majority of the classes, the distinction is not important; however, there are some important anomalies and consequences. An exemplar based system [LaLonde 86] can distinguish between the two and properly handle these anomalies. It can also be used to support the "classical" class viewpoint.

Proceedings of the Third Workshop on Virtual Machines and Intermediate Languages - VMIL '09, 2009

This paper describes how virtual classes can be supported in a virtual machine. Main-stream virtual machines such as the Java Virtual Machine and the .NET platform dominate the world today, and many languages are being executed on these virtual machines even though their embodied design choices conflict with the design choices of the virtual machine. For instance, there is a non-trivial mismatch between the main-stream virtual machines mentioned above and dynamically typed languages. One language concept that creates an even greater mismatch is virtual classes, in particular because fully general support for virtual classes requires generation of new classes at run-time by mixin composition. Languages like CaesarJ and Object Teams can express virtual classes restricted to the subset that does not require run-time generation of classes, because of the restrictions imposed by the Java Virtual Machine. We have chosen to support virtual classes by implementing a specialized virtual machine, and this paper describes how this virtual machine supports virtual classes with full generality.

Proceedings - International Conference on Software Engineering, 2011

The dynamic and reflective features of programming languages are powerful constructs that programmers often mention as extremely useful. However, the ability to modify a program at runtime can be both a boon-in terms of flexibility-, and a curse-in terms of tool support. For instance, usage of these features hampers the design of type systems, the accuracy of static analysis techniques, or the introduction of optimizations by compilers. In this paper, we perform an empirical study of a large Smalltalk codebaseoften regarded as the poster-child in terms of availability of these features-, in order to assess how much these features are actually used in practice, whether some are used more than others, and in which kinds of projects. These results are useful to make informed decisions about which features to consider when designing language extensions or tool support.

The Journal of Object Technology, 2007

Virtual machines raise the abstraction level of the execution environment at the cost of restricting the set of supported languages. Moreover, the ability of a language implementation to integrate with other languages hosted on the same virtual machine typically constrains the features of the language. In this paper, we present a highly flexible yet efficient approach to hosting multiple programming languages on an objectoriented virtual machine. Our approach is based on extending the interface of each class with language-specific wrapper methods, offering each language a tailored view of a given class. This approach can be deployed both on a statically typed virtual machine, such as the JVM, and on a dynamic virtual machine, such as a Smalltalk virtual machine. We have implemented our approach to language interoperability on top of a prototype virtual machine for embedded systems based on the Smalltalk object model, which provides interoperability for embedded versions of the Smalltalk, Java, and BETA programming languages.

Lecture Notes in Computer Science, 2007

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.